Cadre de test Espresso - Architecture

Dans ce chapitre, apprenons les termes du cadre de test espresso, comment écrire un cas de test espresso simple et le flux de travail complet ou l'architecture du cadre de test espresso.

Aperçu

Espresso fournit un grand nombre de classes pour tester l'interface utilisateur et l'interaction utilisateur d'une application Android. Ils peuvent être regroupés en cinq catégories comme spécifié ci-dessous -

Coureur JUnit

Le framework de test Android fournit un runner, AndroidJUnitRunner pour exécuter les cas de test espresso écrits dans les cas de test de style JUnit3 et JUnit4. Il est spécifique à l'application Android et gère de manière transparente le chargement des cas de test espresso et de l'application testée à la fois dans l'appareil réel ou dans l'émulateur, exécute les cas de test et rapporte le résultat des cas de test. Pour utiliser AndroidJUnitRunner dans le cas de test, nous devons annoter la classe de test à l'aide de l'annotation @RunWith, puis transmettre l'argument AndroidJUnitRunner comme spécifié ci-dessous -

@RunWith(AndroidJUnit4.class)
   public class ExampleInstrumentedTest {
}

Règles JUnit

Le framework de test Android fournit une règle, ActivityTestRule pour lancer une activité Android avant d'exécuter les cas de test. Il lance l'activité avant chaque méthode annotée avec @ Test` et @Before. Il mettra fin à l'activité après la méthode annotée avec @After. Un exemple de code est le suivant,

@Rule
public ActivityTestRule<MainActivity> mActivityTestRule = new ActivityTestRule<>(MainActivity.class);

Ici, MainActivity est l'activité à lancer avant d'exécuter un scénario de test et à détruire après l'exécution du scénario de test particulier.

ViewMatchers

Espresso fournit un grand nombre de classes de correspondance de vues (dans le package androidx.test.espresso.matcher.ViewMatchers ) pour faire correspondre et trouver des éléments / vues d'interface utilisateur dans la hiérarchie de vues d'un écran d'activité Android. La méthode de Espresso OnView prend un seul argument de type Matcher (Voir matchers), trouve le point de vue de l' interface utilisateur correspondant et retourne correspondant ViewInteraction objet. L' objet ViewInteraction retourné par la méthode onView peut être utilisé pour invoquer des actions telles que cliquer sur la vue correspondante ou peut être utilisé pour affirmer la vue correspondante. Un exemple de code pour rechercher la vue avec le texte "Hello World!" est comme suit,

ViewInteraction viewInteraction = Espresso.onView(withText("Hello World!"));

Ici, withText est un matcher, qui peut être utilisé pour faire correspondre la vue de l'interface utilisateur avec le texte "Hello World!"

ViewActions

Espresso fournit un grand nombre de classes d'action de vue (dans androidx.test.espresso.action.ViewActions) pour invoquer l'action différente sur la vue sélectionnée / correspondante. Une fois que onView correspond et renvoie l' objet ViewInteraction , toute action peut être appelée en appelant la méthode «perform» de l' objet ViewInteraction et en lui transmettant les actions de vue appropriées. Un exemple de code pour cliquer sur la vue correspondante est le suivant,

ViewInteraction viewInteraction = Espresso.onView(withText("Hello World!"));
viewInteraction.perform(click());

Ici, l'action de clic de la vue correspondante sera appelée.

AfficherAssertions

Semblable aux correspondances de vue et aux actions de vue, Espresso fournit un grand nombre d'assertions de vue (dans le package androidx.test.espresso.assertion.ViewAssertions ) pour affirmer que la vue correspondante est ce que nous attendions. Une fois que onView correspond et renvoie l' objet ViewInteraction , toute assertion peut être vérifiée à l'aide de la méthode check de ViewInteraction en la transmettant avec l'assertion de vue appropriée. Un exemple de code pour affirmer que la vue correspondante est la suivante,

ViewInteraction viewInteraction = Espresso.onView(withText("Hello World!"));
viewInteraction.check(matches(withId(R.id.text_view)));

Ici, les correspondances acceptent la correspondance de vue et retournent l'assertion de vue, qui peut être vérifiée par la méthode de vérification de ViewInteraction .

Flux de travail du cadre de test Espresso

Comprenons comment fonctionne le cadre de test espresso et comment il offre des options pour effectuer tout type d'interaction utilisateur de manière simple et flexible. Le flux de travail d'un cas de test expresso est décrit ci-dessous

Comme nous l'avons appris précédemment, Android JUnit runner, AndroidJUnit4 exécutera les cas de test Android. Les cas de test d'espresso doivent être marqués avec @RunWith (AndroidJUnut.class) . Tout d'abord, AndroidJUnit4 préparera l'environnement pour exécuter les cas de test. Il démarre le périphérique Android connecté ou l'émulateur, installe l'application et s'assure que l'application à tester est prête. Il exécutera les cas de test et rapportera les résultats.
Espresso a besoin d'au moins une seule règle JUnit de type ActivityTestRule pour spécifier l'activité. Le coureur Android JUnit démarrera l'activité à lancer à l'aide d' ActivityTestRule .
Chaque scénario de test nécessite au minimum un appel de méthode onView ou onDate (utilisé pour rechercher des vues basées sur des données comme AdapterView ) pour correspondre et trouver la vue souhaitée. onView ou onData renvoie l' objet ViewInteraction .
Une fois l' objet ViewInteraction renvoyé, nous pouvons soit appeler une action de la vue sélectionnée, soit vérifier la vue pour notre vue attendue à l'aide d'une assertion.
L'action peut être appelée à l'aide de la méthode perform de l' objet ViewInteraction en passant l'une des actions d'affichage disponibles.
L'assertion peut être appelée à l'aide de la méthode check de l' objet ViewInteraction en passant l'une des assertions de vue disponibles.

La représentation schématique du workflow est la suivante,

Exemple d'assertion de vue

Écrivons un cas de test simple pour trouver la vue texte ayant "Hello World!" texte dans notre application «HelloWorldApp», puis affirmez-le en utilisant l'assertion de vue. Le code complet est le suivant,

package com.tutorialspoint.espressosamples.helloworldapp;

import android.content.Context;
import androidx.test.InstrumentationRegistry;
import androidx.test.rule.ActivityTestRule;
import androidx.test.runner.AndroidJUnit4;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import static androidx.test.espresso.Espresso.onView;
import static androidx.test.espresso.matcher.ViewMatchers.withText;;
import static androidx.test.espresso.assertion.ViewAssertions.matches;
import static org.junit.Assert.*;
/**
   * Instrumented test, which will execute on an Android device.
   *
   * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
   @Rule
   public ActivityTestRule<MainActivity> mActivityTestRule = new ActivityTestRule<>(MainActivity.class);
   @Test
   public void view_isCorrect() {
      onView(withText("Hello World!")).check(matches(isDisplayed()));
   }
   @Test
   public void useAppContext() {
      // Context of the app under test.
      Context appContext = InstrumentationRegistry.getTargetContext();
      assertEquals("com.tutorialspoint.espressosamples.helloworldapp", appContext.getPackageName());
   }
}

Ici, nous avons utilisé des correspondances de vue withText pour trouver la vue texte ayant "Hello World!" assertion de texte et de correspondance pour affirmer que la vue de texte est correctement affichée. Une fois le scénario de test appelé dans Android Studio, il exécutera le scénario de test et signalera le message de réussite comme ci-dessous.

view_isCorrect scénario de test

↰ Previous page Next page ↱