Listes d'Espresso

Espresso propose des mécanismes permettant de faire défiler un élément particulier ou d'agir sur celui-ci pour deux types de listes : les vues d'adaptateur et les vues de recycleur.

Lorsque vous utilisez des listes, en particulier celles créées avec un objet RecyclerView ou AdapterView, la vue qui vous intéresse peut ne pas s'afficher à l'écran, car seul un petit nombre d'enfants sont affichés et recyclés lorsque vous faites défiler l'écran. La méthode scrollTo() ne peut pas être utilisée dans ce cas, car elle nécessite une vue existante.

Interagir avec les éléments de liste d'une vue d'adaptateur

Au lieu d'utiliser la méthode onView(), lancez votre recherche avec onData() et fournissez un outil de mise en correspondance pour les données qui soutiennent la vue que vous souhaitez mettre en correspondance. Espresso se charge de trouver la ligne dans l'objet Adapter et de rendre l'élément visible dans la fenêtre d'affichage.

Mettre en correspondance des données à l'aide d'un outil de mise en correspondance de vues personnalisé

L'activité ci-dessous contient un ListView, qui est soutenu par un SimpleAdapter contenant les données de chaque ligne dans un objet Map<String, Object>.

L'activité &quot;Liste&quot; actuellement affichée à l'écran contient une liste de 23 éléments. Chaque élément comporte un nombre, stocké sous forme de chaîne, mappé à un autre nombre, qui est stocké sous forme d'objet.

Chaque mappage comporte deux entrées : une clé "STR" qui contient une chaîne, telle que "item: x", et une clé "LEN" qui contient un Integer, qui représente la longueur du contenu. Exemple :

{"STR" : "item: 0", "LEN": 7}

Le code d'un clic sur la ligne avec "item: 50" se présente comme suit :

onData(
    allOf(
        `is`(instanceOf(Map::class.java)),
        hasEntry(equalTo("STR"), `is`("item: 50"))
    )
).perform(click())

Notez qu'Espresso fait défiler la liste automatiquement si nécessaire.

Examinons le Matcher<Object> dans onData(). La méthode is(instanceOf(Map.class)) limite la recherche à n'importe quel élément de AdapterView, qui repose sur un objet Map.

Dans notre cas, cet aspect de la requête correspond à chaque ligne de la vue sous forme de liste, mais nous voulons cliquer spécifiquement sur un élément. Nous affinons donc la recherche avec :

hasEntry(equalTo("STR"), `is`("item: 50"))

Ce Matcher<String, Object> correspondra à n'importe quel mappage contenant une entrée avec la clé "STR" et la valeur "item: 50". Comme le code permettant de rechercher cet élément est long et que nous voulons le réutiliser à d'autres endroits, écrivons un outil de mise en correspondance withItemContent personnalisé :

return object : BoundedMatcher<Any, Map<*, *>>(Map::class.java) {
    override fun matchesSafely(map: Map<*, *>): Boolean {
        return hasEntry(equalTo("STR"), itemTextMatcher).matches(map)
    }

    override fun describeTo(description: Description) {
        description.appendText("with item content: ")
        itemTextMatcher.describeTo(description)
    }
}

Vous utilisez un BoundedMatcher comme base pour ne faire correspondre que les objets de type Map. Remplacez la méthode matchesSafely() en insérant l'outil de mise en correspondance trouvé précédemment, puis mettez-le en correspondance avec un Matcher<String> que vous pouvez transmettre en tant qu'argument. Cela vous permet d'appeler withItemContent(equalTo("foo")). Pour plus de concision, vous pouvez créer un autre outil de mise en correspondance qui appelle déjà equalTo() et accepte un objet String :

fun withItemContent(expectedText: String): Matcher<Any> {
    checkNotNull(expectedText)
    return withItemContent(equalTo(expectedText))
}

Le code permettant de cliquer sur l'élément est désormais simple :

onData(withItemContent("item: 50")).perform(click())

Pour obtenir le code complet de ce test, consultez la méthode testClickOnItem50() dans la classe AdapterViewTest et ce comparateur LongListMatchers personnalisé sur GitHub.

Mettre en correspondance une vue enfant spécifique

L'exemple ci-dessus émet un clic au milieu de la ligne entière d'un ListView. Mais que se passe-t-il si nous voulons opérer sur un enfant spécifique de la ligne ? Par exemple, nous souhaitons cliquer sur la deuxième colonne de la ligne de LongListActivity, qui affiche la longueur de chaîne du contenu de la première colonne :

Dans cet exemple, il serait utile d'extraire uniquement la longueur d'un contenu particulier. Ce processus implique de déterminer la valeur de la deuxième colonne d'une ligne.

Il vous suffit d'ajouter une spécification onChildView() à votre implémentation de DataInteraction :

onData(withItemContent("item: 60"))
    .onChildView(withId(R.id.item_size))
    .perform(click())

Interagir avec les éléments de liste RecyclerView

Les objets RecyclerView fonctionnent différemment des objets AdapterView. Par conséquent, onData() ne peut pas être utilisé pour interagir avec eux.

Pour interagir avec les RecyclerViews à l'aide d'Espresso, vous pouvez utiliser le package espresso-contrib, qui contient une collection de RecyclerViewActions pouvant être utilisées pour faire défiler l'écran jusqu'à des positions ou pour effectuer des actions sur des éléments :

  • scrollTo() : fait défiler l'écran jusqu'à la vue correspondante, si elle existe.
  • scrollToHolder() : fait défiler l'écran jusqu'au conteneur de vue correspondant, s'il existe.
  • scrollToPosition() : fait défiler l'écran jusqu'à une position spécifique.
  • actionOnHolderItem() : effectue une action d'affichage sur un conteneur de vue correspondant.
  • actionOnItem() : effectue une action d'affichage sur une vue correspondante.
  • actionOnItemAtPosition() : exécute une ViewAction sur une vue à une position spécifique.

Les extraits suivants présentent quelques exemples de l'exemple RecyclerViewSample :

@Test(expected = PerformException::class)
fun itemWithText_doesNotExist() {
    // Attempt to scroll to an item that contains the special text.
    onView(ViewMatchers.withId(R.id.recyclerView))
        .perform(
            // scrollTo will fail the test if no item matches.
            RecyclerViewActions.scrollTo<RecyclerView.ViewHolder>(
                hasDescendant(withText("not in the list"))
            )
        )
}

@Test fun scrollToItemBelowFold_checkItsText() {
    // First, scroll to the position that needs to be matched and click on it.
    onView(ViewMatchers.withId(R.id.recyclerView))
        .perform(
            RecyclerViewActions.actionOnItemAtPosition(
                ITEM_BELOW_THE_FOLD,
                click()
            )
        )

    // Match the text in an item below the fold and check that it's displayed.
    val itemElementText = "${activityRule.activity.resources
        .getString(R.string.item_element_text)} ${ITEM_BELOW_THE_FOLD.toString()}"
    onView(withText(itemElementText)).check(matches(isDisplayed()))
}
@Test fun itemInMiddleOfList_hasSpecialText() {
    // First, scroll to the view holder using the isInTheMiddle() matcher.
    onView(ViewMatchers.withId(R.id.recyclerView))
        .perform(RecyclerViewActions.scrollToHolder(isInTheMiddle()))

    // Check that the item has the special text.
    val middleElementText = activityRule.activity.resources
            .getString(R.string.middle)
    onView(withText(middleElementText)).check(matches(isDisplayed()))
}

Ressources supplémentaires

Pour en savoir plus sur l'utilisation des listes Espresso dans les tests Android, consultez les ressources suivantes.

Exemples

  • DataAdapterSample : présente le point d'entrée onData() pour Espresso, pour les listes et les objets AdapterView.