Premiers pas avec android-espresso

Vérification des éléments du menu Options (en utilisant Spoon pour prendre des captures d’écran)

/**
 * @author piotrek1543
 *
 * This example provides a specific UI testing problem and how it is already solved 
 * with Google's Espresso. Notice that I used also Spoon framework, as Espresso 
 * lacks of taking screenshots functionality.
 */

@RunWith(AndroidJUnit4.class)
public class MainActivityAndroidTest {
    @Rule
    public ActivityTestRule<MainActivity> mRule = new ActivityTestRule<>(MainActivity.class);

    @Test
    public void checkIfSettingsMenuItemsAreVisible() throws InterruptedException {
        //open OptionsMenu to see available items
        openActionBarOverflowOrOptionsMenu(mRule.getActivity());
        //create a screenshot with 'options_menu' TAG
        Spoon.screenshot(mRule.getActivity(), "options_menu");
        //check if Settings item is Visible
        onView(withText(R.string.action_settings)).check(matches(isDisplayed()));
        //check if `Sort` item is Visible
        onView(withText(R.string.action_sort)).check(matches(isDisplayed()));
        //perform click on `Sort` OptionsMenu item
        onView(withText(R.string.action_sort)).perform(click());
        //create a screenshot with 'options_menu_sort' TAG
        Spoon.screenshot(mRule.getActivity(), "options_menu_sort");
        //check if `Sort -> By Value id` item is Visible
        onView(withText(R.string.menu_sort_length)).check(matches(isDisplayed()));
        //check if `Sort -> By Joke length` item is Visible
        onView(withText(R.string.menu_sort_a_z)).check(matches(isDisplayed()));
    }
}

Voir le test

onView(withId(R.id.greet_button)) // withId(R.id.my_view) is a ViewMatcher
.perform(click())                 // click() is a ViewAction
.check(matches(not(isEnabled())); // matches(isEnabled()) is a ViewAssertion

Trouver une vue par ID

onView(withId(R.id.pay))

Trouver la vue par le texte

onView(withText("Pay"))
onView(withText(R.string.pay))

Exemple d’espresso Hello World

Ceci est un tutoriel pour créer un exemple hello world : Utilisé pour cet exemple : Android Studio 2.3 ;

Pour commencer, utilisez Android Studio pour créer un nouveau projet avec une activité vide. Ensuite, nous ajoutons quelques fonctionnalités simples à l’application que nous pouvons tester : nous ajoutons un bouton qui, lors d’un clic, affiche “Hello World” dans une vue textuelle.

Le code d’activité ressemble à ceci :

package com.example.testing.helloworld;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        final TextView textView = (TextView) findViewById(R.id.textView);

        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                textView.setText("Hello World!");
            }
        });
    }
}

Et la mise en page activity_main pour cette activité ressemble à ceci :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Say Hello" />
</LinearLayout>

Nous voulons maintenant tester le comportement de cette nouvelle application créée en utilisant espresso. Généralement, le code de votre application elle-même se trouve dans le package “main”, les tests unitaires se trouvent dans “test” et les tests d’instrumentation expresso se trouvent dans le package “androidTest”. Si vous créez un nouveau projet d’activité vide avec Android Studio, il devrait déjà avoir créé ces packages et classes et il devrait ressembler à ceci :

[![entrez la description de l’image ici][1]][1]

Pour commencer avec espresso, nous devons nous assurer que la dépendance espresso-core est incluse dans le fichier build.gradle (notez qu’elle n’est pas annotée avec le mot-clé compile mais à la place avec androidTestCompile). Les dépendances dans le fichier build.gradle créé par le studio Android devraient ressembler à ceci :

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:25.2.0'
    compile 'com.android.support.constraint:constraint-layout:1.0.2'
    testCompile 'junit:junit:4.12'
}

Maintenant que tout est configuré, nous pouvons commencer par le test proprement dit : ouvrez le fichier ExampleInstrumentationTest et vous voyez qu’il y a déjà un test useAppContext généré à l’intérieur. Nous allons modifier cette classe de test et créer un test pour vérifier le comportement de notre application :

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {

    @Rule
    public ActivityTestRule<MainActivity> mActivityRule = new ActivityTestRule<>(
        MainActivity.class, false, true);

    @Test
    public void checkHelloWorld() throws Exception {
        onView(withId(R.id.textView)).check(matches(withText("")));
        onView(withId(R.id.button)).perform(click());
        onView(withId(R.id.textView)).check(matches(withText("Hello World!")));
    }
}

Démarrez le test en exécutant la classe ExampleInstrumentedTest. Ce test fait alors trois choses :

  1. Il vérifie si le textview contient une chaîne vide ("")
  2. Il clique sur le bouton dans notre mise en page
  3. Il vérifie à nouveau le texte du textview s’il contient “Hello World!”

Le [ActivityTestRule][2] en haut définit quelle activité est testée et la lance au début du test. (Vous pouvez également désactiver le lancement automatique d’une activité et la lancer à la place dans chaque test manuellement)

Les règles du test sont assez simples :

  • onView(withId(R.id.textView)) recherche une vue à l’intérieur de l’écran actuel par l’ID de la vue à l’intérieur de notre fichier de mise en page activity_main.
  • .check(matches(withText(""))); effectue ensuite un cas de test sur cette vue.
  • .perform(click()) exécute une action sur une vue : ces actions peuvent être des clics, des clics longs ou des balayages ou d’autres.

C’était un tutoriel pour commencer avec les tests d’instrumentation d’espresso Android, j’espère qu’il vous a donné quelques idées !

[1] : https://i.stack.imgur.com/KcjES.png [2] : https://developer.android.com/reference/android/support/test/rule/ActivityTestRule.html

## Instructions de configuration de l’espresso

  • Configurer votre environnement de test
  • Télécharger Espresso
  • Régler le rail d’instrumentation
  • Exemple de fichier build.gradle
  • Analytique
  • Ajouter le premier test
  • Exécution d’essais Ce guide couvre l’installation d’Espresso à l’aide du gestionnaire de SDK et sa construction à l’aide de Gradle. Android Studio est recommandé.

Configurez votre environnement de test

Pour éviter les irrégularités, nous vous recommandons vivement de désactiver les animations système sur le ou les appareils virtuels ou physiques utilisés pour les tests.

Sur votre appareil, sous Paramètres->Options développeur, désactivez les 3 paramètres suivants :

  • Échelle d’animation de la fenêtre
  • Échelle d’animation de transition
  • Échelle de durée d’animation

Télécharger Espresso

  • Assurez-vous d’avoir installé le dernier référentiel de support Android sous Extras (voir les instructions).

  • Ouvrez le fichier build.gradle de votre application. Il ne s’agit généralement pas du fichier build.gradle de niveau supérieur, mais de app/build.gradle.

  • Ajoutez les lignes suivantes à l’intérieur des dépendances :

    androidTestCompile ‘com.android.support.test.espresso:espresso-core:2.2.2’ androidTestCompile ‘com.android.support.test🏃‍♂️0.5’

  • Voir la section téléchargements pour plus d’artefacts (espresso-contrib, espresso-web, etc.)

  • Régler le rail d’instrumentation

Ajoutez au même fichier build.gradle la ligne suivante dans android.defaultConfig : testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" Exemple de fichier build.gradle

apply plugin: 'com.android.application'

    android {
        compileSdkVersion 22
        buildToolsVersion "22"
    
        defaultConfig {
            applicationId "com.my.awesome.app"
            minSdkVersion 10
            targetSdkVersion 22.0.1
            versionCode 1
            versionName "1.0"
    
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        }
    }

dependencies {
    // App's dependencies, including test
    compile 'com.android.support:support-annotations:22.2.0'

    // Testing-only dependencies
    androidTestCompile 'com.android.support.test🏃‍♂️0.5'
    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
}

Analytique

Afin de s’assurer que nous sommes sur la bonne voie à chaque nouvelle version, le testeur collecte des analyses. Plus précisément, il télécharge un hachage du nom du package de l’application testée pour chaque invocation. Cela nous permet de mesurer à la fois le nombre de forfaits uniques utilisant Espresso ainsi que le volume d’utilisation.

Si vous ne souhaitez pas télécharger ces données, vous pouvez vous désinscrire en transmettant l’argument suivant au testeur : disableAnalytics “true” (voir comment transmettre des arguments personnalisés).

Ajouter le premier test

Android Studio crée des tests par défaut dans src/androidTest/java/com.example.package/

Exemple de test JUnit4 utilisant des règles :

@RunWith(AndroidJUnit4.class)
@LargeTest
public class HelloWorldEspressoTest {

    @Rule
    public ActivityTestRule<MainActivity> mActivityRule = new ActivityTestRule(MainActivity.class);

    @Test
    public void listGoesOverTheFold() {
        onView(withText("Hello world!")).check(matches(isDisplayed()));
    }
}

Tests en cours

Dans Android Studio

Créer une configuration de test

Dans Android Studio :

  • Ouvrir le menu Exécuter -> Modifier les configurations

  • Ajouter une nouvelle configuration Android Tests

  • Choisissez un module

  • Ajouter un coureur d’instrumentation spécifique :

    android.support.test.runner.AndroidJUnitRunner
    

Exécutez la configuration nouvellement créée.

Depuis la ligne de commande via Gradle

Exécuter

./gradlew connectedAndroidTest

Espresso a essentiellement trois composants :

  1. ViewMatchers - permet de trouver une vue dans la hiérarchie de vue actuelle

  2. ViewActions - permet d’effectuer des actions sur les vues

  3. ViewAssertions - permet d’affirmer l’état d’une vue

Test d’espresso de base

onView(ViewMatcher)       -- 1     
 .perform(ViewAction)     -- 2
   .check(ViewAssertion); -- 3
  1. Trouve la vue
  2. Effectue une action sur la vue
  3. Valide une assertion