Communitygithub.com

UI Testing

Bedingungsbasiertes Warten statt willkürlicher Zeitüberschreitungen für zuverlässige UI-Tests auf Apple-Plattformen. Deckt Recording UI Automation (WWDC 2025), flaky Tests, Crash-Debugging und barrierefreiheitsorientierte Testmuster ab.

Was ist UI Testing?

Diese Skill-Anleitung vermittelt das Kernprinzip, dass UI-Tests auf Bedingungen warten sollten, nicht auf willkürliche Timeouts. Flaky Tests entstehen meist durch Raten, wie lange Operationen dauern – bedingungsbasiertes Warten eliminiert Wettlaufsituationen (Race Conditions). Die Anleitung behandelt häufige Probleme wie lokal bestandene, aber in CI fehlschlagende Tests, die Verwendung von sleep()-Aufrufen und inkonsistentes Pass/Fail-Verhalten. Für Entwickler, die XCTest (Xcode 26 oder neuer) verwenden, werden konkrete Swift-Codebeispiele bereitgestellt: waitForExistence, XCTestExpectation und NSPredicateExpectation für Netzwerkanfragen, Animationen und das Verschwinden von Ladeanzeigen. Zusätzlich wird die neue Recording UI Automation (WWDC 2025) erklärt: Aufzeichnen von Interaktionen, Abspielen über verschiedene Geräte und Sprachen sowie Videoreview zur Fehleranalyse. Die Skill-Anleitung enthält eine Checkliste für die Testentwicklung, eine Entscheidungsbaum-Übersicht und typische Fehler (z. B. hartcodierte Labels, voneinander abhängige Tests). Sie zeigt anhand von echten Auswirkungen vorher/nachher: Testlaufzeit von 15 auf 5 Minuten, Flaky-Rate von 20% auf unter 2%. Die zugrunde liegende Technologie ist das Accessibility-Framework – daher wird empfohlen, accessibilityIdentifier für stabile, nicht lokalisierte Selektoren zu vergeben.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/CharlesWiltgen/Axiom/axiom-ui-testing

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht UI Testing?

Überblick

Warte auf Bedingungen, nicht auf willkürliche Zeitüberschreitungen. Kernprinzip: Flaky Tests entstehen durch Raten, wie lange Operationen dauern. Bedingungsbasiertes Warten eliminiert Wettlaufsituationen.

NEU in WWDC 2025: Recording UI Automation ermöglicht es, Interaktionen aufzuzeichnen, über Geräte/Sprachen hinweg abzuspielen und Videoaufzeichnungen von Testläufen zu überprüfen.

Beispielhafte Prompts

Dies sind echte Fragen von Entwicklern, die diese Skill-Anleitung beantworten soll:

1. „Meine UI-Tests bestehen lokal auf meinem Mac, schlagen aber in CI fehl. Wie mache ich sie zuverlässiger?“

→ Die Anleitung zeigt bedingungsbasierte Wartemuster, die geräte- und geschwindigkeitsunabhängig funktionieren und CI-Zeitunterschiede eliminieren.

2. „Meine Tests verwenden sleep(2) und sleep(5), sind aber immer noch flaky. Wie ersetze ich willkürliche Timeouts durch echte Bedingungen?“

→ Die Anleitung demonstriert waitForExistence, XCTestExpectation und Polling-Muster für Datenladungen, Netzwerkanfragen und Animationen.

3. „Ich habe gerade einen Test mit Xcode 26’s Recording UI Automation aufgezeichnet. Wie überprüfe ich das Video und debugge Fehler?“

→ Die Anleitung behandelt Video-Debugging-Workflows, um Aufzeichnungen zu analysieren und den genauen Schritt zu finden, bei dem Tests fehlschlagen.

4. „Mein Test schlägt auf iPad fehl, besteht aber auf iPhone. Wie schreibe ich Tests, die über alle Gerätegrößen hinweg funktionieren?“

→ Die Anleitung erklärt Multi-Faktor-Testing-Strategien und geräteunabhängige Prädikate für robustes geräteübergreifendes Testen.

5. „Ich möchte Tests schreiben, die nicht flaky sind. Welche kritischen Muster muss ich kennen?“

→ Die Anleitung liefert bedingungsbasierte Wartevorlagen, barrierefreiheitsorientierte Muster und den Entscheidungsbaum für eine zuverlässige Testarchitektur.


Warnsignale – Testzuverlässigkeitsprobleme

Wenn Sie IRGENDEINES davon sehen, vermuten Sie Timing-Probleme:

  • Tests bestehen lokal, schlagen in CI fehl (Timing-Unterschiede)
  • Tests bestehen manchmal, schlagen manchmal fehl (Wettlaufsituationen)
  • Tests verwenden sleep() oder Thread.sleep() (willkürliche Verzögerungen)
  • Tests schlagen mit „UI-Element nicht gefunden“ fehl, bestehen beim Wiederholen
  • Lange Testlaufzeiten (Warten auf Worst-Case-Szenarien)

Schneller Entscheidungsbaum

Test schlägt fehl?
├─ Element nicht gefunden?
│  └─ Verwende waitForExistence(timeout:) nicht sleep()
├─ Besteht lokal, schlägt in CI fehl?
│  └─ Ersetze sleep() durch Bedingungs-Polling
├─ Animation verursacht Probleme?
│  └─ Warte auf Animationsabschluss, deaktiviere nicht
└─ Netzwerkanfrage-Timing?
   └─ Verwende XCTestExpectation oder waitForExistence

Kernmuster: Bedingungsbasiertes Warten

❌ FALSCH (Willkürlicher Timeout):

func testButtonAppears() {
    app.buttons["Login"].tap()
    sleep(2)  // ❌ Raten, dass es 2 Sekunden dauert
    XCTAssertTrue(app.buttons["Dashboard"].exists)
}

✅ RICHTIG (Auf Bedingung warten):

func testButtonAppears() {
    app.buttons["Login"].tap()
    let dashboard = app.buttons["Dashboard"]
    XCTAssertTrue(dashboard.waitForExistence(timeout: 5))
}

Häufige UI-Testing-Muster

Muster 1: Auf Elemente warten

// Warten, dass ein Element erscheint
func waitForElement(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
    return element.waitForExistence(timeout: timeout)
}

// Verwendung
XCTAssertTrue(waitForElement(app.buttons["Submit"]))

Muster 2: Warten, dass ein Element verschwindet

func waitForElementToDisappear(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
    let predicate = NSPredicate(format: "exists == false")
    let expectation = XCTNSPredicateExpectation(predicate: predicate, object: element)
    let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
    return result == .completed
}

// Verwendung
XCTAssertTrue(waitForElementToDisappear(app.activityIndicators["Loading"]))

Muster 3: Warten auf einen bestimmten Zustand

func waitForButton(_ button: XCUIElement, toBeEnabled enabled: Bool, timeout: TimeInterval = 5) -> Bool {
    let predicate = NSPredicate(format: "isEnabled == %@", NSNumber(value: enabled))
    let expectation = XCTNSPredicateExpectation(predicate: predicate, object: button)
    let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
    return result == .completed
}

// Verwendung
let submitButton = app.buttons["Submit"]
XCTAssertTrue(waitForButton(submitButton, toBeEnabled: true))
submitButton.tap()

Muster 4: Accessibility-Identifiers

In der App setzen:

Button("Submit") {
    // Aktion
}
.accessibilityIdentifier("submitButton")

In Tests verwenden:

func testSubmitButton() {
    let submitButton = app.buttons["submitButton"]  // Verwendet Identifier, nicht Label
    XCTAssertTrue(submitButton.waitForExistence(timeout: 5))
    submitButton.tap()
}

Warum: Accessibility-Identifiers ändern sich nicht mit der Lokalisierung und bleiben über UI-Updates hinweg stabil.

Muster 5: Netzwerkanfrage-Verzögerungen

func testDataLoads() {
    app.buttons["Refresh"].tap()

    // Warten, dass Ladeindikator verschwindet
    let loadingIndicator = app.activityIndicators["Loading"]
    XCTAssertTrue(waitForElementToDisappear(loadingIndicator, timeout: 10))

    // Jetzt überprüfen, ob Daten geladen wurden
    XCTAssertTrue(app.cells.count > 0)
}

Muster 6: Animationsbehandlung

func testAnimatedTransition() {
    app.buttons["Next"].tap()

    // Warten, dass die Zielansicht erscheint
    let destinationView = app.otherElements["DestinationView"]
    XCTAssertTrue(destinationView.waitForExistence(timeout: 2))

    // Optional: Etwas länger warten, bis die Animation abgeschlossen ist
    // Nur wenn absolut notwendig
    RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.3))
}

Test-Checkliste

Bevor Sie Tests schreiben

  • Accessibility-Identifiers für alle interaktiven Elemente verwenden
  • Hartcodierte Labels vermeiden (stattdessen Identifiers verwenden)
  • Netzwerkverzögerungen und Animationen einplanen
  • Angemessene Timeouts wählen (2s UI, 10s Netzwerk)

Beim Schreiben von Tests

  • waitForExistence() statt sleep() verwenden
  • Prädikate für komplexe Bedingungen verwenden
  • Sowohl Erfolgs- als auch Fehlerpfade testen
  • Tests unabhängig machen (in beliebiger Reihenfolge ausführbar)

Nach dem Schreiben von Tests

  • Tests 10x lokal ausführen (Flakiness erkennen)
  • Tests auf dem langsamsten unterstützten Gerät ausführen
  • Tests in CI-Umgebung ausführen
  • Testdauer prüfen (bei >30s pro Test optimieren)

Xcode UI Testing Tipps

Launch-Argumente für Tests

func testExample() {
    let app = XCUIApplication()
    app.launchArguments = ["UI-Testing"]
    app.launch()
}

Im App-Code:

if ProcessInfo.processInfo.arguments.contains("UI-Testing") {
    // Mock-Daten verwenden, Onboarding überspringen, etc.
}

Schnellere Testausführung

override func setUpWithError() throws {
    continueAfterFailure = false  // Beim ersten Fehler stoppen
}

Fehlschlagende Tests debuggen

func testExample() {
    // Screenshot bei Fehler machen
    addUIInterruptionMonitor(withDescription: "Alert") { alert in
        alert.buttons["OK"].tap()
        return true
    }

    // Elementhierarchie ausgeben
    print(app.debugDescription)
}

Häufige Fehler

❌ sleep() für alles verwenden

sleep(5)  // ❌ Zeitverschwendung, wenn Vorgang in 1s abgeschlossen ist

❌ Animationen nicht behandeln

app.buttons["Next"].tap()
XCTAssertTrue(app.buttons["Back"].exists)  // ❌ Kann während Animation fehlschlagen

❌ Hartcodierte Textlabels

app.buttons["Submit"].tap()  // ❌ Bricht mit Lokalisierung

❌ Tests sind voneinander abhängig

// ❌ Test 2 geht davon aus, dass Test 1 zuerst lief
func test1_Login() { /* ... */ }
func test2_ViewDashboard() { /* geht von eingeloggtem Zustand aus */ }

❌ Keine Timeout-Strategie

element.waitForExistence(timeout: 100)  // ❌ Zu lang
element.waitForExistence(timeout: 0.1)  // ❌ Zu kurz

Angemessene Timeouts verwenden:

  • UI-Animationen: 2-3 Sekunden
  • Netzwerkanfragen: 10 Sekunden
  • Komplexe Vorgänge: maximal 30 Sekunden

Praxisrelevante Auswirkungen

Vorher (mit sleep()):

  • Test-Suite: 15 Minuten (Warten auf Worst-Case)
  • Flaky Tests: 20% Fehlerrate
  • CI-Fehlschläge: 50% erfordern Wiederholung

Nachher (bedingungsbasiertes Warten):

  • Test-Suite: 5 Minuten (wartet nur bei Bedarf)
  • Flaky Tests: <2% Fehlerrate
  • CI-Fehlschläge: <5% erfordern Wiederholung

Kernerkenntnis: Tests werden schneller abgeschlossen UND sind zuverlässiger, wenn auf tatsächliche Bedingungen gewartet wird, anstatt Zeiten zu raten.


Recording UI Automation

Überblick

NEU in Xcode 26: Aufzeichnen, abspielen und überprüfen von UI-Automation-Tests mit Videoaufzeichnungen.

Drei Phasen:

  1. Aufzeichnen – Interaktionen (Tippen, Wischen, Hardware-Tastendrücke) als Swift-Code erfassen
  2. Abspielen – Auf mehreren Geräten, Sprachen, Regionen, Ausrichtungen ausführen
  3. Überprüfen – Videoaufzeichnungen ansehen, Fehler analysieren, UI-Element-Overlays anzeigen

Unterstützte Plattformen: iOS, iPadOS, macOS, watchOS, tvOS, axiom-visionOS (Designed for iPad)

Wie UI-Automation funktioniert

Schlüsselprinzipien:

  • UI-Automation interagiert mit Ihrer App wie ein Mensch mit Gesten und Hardware-Ereignissen
  • Läuft völlig unabhängig von Ihrer App (App-Modelle/Daten sind nicht direkt zugänglich)
  • Nutzt das Accessibility-Framework als zugrunde liegende Technologie
  • Teilt dem Betriebssystem mit, welche Gesten ausgeführt werden sollen, und wartet dann synchron eine nach der anderen auf deren Abschluss

Aktionen umfassen:

  • Starten Ihrer App
  • Interaktion mit Buttons und Navigation
  • Systemzustand setzen (Dark Mode, axiom-localization, etc.)
  • Simulierten Standort setzen

Accessibility ist die Grundlage

Wichtiges Verständnis: Accessibility stellt Informationen direkt für die UI-Automation bereit.

Was Accessibility sieht:

  • Elementtypen (Button, Text, Bild, etc.)
  • Labels (sichtbarer Text)
  • Werte (aktueller Zustand für Checkboxen, etc.)
  • Rahmen (Elementpositionen)
  • Identifiers (Accessibility-Identifiers – NICHT lokalisiert)

Best Practice: Eine gute Accessibility-Erfahrung = eine gute UI-Automation-Erfahrung.

Ihre App für die Aufzeichnung vorbereiten

Schritt 1: Accessibility-Identifiers hinzufügen

SwiftUI:

Button("Submit") {
    // Aktion
}
.accessibilityIdentifier("submitButton")

// Identifiers instanzspezifisch machen
List(landmarks) { landmark in
    LandmarkRow(landmark)
        .accessibilityIdentifier("landmark-\(landmark.id)")
}

UIKit:

let button = UIButton()
button.accessibilityIdentifier = "submitButton"

// Index für Tabellenzellen verwenden
cell.accessibilityIdentifier = "cell-\(indexPath.row)"

Gute Identifiers sind:

  • ✅ Eindeutig innerhalb der gesamten App
  • ✅ Beschreibend für den Elementinhalt
  • ✅ Statisch (reagieren nicht auf Inhaltsänderungen)
  • ✅ Nicht lokalisiert (gleich in allen Sprachen)

Warum Identifiers wichtig sind:

  • Titel/Beschreibungen können sich ändern, Identifiers bleiben stabil
  • Funktionieren über lokalisierte Zeichenfolgen hinweg
  • Identifizieren Elemente mit dynamischem Inhalt eindeutig

Pro-Tipp: Verwenden Sie den Xcode-Coding-Assistant zum Hinzufügen von Identifiers:

Prompt: „Füge Accessibility-Identifiers zu den relevanten Teilen dieser Ansicht hinzu“

Schritt 2: Accessibility mit dem Accessibility Inspector prüfen

Accessibility Inspector starten:

  • Xcode-Menü → Entwickler-Tool öffnen → Accessibility Inspector
  • Oder: Über Spotlight starten

Funktionen:

  1. Element Inspector – Accessibility-Werte für jede Ansicht auflisten
  2. Eigenschaftsdetails – Auf Eigenschaftsnamen klicken für Dokumentation
  3. Plattformunterstützung – Funktioniert auf allen Apple-Plattformen

Was zu prüfen ist:

  • Elemente haben Labels
  • Interaktive Elemente haben Typen (Button, nicht nur Text)
  • Werte für zustandsbehaftete Elemente festgelegt (Checkboxen, Toggles)
  • Identifiers für Elemente mit dynamischem/lokalisiertem Inhalt festgelegt

Beispielcode-Referenz: Delivering an exceptional accessibility experience

Schritt 3: UI-Testing-Target hinzufügen

  1. Projekteinstellungen in Xcode öffnen
  2. „+" unterhalb der Target-Liste klicken
  3. UI Testing Bundle auswählen
  4. Auf „Fertig“ klicken

Ergebnis: Neuer UI-Testordner mit Vorlagentests wird zum Projekt hinzugefügt.

Interaktionen aufzeichnen

Aufzeichnung starten (Xcode 26)

  1. UI-Testquellcodedatei öffnen
  2. Popover erscheint mit Erklärung, wie die Aufzeichnung gestartet wird (nur beim ersten Mal)
  3. Auf die Schaltfläche „Aufzeichnung starten“ im Editor-Gutter klicken
  4. Xcode erstellt und startet die App im Simulator/Gerät

Während der Aufzeichnung:

  • Normal mit der App interagieren (Tippen, Wischen, Texteingabe, etc.)
  • Code, der die Interaktionen darstellt, erscheint in Echtzeit im Quelleditor
  • Die Aufzeichnung wird während der Eingabe aktualisiert (z. B. Texteingaben in Feldern)

Aufzeichnung beenden:

  • Auf die Schaltfläche „Run stoppen“ in Xcode klicken

Beispiel einer Aufzeichnungssitzung

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

    // Auf „Collections“-Tab tippen (automatisch aufgezeichnet)
    app.tabBars.buttons["Collections"].tap()

    // Auf „+" tippen, um neue Sammlung hinzuzufügen
    app.navigationBars.buttons["Add"].tap()

    // Auf „Edit“-Button tippen
    app.buttons["Edit"].tap()

    // Sammlungsnamen eingeben
    app.textFields.firstMatch.tap()
    app.textFields.firstMatch.typeText("Max's Australian Adventure")

    // Auf „Edit Landmarks" tippen
    app.buttons["Edit Landmarks"].tap()

    // Sehenswürdigkeiten hinzufügen
    app.tables.cells.containing(.staticText, identifier:"Great Barrier Reef").buttons["Add"].tap()
    app.tables.cells.containing(.staticText, identifier:"Uluru").buttons["Add"].tap()

    // Auf Häkchen tippen, um zu speichern
    app.navigationBars.buttons["Done"].tap()
}

Aufgezeichneten Code überprüfen

Nach der Aufzeichnung Abfragen überprüfen und anpassen:

Mehrere Optionen: Jede Zeile hat ein Dropdown mit alternativen Möglichkeiten, das Element anzusprechen.

Auswahl-Empfehlungen:

  1. Für lokalisierte Zeichenfolgen (Text, Button-Labels): Accessibility-Identifier wählen, falls verfügbar
  2. Für tief verschachtelte Ansichten: Kürzeste Abfrage wählen (bleibt stabil, wenn sich die App ändert)
  3. Für dynamische Inhalte (Zeitstempel, Temperatur): Generische Abfrage oder Identifier verwenden

Beispiel:

// Aufgezeichnete Optionen für Textfeld:
app.textFields["Collection Name"]              // ❌ Bricht, wenn Label lokalisiert wird
app.textFields["collectionNameField"]          // ✅ Verwendet Identifier
app.textFields.element(boundBy: 0)             // ✅ Positionsbasiert
app.textFields.firstMatch                      // ✅ Generisch, am kürzesten

Aufgezeichnete Tests abspielen

Test auf einem einzelnen Gerät ausführen

Methode 1 – In der Gutter-Leiste:

  • Klicken Sie auf die Schaltfläche „Ausführen“ neben der Testfunktion oder -klasse

Methode 2 – Test Navigator:

  • Befehl + 6
  • Mit der rechten Maustaste auf den Test klicken → „Test ausführen“

Methode 3 – Produktmenü:

  • Produkt → Test ausführen (Befehl + U)

Test auf mehreren Geräten ausführen

Lokales Testen:

  1. Wählen Sie im Xcode-Schema-Menü ein anderes Ziel aus
  2. Führen Sie den Test auf diesem Ziel aus
  3. Wiederholen Sie dies für jedes Ziel

Cloud-Testing-Optionen (von Drittanbietern):

Test auf mehreren Sprachen ausführen

Xcode 16+: Schema bearbeiten → Test → Optionen → „Sprache“-Dropdown im Abschnitt „App-Sprache“

Vor Xcode 16: Launch-Argumente:

app.launchArguments += ["-AppleLanguages", "(de)", "-AppleLocale", "de_DE"]

Hinweis: Das Testen mehrerer Sprachen validiert die Verwendung von Accessibility-Identifiers – wenn app.buttons["submitButton"] in allen Sprachen funktioniert, sind Ihre Identifiers korrekt.

Testfehler überprüfen

Videoaufzeichnungen durchsuchen

Standard-Video-Overlay:

  • Hauptfenster: Zeigt die Aufzeichnung der Testausführung
  • Suchleiste (unten): Ziehen oder klicken Sie, um durch das Video zu navigieren
  • Steuerelemente (unten): Abspielen/Pause, Geschwindigkeit (1x, 2x, 4x, 8x), Beenden

Erweitertes Video-Overlay (nur im Fehlerfall):

  • Hauptfenster: Wie oben, Video der Testausführung
  • Videomarkierungen: Rote Linien an jedem erkannten Fehler
  • Fehlerliste (rechts): Liste der Fehler mit Schritten und Screenshots
  • Navigationssteuerelemente: „Fehler überspringen“ (vorheriger/nächster Fehler), ausgewähltes Element hervorheben

Fehleranalyse-Workflow

Im erweiterten Overlay-Fenster:

Option 1: Fehler in der Liste überprüfen:

  • Jeder Fehler hat einen zusammenfassenden Text
  • Jeder Fehler hat einen Screenshot zum genauen Zeitpunkt des Fehlers
  • Fehler können als „behoben“ markiert werden, um sie aus der Liste auszublenden

Option 2: Fehler im Video überprüfen:

  • Rote Linien zeigen an, wo Fehler aufgetreten sind
  • Ziehen Sie die Suchleiste, um die App zu einem bestimmten Punkt neu zu zeichnen
  • Verwenden Sie die Suchleistensteuerelemente, um die App an einem bestimmten Frame anzuzeigen

Option 3: Ausgewähltes Element anzeigen:

  • Wählen Sie einen Fehler oder ein UI-Element in der Liste aus
  • Das Element wird im Video-Overlay rot hervorgehoben

Barrierefreiheitstests

Warum Barrierefreiheit wichtig ist:

  • Zur Einhaltung gesetzlicher Anforderungen und Richtlinien (z. B. WCAG)
  • Für inklusives Design – stellt sicher, dass Ihre App von Menschen mit Behinderungen genutzt werden kann

Was zu testen ist:

  • VoiceOver-Navigation: Kann ein Benutzer durch Ihre App navigieren, indem er Accessibility-Elemente verwendet?
  • Tastaturzugänglichkeit: Kann auf macOS/Tastatur vollständig über die Tastatur auf alle Elemente zugegriffen werden?
  • Dynamic Type: Passt sich der Text an die Einstellungen für Dynamic Type an?
  • Farbkontrast: Sind Farbkontraste für sehbehinderte Benutzer ausreichend?

So testen Sie mit UI-Automation:

Barrierefreiheits-Identifiers validieren:

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

    // Prüfen, ob wichtige Elemente Identifiers haben
    XCTAssertTrue(app.buttons["submitButton"].exists)
    XCTAssertTrue(app.textFields["emailField"].exists)
    XCTAssertTrue(app.buttons["cancelButton"].exists)
}

VoiceOver-Interaktionen testen:

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

    // VoiceOver-Gesten simulieren
    app.swipeRight()  // Zum nächsten Element
    app.swipeLeft()   // Zum vorherigen Element
    app.doubleTap()   // Element aktivieren
}

Pro-Tipps:

  • Verwenden Sie die Accessibility-API, um das VoiceOver-Rotor-Verhalten zu testen
  • Testen Sie mit verschiedenen Dynamic-Type-Größen
  • Validieren Sie, dass alle interaktiven Elemente fokussierbar sind

Häufige Fallstricke bei Recording

❌ Identifiers verwenden sich ändernde Werte

// Schlecht – enthält dynamischen Wert
cell.accessibilityIdentifier = "cell-date-\(Date())"

// Gut – statischer Identifier
cell.accessibilityIdentifier = "cell-date"

❌ Abfragen sind zu spezifisch

// Schlecht – bricht bei Layoutänderungen
app.buttons.element(boundBy: 2).tap()

// Gut – beschreibende Abfrage
app.buttons["submitButton"].tap()

❌ Test ist an ein Gerät gebunden

// Schlecht – nimmt bestimmte Gerätegröße an
XCTAssertEqual(app.buttons["submitButton"].frame.width, 100)

// Gut – testet Vorhandensein, nicht Größe
XCTAssertTrue(app.buttons["submitButton"].exists)

❌ Keine Behandlung von Systemdialogen

// Schlecht – geht davon aus, dass kein Dialog kommt
app.buttons["Allow"].tap()

// Gut – behandelt Dialog
addUIInterruptionMonitor(withDescription: "Berechtigung") { alert in
    alert.buttons["Erlauben"].tap()
    return true
}
app.buttons["Standort anfordern"].tap()
app.tap()  // Erforderlich, um Interruptionsmonitor auszulösen

Leistung der Aufzeichnung optimieren

Debug-Navigator für UI-Tests:

  • Öffnen: Befehl + 7
  • Wählen Sie den Test aus, den Sie ausführen möchten
  • Verwenden Sie das Zeitleisten-Panel zum Anzeigen von:
    • Testausführungszeit
    • Speichernutzung
    • CPU-Auslastung

Optimierungstipps:

  • Reduzieren Sie die Anzahl der Screenshots während des Tests
  • Verwenden Sie kürzere Timeouts, wo es sinnvoll ist
  • Vermeiden Sie unnötige Wartezeiten zwischen Aktionen
  • Testen Sie auf der langsamsten unterstützten Hardware für Realitätsnähe

Referenz: XCTest-Funktionen

FunktionZweckBeispiel
waitForExistence(timeout:)Auf das Erscheinen eines Elements wartenbutton.waitForExistence(timeout: 5)
XCTNSPredicateExpectation(predicate:object:)Auf eine Bedingung wartenNSPredicate(format: "exists == false")
XCTWaiter().wait(for:timeout:)Mehrere Erwartungen erfüllenXCTWaiter().wait(for: [exp], timeout: 5)
addUIInterruptionMonitor(withDescription:handler:)Systemdialoge behandelnalert.buttons["OK"].tap()
XCTContext.runActivity(named:block:)Testausgabe organisierenXCTContext.runActivity("Schritt 1") { ... }

Schnellstart-Vorlage

import XCTest

class MyAppUITests: XCTestCase {
    let app = XCUIApplication()

    override func setUpWithError() throws {
        continueAfterFailure = false
        app.launchArguments = ["UI-Testing"]
        app.launch()
    }

    func testButtonTap() throws {
        let button = app.buttons["myButton"]
        XCTAssertTrue(button.waitForExistence(timeout: 5))
        button.tap()

        // Ergebnis bestätigen
        let resultLabel = app.staticTexts["result"]
        XCTAssertTrue(resultLabel.exists)
    }

    func testAsyncOperation() throws {
        app.buttons["LoadData"].tap()

        let loading = app.activityIndicators["loading"]
        let finished = NSPredicate(format: "exists == false")
        let expectation = XCTNSPredicateExpectation(predicate: finished, object: loading)
        let result = XCTWaiter().wait(for: [expectation], timeout: 10)
        XCTAssertEqual(result, .completed)
    }
}

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Verwandte Skills