API de test

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

• Les outils de recherche vous permettent de sélectionner un ou plusieurs éléments (ou nœuds dans le arborescence sémantique) pour effectuer des assertions ou effectuer des actions sur celles-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 à une ou plusieurs nœuds dans l'arborescence sémantique.

Remarque :Tester une interface utilisateur Compose est différent du test d'une interface utilisateur basée sur les vues. La un kit d'interface utilisateur basé sur les vues définit clairement ce qu'est une vue. Une vue occupe d’espace rectangulaire et a des propriétés, telles que les identifiants, la position, la marge et marge intérieure. Dans Compose, car seuls certains composables émettent une UI dans l'UI vous avez besoin d'une approche différente pour faire correspondre les éléments d'UI.

Outils de recherche

Vous pouvez utiliser onNode et onAllNodes pour sélectionner un ou plusieurs nœuds respectivement, mais vous pouvez également utiliser des outils de recherche de commodité recherches, comme onNodeWithText, et onNodeWithContentDescription. Vous pouvez parcourir la liste complète dans le 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 Un bouton comportant deux éléments de texte fusionne les libellés des éléments textuels:

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, ici il est 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 un ou plusieurs outils de mise en correspondance:

// 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 de commodité 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()

Remarque :Vous ne pouvez pas associer des actions dans une fonction d'exécution. Créez 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

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

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 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: les principaux tests Android page de destination offre une vue d'ensemble des principes de base et des techniques de test.
• Principes de base des tests:en savoir plus sur les concepts fondamentaux des tests d'une application Android.
• Tests en local:vous pouvez exécuter des tests. localement, sur votre propre poste de travail.
• Tests d'instrumentation:bon entraînez-vous à exécuter également des tests d'instrumentation. Autrement dit, les 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 déploiement pipeline.
• Testez différentes tailles d'écran:avec de nombreux appareils mis à la disposition des utilisateurs, vous devez les tester pour différents écrans différentes tailles d'écran.
• Espresso: bien qu'il soit destiné aux modèles basés sur les vues IU, la connaissance d'Espresso peut être utile pour certains aspects de Compose. tests.