Se usó la API de Cloud Translation para traducir esta página.

AndroidJUnitRunner
Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

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

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.

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 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 // 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)
@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)));
    }
}

Cómo acceder al contexto de la aplicación

Cuando usas AndroidJUnitRunner para ejecutar tus pruebas, puedes acceder al contexto de la app que se está probando llamando 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 APIs 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.

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 la prueba se debe ejecutar solo en dispositivos físicos, no en emuladores.
@SdkSuppress: Impide que la prueba se ejecute en un nivel de API de Android inferior al nivel determinado. 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. Puedes usar esta anotación para filtrar qué pruebas ejecutar y configurar la propiedad android.testInstrumentationRunnerArguments.size:

-Pandroid.testInstrumentationRunnerArguments.size=small

Pruebas de fragmentos

Si necesitas paralelizar la ejecución de tus pruebas, compartirlas en varios servidores para que se ejecuten más rápido, puedes dividirlas en grupos o 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 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:

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 tu 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 tu entorno de pruebas:

Estado 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. Consulta la sección Cómo habilitar Android Test Orchestrator desde Gradle para ver un ejemplo.
Las fallas son aisladas: Incluso si falla una prueba, solo se elimina su propia instancia de Instrumentation. Esto significa que las otras pruebas de tu suite aún se ejecutan y proporcionan resultados completos.

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

Tanto Android Studio como 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 Gradle. Agrega las siguientes instrucciones 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'
}

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 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:

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, instala Android Test Orchestrator y, luego, úsalo directamente.

adb shell pm list instrumentation

Cómo usar diferentes cadenas de herramientas

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

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

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:

El orquestador te permite controlar las pruebas de JUnit. — **Figura 1**: Estructura del APK de Android Test Orchestration.

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.

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 cómo usar AndroidJUnitRunner, consulta los siguientes recursos.

Ejemplos

AndroidJunitRunnerSample: Muestra anotaciones de prueba, pruebas parametrizadas y la creación de conjuntos de pruebas.