Reading Time: 4 minutes
UI Auto…quoi ?
Comme son nom l’indique, UI Automator est un framework fourni par Android permettant d’exécuter des tests fonctionnels d’interface utilisateur (UI pour User Interface en anglais) de façon automatisée.
Ce framework permet d’interagir avec les éléments visibles sur l’écran du smartphone : cliquer sur un bouton, remplir un champ texte, scroller, etc.
Grâce à UI Automator, vous pouvez par exemple lancer une application, remplir un formulaire de login, naviguer dans les menus…
Écrivons ensemble un premier scénario de test avec UI Automator !
Notre objectif sera modeste : lancer une vidéo depuis l’application YouTube pour Android.
UI Automator, Espresso, Appium…
Dans le framework Android, vous trouverez aussi Espresso : quelle est la différence ?
UI Automator est plutôt orienté tests « boîte noire » : vous pouvez tester n’importe quelle application (même si vous n’avez pas le code) ou même accéder à des paramètres systèmes d’Android (par exemple le panneau de configuration).
Espresso, lui est plutôt orienté tests « boîte blanche » : vous devez avoir le code de l’application à tester, vous pouvez effectuer des assertions plus fines (par exemple sur la création d’activité dans l’application).
Il existe également d’autres outils, comme Appium, mais qui ne sont pas intégrés dans le framework Android.
Ils ont l’avantage d’offrir des fonctionnalités en plus et des couches d’abstractions supplémentaires. C’est cependant au prix d’une certaines complexité de mise en place.
Vous l’aurez compris, UI Automator est pour nous le plus adapté et le plus simple pour commencer rapidement !
Première étape : mettre en place l’environnement de travail
Les tests UI Automator font partie de la famille des test instrumentés : ils doivent être exécutés sur un smartphone ou sur un émulateur Android.
Pendant le test, deux APK s’exécutent au sein du même processus : un premier APK pour l’application à tester et un deuxième APK pour le test.
Vous avez donc besoin d’une application (et d’un scénario !) à tester.
Le code source d’une application Android est usuellement organisé de la façon suivante :
module
|---src
|---androidTest
|---main
|---test
Premier cas : vous êtes le développeur de l’application à tester.
La solution la plus simple consiste alors à développer les tests dans le même module que l’application.
Le dossier main contiendra alors le code source de votre application et le dossier androidTest vos tests UI Automator.
Deuxième cas : vous n’avez pas le code source de l’application à tester.
Il vous suffit alors de créer un nouveau module : le dossier main sera vide et, comme précédemment, le dossier androidTest contiendra vos test UI Automator.
Dans le fichier build.gradle du module, ajoutez les configurations suivantes (UI Automator fonctionne avec AndroidJUnitRunner) :
android {
...
defaultConfig {
...
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
...
}
dependencies {
...
androidTestCompile 'com.android.support.test.uiautomator:uiautomator-v18:2.1.2'
androidTestCompile 'com.android.support.test:runner:0.5'
}
Après vous être assuré que le projet compile correctement, il est temps d’ajouter une nouvelle classe dans module/src/androidTest :
@RunWith(AndroidJUnit4.class)
public class YouTubeTest {
@Test
public void watchVideo() throws Exception {
// TODO
}
}
Tout est maintenant prêt pour l’implémentation du scénario de test !
Deuxième étape : écrire les tests
Quelques petites précisions avant de se lancer…
UI Automator permet d’interagir avec les éléments visibles sur l’écran.
Chaque élément possède un certain nombre de propriétés, parmi lesquelles : content-description, class, resource-id, text.
UI Automator permet de rechercher un élément vérifiant une propriété donnée.
Par exemple, pour accéder au bouton Valider affiché sur votre écran, vous pouvez rechercher l’élément dont la propriété text vaut Valider.
Mais vous pouvez aussi être plus spécifique, par exemple : l’élément dont la class est android.widget.EditText et la content-description est text_name.
La (ou les) propriété(s) utilisée(s) pour rechercher un élément a son importance.
Par exemple, méfiez-vous des libellés, notamment si votre application est disponible en plusieurs langues !
Afin de connaître les propriétés des éléments visibles sur l’écran, il est très pratique d’utiliser l’outil Android uiautomatorviewer (que vous trouverez dans le répertoire tools de votre SDK Android).
Une fois lancé, cet outil permet de faire des captures d’écran d’un smartphone Android.
À chaque capture d’écran est associée un arbre représentant la hiérarchie des éléments visibles, avec leurs propriétés respectives.
Revenons à notre scénario de test, pour lequel nous nous proposons d’effectuer les actions suivantes :
- lancer l’application YouTube ;
- cliquer sur la loupe pour effectuer une recherche ;
- indiquer le texte « greenspector » dans le champ de recherche ;
- lancer la vidéo « Power Test Cloud – Greenspector (FR) » ;
- regarder les 20 premières secondes de la vidéo.
Avant de démarrer toute interaction avec les éléments sur l’écran, il faut instancier un objet UiDevice qui représentera l’état actuel de l’écran du smartphone.
UiDevice mDevice = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
Commençons par lancer l’application YouTube, comme expliqué dans la documentation Android.
L’objet de cet article étant de dérouler quelques fonctionnalités les plus simples d’UI Automator, cette étape n’est pas détaillée.
L’étape suivante consiste à cliquer sur la loupe pour effectuer une recherche.
Après avoir repéré le resource-id de la loupe grâce à uiautomatorviewer, nous utilisons la méthode waitForExists permettant d’attendre que l’élément apparaisse avant de cliquer sur l’objet.
UiObject icon = mDevice.findObject(new UiSelector().resourceId("com.google.android.youtube:id/menu_search"));
icon.waitForExists(TIMEOUT);
icon.click();
Nous nous servons ensuite de la méthode setText pour renseigner le mot clé de recherche souhaité.
UiObject editText = mDevice.findObject(new UiSelector().text("Search YouTube"));
editText.waitForExists(TIMEOUT);
editText.setText("greenspector");
mDevice.pressEnter();
Précédemment, nous n’avons utilisé qu’un seul critère pour rechercher les éléments sur l’écran.
Mais il est possible d’en combiner plusieurs (si certaines propriétés ont la même valeur pour plusieurs éléments), par exemple :
UiObject video = mDevice.findObject(new UiSelector()
.resourceId("com.google.android.youtube:id/title")
.text("Power Test Cloud - Greenspector (FR)"));
Enfin, attendons quelques secondes en regardant le début de la vidéo.
synchronized (mDevice) {
mDevice.wait(20000);
}
Troisième étape : exécuter les tests
Afin d’exécuter les tests, il est nécessaire d’être connecté via ADB à un smartphone (soit un smartphone physique « réel », soit un émulateur Android).
Le lancement peut s’effectuer directement depuis Android Studio, ou bien en ligne de commande avec ADB.
Premier cas : depuis Android Studio.
Se rendre dans le menu Run, puis Edit configurations.
Cliquer sur le signe + pour ajouter une configuration, sélectionner le modèle Android Instrumented Tests.
Adapter la configuration avec le nom du module à tester, le type de test, le smartphone (réel ou émulateur).
Deuxième cas : en ligne de commande avec ADB.
Tout d’abord, compiler l’application ainsi que les tests, par exemple en utilisant les tâches assemble et assembleAndroidTest du wrapper Gradle :
$ ./gradlew clean assemble assembleAndroidTest
Puis installer sur le smartphone les fichiers .apk générés :
$ adb install module/build/outputs/apk/module-debug.apk
$ adb install module/build/outputs/apk/module-debug-androidTest.apk
Enfin, lancer le test :
$ adb shell am instrument com.package.test/android.test.InstrumentationTestRunner
Conclusion
Et voilà ! Objectif atteint pour ce premier test simple UI Automator, c’est maintenant à vous de jouer !
Pour aller plus loin
Documentation Android sur UI Automator.
Documentation Android sur ADB.
