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()ouThread.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()passleep() - 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 :
- Enregistrer — Capturer les interactions (tap, balayages, pressions de boutons matériels) sous forme de code Swift
- Rejouer — Exécuter sur plusieurs appareils, langues, régions, orientations
- 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 :
- Inspecteur d'Éléments — Liste des valeurs d'accessibilité pour n'importe quelle vue
- Détails des propriétés — Cliquer sur le nom d'une propriété pour obtenir la documentation
- 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
- Ouvrir les paramètres du projet dans Xcode
- Cliquer "+" sous la liste des cibles
- Sélectionner UI Testing Bundle
- 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)
- Ouvrir le fichier source du test UI
- Une popup apparaît expliquant comment démarrer l'enregistrement (première fois uniquement)
- Cliquer sur le bouton "Démarrer l'enregistrement" dans la gouttière de l'éditeur
- 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 :
- Pour les chaînes localisées (texte, libellés de boutons) : Choisir l'identifiant d'accessibilité s'il est disponible
- Pour les vues profondément imbriquées : Choisir la requête la plus courte (reste résiliente lorsque l'application change)
- 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]