AndroidJUnitRunner

La clase AndroidJUnitRunner es un ejecutor de pruebas JUnit que te permite ejecutar pruebas instrumentadas JUnit 4 en dispositivos Android, incluidos los que usan Espresso, UI Automator y Compose. los frameworks de prueba.

Nota: AndroidJUnitRunner no es necesario para las pruebas locales. Lee acerca de las diferencia entre las pruebas instrumentadas y locales en los aspectos básicos de las pruebas.

El ejecutor de pruebas controla la carga de tu paquete de prueba y la app a prueba en un el dispositivo, ejecutar las pruebas y, luego, informar los resultados de estas.

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

• Escritura de pruebas de JUnit
• Cómo acceder al contexto de la app
• Filtrado de pruebas
• Fragmentación de pruebas

Cómo escribir pruebas JUnit

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

Kotlin

@RunWith(AndroidJUnit4::class) // Only needed when mixing JUnit 3 and 4 tests
@LargeTest // Optional runner annotation
class ChangeTextBehaviorTest {
 val stringToBeTyped = "Espresso"
 // ActivityTestRule accesses context through the runner
 @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) // Only needed when mixing JUnit 3 and 4 tests
@LargeTest // Optional runner annotation
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)));
    }
}

Nota: Debes evitar combinar código de prueba Junit 3 y Junit 4 en el mismo paquete, ya que podría causar resultados inesperados. Si estás creando una plataforma JUnit 4 para ejecutarse en un dispositivo o emulador, tu clase de prueba debe ser con el prefijo @RunWith(AndroidJUnit4::class) en Kotlin, en Java es @RunWith(AndroidJUnit4.class).

Accede al contexto de la aplicación

Cuando usas AndroidJUnitRunner para ejecutar las pruebas, puedes acceder al contexto para la app que se está probando llamando al método ApplicationProvider.getApplicationContext(). Si creaste una campaña subclase de Application en tu app, este método muestra tu contexto de la subclase.

Si eres un implementador de herramientas, puedes acceder a las APIs de prueba de bajo nivel con el InstrumentationRegistry. Esta clase incluye el objeto Instrumentation, el objeto Context de la app de destino, la app el objeto Context de tu app y los argumentos de la línea de comandos que se pasaron a tu prueba.

Pruebas de filtro

En tus pruebas JUnit 4.x, puedes usar anotaciones para configurar la ejecución de la prueba. Esta minimiza la necesidad de agregar código estándar y condicional a tu y pruebas. Además de las anotaciones estándares compatibles con JUnit 4, la también admite anotaciones específicas de Android, incluida la lo siguiente:

• @RequiresDevice: Especifica que la prueba se debe ejecutar solo en entornos físicos. en dispositivos, no en emuladores.
• @SdkSuppress: Evita que la prueba se ejecute en una API de Android anterior. nivel que el nivel determinado. Por ejemplo, para suprimir pruebas en todos los niveles de API inferiores después de 23 segundos, usa la anotación @SDKSuppress(minSdkVersion=23).
• @SmallTest, @MediumTest y @LargeTest: clasifican la duración de una prueba. y, por lo tanto, la frecuencia con la que se podrá ejecutar la prueba. Tú puedes usar esta anotación para filtrar qué pruebas ejecutar, lo que establece la Propiedad android.testInstrumentationRunnerArguments.size:

-Pandroid.testInstrumentationRunnerArguments.size=small

Pruebas de fragmentos

Si necesitas paralelizar la ejecución de tus pruebas, compártelas en en varios servidores para que se ejecuten más rápido, puedes dividirlos en grupos shards. El ejecutor de pruebas admite la división de un único paquete de pruebas en varios fragmentos, de modo que puedas ejecutar fácilmente pruebas que pertenezcan al mismo fragmento como un grupo. Cada fragmento se identifica con un número de índice. Cuando ejecutes pruebas, usa La opción -e numShards para especificar la cantidad de fragmentos separados que se crearán y el La opción -e shardIndex para especificar qué fragmento ejecutar.

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

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

Cómo usar Android Test Orchestrator

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

Android Test Orchestrator ofrece los siguientes beneficios para tus pruebas. entorno:

• Estado de uso compartido mínimo: Cada prueba se ejecuta en su propio Instrumentation instancia. Por lo tanto, si tus pruebas comparten el estado de la app, la mayor parte de ese estado compartido se quita de la CPU o la memoria del dispositivo después de cada prueba. Para quitar todo el estado de uso compartido de la CPU y la memoria del dispositivo después de cada uno usa la marca clearPackageData. Consulta Cómo habilitar desde Gradle para ver un ejemplo.
• Las fallas se aíslan: Incluso si falla una prueba, solo se interrumpe. propia instancia de Instrumentation. Esto significa que las otras pruebas que tu paquete siga ejecutándose, lo que proporcionará resultados completos de la prueba.

Este aislamiento da como resultado un posible aumento en el tiempo de ejecución de la prueba, ya que el Android Test Orchestrator reinicia la aplicación después de cada prueba.

Nota: El ejecutor de instrumentación de pruebas obsoleto, InstrumentationTestRunner, no es compatible con Android Test Orchestrator. Si usas InstrumentationTestRunner, es posible que debas usar una instrumentación diferente Runner para usar la organización en el dispositivo.

Android Studio y Firebase Test Lab tienen Android Test Orchestrator. preinstalado, aunque debes habilitar la función en Android Studio

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:

• Paso 1: Modifica el archivo de Gradle Agrega las siguientes declaraciones a tu archivo build.gradle del 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'
}

• Paso 2: Ejecuta Android Test Orchestrator con el siguiente comando:

./gradlew connectedCheck

Cómo habilitar Android Test Orchestrator desde Android Studio

Para habilitar Android Test Orchestrator en Android Studio, agrega las sentencias que se muestran. En Habilita desde Gradle al archivo build.gradle de la 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:

DEVICE_API_LEVEL=$(adb shell getprop ro.build.version.sdk)

FORCE_QUERYABLE_OPTION=""
if [[ $DEVICE_API_LEVEL -ge 30 ]]; then
   FORCE_QUERYABLE_OPTION="--force-queryable"
fi

# uninstall old versions
adb uninstall androidx.test.services
adb uninstall androidx.test.orchestrator

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

# Install test services.
adb install $FORCE_QUERYABLE_OPTION -r path/to/m2repository/androidx/test/services/test-services/1.4.2/test-services-1.4.2.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, debes instalar Android Test Orchestrator y, luego, usarlo. directamente.

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

adb shell pm list instrumentation

Cómo usar diferentes cadenas de herramientas

Si usas una cadena de herramientas diferente para probar tu app, puedes usar Android de todos modos. Completa los siguientes pasos para probar Orchestrator:

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

Arquitectura

El APK del servicio Orchestrator se almacena en un proceso independiente del APK de prueba y el APK de la app que se está probando:

Figura 1: Estructura del APK de organización de pruebas de Android.

Android Test Orchestrator recopila pruebas JUnit al comienzo de la prueba suite, pero luego ejecuta cada prueba por separado, en su propia instancia de Instrumentation

Más información

Para obtener más información sobre el uso de AndroidJUnitRunner, consulta la referencia de la API.

Recursos adicionales

Para obtener más información sobre el uso de AndroidJUnitRunner, consulta los siguientes vínculos: de Google Cloud.

Ejemplos

• AndroidJunitRunnerSample: Anotaciones de prueba pruebas parametrizadas y creación de conjuntos de pruebas.