Cómo realizar pruebas con los cambios en la configuración de la pantalla con la API de Espresso Device

Usa la API de Espresso Device para probar tu app cuando el dispositivo experimenta cambios de configuración comunes, como la rotación y el despliegue de la pantalla. La API de Espresso Device es la herramienta recomendada para realizar acciones a nivel del dispositivo junto con tus reglas de prueba de Jetpack Compose. Si no tienes experiencia en la escritura de pruebas de IU para Jetpack Compose, consulta Cómo probar tu diseño de Compose.

La API de Espresso Device te permite activar cambios de configuración en un dispositivo virtual y ejecutar tus pruebas de forma síncrona, de modo que solo se produzca una acción o aserción de IU a la vez y los resultados de las pruebas sean más confiables. Si no tienes experiencia en la escritura de pruebas de IU con Espresso, consulta su documentación.

Para usar la API de Espresso Device, necesitas lo siguiente:

  • Android Studio Iguana o versiones posteriores
  • Complemento de Android para Gradle 8.3 o versiones posteriores
  • Android Emulator 33.1.10 o versiones posteriores
  • Dispositivo virtual de Android que ejecuta el nivel de API 24 o versiones posteriores

Configura tu proyecto para la API de Espresso Device

Para configurar tu proyecto de modo que admita la API de Espresso Device, haz lo siguiente:

  1. Para permitir que la prueba pase comandos al dispositivo de prueba, agrega los permisos de red necesarios al archivo de manifiesto en el conjunto de orígenes androidTest:

      <uses-permission android:name="android.permission.INTERNET" />
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

    Si tu prueba se orienta a Android 17 (nivel de API 37) o versiones posteriores, también debes declarar el permiso ACCESS_LOCAL_NETWORK:

      <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />

  2. Habilita la marca experimental enableEmulatorControl en el archivo gradle.properties:

      android.experimental.androidTest.enableEmulatorControl=true

  3. Habilita la opción emulatorControl en la secuencia de comandos de compilación a nivel de módulo:

    Kotlin

      testOptions {
    emulatorControl {
      enable = true
    }
  }

    Groovy

      testOptions {
    emulatorControl {
      enable = true
    }
  }

  4. En la secuencia de comandos de compilación a nivel de módulo, importa la biblioteca de Espresso Device a tu proyecto:

    Kotlin

    dependencies {
  androidTestImplementation("androidx.test.espresso:espresso-device:1.1.0")
}

    Groovy

    dependencies {
  androidTestImplementation 'androidx.test.espresso:espresso-device:1.1.0'
}

Realiza pruebas en función de cambios de configuración comunes

La API de Espresso Device tiene varios estados de orientación de pantalla y plegables que puedes usar para activar cambios de configuración del dispositivo. En los siguientes ejemplos, se muestra cómo activar estos estados del dispositivo y verificar los cambios de IU resultantes con las reglas de prueba de Compose.

Realiza pruebas en función de la rotación de la pantalla

Para probar la rotación de la pantalla, puedes usar la clase ScreenOrientationRule para definir la orientación del dispositivo durante la prueba.

Este es un ejemplo de cómo probar lo que sucede con tu app cuando gira la pantalla del dispositivo:

  1. Primero, define tu regla de prueba de Compose y usa la clase ScreenOrientationRule para configurar el dispositivo en un estado inicial coherente (como el modo vertical):

    import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.assertDoesNotExist
import androidx.compose.ui.test.junit4.createComposeRule
import androidx.compose.ui.test.onNodeWithTag
import androidx.test.espresso.device.EspressoDevice.onDevice
import androidx.test.espresso.device.action.ScreenOrientation
import androidx.test.espresso.device.rules.ScreenOrientationRule
import org.junit.Rule
import org.junit.Test

class MyConfigurationTest {

    // 1. Define the Compose test rule
    @get:Rule
    val composeTestRule = createComposeRule()

    // 2. Define the Espresso Device rule for a consistent starting state
    @get:Rule
    val screenOrientationRule = ScreenOrientationRule(ScreenOrientation.PORTRAIT)
}

    Si tu prueba se orienta a Android 17 (nivel de API 37) o versiones posteriores, la API de Espresso Device requiere el permiso ACCESS_LOCAL_NETWORK. Debes asegurarte de que se otorgue este permiso antes de que se ejecute la regla ScreenOrientationRule. Usa RuleChain de JUnit para ejecutar primero la regla GrantPermissionRule:

    import androidx.test.rule.GrantPermissionRule
import org.junit.rules.RuleChain

class MyConfigurationTest {
    val grantPermissionRule = GrantPermissionRule.grant(android.Manifest.permission.ACCESS_LOCAL_NETWORK)
    val composeTestRule = createComposeRule()
    val screenOrientationRule = ScreenOrientationRule(ScreenOrientation.PORTRAIT)

    @get:Rule
    val chain = RuleChain
        .outerRule(grantPermissionRule)
        .around(composeTestRule)
        .around(screenOrientationRule)
}

  2. Crea una prueba que configure el dispositivo en orientación horizontal durante la ejecución de la prueba:

    @Test
fun myRotationTest() {
  ...
  // Sets the device to landscape orientation during test execution.
  onDevice().setScreenOrientation(ScreenOrientation.LANDSCAPE)
  ...
}

  3. Después de que gire la pantalla, usa composeTestRule para verificar que tus elementos componibles se adapten al nuevo estado según lo previsto.

    @Test
fun myRotationTest() {
  ...
  // Sets the device to landscape orientation during test execution.
  onDevice().setScreenOrientation(ScreenOrientation.LANDSCAPE)
  composeTestRule.onNodeWithTag("NavRail").assertIsDisplayed()
  composeTestRule.onNodeWithTag("BottomBar").assertDoesNotExist()
}

Realiza pruebas en función del despliegue de la pantalla

Este es un ejemplo de cómo probar lo que sucede con tu app si está en un dispositivo plegable y la pantalla se despliega:

  1. Primero, prueba con el dispositivo en estado plegado llamando a onDevice().setClosedMode(). Asegúrate de que tus elementos componibles se adapten al ancho de pantalla compacto.

    @Test
fun myUnfoldedTest() {
  onDevice().setClosedMode()
  composeTestRule.onNodeWithTag("BottomBar").assertIsDisplayed()
  composeTestRule.onNodeWithTag("NavRail").assertDoesNotExist()
  ...
}

  2. Para realizar la transición a un estado completamente desplegado, llama a onDevice().setFlatMode(). Verifica que los elementos componibles se adapten a la clase de tamaño expandida.

    @Test
fun myUnfoldedTest() {
  onDevice().setClosedMode()
  ...
  onDevice().setFlatMode()
  composeTestRule.onNodeWithTag("NavRail").assertIsDisplayed()
  composeTestRule.onNodeWithTag("BottomBar").assertDoesNotExist()
}

Especifica qué dispositivos necesitan tus pruebas

Si ejecutas una prueba que realiza acciones de plegado en un dispositivo que no es plegable, es probable que la prueba falle. Para ejecutar solo las pruebas que son relevantes para el dispositivo en ejecución, usa la anotación @RequiresDeviceMode. El ejecutor de pruebas omite automáticamente la ejecución de pruebas en dispositivos que no admiten la configuración que se está probando. Puedes agregar la regla de requisito del dispositivo a cada prueba o a una clase de prueba completa.

Por ejemplo, para especificar que una prueba solo se debe ejecutar en dispositivos que admiten el despliegue a una configuración plana, agrega el siguiente código @RequiresDeviceMode a tu prueba:

@Test
@RequiresDeviceMode(mode = FLAT)
fun myUnfoldedTest() {
  ...
}