Comienza a realizar pruebas de instrumentación

En esta guía, se describe cómo preparar y ejecutar una prueba de instrumentación con Firebase Test Lab. Para usar esta guía, necesitas una prueba de instrumentación (escrita por ti o tu equipo) que use los frameworks de pruebas de Android Espresso o UI Automator. Las pruebas de instrumentación pueden ejecutarse hasta 45 minutos en dispositivos físicos y hasta 60 minutos en dispositivos virtuales.

En los pasos posteriores, subirás el archivo APK de la app y el de la prueba a Firebase.

Agrega la biblioteca de capturas de pantalla a tu app (opcional)

Firebase Test Lab incluye una biblioteca (testlab‑instr‑lib) que puedes usar para procesar las capturas de pantalla que realices con ScreenCapture de AndroidX cuando ejecutes pruebas de instrumentación, como aquellas que se escriben con el framework para pruebas Espresso. En esta sección, se describe cómo crear objetos ScreenCapture con la biblioteca de AndroidX y cómo procesarlos con testlab‑instr‑lib.

Después de que se ejecute la prueba de instrumentación, podrás ver las capturas de pantalla tomadas en Firebase console.

Prueba una app de ejemplo

Descarga la app de ejemplo de NotePad para probar esta funcionalidad. La capacidad de tomar capturas de pantalla ya está incorporada en el proyecto del NotePad.

Paso 1: Agrega la biblioteca de capturas de pantalla a tu proyecto

Agrega el repositorio Maven de Google a cada sección de repositorios en el archivo Gradle (build.gradle), de la raíz de tu proyecto de prueba al nivel del proyecto:

buildscript {

  repositories {
    // Add the following line:
    google()  // Google's Maven repository
  }

  dependencies {
    // ...

    // Check that you have the following line (if not, add it):
    classpath 'com.google.gms:google-services:4.3.8'  // Google Services plugin
  }
}

allprojects {
  // ...

  repositories {
    // Add the following line:
    google()  // Google's Maven repository
    // ...
  }
}

En el archivo Gradle (generalmente app/build.gradle), de tu módulo (a nivel de app), agrega una dependencia para la biblioteca de capturas de pantalla de Test Lab.

dependencies {
  // ...
  // Add Test Lab's instrumentation test screenshot library:
  androidTestImplementation 'com.google.firebase:testlab-instr-lib:0.2'
  // ...
}

En el archivo AndroidManifest.xml de la prueba, registra el FirebaseScreenCaptureProcessor en una etiqueta de metadatos dentro del elemento <instrumentation>. También puedes especificar el procesador como un argumento en AndroidJUnitRunner (consulta la documentación de referencia de AndroidJUnitRunner para obtener instrucciones).

<instrumentation
  // Check that you have the following line (if not, add it):
  android:name="androidx.test.runner.AndroidJUnitRunner" // Specifies AndroidJUnitRunner as the test runner
  android:targetPackage="com.your.package.name">

// Add the following:
<meta-data
  android:name="screenCaptureProcessors"
  android:value="com.google.firebase.testlab.screenshot.FirebaseScreenCaptureProcessor" />
</instrumentation>
...

En el archivo AndroidManifest.xml de tu app, agrega las siguientes líneas al elemento <manifest>:
```
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```
En el archivo AndroidManifest.xml, agrega las siguientes líneas a la etiqueta <manifest> para especificar los permisos de sistema de la app. Si realizas pruebas en Android 10 (nivel de API 29) o versiones posteriores, omite el permiso WRITE_EXTERNAL_STORAGE (la app no requiere este permiso para leer y escribir capturas de pantalla en el dispositivo).
```
<manifest ... >
    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>
```

Paso 2: Toma capturas de pantalla durante la prueba

En cualquier momento de la prueba en el que quieras tomar una captura de pantalla, llama al método Screenshot.capture() de la biblioteca de AndroidX. Esto produce un objeto ScreenCapture. Cuando llamas a process() en el objeto ScreenCapture, se procesa mediante el ScreenCaptureProcessor que está registrado en tu AndroidManifest.xml. Ten en cuenta que se usa BasicScreenCaptureProcessor si no se registran procesadores. Debido a que registraste el FirebaseScreenCaptureProcessor, tus capturas de pantalla se procesarán mediante FirebaseScreenCaptureProcessor y estarán disponibles para ti con los resultados cuando ejecutes la prueba con Firebase Test Lab.

A continuación, se muestran casos de uso de ejemplo para crear una `ScreenCapture`:

Realiza una ScreenCapture completa en una API Build.VERSION_CODES.JELLY_BEAN_MR2 y posteriores:
```
Screenshot.capture()
```
Realiza una ScreenCapture de la actividad en cualquier nivel de API. Ten en cuenta que esta es la única opción para los dispositivos que utilizan una versión inferior a Build.VERSION_CODES.JELLY_BEAN_MR2.
```
@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...
```

Ejemplos de casos de uso para procesar una ScreenCapture

Procesa una ScreenCapture a través de FirebaseScreenCaptureProcessor:
```
Screenshot.capture().process();
```

Procesa una ScreenCapture mediante un ScreenCaptureProcessor especificado (esto te permite omitir el registro del procesador):

Set<ScreenCaptureProcessor> processors = new HashSet<>();
processors.add(new FirebaseScreenCaptureProcessor());
Screenshot.capture().process(processors);

Configura el nombre y el formato de la ScreenCapture, y procésala con el procesador registrado:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

Paso 3: Compila y ejecuta tu prueba

Compila tu app y prueba los APK (consulta Prueba tu app para obtener instrucciones).
Sube los archivos APK al panel de Test Lab de Firebase console.
Por último, ejecuta la prueba.

Paso 4: Visualiza las capturas de pantalla de prueba

Una vez que se complete la prueba, podrás ver las capturas de pantalla realizadas en Firebase console.

En la pestaña Pruebas, selecciona la prueba completada y, luego, haz clic en la pestaña Resultados.
Vuelve a seleccionar la prueba y, luego, haz clic en la pestaña Capturas de pantalla que aparece.

Habilita funciones de prueba adicionales (opcional)

Puedes habilitar las siguientes funciones en tu prueba antes de ejecutarla con Test Lab:

Habilita Orchestrator

Android Test Orchestrator es una herramienta que ejecuta cada una de las pruebas de instrumentación de la app de forma independiente. Test Lab siempre usa la versión más reciente de Orchestrator.

Si quieres habilitar Orchestrator para Test Lab, en la configuración de pruebas de instrumentación, haz clic en Opciones adicionales > Ejecutar con Orchestrator.

Beneficios y desventajas

Beneficio: Sin estado compartido. Cada prueba se ejecuta en su propia instancia de instrumentación, por lo que no se acumula el estado compartido entre ellas.
Beneficio: Fallas aisladas. Si falla una prueba, solo se interrumpe su propia instancia de instrumentación, por lo que las demás pruebas se mantienen activas.
Desventaja: Tiempos de ejecución más extensos. Cada prueba ejecuta su propia instancia de instrumentación, por lo que el proceso de prueba tarda un poco más en general. Si no se verifica, el aumento en los tiempos de ejecución podría afectar el uso de la cuota o el tiempo de facturación y hacer que alcances los límites de tiempo de espera de tus dispositivos.

Habilita la fragmentación

Con la fragmentación de pruebas, se divide un conjunto de pruebas en subgrupos (fragmentos) que se ejecutan por separado de forma aislada. Test Lab ejecuta automáticamente cada fragmento en paralelo con varios dispositivos y completa todo el conjunto de pruebas en menos tiempo.

Cómo funciona la fragmentación de pruebas

Supongamos que creas N fragmentos. Por cada dispositivo que selecciones, Test Lab inicia N dispositivos idénticos y ejecuta un subconjunto de las pruebas en cada dispositivo. Esto significa que los casos de prueba fragmentados pueden generar varias ejecuciones de prueba por dispositivo, a diferencia de los casos de prueba no fragmentados, que siempre realizan una ejecución de prueba por dispositivo (para obtener una descripción general rápida de los conceptos clave en Test Lab, consulta Conceptos clave).

Puedes habilitar la fragmentación de pruebas en Firebase console con estos pasos:

En la configuración de la prueba de instrumentación, haz clic en Opciones adicionales.
En la sección Fragmentación, ingresa la cantidad de fragmentos que quieres ejecutar.

Facturación por fragmentos de prueba

Test Lab aprovecha el mecanismo de fragmentación integrado de AndroidJUnitRunner para implementar tus fragmentos. Para evitar que se te cobre por iniciar fragmentos vacíos (fragmentos sin casos de prueba asignados), la cantidad de fragmentos que crees debe ser menor que la cantidad total de casos de prueba. Según cuánto tarde en ejecutarse cada caso de prueba, por lo general, se recomienda asignar de 2 a 10 casos de prueba por fragmento.

Para obtener más detalles sobre la facturación, consulta el artículo sobre uso, cuotas y facturación.