Espresso Testing Framework - Architettura

In questo capitolo, impariamo i termini del framework di test espresso, come scrivere un semplice test case espresso e il flusso di lavoro completo o l'architettura del framework di test espresso.

Panoramica

Espresso fornisce un gran numero di classi per testare l'interfaccia utente e l'interazione utente di un'applicazione Android. Possono essere raggruppati in cinque categorie come specificato di seguito:

Corridore di JUnit

Il framework di test Android fornisce un runner, AndroidJUnitRunner per eseguire i casi di test dell'espresso scritti in casi di test in stile JUnit3 e JUnit4. È specifico per l'applicazione Android e gestisce in modo trasparente il caricamento dei casi di test espresso e dell'applicazione sotto test sia nel dispositivo effettivo che nell'emulatore, esegue i casi di test e riporta il risultato dei casi di test. Per utilizzare AndroidJUnitRunner nel test case, è necessario annotare la classe di test utilizzando l'annotazione @RunWith e quindi passare l'argomento AndroidJUnitRunner come specificato di seguito -

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

Regole di JUnit

Il framework di test Android fornisce una regola, ActivityTestRule per avviare un'attività Android prima di eseguire i casi di test. Avvia l'attività prima di ogni metodo annotato con @ Test` e @Before. Terminerà l'attività dopo che il metodo è stato annotato con @After. Un codice di esempio è il seguente,

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

In questo caso, MainActivity è l'attività da avviare prima di eseguire un test case e distrutta dopo l'esecuzione del test case specifico.

ViewMatchers

Espresso fornisce un gran numero di classi matcher di visualizzazione (nel pacchetto androidx.test.espresso.matcher.ViewMatchers ) per abbinare e trovare elementi / viste dell'interfaccia utente nella gerarchia di visualizzazione di una schermata dell'attività Android. Il metodo onView di Espresso accetta un singolo argomento di tipo Matcher (View matchers), trova la vista dell'interfaccia utente corrispondente e restituisce l' oggetto ViewInteraction corrispondente . L' oggetto ViewInteraction restituito dal metodo onView può essere ulteriormente utilizzato per richiamare azioni come il clic sulla vista corrispondente o può essere utilizzato per affermare la vista corrispondente. Un codice di esempio per trovare la vista con il testo "Hello World!" è come segue,

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

Qui, withText è un matcher, che può essere utilizzato per abbinare la vista dell'interfaccia utente con il testo "Hello World!"

ViewActions

Espresso fornisce un gran numero di classi di azioni di visualizzazione (in androidx.test.espresso.action.ViewActions) per richiamare la diversa azione sulla vista selezionata / corrispondente. Una volta che onView corrisponde e restituisce l' oggetto ViewInteraction , qualsiasi azione può essere richiamata chiamando il metodo "perform" dell'oggetto ViewInteraction e passandola con le azioni di visualizzazione appropriate. Un codice di esempio per fare clic sulla vista corrispondente è il seguente,

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

Qui verrà richiamata l'azione del clic della vista corrispondente.

ViewAssertions

Simile ai matcher di visualizzazione e alle azioni di visualizzazione, Espresso fornisce un gran numero di asserzioni di visualizzazione (nel pacchetto androidx.test.espresso.assertion.ViewAssertions ) per affermare che la visualizzazione corrispondente è ciò che ci aspettavamo. Una volta che onView corrisponde e restituisce l' oggetto ViewInteraction , qualsiasi asserzione può essere controllata utilizzando il metodo di controllo di ViewInteraction passandolo con un'asserzione di visualizzazione appropriata. Un codice di esempio per affermare che la vista corrispondente è la seguente,

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

Qui, le corrispondenze accettano il matcher di visualizzazione e restituiscono l'asserzione di visualizzazione, che può essere verificata tramite il metodo di controllo ViewInteraction .

Flusso di lavoro di Espresso Testing Framework

Cerchiamo di capire come funziona il framework di test espresso e come fornisce opzioni per eseguire qualsiasi tipo di interazione utente in modo semplice e flessibile. Il flusso di lavoro di un test case espresso è come descritto di seguito,

Come abbiamo appreso in precedenza, Android JUnit runner, AndroidJUnit4 eseguirà i casi di test Android. I casi di test dell'espresso devono essere contrassegnati con @RunWith (AndroidJUnut.class) . Innanzitutto, AndroidJUnit4 preparerà l'ambiente per eseguire i casi di test. Avvia il dispositivo Android connesso o l'emulatore, installa l'applicazione e si assicura che l'applicazione da testare sia pronta. Eseguirà i casi di test e riporterà i risultati.
Espresso richiede almeno una singola regola JUnit di tipo ActivityTestRule per specificare l'attività. Il runner Android JUnit inizierà l'attività da avviare utilizzando ActivityTestRule .
Ogni test case richiede un minimo di chiamata del metodo onView o onDate (utilizzato per trovare viste basate sui dati come AdapterView ) per abbinare e trovare la vista desiderata. onView o onData restituisce l' oggetto ViewInteraction .
Una volta restituito l' oggetto ViewInteraction , possiamo richiamare un'azione della vista selezionata o controllare la vista per la nostra vista prevista usando l'asserzione.
L'azione può essere richiamata utilizzando il metodo perform dell'oggetto ViewInteraction passando una qualsiasi delle azioni di visualizzazione disponibili.
L'asserzione può essere richiamata utilizzando il metodo di controllo dell'oggetto ViewInteraction passando una qualsiasi delle asserzioni di visualizzazione disponibili.

La rappresentazione del diagramma del flusso di lavoro è la seguente,

Esempio: asserzione vista

Scriviamo un semplice test case per trovare la visualizzazione del testo con "Hello World!" testo nella nostra applicazione "HelloWorldApp" e quindi asserirlo utilizzando l'asserzione di visualizzazione. Il codice completo è il seguente,

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

Qui, abbiamo utilizzato i matcher della vista del testo per trovare la vista del testo con "Hello World!" text e corrisponde all'asserzione della vista per affermare che la vista del testo è visualizzata correttamente. Una volta che il test case viene richiamato in Android Studio, eseguirà il test case e segnalerà il messaggio di successo come di seguito.

view_is Caso di test corretto