Communitygithub.com

ComeOnOliver/skillshub

Verwenden Sie dieses Skill, um UI-Testaufzeichnungen in Xcode 26 einzurichten, aufgenommene Tests für Stabilität zu verbessern oder Testpläne für Multi-Konfigurations-Wiedergaben zu konfigurieren. Basierend auf der WWDC 2025-344 „Record, replay, and review“.

Was ist skillshub?

Dieser Skill bietet eine umfassende Anleitung zur UI-Automatisierungsaufzeichnung in Xcode 26 und neueren Versionen. Er beschreibt den dreiphasigen Workflow aus Aufzeichnen, Wiedergeben und Überprüfen, der es Entwicklern ermöglicht, UI-Tests durch einfache Benutzerinteraktionen im Simulator zu erstellen. Der Skill erklärt detailliert, wie aufgezeichnete Code-Snippets für mehr Stabilität optimiert werden können, insbesondere durch die Verwendung von `accessibilityIdentifier`, `waitForExistence` und klaren Assertions, anstatt sich auf fragile Labels oder `sleep()`-Aufrufe zu verlassen. Darüber hinaus wird die Erstellung und Verwendung von Testplänen für Multi-Konfigurations-Tests (z. B. verschiedene Sprachen, Regionen oder Darstellungsmodi) sowie die Analyse von Testergebnissen mit Videoaufzeichnungen und Screenshots behandelt. Der Skill eignet sich für alle, die UI-Tests in Xcode effizienter gestalten und in CI/CD-Umgebungen stabil halten möchten.

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

In Ihrer bevorzugten KI fragen

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

Dokumentation

UI-Automatisierung aufzeichnen (Xcode 26+)

Anleitung zur Aufzeichnungsfunktion für UI-Automatisierung in Xcode 26 zum Erstellen von UI-Tests durch Benutzerinteraktionsaufzeichnung.

Der Dreiphasen-Workflow

Aus WWDC 2025-344:

┌─────────────────────────────────────────────────────────────┐
│                  UI-Automatisierungs-Workflow               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. AUFZEICHNEN ──► Mit App im Simulator interagieren       │
│                    Xcode erfasst als Swift-Testcode         │
│                                                             │
│  2. WIEDERGEBEN ──► Auf verschiedenen Geräten,              │
│                    Sprachen und Konfigurationen ausführen   │
│                    Mit Testplänen für Multi-Konfiguration   │
│                                                             │
│  3. ÜBERPRÜFEN ──► Videoaufzeichnungen im Testbericht       │
│                    ansehen und Fehler mit Screenshots       │
│                    analysieren                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Phase 1: Aufzeichnen

Aufzeichnung starten

  1. Öffnen Sie Ihre UI-Testdatei in Xcode
  2. Platzieren Sie den Cursor innerhalb einer Testmethode
  3. Debug → UI-Automatisierung aufzeichnen (oder den Aufnahmebutton verwenden)
  4. Die App wird im Simulator gestartet
  5. Führen Sie Interaktionen durch – Xcode generiert Code
  6. Stoppen Sie die Aufzeichnung, wenn Sie fertig sind

Was wird aufgezeichnet

  • Tippen auf Buttons, Zellen, Steuerelemente
  • Texteingabe in Textfelder
  • Wischen und Scrollen
  • Gesten (Zusammenziehen, Drehen)
  • Hardware-Tastendrücke (Home, Lautstärke)

Beispiel für generierten Code

// Xcode generiert diesen Code aus Ihren Interaktionen
func testLoginFlow() {
    let app = XCUIApplication()
    app.launch()

    // Aufgezeichnet: E-Mail-Feld antippen, E-Mail eingeben
    app.textFields["Email"].tap()
    app.textFields["Email"].typeText("[email protected]")

    // Aufgezeichnet: Passwortfeld antippen, Passwort eingeben
    app.secureTextFields["Password"].tap()
    app.secureTextFields["Password"].typeText("password123")

    // Aufgezeichnet: Login-Button antippen
    app.buttons["Login"].tap()
}

Aufgezeichneten Code verbessern

Wichtig: Aufgezeichneter Code ist oft instabil. Verbessern Sie ihn immer für Stabilität.

1. Accessibility-Identifier hinzufügen

Aufgezeichneter Code verwendet Labels, die bei Lokalisierung brechen:

// AUFGEZEICHNET (instabil – bricht bei Lokalisierung)
app.buttons["Login"].tap()

// VERBESSERT (stabil – verwendet Identifier)
app.buttons["loginButton"].tap()

Fügen Sie Identifier in Ihrem App-Code hinzu:

// SwiftUI
Button("Login") { ... }
    .accessibilityIdentifier("loginButton")

// UIKit
loginButton.accessibilityIdentifier = "loginButton"

2. waitForExistence hinzufügen

Aufgezeichneter Code geht davon aus, dass Elemente sofort existieren:

// AUFGEZEICHNET (kann fehlschlagen, wenn App langsam ist)
app.buttons["Login"].tap()

// VERBESSERT (wartet auf Element)
let loginButton = app.buttons["loginButton"]
XCTAssertTrue(loginButton.waitForExistence(timeout: 5))
loginButton.tap()

3. Assertions hinzufügen

Aufgezeichneter Code führt nur Aktionen ohne Verifizierung aus:

// AUFGEZEICHNET (keine Verifizierung)
app.buttons["Login"].tap()

// VERBESSERT (mit Assertion)
app.buttons["loginButton"].tap()
let welcomeLabel = app.staticTexts["welcomeLabel"]
XCTAssertTrue(welcomeLabel.waitForExistence(timeout: 10),
              "Willkommensbildschirm sollte nach Login erscheinen")

4. Kürzere Abfragen verwenden

Aufgezeichneter Code kann übermäßig spezifische Abfragen enthalten:

// AUFGEZEICHNET (zu spezifisch)
app.tables.cells.element(boundBy: 0).buttons["Action"].tap()

// VERBESSERT (einfacher)
app.buttons["actionButton"].tap()

Richtlinien zur Abfrageauswahl

Aus WWDC 2025-344:

SzenarioProblemLösung
Lokalisierte Zeichenketten"Login" ändert sich je nach SpracheaccessibilityIdentifier verwenden
Tief verschachtelte AnsichtenLange Abfrageketten brechen leichtKürzestmögliche Abfrage verwenden
Dynamischer InhaltZellinhalt ändert sichIdentifier oder generische Abfrage verwenden
Mehrere TrefferAbfrage gibt viele Elemente zurückEindeutigen Identifier hinzufügen

Best Practices

  1. Identifier Labels vorziehen
  2. Die kürzeste funktionierende Abfrage verwenden
  3. Indexbasierte Abfragen vermeiden (element(boundBy: 0))
  4. Identifier zu dynamischem Inhalt hinzufügen

Phase 2: Wiedergeben mit Testplänen

Testpläne ermöglichen das Ausführen derselben Tests über mehrere Konfigurationen hinweg.

Testplan erstellen

  1. Datei → Neu → Datei → Testplan
  2. Testziele hinzufügen
  3. Konfigurationen konfigurieren

Testplan-Struktur

{
  "configurations": [
    {
      "name": "iPhone - Englisch",
      "options": {
        "targetForVariableExpansion": {
          "containerPath": "container:MyApp.xcodeproj",
          "identifier": "MyApp"
        },
        "language": "en",
        "region": "US"
      }
    },
    {
      "name": "iPhone - Spanisch",
      "options": {
        "language": "es",
        "region": "ES"
      }
    },
    {
      "name": "iPhone - Dunkelmodus",
      "options": {
        "userInterfaceStyle": "dark"
      }
    },
    {
      "name": "iPad - Querformat",
      "options": {
        "defaultTestExecutionTimeAllowance": 120,
        "testTimeoutsEnabled": true
      }
    }
  ],
  "defaultOptions": {
    "targetForVariableExpansion": {
      "containerPath": "container:MyApp.xcodeproj",
      "identifier": "MyApp"
    }
  },
  "testTargets": [
    {
      "target": {
        "containerPath": "container:MyApp.xcodeproj",
        "identifier": "MyAppUITests",
        "name": "MyAppUITests"
      }
    }
  ],
  "version": 1
}

Konfigurationsoptionen

OptionZweck
languageLokalisierung testen
regionRegionale Formatierung testen
userInterfaceStyleDunkel-/Hellmodus testen
targetForVariableExpansionApp-Ziel für Konfiguration
testTimeoutsEnabledTimeout-Erzwingung aktivieren
defaultTestExecutionTimeAllowanceTimeout in Sekunden

Mit Testplan ausführen

# Befehlszeile
xcodebuild test \
  -scheme "MyApp" \
  -testPlan "MyTestPlan" \
  -destination "platform=iOS Simulator,name=iPhone 16" \
  -resultBundlePath /tmp/results.xcresult

# In Xcode
# Produkt → Testplan → Wählen Sie Ihren Plan
# Dann Cmd+U, um Tests auszuführen

Phase 3: Überprüfen

Funktionen des Testberichts

Nach Abschluss der Tests:

  1. Testergebnisse anzeigen im Berichtsnavigator
  2. Videoaufzeichnungen jedes Tests ansehen
  3. Screenshots an Fehlerstellen sehen
  4. Zeitleiste der Aktionen analysieren

Anhänge aktivieren

Im Testplan oder Schema:

"options": {
  "systemAttachmentLifetime": "keepAlways",
  "userAttachmentLifetime": "keepAlways"
}

Benutzerdefinierte Screenshots erfassen

func testCheckout() {
    // ... Aktionen ...

    // Manueller Screenshot zu einem bestimmten Zeitpunkt
    let screenshot = app.screenshot()
    let attachment = XCTAttachment(screenshot: screenshot)
    attachment.name = "Checkout-Bestätigung"
    attachment.lifetime = .keepAlways
    add(attachment)
}

Häufige Muster

Vorlage für Login-Ablauf

func testLoginWithValidCredentials() throws {
    let app = XCUIApplication()
    app.launch()

    // Zum Login navigieren
    let showLoginButton = app.buttons["showLoginButton"]
    XCTAssertTrue(showLoginButton.waitForExistence(timeout: 5))
    showLoginButton.tap()

    // Anmeldedaten eingeben
    let emailField = app.textFields["emailTextField"]
    XCTAssertTrue(emailField.waitForExistence(timeout: 5))
    emailField.tap()
    emailField.typeText("[email protected]")

    let passwordField = app.secureTextFields["passwordTextField"]
    passwordField.tap()
    passwordField.typeText("password123")

    // Absenden
    app.buttons["loginButton"].tap()

    // Erfolg überprüfen
    let welcomeScreen = app.staticTexts["welcomeLabel"]
    XCTAssertTrue(welcomeScreen.waitForExistence(timeout: 10))
}

Vorlage für Navigationsablauf

func testNavigateToSettings() throws {
    let app = XCUIApplication()
    app.launch()

    // Tab-Leiste öffnen
    app.tabBars.buttons["Einstellungen"].tap()

    // Navigation überprüfen
    let settingsTitle = app.navigationBars["Einstellungen"]
    XCTAssertTrue(settingsTitle.waitForExistence(timeout: 5))

    // Tiefer navigieren
    app.tables.cells["Konto"].tap()
    XCTAssertTrue(app.navigationBars["Konto"].exists)
}

Vorlage für Formularvalidierung

func testFormValidation() throws {
    let app = XCUIApplication()
    app.launch()

    // Leeres Formular absenden
    app.buttons["submitButton"].tap()

    // Fehler überprüfen
    let errorAlert = app.alerts["Fehler"]
    XCTAssertTrue(errorAlert.waitForExistence(timeout: 5))
    XCTAssertTrue(errorAlert.staticTexts["Bitte füllen Sie alle Felder aus"].exists)

    // Alert schließen
    errorAlert.buttons["OK"].tap()
}

Fehlerbehebung

Aufzeichnung startet nicht

  1. Stellen Sie sicher, dass Sie sich in einer Testmethode befinden
  2. Überprüfen Sie, ob der Simulator verfügbar ist
  3. Verifizieren Sie, dass die App erstellt und ausgeführt wird
  4. Versuchen Sie, Xcode neu zu starten

Aufgezeichneter Code funktioniert nicht

  1. waitForExistence vor Interaktionen hinzufügen
  2. Überprüfen Sie Accessibility-Identifier sind gesetzt
  3. Vereinfachen Sie Abfragen auf die kürzeste Form
  4. Führen Sie die App manuell aus, um den Ablauf zu überprüfen

Tests bestehen lokal, schlagen in CI fehl

  1. Erhöhen Sie Timeouts für langsamere CI-Maschinen
  2. Fügen Sie explizite Wartezeiten für Animationen hinzu
  3. Überprüfen Sie die Simulator-Konfiguration auf Übereinstimmung
  4. Deaktivieren Sie Animationen im Test-Setup:
    app.launchArguments = ["--disable-animations"]
    

Anti-Patterns

Roh aufgezeichneten Code nicht in CI verwenden

// SCHLECHT – Roh aufgezeichneter Code
app.buttons["Login"].tap()
app.textFields["Email"].typeText("[email protected]")

// GUT – Für CI verbessert
let loginButton = app.buttons["loginButton"]
XCTAssertTrue(loginButton.waitForExistence(timeout: 10))
loginButton.tap()

Koordinaten nicht hartcodieren

// SCHLECHT – Koordinaten aus Aufzeichnung
app.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5)).tap()

// GUT – Elementabfragen verwenden
app.buttons["centerButton"].tap()

Assertions nicht auslassen

// SCHLECHT – Nur Aktionen
app.buttons["Login"].tap()
sleep(2)  // Hoffen, dass es funktioniert

// GUT – Ergebnisse überprüfen
app.buttons["loginButton"].tap()
XCTAssertTrue(app.staticTexts["Willkommen"].waitForExistence(timeout: 10))

Ressourcen

WWDC: 2025-344, 2024-10206, 2019-413

Dokumentation: /xcode/testing/recording-ui-tests, /xctest/xcuiapplication

Skills: axiom-xctest-automation, axiom-ui-testing


Übersetzt aus dem Englischen. Die ursprüngliche Quelle ist die WWDC 2025-344.

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