API de prueba

Hay tres formas principales de interactuar con los elementos de la IU:

  • Los buscadores te permiten seleccionar uno o varios elementos (o nodos en la árbol semántico) para realizar aserciones o acciones sobre ellas.
  • Las aserciones se usan para verificar que los elementos existan o tengan determinados atributos.
  • Las acciones insertan eventos simulados del usuario en los elementos, como clics u otros gestos.

Algunas de estas APIs aceptan un SemanticsMatcher para hacer referencia a uno o más. nodos en el árbol semántico.

Buscadores

Puedes usar onNode y onAllNodes para seleccionar uno o varios nodos respectivamente, pero también puedes usar buscadores de conveniencia búsquedas, como onNodeWithText, y onNodeWithContentDescription. Puedes explorar la lista completa en la Hoja de referencia de pruebas de Compose.

Seleccionar un solo nodo

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

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

Para seleccionar varios nodos

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

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

Árbol separado

Algunos nodos combinan la información semántica de sus elementos secundarios. Por ejemplo, un botón con dos elementos de texto combina las etiquetas de cada uno de ellos:

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

En una prueba, usa printToLog() para mostrar el árbol semántico:

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

Este código muestra el siguiente resultado:

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

Si necesitas vincular un nodo de lo que sería el árbol separado, puedes configurar useUnmergedTree como true:

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

Este código muestra el siguiente resultado:

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]'

El parámetro useUnmergedTree está disponible en todos los buscadores. Por ejemplo, aquí se usa en un buscador onNodeWithText.

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

Aserciones

Llama a assert() en SemanticsNodeInteraction para verificar las aserciones. El buscador muestra uno o varios comparadores:

// 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"))

También puedes usar funciones útiles para las aserciones más comunes, como assertExists, assertIsDisplayed y assertTextEquals. Puedes explorar la lista completa en la hoja de referencia para pruebas de Compose.

También existen funciones para verificar aserciones en una colección de nodos:

// 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())

Acciones

Para insertar una acción en un nodo, llama a una función perform…():

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

Estos son algunos ejemplos de acciones:

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

Puedes consultar la lista completa en la hoja de referencia para pruebas de Compose.

Comparadores

Hay una variedad de comparadores disponibles para probar tu Compose. código.

Comparadores jerárquicos

Los comparadores jerárquicos te permiten subir o bajar por el árbol semántico y realizar que coinciden con la búsqueda.

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

Estos son algunos ejemplos de cómo se usan esos comparadores:

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

Selectores

Otra forma de crear pruebas es usar selectores, que pueden hacer que algunas pruebas sean más legibles.

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

Puedes explorar la lista completa en la hoja de referencia para pruebas de Compose.

Recursos adicionales

  • Cómo probar apps en Android: Las pruebas principales de Android proporciona una visión más amplia de los fundamentos y las técnicas de prueba.
  • Aspectos básicos de las pruebas: Más información sobre los conceptos básicos de prueba de una app para Android.
  • Pruebas locales: Puedes ejecutar algunas pruebas. de forma local, en tu propia estación de trabajo.
  • Pruebas instrumentadas: Es bueno. practicar para ejecutar también pruebas de instrumentación. Es decir, las pruebas que se ejecutan directamente en el dispositivo.
  • Integración continua: La integración continua te permite integrar las pruebas en tu implementación. en una canalización de integración continua.
  • Prueba diferentes tamaños de pantalla: algunos dispositivos disponibles para los usuarios, debes probar diferentes pantallas tamaños.
  • Espresso: Aunque está diseñado para objetos View basados en IUs y el conocimiento de Espresso puede ser útil para algunos aspectos de Compose. y pruebas.