Les activités servent de conteneurs pour chaque interaction utilisateur dans votre application. Il est donc important de tester le comportement des activités de votre application lors d'événements au niveau de l'appareil, tels que les suivants :
- Une autre application, telle que l'application Téléphone de l'appareil, interrompt l'activité de votre application.
- Le système détruit et recrée votre activité.
- L'utilisateur place votre activité dans un nouvel environnement de fenêtrage, tel que le mode Picture-in-Picture (PIP) ou le mode multifenêtre.
En particulier, il est important de vous assurer que votre activité se comporte correctement en réponse aux événements décrits dans le cycle de vie de l'activité.
Ce guide explique comment évaluer la capacité de votre application à maintenir l'intégrité des données et une bonne expérience utilisateur lorsque les activités de votre application passent par différents états de leur cycle de vie.
Tester des activités dans Compose
Lorsque vous testez une application créée avec Jetpack Compose, vous utilisez généralement
createAndroidComposeRule pour lancer votre activité et interagir avec vos
composants d'interface utilisateur.
Toutefois, pour tester les événements au niveau de l'appareil, tels que les modifications de configuration ou la mise en arrière-plan ou la destruction de l'activité par le système, vous devez manipuler directement le cycle de vie de l'activité. Pour ce faire, vous utilisez le
framework ActivityScenario sous-jacent.
La règle de test Compose encapsule et gère automatiquement ce scénario pour vous. Tout au long de ce guide, vous verrez le modèle suivant utilisé pour combler le fossé entre les tests d'interface utilisateur modernes et la gestion standard du cycle de vie :
@get:Rule
val composeTestRule = createAndroidComposeRule<MyActivity>()
@Test fun testEvent() {
val scenario = composeTestRule.activityRule.scenario
// ...
}
Gérer l'état d'une activité
Un aspect clé du test des activités de votre application consiste à placer les activités de votre application dans des états spécifiques. Pour définir cette partie "given" de vos tests, utilisez
des instances de ActivityScenario, qui font partie de la bibliothèque de test AndroidX. À l'aide de cette classe, vous pouvez placer votre activité dans des états qui simulent des événements au niveau de l'appareil.
ActivityScenario est une API multiplate-forme que vous pouvez utiliser dans les tests unitaires locaux et les tests d'intégration sur l'appareil. Sur un appareil réel ou virtuel, ActivityScenario assure la sécurité des threads en synchronisant les événements entre le thread d'instrumentation de votre test et le thread qui exécute votre activité testée.
L'API est particulièrement adaptée pour évaluer le comportement d'une activité testée lorsqu'elle est détruite ou créée. Cette section présente les cas d'utilisation les plus courants associés à cette API.
Créer une activité
Pour créer l'activité testée, ajoutez le code indiqué dans l'extrait suivant :
@RunWith(AndroidJUnit4::class)
class MyTestSuite {
@Test fun testEvent() {
launchActivity<MyActivity>().use {
}
}
}
Après avoir créé l'activité, ActivityScenario la fait passer à l'état RESUMED. Cet état indique que votre activité est en cours d'exécution et qu'elle est visible par les utilisateurs. Dans cet état, vous pouvez interagir avec les composables de votre activité
à l'aide des API de test Compose.
Google vous recommande d'appeler close sur l'activité une fois le test terminé.
Cela permet de nettoyer les ressources associées et d'améliorer la stabilité de vos tests. ActivityScenario implémente Closeable. Vous pouvez donc appliquer l'extension use pour que l'activité se ferme automatiquement.
Vous pouvez également utiliser createAndroidComposeRule pour lancer automatiquement l'Activity avant chaque test, gérer la suppression et vous donner accès à la fois aux méthodes de test de l'interface utilisateur Compose et à l'élément ActivityScenario sous-jacent. L'exemple suivant montre comment définir une règle et obtenir une instance de scénario à partir de celle-ci :
@RunWith(AndroidJUnit4::class)
class MyTestSuite {
@get:Rule
val composeTestRule = createAndroidComposeRule<MyActivity>()
@Test fun testEvent() {
val scenario = composeTestRule.activityRule.scenario
}
}
Faire passer l'activité à un nouvel état
Pour faire passer l'activité à un autre état, tel que CREATED ou STARTED, appelez moveToState. Cette action simule une situation dans laquelle votre activité est respectivement arrêtée ou mise en pause, car elle est interrompue par une autre application ou une action système.
Un exemple d'utilisation de moveToState apparaît dans l'extrait de code suivant :
@RunWith(AndroidJUnit4::class)
class MyTestSuite {
@Test fun testEvent() {
launchActivity<MyActivity>().use { scenario ->
scenario.moveToState(State.CREATED)
}
}
}
Déterminer l'état actuel de l'activité
Pour déterminer l'état actuel d'une activité testée, obtenez la valeur du champ state dans votre objet ActivityScenario. Il est particulièrement utile de vérifier l'état d'une activité testée si elle redirige vers une autre activité ou se termine elle-même, comme illustré dans l'extrait de code suivant :
@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
}
}
}
Recréer l'activité
Lorsque les ressources d'un appareil sont faibles, le système peut détruire une activité, ce qui oblige votre application à recréer cette activité lorsque l'utilisateur revient à votre application. Pour simuler ces conditions, appelez recreate :
@RunWith(AndroidJUnit4::class)
class MyTestSuite {
@Test fun testEvent() {
launchActivity<MyActivity>().use { scenario ->
scenario.recreate()
}
}
}
La classe ActivityScenario conserve l'état d'instance enregistré de l'activité et tous les objets annotés à l'aide de @NonConfigurationInstance. Ces objets sont chargés dans la nouvelle instance de votre activité testée.
Récupérer les résultats de l'activité
Pour obtenir le code de résultat ou les données associées à une activité terminée, obtenez la valeur du champ result dans votre objet ActivityScenario. À l'aide de createAndroidComposeRule, vous pouvez facilement déclencher l'action d'interface utilisateur qui termine l'activité, comme illustré dans l'extrait de code suivant :
@RunWith(AndroidJUnit4::class)
class MyTestSuite {
@get:Rule
val composeTestRule = createAndroidComposeRule<MyActivity>()
@Test fun testResult() {
composeTestRule.onNodeWithTag("finish_button").performClick()
val scenario = composeTestRule.activityRule.scenario
val resultCode = scenario.result.resultCode
val resultData = scenario.result.resultData
}
}
Déclencher des actions dans l'activité
Toutes les méthodes de ActivityScenario sont des appels bloquants. L'API vous oblige donc à les exécuter dans le thread d'instrumentation.
Pour déclencher des actions dans votre activité testée, utilisez les API de test Compose pour interagir avec vos composables :
@RunWith(AndroidJUnit4::class)
class MyTestSuite {
@get:Rule
val composeTestRule = createAndroidComposeRule<MyActivity>()
@Test fun testEvent() {
composeTestRule.onNodeWithText("Refresh").performClick()
}
}
Toutefois, si vous devez appeler une méthode sur l'activité elle-même, vous pouvez le faire en toute sécurité à l'aide de onActivity :
@RunWith(AndroidJUnit4::class)
class MyTestSuite {
@Test fun testEvent() {
launchActivity<MyActivity>().use { scenario ->
scenario.onActivity { activity ->
activity.handleSwipeToRefresh()
}
}
}
}
Ressources supplémentaires
Pour en savoir plus sur les tests, consultez les ressources supplémentaires suivantes :