iOS-Automatisierungstests mit Xcode UI Framework

⚡ Intelligente Zusammenfassung

iOS-Automatisierungstests mit Xcode zeichnet Benutzerinteraktionen einer zu testenden Anwendung auf und gibt sie wieder, wobei ein testgetriebener Zyklus aus Entwurf, Test, Implementierung und erneutem Test durchgeführt wird, bis jeder Fall erfolgreich ist.

  • 🔘 TDD-Zyklus: Entwerfen, testen, implementieren und erneut testen – das sind die vier Phasen, die beim Testen von iOS-Anwendungen Anwendung finden.
  • ☑️ Voraussetzungen: Ein Mac mit OS X und dem Xcode IDE, ein Automatisierungs-Framework und das iOS SDK sind installiert.
  • Instrumentenroute: Das Automatisierungsinstrument zeichnet ein Skript auf, zeigt es im Skriptprotokoll an und spielt es bei Bedarf wieder ab.
  • 🧪 OCUnit-Route: Ein Unit-Test-Bundle-Ziel, ein aktives Schema, eine Testgruppe und eine in Objective-C geschriebene Testklasse.
  • ⚠️ Missbilligung: Das UIAutomation-Instrument wurde in der Xcode 8 und entfernt; XCUITest ist der unterstützte Nachfolger.
  • Modernes Äquivalent: Ein UI Testing Bundle-Ziel plus XCUIApplication-Abfragen ersetzt das aufgezeichnete Instruments-Skript.

iOS-Automatisierungstests mit dem Xcode UI-Automatisierungsframework führt ein aufgezeichnetes Skript für eine App aus

iOS-Automatisierungstests mit Xcode

Um die Qualität Ihrer iOS-Anwendung zu gewährleisten, sollten Sie den in der folgenden Abbildung dargestellten testgetriebenen Entwicklungsprozess befolgen.

Testgetriebener Entwicklungszyklus für iOS-Automatisierungstests mit den Phasen Design, Test, Implementierung und erneutem Test.

Testgetriebene Entwicklung (TDD) ist eine testing Modell, das beim Testen von iOS-Anwendungen angewendet wird und in die umfassendere Praxis von mobile TestsIn diesem Modell muss ein Tester die folgenden vier Phasen durchlaufen:

  • Design: Überlegen Sie sich, was Sie testen möchten, und entwerfen Sie Ihre Testfälle.
  • Test: Führe alle Tests durch und prüfe, ob Testfälle fehlschlagen.
  • Implementieren: RevNutze deinen Code und behebe die Fehler, die zum Fehlschlagen des Tests geführt haben.
  • Testen Sie erneut: Schlägt ein Test fehl, wird auf das ursprüngliche Design zurückgegriffen. Sind alle Testfälle erfolgreich, erfüllt der Code alle getesteten Anforderungen.

Einrichten Xcode Projekt für UI-Tests

Um ein iOS-Testprogramm zu erstellen, benötigen Sie einen Mac. Auf Ihrem Mac müssen bereits folgende Programme installiert sein:

  • OS X — das Betriebssystem für einen Mac.
  • Xcode IDE — das Entwicklungstool für iOS.
  • Ein automatisiertes Testframework — UI-Automatisierung, OCUnit usw.
  • iOS SDK 4 oder höher.

⚠️ Versionshinweis: Die oben genannten Voraussetzungen beschreiben die Toolchain der Zeit, in der die beiden folgenden Anleitungen verfasst wurden. Auf einem aktuellen Mac, Xcode Die XCTest- und XCUITest-Frameworks sind im Lieferumfang enthalten, das separate UI-Automatisierungsinstrument ist nicht mehr Teil der Installation. Die ursprünglichen Schritte sind unten aufgeführt, da sie die Funktionsweise des Frameworks dokumentieren; die moderne Entsprechung wird weiter unten beschrieben.

So erstellen Sie eine iOS-Automatisierung mit dem UI Automation Framework

Die folgenden acht Schritte zeichnen ein Skript mit dem Automatisierungsinstrument auf und spielen es für die zu testende Anwendung ab.

Schritt 1) ​​Starten Sie Instrumente

Öffnen Sie XCode -> Entwicklertools öffnen -> Instrument

Eröffnungsinstrumente aus dem Xcode Entwicklertools-Menü öffnen

Schritt 2) Automatisierungsinstrument hinzufügen

Wählen Sie im Fenster „Instrumente“ das Automatisierungsinstrument aus.

Auswahl des Automatisierungsinstruments in der Instrumentenvorlagenauswahl

Um ein Testskript zu erstellen, zeichnen Sie entweder ein Testszenario Oder Sie programmieren es manuell.

Schritt 3) Drücken Sie die rote Taste

Ein Instrument wird gestartet – die Aufnahme sofort stoppen. Um die Aufnahme zu starten, drücken Sie den roten Knopf.

Der rote Aufnahmeknopf in der Instrumenten-Symbolleiste dient zum Starten und Stoppen einer Aufnahme. trace

Schritt 4) Erstellen Sie ein neues Skript

Klicken Sie im Fenster „Skripte“ auf „Hinzufügen“ > „Erstellen“, um ein neues Skript zu erstellen.

Im Menü „Hinzufügen und Erstellen“ im Fenster „Instrumentenskripte“ können Sie ein neues Automatisierungsskript hinzufügen.

Schritt 5) Wählen Sie das Ziel

Sie befinden sich nun im TracDas Auswahlfenster verwenden. Target Ziehen Sie die Liste nach unten, um zur Debugging-Version Ihrer App zu gelangen.

Wählen Target Dropdown-Menü im Menü „Instrumente“ TracDas Fenster zeigt auf den Debug-Build.

In diesem Fall handelt es sich um Apples Probe. SimpleDrillDown Die App dient als Testanwendung. Sie verfügt über die unten dargestellte grafische Benutzeroberfläche.

Die Benutzeroberfläche der Beispielanwendung SimpleDrillDown wurde als Testanwendung verwendet.

Schritt 6) Beginnen Sie mit der Aufzeichnung Ihres Skripts

Zeichnen Sie Ihr Skript auf, indem Sie oben oder unten im Tool auf die Aufnahmeschaltfläche klicken.

Die Aufnahmetaste am Rand des Instruments-Fensters startet die Skriptaufzeichnung.

Sie können nun einige UI-Aktionen in Ihrer zu testenden Anwendung durchführen, und Ihr Skript wird aufgezeichnet.

Schritt 7) Sehen Sie sich Ihr Skript an

Um Ihr Skript anzuzeigen, klicken Sie auf TracÖffnen Sie das Dropdown-Menü „Log / Editor Log“ und wechseln Sie zur Skriptprotokollansicht.

TracDas Dropdown-Menü „Protokoll und Editor-Protokoll“ dient zum Umschalten auf die Skriptprotokollansicht.

Sie sehen Ihr aufgezeichnetes Skript.

Aufgezeichnetes UI-Automatisierungsskript, das in der Skriptprotokollansicht von Instruments angezeigt wird

Schritt 8) Spielen Sie Ihr Skript ab

Drücken Sie die Wiedergabetaste. Das Skript wird ausgeführt und kann nach Erscheinen der Protokolle gestoppt werden.

Wiedergabe des aufgezeichneten Automatisierungsskripts mit Protokollausgabe im Instrumentenfenster

⚠️ Historischer Hinweis: Das in diesen acht Schritten verwendete Automatisierungsinstrument wurde in Xcode 8 und später entfernt, ist es daher in der aktuellen Version nicht mehr vorhanden. Xcode Installationen. Die Schritte werden hier als Dokumentation der Funktionsweise des Frameworks festgehalten; für neue Projekte verwenden Sie bitte die XCUITest-Anleitung weiter unten auf dieser Seite.

So erstellen Sie eine iOS-Automatisierung mit dem OCUnit-Framework

Die zweite Route platziert die Tests innerhalb der Xcode Das Projekt selbst und nicht innerhalb von Instruments.

Schritt 1) Starten Xcode IDE, Ziel „Unit-Test-Bundle hinzufügen“

Hinzufügen eines Unit-Test-Bundle-Ziels zu einem bestehenden Xcode Projekt

Schritt 2) Geben Sie den Namen des neuen Unit-Test-Bundles ein. Klicken Sie anschließend auf Fertigstellen, wie in der obigen Abbildung dargestellt.

Schritt 3) Machen Sie Unit Test zum aktiven Ziel

Auswahl des Unit-Test-Bundles als aktives Ziel in Xcode

Schritt 4) Fügen Sie eine Gruppe für Testklassen hinzu

Erstellung einer Projektgruppe zur Aufnahme der iOS-Unit-Testklassen

Schritt 5) Fügen Sie eine Unit-Test-Klasse hinzu

Hinzufügen einer neuen Unit-Test-Klassendatei innerhalb der Testgruppe in Xcode

Schritt 6) Beginnen Sie nun mit der Implementierung.

Leere Unit-Test-Klasse im Xcode Editor bereit für die Testimplementierung

OCUnit verwendet die Programmiersprache Objective-C zur Erstellung des Testprogramms, daher muss der Entwickler diese Sprache beherrschen. Modern Xcode Versionen werden ausgeliefert Unit-Test stattdessen durch XCTest, das sowohl Objective-C als auch unterstützt. SwiftDie in diesen sechs Schritten dargestellte Ziel- und Klassenstruktur bleibt jedoch unverändert.

UIAutomation vs XCUITest: Was hat sich geändert?

Da die beiden oben genannten Frameworks einer früheren Generation der Apple-Toolchain angehören, ist es wichtig, genau anzugeben, was sie ersetzt hat und warum.

Aspekt UI-Automatisierung (Instrumente) XCUITest
Status Veraltet in Xcode 8 und wurde aus späteren Versionen entfernt Apples unterstütztes UI-Testframework
Wo Tests stattfinden Skripte innerhalb eines Instruments trace Dokument Ein UI-Test-Bundle-Ziel innerhalb des Xcode Projekt
Sprache JavaSkript Swift oder Objective-C
Testläufer Das Automatisierungsinstrument XCTest, der gleiche Runner wie Unit-Tests
Kontinuierliche Integration Ungeschickt — durch Instrumente getrieben Läuft von der Kommandozeile aus zusammen mit Unit-Tests
Aufnahme Aufnahmetaste in der Instrumenten-Symbolleiste Aufnahmetaste im Xcode Editor, der ausgibt Swift

Die praktische Konsequenz ist, dass eine XCUITest-Suite gewöhnlicher Projektquellcode ist. Sie wird wie der Rest der Codebasis überprüft, versioniert und ausgeführt, was der Hauptgrund dafür ist, dass die Testsuite aufgezeichnet wird.tracDas Modell ist verschwunden.

Wie man einen iOS-UI-Test mit XCUITest schreibt

Das moderne Äquivalent der acht Schritte von Instruments ist kurz. Die folgende Struktur spiegelt das gleiche Prinzip des Aufnehmens und Wiedergebens wider, aber die Ausgabe ist eine Quelldatei anstelle einer … trace.

  1. Füge das Ziel hinzu. In Xcode Wählen Sie Datei > Neu > Target und wählen Sie die Vorlage „UI Testing Bundle“ aus oder aktivieren Sie die Option, Tests beim Erstellen eines neuen Projekts einzuschließen.
  2. Öffnen Sie die generierte Testklasse. Xcode Erstellt eine XCTestCase-Unterklasse mit leeren Setup- und Testmethoden.
  3. Starten Sie die zu testende App. Erstellen Sie eine XCUIApplication-Instanz und rufen Sie die launch-Funktion auf, um die Anwendung in einem separaten Prozess zu starten.
  4. Fragen stellen und handeln. Greifen Sie über Elementabfragen auf Elemente zu – Schaltflächen, Tabellen, statische Texte – und rufen Sie darauf die Aktionen „Tap“, „TypeText“ oder „Swipe“ auf.
  5. Behaupten. Verwenden Sie XCTAssert, um zu überprüfen, ob das erwartete Element nach der Aktion vorhanden ist.
  6. Lauf. Führen Sie den Test von der Xcode Test-Navigator oder über die Kommandozeile, sodass dieselbe Testsuite in der kontinuierlichen Integration ausgeführt wird.

Ein Minimaltest hat folgendes Format:

import XCTest

final class AppUITests: XCTestCase {

    func testTappingFirstRowShowsDetail() {
        let app = XCUIApplication()
        app.launch()

        // act on the first row of the list
        app.tables.cells.element(boundBy: 0).tap()

        // verify that the next screen appeared
        XCTAssertTrue(app.staticTexts.firstMatch.waitForExistence(timeout: 5))
    }
}

Der Recorder ist weiterhin vorhanden: Durch Platzieren des Cursors innerhalb einer Testmethode und Drücken der Aufnahmetaste im Editor werden diese Abfragen automatisch generiert, was eine direkte Folge von Schritt 6 ist. Die übergeordneten Prinzipien von Automatisierungstests gelten unverändert.

UI-Automatisierungsbeispiel Code

Dieser Artikel enthält einige Quellcodebeispiele. Sie helfen Ihnen, das Tutorial besser und schneller zu verstehen.

UI-Automatisierungsbeispiel — Testskript für die UI-Automatisierungsdemo.

Häufig gestellte Fragen

Nein. Xcode und die iOS-Simulatoren laufen nur auf macOSDaher wird ein Mac benötigt, entweder lokal oder als gehosteter Build-Rechner. Cloud-Gerätefarmen und gehostete CI-Anbieter existieren genau dafür, dass Teams ohne Mac-Hardware die Suite trotzdem ausführen können.

Maschinelle Lernmodelle schlagen Ersatzelementabfragen bei Bildschirmwechseln vor, gruppieren sporadische Fehler nach ihrer Ursache und ordnen fehlgeschlagene Läufe nach echten Regressionen. Dies ist insbesondere für UI-Suites relevant, da kleine Layoutänderungen sonst viele Selektoren gleichzeitig beeinträchtigen.

Es bewältigt die wiederkehrenden Teile gut – Testklassen-Gerüst, Startargumente, Page-Object-Wrapper und Assertions-Boilerplate-Code. Elementbezeichner müssen jedoch weiterhin mit der realen Anwendung übereinstimmen, daher muss jede generierte Abfrage anhand des laufenden Builds verifiziert werden, bevor sie als vertrauenswürdig eingestuft wird.

Appium iOS wird über seinen XCUITest-Treiber gesteuert, der den älteren UIAutomation-Treiber ersetzt hat. Der Vorteil besteht darin, dass es eine plattformübergreifende Testsprache für iOS und AndroidDer Kompromiss besteht in einer zusätzlichen Ebene zwischen dem Test und Apples eigenem Runner.

Ein Unit-Test läuft innerhalb des Anwendungsprozesses und ruft Ihren Code direkt auf. Ein UI-Test startet die Anwendung als separaten Prozess und interagiert ausschließlich über die Benutzeroberfläche. Daher ist er langsamer, validiert aber die tatsächliche Benutzererfahrung.

Simulatoren sind schneller und für die meisten funktionalen Abläufe in einer Pipeline ausreichend. Für Kameras, Biometrie, Push-Benachrichtigungen, Leistungstests und alles, was Hardware-Sensoren nutzt, werden reale Geräte benötigt. Daher setzen die meisten Teams beides zu unterschiedlichen Zeitpunkten im Zyklus ein.

Jeder Test startet die App neu und wartet auf Animationen. Die Stabilität verbessert sich, wenn Sie Barrierefreiheitskennungen anstelle von Beschriftungen verwenden und auf das Vorhandensein von Elementen warten, anstatt zu warten.pingDen Zustand zwischen den Tests zurücksetzen und jeden Fall auf einen einzigen Ablauf konzentrieren.

Nicht direkt, da sich die Sprachen und Elementmodelle unterscheiden. Üblicherweise werden die alten Skripte als Dokumentation der angestrebten Testabdeckung beibehalten und anschließend jedes Szenario als XCUITest-Fall neu geschrieben, beginnend mit den Abläufen, die in der Produktion am häufigsten fehlschlagen.

Fassen Sie diesen Beitrag mit folgenden Worten zusammen: