Looking for android-espresso Answers? Try Ask4KnowledgeBase
Looking for android-espresso Keywords? Try Ask4Keywords

android-espressoCommencer avec Android-espresso


Remarques

Cette section donne un aperçu de ce qu'est android-espresso et pourquoi un développeur peut vouloir l'utiliser.

Il devrait également mentionner tous les grands sujets dans android-espresso, et établir un lien avec les sujets connexes. Étant donné que la documentation pour android-espresso est nouvelle, vous devrez peut-être créer des versions initiales de ces rubriques connexes.

Instructions d'installation d'espresso

  • Configurez votre environnement de test
  • Télécharger Espresso
  • Définir le coureur d'instrumentation
  • Exemple de fichier build.gradle
  • Analytique
  • Ajouter le premier test
  • Exécution de tests Ce guide traite de l'installation d'Espresso à l'aide du gestionnaire de SDK et de sa création à l'aide de Gradle. Android Studio est recommandé.

Configurez votre environnement de test

Pour éviter les défauts, nous vous recommandons fortement de désactiver les animations système sur les périphériques virtuels ou physiques utilisés pour les tests.

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

  • Echelle d'animation de fenêtre
  • Échelle d'animation de transition
  • Échelle de durée de l'animateur

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. Ce n'est généralement pas le fichier build.gradle de niveau supérieur, mais app / build.gradle.

  • Ajoutez les lignes suivantes dans les dépendances:

    androidTestCompile 'com.android.support.test.espresso: espresso-core: 2.2.2' androidTestCompile 'com.android.support.test: coureur: 0.5'

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

  • Définir le coureur 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:runner: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 lanceur de tests collecte des analyses. Plus précisément, il télécharge un hachage du nom du package de l'application testée pour chaque appel. Cela nous permet de mesurer le nombre de paquets uniques utilisant Espresso ainsi que le volume d'utilisation.

Si vous ne souhaitez pas télécharger ces données, vous pouvez les désactiver en transmettant l'argument suivant au programme de test: 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 les 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 assertioin

Vérification d'un élément du menu Options (utilisation de Spoon pour faire 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()));
    }
}
 

Trouver une vue par identifiant

onView(withId(R.id.pay))
 

Trouver la vue par le texte

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

Hello World Espresso Exemple

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

Pour démarrer, utilisez Android Studio pour créer un nouveau projet avec une activité vide. Ensuite, nous ajoutons des fonctionnalités simples à l'application que nous pouvons tester: Nous ajoutons un bouton qui, lorsqu'il clique, affiche "Hello World" dans une vue de texte.

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 disposition activity_main de 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>
 

Maintenant, nous voulons 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 l'emballage main , les tests unitaires sont à l'intérieur du 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 doit déjà avoir créé ces packages et ces classes et cela doit ressembler à ceci:

entrer la description de l'image ici

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 avec androidTestCompile ). Les dépendances dans le fichier build.gradle créé par Android studio 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 avec le test actuel: Ouvrez le fichier ExampleInstrumentationTest et vous voyez qu'il y a déjà un test useAppContext généré à l'intérieur. Nous allons changer 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 la textview contient une chaîne vide ("")
  2. Il clique sur le bouton dans notre mise en page
  3. Il vérifie à nouveau le texte de la textview s'il contient "Hello World!"

ActivityTestRule 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 le lancer manuellement dans chaque test)

Les règles de test sont assez simples:

  • onView(withId(R.id.textView)) recherche une vue dans l'écran actuel par l'ID de la vue dans notre fichier de disposition activity_main .
  • .check(matches(withText(""))); effectue ensuite un test sur cette vue.
  • .perform(click()) effectue une action sur une vue: il peut s'agir de clics, de longs clics ou de glissements, ou d'autres encore.

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

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