Communitygithub.com

ComeOnOliver/skillshub

À utiliser lors de l'écriture de tests d'interface utilisateur, de l'enregistrement d'interactions, en présence de conditions de course, de dépendances temporelles, de comportements de réussite/échec incohérents, ou de tests UI XCTest instables. Couvre l'automatisation UI enregistrée (WWDC 2025), l'attente conditionnelle, le conditionnement réseau, les tests multi-facteurs, le débogage de crash et les schémas de test axés sur l'accessibilité.

Qu'est-ce que skillshub ?

Cette compétence résout le problème fondamental des tests UI instables (flaky) en remplaçant les délais d'attente arbitraires (`sleep`) par des attentes basées sur des conditions réelles via les API de XCTest comme `waitForExistence`, `XCTNSPredicateExpectation` et `XCTWaiter`. Elle introduit les nouveautés de Xcode 26 (WWDC 2025) : la fonctionnalité d'enregistrement et de relecture vidéo des interactions UI, permettant de capturer des tests en Swift, de les rejouer sur plusieurs appareils et langues, et de déboguer les échecs via des enregistrements vidéo. La compétence couvre six schémas pratiques (attente d'élément, disparition, état, identifiants d'accessibilité, délais réseau, animations), une checklist de fiabilité, et des conseils pour les arguments de lancement et le débogage. Elle s'appuie sur le framework d'accessibilité comme fondation : utiliser des identifiants uniques et stables (non localisés) garantit des tests robustes sur toutes les plateformes Apple (iOS, iPadOS, macOS, watchOS, tvOS, visionOS). L'impact mesuré montre une réduction du temps de la suite de tests de 15 à 5 minutes et un taux d'échec instable passant de 20% à moins de 2%.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Tests UI

Aperçu

Attendez des conditions, pas des délais arbitraires. Principe fondamental Les tests instables proviennent de suppositions sur la durée des opérations. L'attente conditionnelle élimine les conditions de course.

NOUVEAU dans WWDC 2025 : L'automatisation UI enregistrée vous permet d'enregistrer des interactions, de les rejouer sur plusieurs appareils/langues, et de visionner les enregistrements vidéo des exécutions de tests.

Exemples de Prompts

Voici des questions réelles que les développeurs posent et auxquelles cette compétence est conçue pour répondre :

1. "Mes tests UI passent localement sur mon Mac mais échouent dans le CI. Comment les rendre plus fiables ?"

→ La compétence montre des schémas d'attente conditionnelle qui fonctionnent sur tous les appareils/vitesses, éliminant les différences de timing du CI

2. "Mes tests utilisent sleep(2) et sleep(5) mais ils restent instables. Comment remplacer les délais arbitraires par des conditions réelles ?"

→ La compétence démontre waitForExistence, XCTestExpectation, et les schémas de scrutation pour les chargements de données, les requêtes réseau et les animations

3. "Je viens d'enregistrer un test avec l'automatisation UI enregistrée de Xcode 26. Comment puis-je visionner la vidéo et déboguer les échecs ?"

→ La compétence couvre les flux de travail de débogage vidéo pour analyser les enregistrements et trouver l'étape exacte où les tests échouent

4. "Mon test échoue sur iPad mais réussit sur iPhone. Comment écrire des tests qui fonctionnent sur toutes les tailles d'appareils ?"

→ La compétence explique les stratégies de test multi-facteurs et les prédicats indépendants de l'appareil pour des tests multi-appareils robustes

5. "Je veux écrire des tests qui ne sont pas instables. Quels sont les schémas critiques à connaître ?"

→ La compétence fournit des modèles d'attente conditionnelle, des schémas axés sur l'accessibilité, et l'arbre de décision pour une architecture de test fiable


Drapeaux Rouges — Problèmes de Fiabilité des Tests

Si vous voyez L'UN DE CES SIGNES, suspectez des problèmes de timing :

  • Les tests passent localement, échouent dans le CI (différences de timing)
  • Les tests réussissent parfois, échouent parfois (conditions de course)
  • Les tests utilisent sleep() ou Thread.sleep() (délais arbitraires)
  • Les tests échouent avec "élément UI non trouvé" puis passent après une nouvelle tentative
  • Exécutions de tests longues (attente des scénarios les pires)

Arbre de Décision Rapide

Test échoue ?
├─ Élément non trouvé ?
│  └─ Utilisez waitForExistence(timeout:) pas sleep()
├─ Passe localement, échoue CI ?
│  └─ Remplacez sleep() par une scrutation conditionnelle
├─ L'animation cause des problèmes ?
│  └─ Attendez la fin de l'animation, ne la désactivez pas
└─ Timing de requête réseau ?
   └─ Utilisez XCTestExpectation ou waitForExistence

Schéma de Base : Attente Conditionnelle

❌ INCORRECT (Délai Arbitraire) :

func testButtonAppears() {
    app.buttons["Login"].tap()
    sleep(2)  // ❌ On suppose que cela prend 2 secondes
    XCTAssertTrue(app.buttons["Dashboard"].exists)
}

✅ CORRECT (Attendre une Condition) :

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

Schémas Courants de Tests UI

Schéma 1 : Attente d'Éléments

// Attendre qu'un élément apparaisse
func waitForElement(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
    return element.waitForExistence(timeout: timeout)
}

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

Schéma 2 : Attente de Disparition d'un Élément

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
}

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

Schéma 3 : Attente d'un État Spécifique

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
}

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

Schéma 4 : Identifiants d'Accessibilité

Définir dans l'application :

Button("Soumettre") {
    // action
}
.accessibilityIdentifier("submitButton")

Utiliser dans les tests :

func testSubmitButton() {
    let submitButton = app.buttons["submitButton"]  // Utilise l'identifiant, pas le libellé
    XCTAssertTrue(submitButton.waitForExistence(timeout: 5))
    submitButton.tap()
}

Pourquoi : Les identifiants d'accessibilité ne changent pas avec la localisation, restent stables lors des mises à jour UI.

Schéma 5 : Délais de Requêtes Réseau

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

    // Attendre que l'indicateur de chargement disparaisse
    let loadingIndicator = app.activityIndicators["Loading"]
    XCTAssertTrue(waitForElementToDisappear(loadingIndicator, timeout: 10))

    // Maintenant vérifier que les données sont chargées
    XCTAssertTrue(app.cells.count > 0)
}

Schéma 6 : Gestion des Animations

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

    // Attendre que la vue de destination apparaisse
    let destinationView = app.otherElements["DestinationView"]
    XCTAssertTrue(destinationView.waitForExistence(timeout: 2))

    // Optionnel : Attendre un peu plus pour que l'animation se stabilise
    // Seulement si absolument nécessaire
    RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.3))
}

Liste de Vérification des Tests

Avant d'Écrire les Tests

  • Utiliser des identifiants d'accessibilité pour tous les éléments interactifs
  • Éviter les libellés codés en dur (utiliser plutôt des identifiants)
  • Prévoir les délais réseau et les animations
  • Choisir des délais d'attente appropriés (2s UI, 10s réseau)

Lors de l'Écriture des Tests

  • Utiliser waitForExistence() pas sleep()
  • Utiliser des prédicats pour les conditions complexes
  • Tester à la fois les chemins de succès et d'échec
  • Rendre les tests indépendants (peuvent s'exécuter dans n'importe quel ordre)

Après l'Écriture des Tests

  • Exécuter les tests 10 fois localement (détecter l'instabilité)
  • Exécuter les tests sur l'appareil supporté le plus lent
  • Exécuter les tests dans l'environnement CI
  • Vérifier la durée des tests (si >30s par test, optimiser)

Astuces pour les Tests UI Xcode

Arguments de Lancement pour les Tests

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

Dans le code de l'application :

if ProcessInfo.processInfo.arguments.contains("UI-Testing") {
    // Utiliser des données mock, ignorer l'onboarding, etc.
}

Exécution Plus Rapide des Tests

override func setUpWithError() throws {
    continueAfterFailure = false  // Arrêter au premier échec
}

Débogage des Tests en Échec

func testExample() {
    // Prendre une capture d'écran en cas d'échec
    addUIInterruptionMonitor(withDescription: "Alerte") { alert in
        alert.buttons["OK"].tap()
        return true
    }

    // Afficher la hiérarchie des éléments
    print(app.debugDescription)
}

Erreurs Courantes

❌ Utiliser sleep() pour Tout

sleep(5)  // ❌ Perd du temps si l'opération se termine en 1s

❌ Ne Pas Gérer les Animations

app.buttons["Next"].tap()
XCTAssertTrue(app.buttons["Back"].exists)  // ❌ Peut échouer pendant l'animation

❌ Libellés de Texte Codés en Dur

app.buttons["Submit"].tap()  // ❌ Casse avec la localisation

❌ Tests Dépendants les Uns des Autres

// ❌ Le test 2 suppose que le test 1 a été exécuté en premier
func test1_Login() { /* ... */ }
func test2_ViewDashboard() { /* suppose connecté */ }

❌ Absence de Stratégie de Délai d'Attente

element.waitForExistence(timeout: 100)  // ❌ Trop long
element.waitForExistence(timeout: 0.1)  // ❌ Trop court

Utiliser des délais d'attente appropriés :

  • Animations UI : 2-3 secondes
  • Requêtes réseau : 10 secondes
  • Opérations complexes : 30 secondes maximum

Impact dans le Monde Réel

Avant (en utilisant sleep()) :

  • Suite de tests : 15 minutes (attente du pire scénario)
  • Tests instables : 20% de taux d'échec
  • Échecs CI : 50% nécessitent une nouvelle tentative

Après (attente conditionnelle) :

  • Suite de tests : 5 minutes (attend uniquement si nécessaire)
  • Tests instables : <2% de taux d'échec
  • Échecs CI : <5% nécessitent une nouvelle tentative

Point clé Les tests se terminent plus rapidement ET sont plus fiables lorsqu'on attend des conditions réelles au lieu de deviner des temps.


Automatisation UI Enregistrée

Aperçu

NOUVEAU dans Xcode 26 : Enregistrez, rejouez et révisez les tests d'automatisation UI avec des enregistrements vidéo.

Trois Phases :

  1. Enregistrer — Capturer les interactions (tap, balayages, pressions de boutons matériels) sous forme de code Swift
  2. Rejouer — Exécuter sur plusieurs appareils, langues, régions, orientations
  3. Réviser — Regarder les enregistrements vidéo, analyser les échecs, voir les superpositions d'éléments UI

Plateformes Supportées : iOS, iPadOS, macOS, watchOS, tvOS, axiom-visionOS (Conçu pour iPad)

Comment Fonctionne l'Automatisation UI

Principes Clés :

  • L'automatisation UI interagit avec votre application comme le ferait une personne en utilisant des gestes et des événements matériels
  • Fonctionne complètement indépendamment de votre application (les modèles/données de l'application ne sont pas directement accessibles)
  • Utilise le framework d'accessibilité comme technologie sous-jacente
  • Indique au système d'exploitation quels gestes effectuer, puis attend la fin de manière synchrone un par un

Les actions incluent :

  • Lancer votre application
  • Interagir avec les boutons et la navigation
  • Définir l'état du système (Mode sombre, axiom-localization, etc.)
  • Définir une localisation simulée

L'Accessibilité est le Fondement

Compréhension Critique : L'accessibilité fournit directement les informations à l'automatisation UI.

Ce que voit l'accessibilité :

  • Types d'éléments (bouton, texte, image, etc.)
  • Libellés (texte visible)
  • Valeurs (état actuel pour les cases à cocher, etc.)
  • Cadres (positions des éléments)
  • Identifiants (identifiants d'accessibilité — PAS localisés)

Bonne Pratique : Une excellente expérience d'accessibilité = une excellente expérience d'automatisation UI.

Préparer Votre Application pour l'Enregistrement

Étape 1 : Ajouter des Identifiants d'Accessibilité

SwiftUI :

Button("Soumettre") {
    // action
}
.accessibilityIdentifier("submitButton")

// Rendre les identifiants spécifiques à l'instance
List(landmarks) { landmark in
    LandmarkRow(landmark)
        .accessibilityIdentifier("landmark-\(landmark.id)")
}

UIKit :

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

// Utiliser l'index pour les cellules de table
cell.accessibilityIdentifier = "cell-\(indexPath.row)"

Les bons identifiants sont :

  • ✅ Uniques dans toute l'application
  • ✅ Descriptifs du contenu de l'élément
  • ✅ Statiques (ne réagissent pas aux changements de contenu)
  • ✅ Non localisés (identiques dans toutes les langues)

Pourquoi les identifiants sont importants :

  • Les titres/descriptions peuvent changer, les identifiants restent stables
  • Fonctionnent avec les chaînes localisées
  • Identifient de manière unique les éléments avec du contenu dynamique

Conseil Pro : Utilisez l'assistant de codage Xcode pour ajouter des identifiants :

Invite : "Ajouter des identifiants d'accessibilité aux parties pertinentes de cette vue"

Étape 2 : Réviser l'Accessibilité avec l'Inspecteur d'Accessibilité

Lancer l'Inspecteur d'Accessibilité :

  • Menu Xcode → Ouvrir Outil Développeur → Inspecteur d'Accessibilité
  • Ou : Lancer depuis Spotlight

Fonctionnalités :

  1. Inspecteur d'Éléments — Liste des valeurs d'accessibilité pour n'importe quelle vue
  2. Détails des propriétés — Cliquer sur le nom d'une propriété pour obtenir la documentation
  3. Support des plateformes — Fonctionne sur toutes les plateformes Apple

Ce qu'il faut vérifier :

  • Les éléments ont des libellés
  • Les éléments interactifs ont des types (bouton, pas seulement du texte)
  • Les valeurs sont définies pour les éléments avec état (cases à cocher, bascules)
  • Les identifiants sont définis pour les éléments avec du contenu dynamique/localisé

Référence d'exemple de code : Offrir une expérience d'accessibilité exceptionnelle

Étape 3 : Ajouter une Cible de Test UI

  1. Ouvrir les paramètres du projet dans Xcode
  2. Cliquer "+" sous la liste des cibles
  3. Sélectionner UI Testing Bundle
  4. Cliquer sur Terminé

Résultat : Un nouveau dossier de test UI avec des tests modèles est ajouté au projet.

Enregistrer des Interactions

Démarrer un Enregistrement (Xcode 26)

  1. Ouvrir le fichier source du test UI
  2. Une popup apparaît expliquant comment démarrer l'enregistrement (première fois uniquement)
  3. Cliquer sur le bouton "Démarrer l'enregistrement" dans la gouttière de l'éditeur
  4. Xcode construit et lance l'application dans le Simulateur/sur l'appareil

Pendant l'enregistrement :

  • Interagir avec l'application normalement (tap, balayages, saisie de texte, etc.)
  • Le code représentant les interactions apparaît dans l'éditeur source en temps réel
  • L'enregistrement se met à jour au fur et à mesure que vous tapez (par exemple, les saisies dans les champs de texte)

Arrêter l'enregistrement :

  • Cliquer sur le bouton "Arrêter l'exécution" dans Xcode

Exemple de Session d'Enregistrement

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

    // Appuyer sur l'onglet "Collections" (enregistré automatiquement)
    app.tabBars.buttons["Collections"].tap()

    // Appuyer sur "+" pour ajouter une nouvelle collection
    app.navigationBars.buttons["Add"].tap()

    // Appuyer sur le bouton "Edit"
    app.buttons["Edit"].tap()

    // Saisir le nom de la collection
    app.textFields.firstMatch.tap()
    app.textFields.firstMatch.typeText("Max's Australian Adventure")

    // Appuyer sur "Edit Landmarks"
    app.buttons["Edit Landmarks"].tap()

    // Ajouter des points de repère
    app.tables.cells.containing(.staticText, identifier:"Great Barrier Reef").buttons["Add"].tap()
    app.tables.cells.containing(.staticText, identifier:"Uluru").buttons["Add"].tap()

    // Appuyer sur la coche pour sauvegarder
    app.navigationBars.buttons["Done"].tap()
}

Réviser le Code Enregistré

Après l'enregistrement, réviser et ajuster les requêtes :

Options Multiples : Chaque ligne a un menu déroulant montrant des manières alternatives de cibler l'élément.

Recommandations de Sélection :

  1. Pour les chaînes localisées (texte, libellés de boutons) : Choisir l'identifiant d'accessibilité s'il est disponible
  2. Pour les vues profondément imbriquées : Choisir la requête la plus courte (reste résiliente lorsque l'application change)
  3. Pour le contenu dynamique (horodatages, température) : Utiliser une requête générique ou un identifiant

Exemple :

// Options enregistrées pour le champ de texte :
app.textFields["Collection Name"]              // ❌ Casse si le libellé se localise
app.textFields["collectionNameField"]          // ✅ Utilise l'identifiant
app.textFields.element(boundBy: 0)             // ✅ Basé sur la position
app.textFields.firstMatch                      // ✅ Générique, le plus court

...

[Le reste du contenu a été tronqué pour la traduction]

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

Skills associés