Marco de prueba de Espresso - Arquitectura

En este capítulo, aprendamos los términos del marco de prueba de espresso, cómo escribir un caso de prueba de espresso simple y el flujo de trabajo completo o la arquitectura del marco de prueba de espresso.

Visión general

Espresso ofrece una gran cantidad de clases para probar la interfaz de usuario y la interacción del usuario de una aplicación de Android. Se pueden agrupar en cinco categorías como se especifica a continuación:

Corredor de JUnit

El marco de prueba de Android proporciona un corredor, AndroidJUnitRunner para ejecutar los casos de prueba espresso escritos en casos de prueba de estilo JUnit3 y JUnit4. Es específico para la aplicación de Android y maneja de manera transparente la carga de los casos de prueba de espresso y la aplicación bajo prueba tanto en el dispositivo real como en el emulador, ejecuta los casos de prueba e informa el resultado de los casos de prueba. Para usar AndroidJUnitRunner en el caso de prueba, necesitamos anotar la clase de prueba usando la anotación @RunWith y luego pasar el argumento AndroidJUnitRunner como se especifica a continuación:

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

Reglas de JUnit

El marco de prueba de Android proporciona una regla, ActivityTestRule, para iniciar una actividad de Android antes de ejecutar los casos de prueba. Lanza la actividad antes de cada método anotado con @ Test` y @Before. Terminará la actividad después del método anotado con @After. Un código de muestra es el siguiente,

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

Aquí, MainActivity es la actividad que se lanzará antes de ejecutar un caso de prueba y se destruirá después de ejecutar el caso de prueba en particular.

ViewMatchers

Espresso proporciona una gran cantidad de clases de comparadores de vistas (en el paquete androidx.test.espresso.matcher.ViewMatchers ) para hacer coincidir y encontrar elementos / vistas de la IU en la jerarquía de vistas de una pantalla de actividad de Android. El método onView de Espresso toma un único argumento de tipo Matcher (View matchers), encuentra la vista de IU correspondiente y devuelve el objeto ViewInteraction correspondiente . El objeto ViewInteraction devuelto por el método onView se puede utilizar para invocar acciones como hacer clic en la vista coincidente o se puede utilizar para afirmar la vista coincidente. Un código de muestra para encontrar la vista con el texto "¡Hola, mundo!" es como sigue,

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

Aquí, withText es un comparador, que se puede usar para hacer coincidir la vista de la interfaz de usuario con el texto "¡Hola, mundo!"

ViewActions

Espresso proporciona una gran cantidad de clases de acción de vista (en androidx.test.espresso.action.ViewActions) para invocar la acción diferente en la vista seleccionada / emparejada. Una vez que onView coincide y devuelve el objeto ViewInteraction , se puede invocar cualquier acción llamando al método "perform" del objeto ViewInteraction y pasarlo con las acciones de visualización adecuadas. Un código de muestra para hacer clic en la vista coincidente es el siguiente:

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

Aquí, se invocará la acción de clic de la vista coincidente.

Ver afirmaciones

De forma similar a los comparadores de vistas y las acciones de visualización, Espresso proporciona una gran cantidad de aserciones de vistas (en el paquete androidx.test.espresso.assertion.ViewAssertions ) para afirmar que la vista coincidente es la que esperábamos. Una vez que onView coincide y devuelve el objeto ViewInteraction , cualquier aserción se puede verificar usando el método de verificación de ViewInteraction pasándola con la aserción de vista adecuada. Un código de muestra para afirmar que la vista coincidente es la siguiente,

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

Aquí, las coincidencias aceptan el comparador de vistas y devuelven la aserción de vista, que se puede verificar mediante el método de verificación de ViewInteraction .

Flujo de trabajo del marco de prueba de Espresso

Entendamos cómo funciona el marco de prueba de espresso y cómo proporciona opciones para realizar cualquier tipo de interacción con el usuario de una manera simple y flexible. El flujo de trabajo de un caso de prueba de espresso es como se describe a continuación,

Como aprendimos anteriormente, Android JUnit runner, AndroidJUnit4 ejecutará los casos de prueba de Android. Los casos de prueba de expreso deben marcarse con @RunWith (AndroidJUnut.class) . Primero, AndroidJUnit4 preparará el entorno para ejecutar los casos de prueba. Inicia el dispositivo Android conectado o el emulador, instala la aplicación y se asegura de que la aplicación que se va a probar esté lista. Ejecutará los casos de prueba e informará los resultados.
Espresso necesita al menos una única regla JUnit de tipo ActivityTestRule para especificar la actividad. El corredor de Android JUnit iniciará la actividad que se iniciará mediante ActivityTestRule .
Cada caso de prueba necesita un mínimo de invocación del método onView u onDate (utilizado para encontrar vistas basadas en datos como AdapterView ) para que coincida y encuentre la vista deseada. onView u onData devuelve el objeto ViewInteraction .
Una vez que se devuelve el objeto ViewInteraction , podemos invocar una acción de la vista seleccionada o verificar la vista para nuestra vista esperada usando aserción.
La acción se puede invocar utilizando el método perform del objeto ViewInteraction pasando cualquiera de las acciones de vista disponibles.
La aserción se puede invocar mediante el método de verificación del objeto ViewInteraction pasando cualquiera de las aserciones de vista disponibles.

La representación del diagrama del flujo de trabajo es la siguiente,

Ejemplo: ver aserción

Escribamos un caso de prueba simple para encontrar la vista de texto que tiene "¡Hola mundo!" texto en nuestra aplicación "HelloWorldApp" y luego afirmarlo usando la aserción de vista. El código completo es el siguiente,

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

Aquí, hemos utilizado con comparadores de vista de texto para encontrar la vista de texto que tiene "¡Hola mundo!" text y coincide con la aserción de vista para afirmar que la vista de texto se muestra correctamente. Una vez que se invoca el caso de prueba en Android Studio, ejecutará el caso de prueba e informará el mensaje de éxito como se muestra a continuación.

view_isCorrect caso de prueba

↰ Previous page Next page ↱