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.
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:
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:
ViewMatchers - permet de trouver une vue dans la hiérarchie de vue actuelle
ViewActions - permet d'effectuer des actions sur les vues
ViewAssertions - permet d'affirmer l'état d'une vue
Test d'espresso de base
onView(ViewMatcher) -- 1
.perform(ViewAction) -- 2
.check(ViewAssertion); -- 3
/**
* @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()));
}
}
onView(withId(R.id.pay))
onView(withText("Pay"))
onView(withText(R.string.pay))
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:
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:
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!
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