Tester les activités de votre application

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 multifenêtre.

En particulier, il est important de s'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 décrit 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 d'un état à un autre dans leur cycle de vie.

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 particuliers. Pour définir cette partie "given" de vos tests, utilisez des instances de ActivityScenario, qui font partie de la bibliothèque AndroidX Test. Cette classe vous permet de 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é en cours de test.

L'API est particulièrement adaptée pour évaluer le comportement d'une activité en cours de test 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é à tester, ajoutez le code indiqué dans l'extrait suivant :

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

Une fois l'activité créée, ActivityScenario la fait passer à l'état RESUMED. Cet état indique que votre activité est en cours d'exécution et visible par les utilisateurs. Dans cet état, vous êtes libre d'interagir avec les éléments View de votre activité à l'aide des tests de l'UI Espresso.

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 ou try-with-resources dans le langage de programmation Java pour que l'activité se ferme automatiquement.

Vous pouvez également utiliser ActivityScenarioRule pour appeler automatiquement ActivityScenario.launch avant chaque test et ActivityScenario.close lors de la suppression du test. 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 var activityScenarioRule = activityScenarioRule<MyActivity>()

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

Faire passer l'activité à un nouvel état

Pour que l'activité passe à 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é en cours de test, obtenez la valeur du champ state dans votre objet ActivityScenario. Il est particulièrement utile de vérifier l'état d'une activité en cours de test si elle redirige vers une autre activité ou se termine elle-même, comme le montre 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é

Lorsqu'un appareil manque de ressources, le système peut détruire une activité, ce qui oblige votre application à recréer cette activité lorsque l'utilisateur y revient. 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 se chargent dans la nouvelle instance de votre activité en cours de test.

Récupérer les résultats d'une 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, comme indiqué dans l'extrait de code suivant :

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

Déclencher des actions dans l'activité

Toutes les méthodes de ActivityScenario sont des appels bloquants. L'API vous demande donc de les exécuter dans le thread d'instrumentation.

Pour déclencher des actions dans votre activité testée, utilisez les outils de mise en correspondance des affichages Espresso pour interagir avec les éléments de votre affichage :

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

Toutefois, si vous devez appeler une méthode sur l'activité elle-même, vous pouvez le faire en toute sécurité en implémentant ActivityAction :

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