Espresso Testing Framework - Arquitetura

Neste capítulo, vamos aprender os termos da estrutura de teste do espresso, como escrever um caso de teste simples do espresso e o fluxo de trabalho completo ou arquitetura da estrutura de teste do espresso.

visão global

O Espresso oferece um grande número de classes para testar a interface do usuário e a interação do usuário com um aplicativo Android. Eles podem ser agrupados em cinco categorias, conforme especificado abaixo -

Corredor JUnit

A estrutura de teste do Android fornece um executor, AndroidJUnitRunner, para executar os casos de teste espresso escritos em casos de teste estilo JUnit3 e JUnit4. É específico para o aplicativo Android e trata de forma transparente o carregamento dos casos de teste do espresso e do aplicativo em teste no dispositivo real ou emulador, executa os casos de teste e relata o resultado dos casos de teste. Para usar AndroidJUnitRunner no caso de teste, precisamos anotar a classe de teste usando @RunWith annotation e, em seguida, passar o argumento AndroidJUnitRunner conforme especificado abaixo -

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

Regras JUnit

A estrutura de teste do Android fornece uma regra, ActivityTestRule, para iniciar uma atividade do Android antes de executar os casos de teste. Ele inicia a atividade antes de cada método anotado com @ Test` e @Before. Ele encerrará a atividade após o método anotado com @After. Um exemplo de código é o seguinte,

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

Aqui, MainActivity é a atividade a ser iniciada antes de executar um caso de teste e destruída após a execução do caso de teste específico.

ViewMatchers

O Espresso fornece um grande número de classes de combinação de visualização (no pacote androidx.test.espresso.matcher.ViewMatchers ) para combinar e encontrar elementos / visualizações da IU em uma hierarquia de visualização da tela de atividade do Android. O método onView do Espresso recebe um único argumento do tipo Matcher (View matchers), encontra a visualização da IU correspondente e retorna o objeto ViewInteraction correspondente . O objeto ViewInteraction retornado pelo método onView pode ser usado posteriormente para invocar ações como clicar na visualização combinada ou pode ser usado para declarar a visualização combinada. Um exemplo de código para encontrar a visualização com o texto “Hello World!” é o seguinte,

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

Aqui, withText é um matcher, que pode ser usado para corresponder à visualização da IU com o texto “Hello World!”

ViewActions

O Espresso fornece um grande número de classes de ação de visualização (em androidx.test.espresso.action.ViewActions) para invocar a ação diferente na visualização selecionada / correspondente. Uma vez que onView corresponda e retorne o objeto ViewInteraction , qualquer ação pode ser invocada chamando o método “executar” do objeto ViewInteraction e transmitindo-o com as ações de visualização adequadas. Um exemplo de código para clicar na visualização correspondente é o seguinte,

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

Aqui, a ação de clique da visualização correspondente será invocada.

ViewAssertions

Semelhante a view matchers e view actions, o Espresso oferece um grande número de view assertion (no pacote androidx.test.espresso.assertion.ViewAssertions ) para afirmar que a view correspondente é o que esperávamos. Uma vez que onView corresponda e retorne o objeto ViewInteraction , qualquer declaração pode ser verificada usando o método de verificação de ViewInteraction , passando-o com a declaração de visão apropriada. Um código de amostra para afirmar que a visualização correspondente é a seguinte,

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

Aqui, as correspondências aceitam o matcher da visão e retornam a asserção da visão, que pode ser verificada pelo método de verificação de ViewInteraction .

Fluxo de trabalho do Espresso Testing Framework

Vamos entender como a estrutura de teste do espresso funciona e como ela oferece opções para fazer qualquer tipo de interação com o usuário de uma forma simples e flexível. O fluxo de trabalho de um caso de teste do espresso é conforme descrito abaixo,

Como aprendemos anteriormente, o executor Android JUnit, AndroidJUnit4 , executará os casos de teste do Android. Os casos de teste do espresso precisam ser marcados com @RunWith (AndroidJUnut.class) . Primeiro, o AndroidJUnit4 preparará o ambiente para executar os casos de teste. Ele inicia o dispositivo ou emulador Android conectado, instala o aplicativo e garante que o aplicativo a ser testado esteja pronto. Ele executará os casos de teste e relatará os resultados.
O Espresso precisa de pelo menos uma única regra JUnit do tipo ActivityTestRule para especificar a atividade. O executor Android JUnit iniciará a atividade a ser iniciada usando ActivityTestRule .
Cada caso de teste precisa de um mínimo de chamada de método onView ou onDate (usado para localizar visualizações baseadas em dados como AdapterView ) para corresponder e localizar a visualização desejada. onView ou onData retorna o objeto ViewInteraction .
Depois que o objeto ViewInteraction é retornado, podemos invocar uma ação da visão selecionada ou verificar a visão de nossa visão esperada usando asserção.
A ação pode ser chamada usando o método perform do objeto ViewInteraction , passando qualquer uma das ações de visualização disponíveis.
A asserção pode ser chamada usando o método check do objeto ViewInteraction , passando qualquer uma das asserções de visualização disponíveis.

A representação do diagrama do Fluxo de Trabalho é a seguinte,

Exemplo - ver asserção

Vamos escrever um caso de teste simples para encontrar a visualização de texto com “Olá, mundo!” texto em nosso aplicativo “HelloWorldApp” e, em seguida, declare-o usando a asserção de visão. O código completo é o seguinte,

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

Aqui, temos utilizado withText vista matchers para encontrar a exibição de texto com “Olá mundo!” text e corresponde à asserção de visão para afirmar que a visão de texto é exibida corretamente. Assim que o caso de teste for invocado no Android Studio, ele executará o caso de teste e relatará a mensagem de sucesso conforme abaixo.

view_isCorrect test case