Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

AndroidJUnitRunner

La clase AndroidJUnitRunner es un ejecutor de pruebas JUnit que te permite ejecutar las clases de pruebas de estilo de JUnit 3 o JUnit 4 en dispositivos Android, incluidos aquellos que usan los frameworks de pruebas Espresso e UI Automator.

El ejecutor de pruebas controla la carga del paquete de pruebas y la app sometida a prueba en el dispositivo, ejecuta las pruebas e informa los resultados. Esa clase reemplaza a la clase InstrumentationTestRunner, que solo admite las pruebas de JUnit 3.

Este panel de prueba admite varias tareas de prueba comunes, entre otras:

Cómo escribir pruebas JUnit

El panel de prueba es compatible con tus pruebas Junit 3 y Junit 4 (hasta Junit 4.10). Sin embargo, debes evitar combinar código de prueba de Junit 3 y Junit 4 en el mismo paquete, ya que eso puede ocasionar resultados inesperados. Si creas una clase de prueba instrumentada de JUnit 4 para que se ejecute en un dispositivo o emulador, tu clase de prueba debe contener un prefijo con la anotación @RunWith(AndroidJUnit4.class).

En el siguiente fragmento de código, se muestra cómo se podría escribir una prueba instrumentada de JUnit 4 para validar que la operación changeText en la clase ChangeTextBehavior funcione correctamente:

Kotlin

    @RunWith(AndroidJUnit4::class)
    @LargeTest
    class ChangeTextBehaviorTest {
        val stringToBeTyped = "Espresso"
        @get:Rule
        val activityRule = ActivityTestRule(MainActivity::class.java)

        @Test fun changeText_sameActivity() {
            // Type text and then press the button.
            onView(withId(R.id.editTextUserInput))
                .perform(typeText(stringToBeTyped), closeSoftKeyboard())
            onView(withId(R.id.changeTextBt)).perform(click())

            // Check that the text was changed.
            onView(withId(R.id.textToBeChanged))
                .check(matches(withText(stringToBeTyped)))
        }
    }
    

Java

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

        private static final String stringToBeTyped = "Espresso";

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

        @Test
        public void changeText_sameActivity() {
            // Type text and then press the button.
            onView(withId(R.id.editTextUserInput))
                    .perform(typeText(stringToBeTyped), closeSoftKeyboard());
            onView(withId(R.id.changeTextBt)).perform(click());

            // Check that the text was changed.
            onView(withId(R.id.textToBeChanged))
                    .check(matches(withText(stringToBeTyped)));
        }
    }
    

Cómo usar Android Test Orchestrator

Cuando usas AndroidJUnitRunner versión 1.0 o una versión posterior, tienes acceso a una herramienta llamada Android Test Orchestrator, que te permite ejecutar cada una de las pruebas de tu app dentro de su propia invocación de Instrumentation.

Android Test Orchestrator ofrece los siguientes beneficios para tu entorno de pruebas:

  • Estado de uso compartido mínimo. Cada prueba se ejecuta en su propia instancia de Instrumentation. Por lo tanto, si las pruebas comparten el estado de la app, se quitará la mayor parte de ese estado compartido de la CPU o la memoria del dispositivo después de cada prueba.

    Para quitar todo el estado compartido de la CPU y la memoria de tu dispositivo después de cada prueba, usa la marca clearPackageData.

  • Se aíslan las fallas. Incluso si falla una prueba, solo elimina su propia instancia de Instrumentation; es decir, se seguirán ejecutando las otras pruebas de tu conjunto de aplicaciones.

Tanto Android Studio como Firebase Test Lab cuentan con Android Test Orchestrator previamente instalado, aunque debes habilitar la función en Android Studio.

Sin embargo, si usas una cadena de herramientas diferente para probar la app, aún puedes usar Android Test Orchestrator. Para eso, completa los siguientes pasos:

  1. Incluye los paquetes necesarios en el archivo de compilación de la app.
  2. Habilita Android Test Orchestrator desde la línea de comandos.

Cómo habilitar Android Test Orchestrator desde Gradle

Para habilitar Android Test Orchestrator con la herramienta de línea de comandos de Gradle, completa estos pasos:

  1. Agrega las siguientes declaraciones al archivo build.gradle de tu proyecto:

        android {
          defaultConfig {
           ...
           testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    
           // The following argument makes the Android Test Orchestrator run its
           // "pm clear" command after each test invocation. This command ensures
           // that the app's state is completely cleared between tests.
           testInstrumentationRunnerArguments clearPackageData: 'true'
         }
    
          testOptions {
            execution 'ANDROIDX_TEST_ORCHESTRATOR'
          }
        }
    
        dependencies {
          androidTestImplementation 'androidx.test:runner:1.1.0'
          androidTestUtil 'androidx.test:orchestrator:1.1.0'
        }
  2. Ejecuta el siguiente comando y activa Android Test Orchestrator:

        ./gradlew connectedCheck

Cómo habilitar Android Test Orchestrator desde Android Studio

Android Test Orchestrator es compatible con Android Studio 3.0 y versiones posteriores. Para habilitar Android Test Orchestrator en Android Studio, agrega las declaraciones que se muestran en Cómo habilitar Android Test Orchestrator desde Gradle al archivo build.gradle de tu app.

Cómo habilitar Android Test Orchestrator desde la línea de comandos

Para usar Android Test Orchestrator en la línea de comandos, ejecuta los siguientes comandos en una ventana de terminal:

    # Install the test orchestrator.
    adb install -r path/to/m2repository/androidx/test/orchestrator/1.1.0/orchestrator-1.1.0.apk

    # Install test services.
    adb install -r path/to/m2repository/androidx/test/services/test-services/1.1.0/test-services-1.1.0.apk

    # Replace "com.example.test" with the name of the package containing your tests.
    # Add "-e clearPackageData true" to clear your app's data in between runs.
    adb shell 'CLASSPATH=$(pm path androidx.test.services) app_process / \
      androidx.test.services.shellexecutor.ShellMain am instrument -w -e \
      targetInstrumentation com.example.test/androidx.test.runner.AndroidJUnitRunner \
      androidx.test.orchestrator/.AndroidTestOrchestrator'
    

Como se muestra en la sintaxis del comando, instala Android Test Orchestrator y luego úsalo directamente.

Nota: Si no conoces la instrumentación de destino, puedes buscarla ejecutando el siguiente comando:

    adb shell pm list instrumentation

Arquitectura

El APK del servicio Orchestrator se almacena en un proceso que es independiente del APK de prueba y del APK de la app que se está probando, como se muestra en la figura 1:

Figura 1: Estructura del APK de Android Test Orchestrator

Android Test Orchestrator recopila pruebas de JUnit al comienzo de la ejecución de tu conjunto de pruebas, pero luego ejecuta cada prueba por separado, en su propia instancia de Instrumentation.

Cómo acceder al contexto de la app

Para obtener el contexto de la app que se está probando, llama al método ApplicationProvider.getApplicationContext() estático. Si creaste una subclase personalizada de Application en tu app, este método muestra el contexto de la subclase personalizada.

Si eres un implementador de herramientas, puedes acceder a las API de prueba de bajo nivel con la clase InstrumentationRegistry. Esta clase incluye el objeto Instrumentation, el objeto Context de la app de destino, el objeto Context de la app de prueba y los argumentos de la línea de comandos que se pasan a tu prueba. Esos datos son útiles cuando escribes pruebas con el framework de UI Automator, o cuando tus pruebas dependen del contexto de la app.

Pruebas de filtro

En tus pruebas JUnit 4.x, puedes usar anotaciones para configurar la ejecución de la prueba. Esta función minimiza la necesidad de agregar un código estándar y condicional a tus pruebas. Además de las anotaciones estándares compatibles con Junit 4, el ejecutor de pruebas también es compatible con anotaciones específicas de Android, incluidas las siguientes:

  • @RequiresDevice: especifica que se debe ejecutar la prueba solo en dispositivos físicos, no en emuladores.
  • @SdkSuppress: impide que se ejecute la prueba en un nivel de API de Android inferior al nivel en cuestión. Por ejemplo, para impedir la ejecución de pruebas en todos los niveles de API inferiores a 23, usa la anotación @SDKSuppress(minSdkVersion=23).
  • @SmallTest, @MediumTest y @LargeTest: clasifican el tiempo que debe demorar en ejecutarse una prueba, y, en consecuencia, la frecuencia con la que puedes ejecutarla.

Pruebas de fragmentos

El ejecutor de pruebas admite la división de un único conjunto de pruebas en varios fragmentos, de modo que puedas ejecutar pruebas de un mismo fragmento como un grupo y en la misma instancia de Instrumentation de manera sencilla. Cada fragmento se identifica con un número de índice. Cuando se ejecutan pruebas, usa la opción -e numShards para especificar la cantidad de fragmentos separados que se crearán y la opción -e shardIndex para especificar el fragmento que se ejecutará.

Por ejemplo, para dividir el conjunto de pruebas en 10 fragmentos y ejecutar solo las pruebas agrupadas en el segundo fragmento, usa el siguiente comando:

    adb shell am instrument -w -e numShards 10 -e shardIndex 2
    

Más información

Para obtener más información sobre cómo usar el ejecutor de prueba, consulta la referencia de la API.

Para usar la clase AndroidJUnitRunner, inclúyela como uno de los paquetes de tu proyecto, tal como se describe en Cómo configurar un proyecto para AndroidX Test.

Recursos adicionales

Para obtener más información sobre cómo usar AndroidJUnitRunner, consulta los recursos que se indican a continuación.

Ejemplos

  • AndroidJunitRunnerSample: muestra ejemplos de anotaciones de prueba, pruebas parametrizadas y la creación de conjuntos de pruebas.