Cette page a été traduite par l'API Cloud Translation.

API de test

Il existe trois façons principales d'interagir avec les éléments de l'interface utilisateur:

Les Finders vous permettent de sélectionner un ou plusieurs éléments (ou nœuds de l'arborescence sémantique) pour effectuer des assertions ou effectuer des actions sur ceux-ci.
Les assertions permettent de vérifier que les éléments existent ou qu'ils possèdent certains attributs.
Les actions ajoutent des événements utilisateur simulés sur les éléments tels que des clics ou d'autres gestes.

Certaines de ces API acceptent un SemanticsMatcher pour faire référence à un ou plusieurs nœuds de l'arborescence sémantique.

Outils de recherche

Vous pouvez utiliser onNode et onAllNodes pour sélectionner un ou plusieurs nœuds, mais vous pouvez également utiliser des outils de recherche pour les recherches les plus courantes, tels que onNodeWithText et onNodeWithContentDescription. Vous pouvez consulter la liste complète dans l'aide-mémoire pour les tests Compose.

Sélectionner un seul nœud

composeTestRule.onNode(<<SemanticsMatcher>>, useUnmergedTree = false): SemanticsNodeInteraction

// Example
composeTestRule
    .onNode(hasText("Button")) // Equivalent to onNodeWithText("Button")

Sélectionner plusieurs nœuds

composeTestRule
    .onAllNodes(<<SemanticsMatcher>>): SemanticsNodeInteractionCollection

// Example
composeTestRule
    .onAllNodes(hasText("Button")) // Equivalent to onAllNodesWithText("Button")

Arborescence non fusionnée

Certains nœuds fusionnent les informations sémantiques de leurs enfants. Par exemple, un bouton avec deux éléments de texte fusionne les libellés d'éléments de texte:

MyButton {
    Text("Hello")
    Text("World")
}

À partir d'un test, utilisez printToLog() pour afficher l'arborescence sémantique:

composeTestRule.onRoot().printToLog("TAG")

Ce code imprime le résultat suivant :

Node #1 at (...)px
 |-Node #2 at (...)px
   Role = 'Button'
   Text = '[Hello, World]'
   Actions = [OnClick, GetTextLayoutResult]
   MergeDescendants = 'true'

Si vous devez faire correspondre un nœud de l'arborescence non fusionnée, vous pouvez définir useUnmergedTree sur true :

composeTestRule.onRoot(useUnmergedTree = true).printToLog("TAG")

Ce code imprime le résultat suivant :

Node #1 at (...)px
 |-Node #2 at (...)px
   OnClick = '...'
   MergeDescendants = 'true'
    |-Node #3 at (...)px
    | Text = '[Hello]'
    |-Node #5 at (83.0, 86.0, 191.0, 135.0)px
      Text = '[World]'

Le paramètre useUnmergedTree est disponible dans tous les outils de recherche. Par exemple, il est ici utilisé dans un outil de recherche onNodeWithText.

composeTestRule
    .onNodeWithText("World", useUnmergedTree = true).assertIsDisplayed()

Assertions

Vérifiez les assertions en appelant assert() sur le SemanticsNodeInteraction renvoyé par un outil de recherche avec une ou plusieurs correspondances:

// Single matcher:
composeTestRule
    .onNode(matcher)
    .assert(hasText("Button")) // hasText is a SemanticsMatcher

// Multiple matchers can use and / or
composeTestRule
    .onNode(matcher).assert(hasText("Button") or hasText("Button2"))

Vous pouvez également utiliser des fonctions pratiques pour les assertions les plus courantes, telles que assertExists, assertIsDisplayed et assertTextEquals. Vous pouvez consulter la liste complète dans l'aide-mémoire pour les tests Compose.

Il existe aussi des fonctions permettant de vérifier les assertions sur un ensemble de nœuds :

// Check number of matched nodes
composeTestRule
    .onAllNodesWithContentDescription("Beatle").assertCountEquals(4)
// At least one matches
composeTestRule
    .onAllNodesWithContentDescription("Beatle").assertAny(hasTestTag("Drummer"))
// All of them match
composeTestRule
    .onAllNodesWithContentDescription("Beatle").assertAll(hasClickAction())

Actions

Pour ajouter une action sur un nœud, appelez une fonction perform…() :

composeTestRule.onNode(...).performClick()

Voici quelques exemples d'actions :

performClick(),
performSemanticsAction(key),
performKeyPress(keyEvent),
performGesture { swipeLeft() }

Retrouvez-en la liste complète dans l'aide-mémoire pour les tests Compose.

Outils de mise en correspondance

Divers outils de mise en correspondance sont disponibles pour tester votre code Compose.

Outils de mise en correspondance hiérarchique

Les outils de mise en correspondance hiérarchique vous permettent de monter ou de descendre dans l'arborescence sémantique et d'effectuer la mise en correspondance.

fun hasParent(matcher: SemanticsMatcher): SemanticsMatcher
fun hasAnySibling(matcher: SemanticsMatcher): SemanticsMatcher
fun hasAnyAncestor(matcher: SemanticsMatcher): SemanticsMatcher
fun hasAnyDescendant(matcher: SemanticsMatcher):  SemanticsMatcher

Voici quelques exemples de mise en correspondance :

composeTestRule.onNode(hasParent(hasText("Button")))
    .assertIsDisplayed()

Sélecteurs

Pour créer des tests, vous pouvez aussi utiliser des sélecteurs, qui permettent de les rendre plus lisibles.

composeTestRule.onNode(hasTestTag("Players"))
    .onChildren()
    .filter(hasClickAction())
    .assertCountEquals(4)
    .onFirst()
    .assert(hasText("John"))

Vous pouvez consulter la liste complète dans l'aide-mémoire pour les tests Compose.

Autres ressources

Tester des applications sur Android: la page de destination principale de test Android offre une vue plus large des principes de base et des techniques de test.
Principes de base des tests:découvrez les concepts fondamentaux qui sous-tendent les tests d'une application Android.
Tests locaux:vous pouvez exécuter certains tests en local, sur votre propre poste de travail.
Tests d'instrumentation:il est recommandé d'exécuter également des tests d'instrumentation. c'est-à-dire des tests qui s'exécutent directement sur l'appareil.
Intégration continue:l'intégration continue vous permet d'intégrer vos tests dans votre pipeline de déploiement.
Testez différentes tailles d'écran:étant donné que de nombreux appareils sont disponibles pour les utilisateurs, vous devez tester différentes tailles d'écran.
Espresso: bien qu'il soit destiné aux UI basées sur les vues, la connaissance d'Espresso peut toujours être utile pour certains aspects des tests Compose.