Une ressource idling représente une opération asynchrone dont les résultats affectent les opérations ultérieures dans un test d'UI. En enregistrant les ressources idling avec Espresso, vous pouvez valider ces opérations asynchrones de manière plus fiable lorsque vous testez votre application.
Identifier quand des ressources idling sont nécessaires
Espresso fournit un ensemble sophistiqué de fonctionnalités de synchronisation. Toutefois, cette caractéristique du framework ne s'applique qu'aux opérations qui publient des messages sur le MessageQueue, comme une sous-classe de View qui dessine son contenu à l'écran.
Comme Espresso n'a pas connaissance des autres opérations asynchrones, y compris celles qui s'exécutent sur un thread d'arrière-plan, il ne peut pas fournir ses garanties de synchronisation dans ces situations. Pour qu'Espresso soit informé des opérations de longue durée de votre application, vous devez enregistrer chacune d'elles en tant que ressource d'inactivité.
Si vous n'utilisez pas de ressources idling lorsque vous testez les résultats du travail asynchrone de votre application, vous devrez peut-être utiliser l'une des solutions de contournement suivantes pour améliorer la fiabilité de vos tests :
- Ajout d'appels à
Thread.sleep(). Lorsque vous ajoutez des délais artificiels à vos tests, l'exécution de votre suite de tests prend plus de temps, et vos tests peuvent toujours échouer lorsqu'ils sont exécutés sur des appareils plus lents. De plus, ces délais ne s'adaptent pas bien, car votre application peut avoir à effectuer des tâches asynchrones plus chronophages dans une version ultérieure. - Implémenter des wrappers de nouvelle tentative, qui utilisent une boucle pour vérifier de manière répétée si votre application effectue toujours un travail asynchrone jusqu'à ce qu'un délai avant expiration se produise. Même si vous spécifiez un nombre maximal de nouvelles tentatives dans vos tests, chaque réexécution consomme des ressources système, en particulier le processeur.
- Utiliser des instances de
CountDownLatch, qui permettent à un ou plusieurs threads d'attendre qu'un nombre spécifique d'opérations en cours d'exécution dans un autre thread soient terminées. Ces objets nécessitent que vous spécifiiez un délai avant expiration. Sinon, votre application risque d'être bloquée indéfiniment. Les verrous ajoutent également une complexité inutile à votre code, ce qui rend la maintenance plus difficile.
Espresso vous permet de supprimer ces solutions de contournement peu fiables de vos tests et d'enregistrer le travail asynchrone de votre application en tant que ressources inactives.
Cas d'utilisation courants
Lorsque vous effectuez des opérations semblables aux exemples suivants dans vos tests, envisagez d'utiliser une ressource idling :
- Charger des données depuis Internet ou une source de données locale
- Établir des connexions avec des bases de données et des rappels.
- Gérer les services, à l'aide d'un service système ou d'une instance de
IntentService. - Exécuter une logique métier complexe, telle que des transformations de bitmap.
Il est particulièrement important d'enregistrer les ressources idling lorsque ces opérations mettent à jour une UI que vos tests valident ensuite.
Exemples d'implémentations de ressources idling
La liste suivante décrit plusieurs exemples d'implémentations de ressources idling que vous pouvez intégrer à votre application :
CountingIdlingResource- Conserve un compteur des tâches actives. Lorsque le compteur est à zéro, la ressource associée est considérée comme inactive. Cette fonctionnalité ressemble beaucoup à celle d'un
Semaphore. Dans la plupart des cas, cette implémentation est suffisante pour gérer le travail asynchrone de votre application pendant les tests. UriIdlingResource- Semblable à
CountingIdlingResource, mais le compteur doit être égal à zéro pendant une période spécifique avant que la ressource ne soit considérée comme inactive. Ce délai d'attente supplémentaire prend en compte les requêtes réseau consécutives, où une application de votre thread peut effectuer une nouvelle requête immédiatement après avoir reçu une réponse à une requête précédente. IdlingThreadPoolExecutor- Une implémentation personnalisée de
ThreadPoolExecutorqui effectue le suivi du nombre total de tâches en cours d'exécution dans les pools de threads créés. Cette classe utilise unCountingIdlingResourcepour gérer le compteur des tâches actives. IdlingScheduledThreadPoolExecutor- Une implémentation personnalisée de
ScheduledThreadPoolExecutor. Elle fournit les mêmes fonctionnalités et capacités que la classeIdlingThreadPoolExecutor, mais elle peut également suivre les tâches planifiées pour l'avenir ou planifiées pour s'exécuter périodiquement.
Créer votre propre ressource idling
Lorsque vous utilisez des ressources idling dans les tests de votre application, vous devrez peut-être fournir une gestion ou une journalisation personnalisées des ressources. Dans ce cas, les implémentations listées dans la section précédente peuvent ne pas suffire. Si tel est le cas, vous pouvez étendre l'une de ces implémentations de ressources idling ou créer la vôtre.
Si vous implémentez votre propre fonctionnalité de ressource idling, tenez compte des bonnes pratiques suivantes, en particulier de la première :
- Appelez les transitions vers l'état inactif en dehors des vérifications d'inactivité.
- Une fois que votre application est inactive, appelez
onTransitionToIdle()en dehors de toute implémentation deisIdleNow(). De cette façon, Espresso n'effectue pas de deuxième vérification inutile pour déterminer si une ressource idling donnée est inactive.
L'extrait de code suivant illustre cette recommandation :
fun isIdle() { // DON'T call callback.onTransitionToIdle() here! } fun backgroundWorkDone() { // Background work finished. callback.onTransitionToIdle() // Good. Tells Espresso that the app is idle. // Don't do any post-processing work beyond this point. Espresso now // considers your app to be idle and moves on to the next test action. }
- Enregistrez les ressources idling avant d'en avoir besoin.
Les avantages de la synchronisation associés aux ressources idling ne prennent effet qu'après la première invocation par Espresso de la méthode
isIdleNow()de cette ressource.La liste suivante présente plusieurs exemples de cette propriété :
- Si vous enregistrez une ressource idling dans une méthode annotée avec
@Before, la ressource idling prend effet à la première ligne de chaque test. - Si vous enregistrez une ressource d'inactivité dans un test, elle prend effet lors de l'action Espresso suivante. Ce comportement se produit même si l'action suivante se trouve dans le même test que l'instruction qui enregistre la ressource idling.
- Si vous enregistrez une ressource idling dans une méthode annotée avec
- Annulez l'enregistrement des ressources idling une fois que vous avez fini de les utiliser.
Pour préserver les ressources système, vous devez annuler l'enregistrement des ressources idling dès que vous n'en avez plus besoin. Par exemple, si vous enregistrez une ressource idling dans une méthode annotée avec
@Before, il est préférable de la désenregistrer dans une méthode correspondante annotée avec@After.- Utilisez un registre d'inactivité pour enregistrer et annuler l'enregistrement des ressources d'inactivité.
En utilisant ce conteneur pour les ressources idling de votre application, vous pouvez enregistrer et annuler l'enregistrement des ressources idling à plusieurs reprises, selon vos besoins, tout en observant un comportement cohérent.
- Ne conservez que l'état simple de l'application dans les ressources idling.
Par exemple, les ressources idling que vous implémentez et enregistrez ne doivent pas contenir de références à des objets
View.
Enregistrer des ressources idling
Espresso fournit une classe de conteneur dans laquelle vous pouvez placer les ressources idling de votre application. Cette classe, appelée IdlingRegistry, est un artefact autonome qui n'entraîne qu'une surcharge minimale pour votre application. Elle vous permet également de prendre les mesures suivantes pour améliorer la facilité de maintenance de votre application :
- Créez une référence à
IdlingRegistry, au lieu des ressources idling qu'il contient, dans les tests de votre application. - Conservez les différences dans la collection de ressources idling que vous utilisez pour chaque variante de compilation.
- Définissez les ressources idling dans les services de votre application, plutôt que dans les composants d'interface utilisateur qui font référence à ces services.
Intégrer des ressources idling dans votre application
Bien que vous puissiez ajouter des ressources idling à une application de différentes manières, une approche en particulier permet de conserver l'encapsulation de votre application tout en vous permettant de spécifier une opération particulière représentée par une ressource idling donnée.
Approche recommandée
Lorsque vous ajoutez des ressources idling à votre application, nous vous recommandons vivement de placer la logique de la ressource idling dans l'application elle-même et de n'effectuer que les opérations d'enregistrement et de désinscription dans vos tests.
Bien que cette approche crée une situation inhabituelle d'utilisation d'une interface réservée aux tests dans le code de production, vous pouvez encapsuler les ressources idling autour du code dont vous disposez déjà, en conservant la taille de l'APK et le nombre de méthodes de votre application.
Autres approches
Si vous préférez ne pas inclure de logique de ressources idling dans le code de production de votre application, il existe plusieurs autres stratégies d'intégration viables :
- Créez des variantes de compilation, telles que les types de produit de Gradle, et n'utilisez les ressources idling que dans la version de débogage de votre application.
- Utilisez un framework d'injection de dépendances comme Dagger pour injecter le graphique de dépendance de la ressource idling de votre application dans vos tests. Si vous utilisez Dagger 2, l'injection elle-même doit provenir d'un sous-composant.
Implémentez une ressource idling dans les tests de votre application et exposez la partie de l'implémentation de votre application qui doit être synchronisée dans ces tests.
Attention : Bien que cette décision de conception semble créer une référence autonome aux ressources idling, elle interrompt également l'encapsulation dans toutes les applications, sauf les plus simples.
Ressources supplémentaires
Pour en savoir plus sur l'utilisation d'Espresso dans les tests Android, consultez les ressources suivantes.
Exemples
- IdlingResourceSample : synchronisation avec les tâches en arrière-plan.