Recursos inactivos de Espresso

Un recurso inactivo representa una operación asíncrona cuyos resultados afectan las operaciones posteriores en una prueba de IU. Si registras recursos inactivos con Espresso, puedes validar estas operaciones asíncronas de manera más confiable cuando pruebes tu app.

Cómo identificar si se necesitan recursos inactivos

Espresso proporciona un conjunto sofisticado de capacidades de sincronización. Sin embargo, esta característica del framework solo se aplica a las operaciones que publican mensajes en el MessageQueue, como una subclase de View que dibuja su contenido en la pantalla.

Como Espresso no conoce ninguna otra operación asíncrona, incluidas las que se ejecutan en un subproceso en segundo plano, no puede proporcionar sus garantías de sincronización en esas situaciones. Para que Espresso conozca las operaciones de larga duración de tu app, debes registrar cada una como un recurso inactivo.

Si no usas recursos inactivos cuando pruebas los resultados del trabajo asíncrono de tu app, es posible que debas usar una de las siguientes soluciones alternativas deficientes para mejorar la confiabilidad de tus pruebas:

  • Agrega llamadas del anuncio a Thread.sleep(). Cuando agregas retrasos artificiales a tus pruebas, el paquete de pruebas tarda más en terminar de ejecutarse, y es posible que las pruebas sigan fallando algunas veces cuando se ejecutan en dispositivos más lentos. Además, estos retrasos no se escalan bien, ya que es posible que tu app deba realizar un trabajo asíncrono que requiera más tiempo en una versión futura.
  • Implementar wrappers de reintento, que usan un bucle para verificar de forma repetida si tu app aún realiza trabajo asíncrono hasta que se agota el tiempo de espera. Incluso si especificas un recuento máximo de reintentos en tus pruebas, cada nueva ejecución consume recursos del sistema, en especial la CPU.
  • Usar instancias de CountDownLatch, que permiten que uno o más subprocesos esperen hasta que se complete una cantidad específica de operaciones que se ejecutan en otro subproceso. Estos objetos requieren que especifiques un tiempo de espera; de lo contrario, es posible que tu app se bloquee de forma indefinida. Los bloqueos también agregan complejidad innecesaria a tu código, lo que dificulta el mantenimiento.

Espresso te permite quitar estas soluciones alternativas poco confiables de tus pruebas y, en su lugar, registrar el trabajo asíncrono de tu app como recursos inactivos.

Casos de uso habituales

Cuando realices operaciones similares a los siguientes ejemplos en tus pruebas, considera usar un recurso inactivo:

  • Carga datos desde Internet o una fuente de datos local.
  • Establece conexiones con bases de datos y devoluciones de llamadas.
  • Administrar servicios, ya sea con un servicio del sistema o una instancia de IntentService
  • Desarrolla una lógica empresarial compleja, como transformaciones de mapas de bits.

Es especialmente importante registrar recursos inactivos cuando estas operaciones actualizan una IU que luego validan tus pruebas.

Ejemplo de implementaciones de recursos inactivos

En la siguiente lista, se describen varios ejemplos de implementaciones de recursos inactivos que puedes integrar en tu app:

CountingIdlingResource
Realiza un recuento de tareas activas. Cuando el contador es cero, el recurso asociado se considera inactivo. Esta funcionalidad se parece mucho a la de un Semaphore. En la mayoría de los casos, esta implementación es suficiente para administrar el trabajo asíncrono de tu app durante las pruebas.
UriIdlingResource
Es similar a CountingIdlingResource, pero el contador debe ser cero durante un período específico antes de que el recurso se considere inactivo. Este período de espera adicional tiene en cuenta las solicitudes de red consecutivas, en las que una app de tu subproceso puede realizar una solicitud nueva inmediatamente después de recibir una respuesta a una solicitud anterior.
IdlingThreadPoolExecutor
Una implementación personalizada de ThreadPoolExecutor que hace un seguimiento de la cantidad total de tareas en ejecución dentro de los grupos de subprocesos creados. Esta clase usa un CountingIdlingResource para mantener el contador de tareas activas.
IdlingScheduledThreadPoolExecutor
Es una implementación personalizada de ScheduledThreadPoolExecutor. Proporciona la misma funcionalidad y las mismas capacidades que la clase IdlingThreadPoolExecutor, pero también puede realizar un seguimiento de las tareas programadas para el futuro o para ejecutarse de forma periódica.

Crea tu propio recurso inactivo

A medida que uses recursos inactivos en las pruebas de tu app, es posible que debas proporcionar un registro o una administración de recursos personalizados. En esos casos, es posible que las implementaciones que se mencionan en la sección anterior no sean suficientes. Si ese es el caso, puedes extender una de estas implementaciones de recursos inactivos o crear la tuya.

Si implementas tu propia funcionalidad de recursos inactivos, ten en cuenta las siguientes prácticas recomendadas, en especial la primera:

Invoca transiciones al estado inactivo fuera de las comprobaciones inactivas.
Después de que tu app quede inactiva, llama a onTransitionToIdle() fuera de cualquier implementación de isIdleNow(). De esa manera, Espresso no realiza una segunda verificación innecesaria para determinar si un recurso inactivo determinado está inactivo.

En el siguiente fragmento de código, se muestra un ejemplo de esta recomendación:

fun isIdle() {
    // DON'T call callback.onTransitionToIdle() here!
}

fun backgroundWorkDone() {
    // Background work finished.
    callback.onTransitionToIdle() // Good. Tells Espresso that the app is idle.

    // Don't do any post-processing work beyond this point. Espresso now
    // considers your app to be idle and moves on to the next test action.
}

Registra los recursos inactivos antes de que los necesites.

Los beneficios de sincronización asociados con los recursos inactivos solo se aplican después de la primera invocación de Espresso del método isIdleNow() de ese recurso.

En la siguiente lista, se muestran varios ejemplos de esta propiedad:

  • Si registras un recurso inactivo en un método anotado con @Before, este tendrá efecto en la primera línea de cada prueba.
  • Si registras un recurso inactivo dentro de una prueba, este tendrá efecto durante la siguiente acción basada en Espresso. Este comportamiento se produce incluso si la siguiente acción se encuentra en la misma prueba que la sentencia que registra el recurso inactivo.
Cancela el registro de los recursos inactivos una vez que hayas terminado de usarlos.

Para conservar los recursos del sistema, debes cancelar el registro de los recursos inactivos en cuanto ya no los necesites. Por ejemplo, si registras un recurso inactivo en un método anotado con @Before, lo mejor es cancelar el registro de este recurso en un método correspondiente que esté anotado con @After.

Usa un registro inactivo para registrar y cancelar el registro de recursos inactivos.

Si usas este contenedor para los recursos inactivos de tu app, puedes registrar y cancelar el registro de los recursos inactivos de forma repetida según sea necesario y, aun así, observar un comportamiento coherente.

Mantén solo el estado simple de la app dentro de los recursos inactivos.

Por ejemplo, los recursos inactivos que implementes y registres no deben contener referencias a objetos View.

Registra recursos inactivos

Espresso proporciona una clase de contenedor en la que puedes colocar los recursos inactivos de tu app. Esta clase, llamada IdlingRegistry, es un artefacto independiente que genera una sobrecarga mínima en tu app. Además, te permite realizar los siguientes pasos para mejorar la capacidad de mantenimiento de tu app:

  • Crea una referencia al IdlingRegistry, en lugar de los recursos inactivos que contiene, en las pruebas de tu app.
  • Mantén las diferencias en la colección de recursos inactivos que usas para cada variante de compilación.
  • Define recursos inactivos en los servicios de tu app, en lugar de en los componentes de la IU que hacen referencia a esos servicios.

Integra recursos inactivos en tu app

Si bien puedes agregar recursos inactivos a una app de varias maneras, un enfoque en particular mantiene la encapsulación de tu app y, al mismo tiempo, te permite especificar una operación particular que representa un recurso inactivo determinado.

Cuando agregues recursos inactivos a tu app, te recomendamos encarecidamente que coloques la lógica de recursos inactivos en la app y que solo realices las operaciones de registro y cancelación de registro en tus pruebas.

Si bien con este enfoque creas la situación inusual de usar una interfaz solo de prueba en el código de producción, puedes unir los recursos inactivos al código que ya tienes, lo que mantiene el tamaño del APK y el recuento de métodos de tu app.

Enfoques alternativos

Si prefieres no tener lógica de recursos inactivos en el código de producción de tu app, existen otras estrategias de integración viables:

  • Crea variantes de compilación, como las variantes de productos de Gradle, y usa recursos inactivos solo en la compilación de depuración de tu app.
  • Usa un framework de inyección de dependencias, como Dagger, para insertar el gráfico de dependencias de recursos inactivos de tu app en las pruebas. Si usas Dagger 2, la inyección en sí debe originarse en un subcomponente.
  • Implementa un recurso inactivo en las pruebas de tu app y expón la parte de la implementación de la app que se debe sincronizar en esas pruebas.

    Precaución: Aunque esta decisión de diseño parece crear una referencia independiente a los recursos inactivos, también rompe la encapsulación en todas las apps, excepto en las más simples.

Recursos adicionales

Para obtener más información sobre el uso de Espresso en las pruebas de Android, consulta los siguientes recursos.

Ejemplos