Espresso Testing Framework - Architektur

In diesem Kapitel lernen wir die Bedingungen des Espresso-Test-Frameworks, das Schreiben eines einfachen Espresso-Testfalls und den vollständigen Workflow oder die Architektur des Espresso-Test-Frameworks kennen.

Überblick

Espresso bietet eine große Anzahl von Klassen zum Testen der Benutzeroberfläche und der Benutzerinteraktion einer Android-Anwendung. Sie können wie unten angegeben in fünf Kategorien eingeteilt werden:

JUnit Läufer

Das Android-Testframework bietet einen Runner, AndroidJUnitRunner, zum Ausführen der Espresso-Testfälle, die in Testfällen im JUnit3- und JUnit4-Stil geschrieben wurden. Es ist spezifisch für Android-Anwendungen und behandelt das Laden der Espresso-Testfälle und der zu testenden Anwendung sowohl auf dem tatsächlichen Gerät als auch im Emulator transparent, führt die Testfälle aus und meldet das Ergebnis der Testfälle. Um AndroidJUnitRunner im Testfall zu verwenden, müssen wir die Testklasse mit der Annotation @RunWith kommentieren und dann das Argument AndroidJUnitRunner wie unten angegeben übergeben.

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

JUnit-Regeln

Das Android-Testframework bietet die Regel ActivityTestRule, mit der eine Android-Aktivität gestartet werden kann, bevor die Testfälle ausgeführt werden. Es startet die Aktivität vor jeder mit @ Test` und @Before annotierten Methode. Die Aktivität wird nach der mit @After kommentierten Methode beendet. Ein Beispielcode lautet wie folgt:

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

Hier ist MainActivity die Aktivität, die vor dem Ausführen eines Testfalls gestartet und nach dem Ausführen des jeweiligen Testfalls zerstört werden soll.

ViewMatchers

Espresso bietet eine große Anzahl von View Matcher-Klassen (im androidx.test.espresso.matcher.ViewMatchers-Paket ), um UI-Elemente / Ansichten in der Ansichtshierarchie eines Android-Aktivitätsbildschirms abzugleichen und zu finden. Die Espresso-Methode onView verwendet ein einzelnes Argument vom Typ Matcher (View Matchers), findet die entsprechende UI-Ansicht und gibt das entsprechende ViewInteraction- Objekt zurück. Das von der onView- Methode zurückgegebene ViewInteraction- Objekt kann weiterhin zum Aufrufen von Aktionen wie Klicken auf die übereinstimmende Ansicht oder zum Aktivieren der übereinstimmenden Ansicht verwendet werden. Ein Beispielcode zum Auffinden der Ansicht mit dem Text "Hallo Welt!" ist wie folgt,

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

Hier ist withText ein Matcher, mit dem die UI-Ansicht mit dem Text "Hello World!"

ViewActions

Espresso bietet eine große Anzahl von Ansichtsaktionsklassen (in androidx.test.espresso.action.ViewActions), um die verschiedenen Aktionen für die ausgewählte / übereinstimmende Ansicht aufzurufen. Sobald onView mit dem ViewInteraction- Objekt übereinstimmt und es zurückgibt , kann jede Aktion aufgerufen werden, indem die Methode "perform" des ViewInteraction- Objekts aufgerufen und mit den richtigen Ansichtsaktionen übergeben wird. Ein Beispielcode zum Klicken auf die übereinstimmende Ansicht lautet wie folgt:

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

Hier wird die Klickaktion der übereinstimmenden Ansicht aufgerufen.

ViewAssertions

Ähnlich wie beim Anzeigen von Matchern und Ansichtsaktionen bietet Espresso eine große Anzahl von Ansichtszusicherungen (im Paket androidx.test.espresso.assertion.ViewAssertions ), um sicherzustellen , dass die übereinstimmende Ansicht unseren Erwartungen entspricht. Sobald onView mit dem ViewInteraction- Objekt übereinstimmt und es zurückgibt , kann jede Zusicherung mithilfe der Prüfmethode von ViewInteraction überprüft werden, indem sie mit der richtigen Ansichtszusicherung übergeben wird. Ein Beispielcode, um zu bestätigen, dass die übereinstimmende Ansicht wie folgt lautet:

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

Hier akzeptieren Übereinstimmungen den View Matcher und geben die View Assertion zurück, die mit der Check-Methode von ViewInteraction überprüft werden kann .

Workflow des Espresso Testing Framework

Lassen Sie uns verstehen, wie das Espresso-Test-Framework funktioniert und wie es Optionen bietet, um jede Art von Benutzerinteraktion auf einfache und flexible Weise durchzuführen. Der Arbeitsablauf eines Espresso-Testfalls ist wie folgt:

Wie wir zuvor erfahren haben, wird Android JUnit Runner, AndroidJUnit4 die Android-Testfälle ausführen. Die Espresso-Testfälle müssen mit @RunWith (AndroidJUnut.class) gekennzeichnet sein . Zunächst bereitet AndroidJUnit4 die Umgebung für die Ausführung der Testfälle vor. Es startet entweder das angeschlossene Android-Gerät oder den Emulator, installiert die Anwendung und stellt sicher, dass die zu testende Anwendung bereit ist. Es werden die Testfälle ausgeführt und die Ergebnisse gemeldet.
Espresso benötigt mindestens eine einzelne JUnit- Regel vom Typ ActivityTestRule , um die Aktivität anzugeben. Android JUnit Runner startet die Aktivität, die mit ActivityTestRule gestartet werden soll .
Jeder Testfall benötigt mindestens einen einzelnen Aufruf der Methode onView oder onDate (zum Auffinden datenbasierter Ansichten wie AdapterView ), um die gewünschte Ansicht zu finden. onView oder onData geben das ViewInteraction- Objekt zurück.
Sobald das ViewInteraction- Objekt zurückgegeben wird, können wir entweder eine Aktion der ausgewählten Ansicht aufrufen oder die Ansicht mithilfe der Zusicherung auf unsere erwartete Ansicht überprüfen.
Die Aktion kann mit der Methode perform des ViewInteraction- Objekts aufgerufen werden, indem eine der verfügbaren Ansichtsaktionen übergeben wird.
Die Zusicherung kann mithilfe der Prüfmethode des ViewInteraction- Objekts aufgerufen werden, indem eine der verfügbaren Ansichtszusicherungen übergeben wird.

Die Diagrammdarstellung des Workflows lautet wie folgt:

Beispiel - Ansicht Behauptung

Schreiben wir einen einfachen Testfall, um die Textansicht mit "Hello World!" Text in unserer Anwendung „HelloWorldApp“ und bestätigen Sie ihn dann mithilfe der Ansichtszusicherung. Der vollständige Code lautet wie folgt:

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());
   }
}

Hier haben wir withText View Matcher verwendet, um die Textansicht mit "Hello World!" Zusicherung der Text- und Übereinstimmungsansicht, um sicherzustellen, dass die Textansicht ordnungsgemäß angezeigt wird. Sobald der Testfall in Android Studio aufgerufen wurde, wird der Testfall ausgeführt und die Erfolgsmeldung wie folgt gemeldet.

view_isKorrekter Testfall