Tester les changements de configuration de l'écran avec l'API Espresso Device

Utilisez l'API Espresso Device pour tester votre application lorsque l'appareil subit des modifications de configuration courantes, telles que la rotation et le dépliage de l'écran. L'API Espresso Device est l'outil recommandé pour simuler des actions au niveau de l'appareil en plus de vos règles de test Jetpack Compose. Si vous ne savez pas comment écrire des tests d'interface utilisateur pour Jetpack Compose, consultez la section Tester votre mise en page Compose.

L'API Espresso Device vous permet de simuler des modifications de configuration sur un appareil virtuel et d'exécuter vos tests de manière synchrone. Ainsi, une seule action ou assertion d'interface utilisateur se produit à la fois, et les résultats de vos tests sont plus fiables. Si vous ne savez pas comment écrire des tests d'interface utilisateur avec Espresso, consultez sa documentation.

Pour utiliser l'API Espresso Device, vous avez besoin des éléments suivants :

• Android Studio Iguana ou version ultérieure
• Plug-in Android Gradle 8.3 ou version ultérieure
• Émulateur Android 33.1.10 ou version ultérieure
• Appareil virtuel Android exécutant le niveau d'API 24 ou version ultérieure

Configurer votre projet pour l'API Espresso Device

Pour configurer votre projet afin qu'il soit compatible avec l'API Espresso Device, procédez comme suit :

1. Pour que le test transmette des commandes à l'appareil de test, ajoutez les autorisations INTERNET et ACCESS_NETWORK_STATE au fichier manifeste dans l'ensemble de sources androidTest :

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

2. Activez l'indicateur expérimental enableEmulatorControl dans le fichier gradle.properties :

     android.experimental.androidTest.enableEmulatorControl=true
   

3. Activez l'option emulatorControl dans le script de compilation au niveau du module :

   Kotlin

     testOptions {
       emulatorControl {
         enable = true
       }
     }
     

   Groovy

     testOptions {
       emulatorControl {
         enable = true
       }
     }
     

4. Dans le script de compilation au niveau du module, importez la bibliothèque Espresso Device dans votre projet :

   Kotlin

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

   Groovy

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

Tester les modifications de configuration courantes

L'API Espresso Device comporte plusieurs orientations d'écran et états pliables que vous pouvez utiliser pour simuler des modifications de configuration de l'appareil. Les exemples suivants montrent comment déclencher ces états de l'appareil et vérifier les modifications d'interface utilisateur résultantes à l'aide des règles de test Compose.

Tester la rotation de l'écran

Voici un exemple de test de ce qui se passe dans votre application lorsque l'écran de l'appareil pivote :

1. Commencez par définir votre règle de test Compose et définissez l'appareil sur un état de démarrage cohérent (comme le mode Portrait) :

   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)
   }
   

2. Créez un test qui définit l'appareil sur l'orientation Paysage lors de l'exécution du test :

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

3. Une fois l'écran pivoté, utilisez composeTestRule pour vérifier que vos composables s'adaptent au nouvel état comme prévu.

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

Tester le dépliage de l'écran

Voici un exemple de test de ce qui se passe dans votre application si elle se trouve sur un appareil pliable et que l'écran se déplie :

1. Commencez par tester l'appareil en mode plié en appelant onDevice().setClosedMode(). Assurez-vous que vos composables s'adaptent à la largeur d'écran compacte.

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

2. Pour passer à un état entièrement déplié, appelez onDevice().setFlatMode(). Vérifiez que les composables s'adaptent à la classe de taille étendue.

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

Spécifier les appareils dont vos tests ont besoin

Si vous exécutez un test qui effectue des actions de pliage sur un appareil qui n'est pas pliable, le test échouera probablement. Pour n'exécuter que les tests pertinents pour l'appareil en cours d'exécution, utilisez l'annotation @RequiresDeviceMode. Le test runner ignore automatiquement l'exécution des tests sur les appareils qui ne sont pas compatibles avec la configuration testée. Vous pouvez ajouter la règle d'exigence de l'appareil à chaque test ou à une classe de test entière.

Par exemple, pour spécifier qu'un test ne doit être exécuté que sur les appareils compatibles avec le dépliage dans une configuration à plat, ajoutez le code @RequiresDeviceMode suivant à votre test :

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