Cómo probar las actividades de tu app

Las actividades sirven como contenedores para cada interacción del usuario dentro de tu app. es importante probar cómo se comportan las actividades de tu app durante eventos como los siguientes:

• Otra app, como la app de teléfono del dispositivo, interrumpe la actividad de tu app.
• El sistema elimina y vuelve a crear tu actividad.
• El usuario coloca tu actividad en un nuevo entorno de renderización en ventanas, como pantalla en pantalla (PIP) o multiventana.

En particular, es importante que te asegures de que tu actividad se comporte correctamente en respuesta a los eventos descritos en La actividad ciclo de vida.

En esta guía, se describe cómo evaluar la capacidad de tu app para mantener datos integridad y una buena experiencia del usuario a medida que se cambian las actividades de la app a través de diferentes estados en sus ciclos de vida.

Cómo administrar el estado de una actividad

Un aspecto clave al probar las actividades de tu aplicación consiste en ubicar los componentes actividades en estados particulares. Para definir este “dado” parte de tus pruebas, usa instancias de ActivityScenario, parte del Biblioteca de prueba de AndroidX. Con esta clase, puedes hacer lo siguiente: colocar tu actividad en estados que simulan eventos a nivel del dispositivo.

ActivityScenario es una API multiplataforma que puedes usar en pruebas de unidades locales. y de integración en el dispositivo. En un dispositivo real o virtual, ActivityScenario brinda seguridad de subprocesos, ya que sincroniza eventos entre tus el subproceso de instrumentación de la prueba y el subproceso que ejecuta la actividad que estás probando.

La API es particularmente adecuada para evaluar cómo una actividad en el comportamiento del modelo cuando se destruye o crea. En esta sección, se presentan las vulnerabilidades los casos de uso asociados a esta API.

Cómo crear una actividad

Para crear la actividad que se está probando, agrega el código que se muestra en el siguiente fragmento:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
       launchActivity<MyActivity>().use {
       }
    }
}

Después de crear la actividad, ActivityScenario realiza la transición de esta a la RESUMED. Este estado indica que tu actividad se está ejecutando y está visibles para los usuarios. En este estado, tienes la libertad de interactuar con el archivo Elementos View con pruebas de IU de Espresso.

Google recomienda que llames a close en la actividad cuando se realice la prueba. de datos completados. Esto limpia los recursos asociados y mejora el la estabilidad de las pruebas. ActivityScenario implementa Closeable, por lo que puedes aplica la extensión use, o try-with-resources en la clase de programación de Java idioma, de modo que la actividad se cierre automáticamente.

También puedes usar ActivityScenarioRule para llamar automáticamente ActivityScenario.launch antes de cada prueba y ActivityScenario.close en el desmontaje de la prueba. En el siguiente ejemplo, se muestra cómo definir una regla y obtener un de una situación a partir de él:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @get:Rule var activityScenarioRule = activityScenarioRule<MyActivity>()

    @Test fun testEvent() {
        val scenario = activityScenarioRule.scenario
    }
}

Cómo pasar la actividad a un nuevo estado

Para llevar la actividad a un estado diferente, como CREATED o STARTED, llama moveToState() Esta acción simula una situación en la que tu actividad es detenida o pausada, respectivamente, porque la interrumpe otra app o un acción del sistema.

En el siguiente fragmento de código, se muestra un ejemplo del uso de moveToState():

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.moveToState(State.CREATED)
        }
    }
}

Cómo determinar el estado actual de la actividad

Para determinar el estado actual de una actividad que se está probando, obtén el valor de la Campo state en el objeto ActivityScenario. Es particularmente útil para comprobar el estado de una actividad que se está probando si esta redirige a otra actividad o se finaliza a sí misma, como se muestra en el siguiente código snippet:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.onActivity { activity ->
              startActivity(Intent(activity, MyOtherActivity::class.java))
            }

            val originalActivityState = scenario.state
        }
    }
}

Cómo volver a crear la actividad

Cuando un dispositivo tiene pocos recursos, el sistema puede destruir una actividad, requerir que tu app vuelva a crear esa actividad cuando el usuario regrese a ella Para simular estas condiciones, llama a recreate():

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.recreate()
        }
    }
}

La clase ActivityScenario mantiene el estado de instancia guardado de la actividad y cualquier objeto anotado con @NonConfigurationInstance Estos objetos cargan a la nueva instancia de la actividad que estás probando.

Cómo obtener los resultados de la actividad

Para obtener el código de resultado o los datos asociados con una actividad finalizada, obtén la del campo result en tu objeto ActivityScenario, como se muestra en el siguiente fragmento de código:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testResult() {
        launchActivity<MyActivity>().use {
            onView(withId(R.id.finish_button)).perform(click())

            // Activity under test is now finished.

            val resultCode = scenario.result.resultCode
            val resultData = scenario.result.resultData
        }
    }
}

Cómo activar acciones en la actividad

Todos los métodos dentro de ActivityScenario bloquean llamadas, por lo que la API requiere para ejecutarlas en el subproceso de instrumentación.

Para activar acciones en la actividad que estás probando, usa los comparadores de vistas de Espresso para interactuar con los elementos de tu vista:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use {
            onView(withId(R.id.refresh)).perform(click())
        }
    }
}

Sin embargo, si necesitas llamar a un método en la actividad en sí, puedes hacerlo. de forma segura implementando ActivityAction:

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @Test fun testEvent() {
        launchActivity<MyActivity>().use { scenario ->
            scenario.onActivity { activity ->
              activity.handleSwipeToRefresh()
            }
        }
    }
}