API de test

Il existe trois manières principales d'interagir avec les éléments d'interface utilisateur:

• Les outils de recherche permettent de sélectionner un ou plusieurs éléments (ou nœuds de l'arborescence sémantique) pour définir des assertions ou effectuer des actions par rapport à eux.
• 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.

Remarque :Tester une interface utilisateur Compose ne revient pas à tester une interface utilisateur basée sur des vues. Le kit d'interface utilisateur basé sur les vues définit clairement ce qu'est une vue, à savoir un espace rectangulaire qui dispose de propriétés comme les identifiants, la position, la marge et la marge intérieure. Dans Compose, seuls certains composables émettent une interface utilisateur dans la hiérarchie de l'interface utilisateur. Vous devez donc adopter une approche différente pour faire correspondre les éléments d'interface utilisateur.

Outils de recherche

Vous pouvez utiliser onNode et onAllNodes pour sélectionner un ou plusieurs nœuds, mais vous pouvez également utiliser des paramètres de recherche définis pour les recherches les plus courantes, comme 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 étiquettes des é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. Il est par exemple 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 définies pour les assertions les plus courantes, comme assertExists, assertIsDisplayed et assertTextEquals. Retrouvez-en 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()

Remarque :Vous ne pouvez pas associer des actions dans une fonction d'exécution. Effectuez plutôt plusieurs appels perform…().

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

Différents 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 une 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"))

Retrouvez-en 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 des tests Android offre une vue plus large des principes et des techniques de test.
• Principes de base des tests : découvrez les concepts fondamentaux des tests d'une application Android.
• Tests locaux:vous pouvez exécuter certains tests en local, sur votre propre poste de travail.
• Tests instrumentés:il est recommandé d'exécuter également des tests instrumentés. 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 à votre pipeline de déploiement.
• Testez différentes tailles d'écran:avec de nombreux appareils à la disposition des utilisateurs, vous devez tester différentes tailles d'écran.
• Espresso : bien que destiné aux UI basées sur les vues, les connaissances sur Espresso peuvent toujours être utiles pour certains aspects des tests Compose.