Primeros pasos con android-espresso

Comprobación de los elementos del menú de opciones (usando Spoon para tomar capturas de pantalla)

/**
 * @author piotrek1543
 *
 * This example provides a specific UI testing problem and how it is already solved 
 * with Google's Espresso. Notice that I used also Spoon framework, as Espresso 
 * lacks of taking screenshots functionality.
 */

@RunWith(AndroidJUnit4.class)
public class MainActivityAndroidTest {
    @Rule
    public ActivityTestRule<MainActivity> mRule = new ActivityTestRule<>(MainActivity.class);

    @Test
    public void checkIfSettingsMenuItemsAreVisible() throws InterruptedException {
        //open OptionsMenu to see available items
        openActionBarOverflowOrOptionsMenu(mRule.getActivity());
        //create a screenshot with 'options_menu' TAG
        Spoon.screenshot(mRule.getActivity(), "options_menu");
        //check if Settings item is Visible
        onView(withText(R.string.action_settings)).check(matches(isDisplayed()));
        //check if `Sort` item is Visible
        onView(withText(R.string.action_sort)).check(matches(isDisplayed()));
        //perform click on `Sort` OptionsMenu item
        onView(withText(R.string.action_sort)).perform(click());
        //create a screenshot with 'options_menu_sort' TAG
        Spoon.screenshot(mRule.getActivity(), "options_menu_sort");
        //check if `Sort -> By Value id` item is Visible
        onView(withText(R.string.menu_sort_length)).check(matches(isDisplayed()));
        //check if `Sort -> By Joke length` item is Visible
        onView(withText(R.string.menu_sort_a_z)).check(matches(isDisplayed()));
    }
}

Ver prueba

onView(withId(R.id.greet_button)) // withId(R.id.my_view) is a ViewMatcher
.perform(click())                 // click() is a ViewAction
.check(matches(not(isEnabled())); // matches(isEnabled()) is a ViewAssertion

Encuentra alguna vista por ID

onView(withId(R.id.pay))

Buscar vista por el texto

onView(withText("Pay"))
onView(withText(R.string.pay))

Ejemplo de Hello World Espresso

Este es un tutorial para crear un ejemplo de hola mundo: Usado para este ejemplo: Android Studio 2.3;

Para comenzar, use Android Studio para crear un nuevo proyecto con una actividad vacía. Luego, agregamos algunas funciones simples a la aplicación que podemos probar: agregamos un botón que, cuando se hace clic, muestra “Hello World” en una vista de texto.

El código de actividad se ve así:

package com.example.testing.helloworld;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        final TextView textView = (TextView) findViewById(R.id.textView);

        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                textView.setText("Hello World!");
            }
        });
    }
}

Y el diseño de actividad_principal para esta actividad se ve así:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Say Hello" />
</LinearLayout>

Ahora queremos probar el comportamiento de esta nueva aplicación usando espresso. Por lo general, el código de su aplicación en sí está dentro del paquete “principal”, las pruebas unitarias están dentro de “prueba” y las pruebas de instrumentación de espresso están dentro del paquete “androidTest”. Si crea un nuevo proyecto de actividad vacío con Android Studio, ya debería haber creado esos paquetes y clases y debería verse así:

ingrese la descripción de la imagen aquí

Para comenzar con espresso, debemos asegurarnos de que la dependencia espresso-core esté incluida en el archivo build.gradle (tenga en cuenta que no está anotado con la palabra clave compile sino con androidTestCompile). Las dependencias en el archivo build.gradle creado por Android Studio deberían verse así:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:25.2.0'
    compile 'com.android.support.constraint:constraint-layout:1.0.2'
    testCompile 'junit:junit:4.12'
}

Ahora que todo está configurado, podemos comenzar con la prueba real: abra el archivo ExampleInstrumentationTest y verá que ya hay una prueba useAppContext generada dentro. Cambiaremos esta clase de prueba y crearemos una prueba para comprobar el comportamiento de nuestra aplicación:

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {

    @Rule
    public ActivityTestRule<MainActivity> mActivityRule = new ActivityTestRule<>(
        MainActivity.class, false, true);

    @Test
    public void checkHelloWorld() throws Exception {
        onView(withId(R.id.textView)).check(matches(withText("")));
        onView(withId(R.id.button)).perform(click());
        onView(withId(R.id.textView)).check(matches(withText("Hello World!")));
    }
}

Inicie la prueba ejecutando la clase ExampleInstrumentedTest. Esta prueba entonces hace tres cosas:

  1. Comprueba si la vista de texto contiene una cadena vacía ("")
  2. Hace clic en el botón en nuestro diseño
  3. Vuelve a comprobar el texto de la vista de texto si contiene “Hello World!”

ActivityTestRule en la parte superior define qué actividad se prueba y la inicia al comienzo de la prueba. (También puede desactivar el inicio automático de una actividad y, en su lugar, iniciarlo dentro de cada prueba manualmente)

Las reglas de la prueba son bastante simples:

  • onView(withId(R.id.textView)) busca una vista dentro de la pantalla actual por el ID de la vista dentro de nuestro archivo de diseño actividad_principal.
  • .check(matches(withText(""))); luego realiza un caso de prueba en esa vista.
  • .perform(click()) realiza una acción en una vista: estas acciones pueden ser clics, clics largos, deslizamientos o más.

Este fue un tutorial para comenzar con las pruebas de instrumentación de Android espresso, ¡espero que te haya dado algunas ideas!

Instrucciones de configuración del espresso

  • Configure su entorno de prueba
  • Descargar Expreso
  • Establecer el corredor de instrumentación
  • Ejemplo de archivo build.gradle
  • Analítica
  • Agregar la primera prueba
  • Ejecución de pruebas Esta guía cubre la instalación de Espresso con SDK Manager y su compilación con Gradle. Se recomienda Android Studio.

Configura tu entorno de prueba

Para evitar la descamación, le recomendamos que desactive las animaciones del sistema en los dispositivos virtuales o físicos que se utilizan para la prueba.

En su dispositivo, en Configuración->Opciones de desarrollador, deshabilite las siguientes 3 configuraciones:

  • Escala de animación de ventana
  • Escala de animación de transición
  • Escala de duración del animador

Descargar Expreso

  • Asegúrese de haber instalado el Repositorio de soporte de Android más reciente en Extras (consulte las instrucciones).

  • Abra el archivo build.gradle de su aplicación. Por lo general, este no es el archivo build.gradle de nivel superior, sino app/build.gradle.

  • Agregue las siguientes líneas dentro de las dependencias:

    androidTestCompile ‘com.android.support.test.espresso:espresso-core:2.2.2’ androidTestCompile ‘com.android.support.test🏃‍♂️0.5’

  • Consulte la sección de descargas para obtener más artefactos (espresso-contrib, espresso-web, etc.)

  • Establecer el corredor de instrumentación

Agregue al mismo archivo build.gradle la siguiente línea en android.defaultConfig: testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" Ejemplo de archivo build.gradle

apply plugin: 'com.android.application'

    android {
        compileSdkVersion 22
        buildToolsVersion "22"
    
        defaultConfig {
            applicationId "com.my.awesome.app"
            minSdkVersion 10
            targetSdkVersion 22.0.1
            versionCode 1
            versionName "1.0"
    
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        }
    }

dependencies {
    // App's dependencies, including test
    compile 'com.android.support:support-annotations:22.2.0'

    // Testing-only dependencies
    androidTestCompile 'com.android.support.test🏃‍♂️0.5'
    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
}

Analítica

Para asegurarnos de que estamos en el camino correcto con cada nueva versión, el corredor de prueba recopila análisis. Más específicamente, carga un hash del nombre del paquete de la aplicación bajo prueba para cada invocación. Esto nos permite medir tanto la cantidad de paquetes únicos que usan Espresso como el volumen de uso.

Si no desea cargar estos datos, puede rechazarlo pasando el siguiente argumento al corredor de prueba: disabledAnalytics “true” (vea cómo pasar argumentos personalizados).

Agregar la primera prueba

Android Studio crea pruebas de forma predeterminada en src/androidTest/java/com.example.package/

Ejemplo de prueba JUnit4 usando Reglas:

@RunWith(AndroidJUnit4.class)
@LargeTest
public class HelloWorldEspressoTest {

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

    @Test
    public void listGoesOverTheFold() {
        onView(withText("Hello world!")).check(matches(isDisplayed()));
    }
}

Ejecutando pruebas

En Estudio Android

Crear una configuración de prueba

En Estudio Android:

  • Abrir el menú Ejecutar -> Editar configuraciones

  • Agregar una nueva configuración de Pruebas de Android

  • Elija un módulo

  • Agregar un corredor de instrumentación específico:

    android.support.test.runner.AndroidJUnitRunner
    

Ejecute la configuración recién creada.

Desde la línea de comandos a través de Gradle

Ejecutar

./gradlew connectedAndroidTest

El espresso tiene básicamente tres componentes:

  1. ViewMatchers: permite encontrar vistas en la jerarquía de vistas actual

  2. ViewActions: permite realizar acciones en las vistas

  3. ViewAssertions: permite afirmar el estado de una vista

Prueba Base Espresso

onView(ViewMatcher)       -- 1     
 .perform(ViewAction)     -- 2
   .check(ViewAssertion); -- 3
  1. Encuentra la vista
  2. Realiza una acción en la vista
  3. Valida una afirmación