android-espresso Tutorial
Erste Schritte mit Android-Espresso

Bemerkungen

Anweisungen zum Einrichten von Espresso

• Richten Sie Ihre Testumgebung ein
• Laden Sie Espresso herunter
• Stellen Sie den Instrumentierungsläufer ein
• Beispiel build.gradle -Datei
• Analytics
• Fügen Sie den ersten Test hinzu
• Laufende Tests In diesem Handbuch wird die Installation von Espresso mit dem SDK Manager und die Erstellung mit Gradle beschrieben. Android Studio wird empfohlen.

Richten Sie Ihre Testumgebung ein

Um Flockigkeit zu vermeiden, wird dringend empfohlen, die Systemanimationen auf den virtuellen oder physischen Geräten zu deaktivieren, die zum Testen verwendet werden.

Deaktivieren Sie auf Ihrem Gerät unter Einstellungen-> Entwickleroptionen die folgenden 3 Einstellungen:

• Fensteranimationsskala
• Übergangsanimationsskala
• Animationsdauer-Skala

Laden Sie Espresso herunter

• Stellen Sie sicher, dass Sie das neueste Android-Support-Repository unter Extras installiert haben (siehe Anweisungen).

• Öffnen Sie die build.gradle-Datei Ihrer App. Dies ist normalerweise nicht die oberste build.gradle-Datei, sondern app / build.gradle.

• Fügen Sie die folgenden Zeilen in Abhängigkeiten hinzu:

  androidTestCompile 'com.android.support.test.espresso: espresso-core: 2.2.2' androidTestCompile 'com.android.support.test: Läufer: 0.5'

• Im Download-Bereich finden Sie weitere Artefakte (Espresso-Contrib, Espresso-Web usw.).

• Stellen Sie den Instrumentierungsläufer ein

Fügen Sie zur gleichen build.gradle-Datei die folgende Zeile in android.defaultConfig hinzu: testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" Beispieldatei 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'
}

Analytics

Um sicherzustellen, dass wir mit jeder neuen Version auf dem richtigen Weg sind, sammelt der Testläufer Analysen. Insbesondere wird für jeden Aufruf ein Hash des Paketnamens der getesteten Anwendung hochgeladen. Dadurch können wir sowohl die Anzahl der einzigartigen Pakete mit Espresso als auch das Nutzungsvolumen messen.

Wenn Sie diese Daten nicht hochladen möchten, können Sie dies deaktivieren, indem Sie das folgende Argument an den Testläufer übergeben: disableAnalytics "true" (siehe Übergeben benutzerdefinierter Argumente).

Fügen Sie den ersten Test hinzu

Android Studio erstellt standardmäßig Tests in src / androidTest / java / com.example.package /

Beispiel JUnit4-Test mit Regeln:

@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()));
    }
}

Laufende Tests

In Android Studio

Erstellen Sie eine Testkonfiguration

In Android Studio:

• Öffnen Sie das Menü Ausführen -> Konfigurationen bearbeiten

• Fügen Sie eine neue Android-Test-Konfiguration hinzu

• Wählen Sie ein Modul aus

• Fügen Sie einen bestimmten Instrumentationsläufer hinzu:

  android.support.test.runner.AndroidJUnitRunner

Führen Sie die neu erstellte Konfiguration aus.

Von der Kommandozeile über Gradle

Ausführen

./gradlew connectedAndroidTest

Espresso besteht im Wesentlichen aus drei Komponenten:

1. ViewMatchers - Ermöglicht das Suchen von Ansichten in der aktuellen Ansichtshierarchie

2. ViewActions - Ermöglicht das Ausführen von Aktionen für die Ansichten

3. ViewAssertions - ermöglicht den Status einer Ansicht zu bestätigen

Basis-Espresso-Test

onView(ViewMatcher)       -- 1     
 .perform(ViewAction)     -- 2
   .check(ViewAssertion); -- 3

1. Findet die Ansicht
2. Führt eine Aktion für die Ansicht aus
3. Bestätigt eine Zusicherung

Optionen im Optionsmenü überprüfen (mit Löffel zum Erstellen von Screenshots)

/**
 * @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()));
    }
}

Test anzeigen

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

Finden Sie eine Ansicht nach ID

onView(withId(R.id.pay))

Ansicht durch den Text suchen

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

Hello World Espresso Beispiel

Dies ist ein Tutorial zum Erstellen eines Hello-World-Beispiels: Für dieses Beispiel verwendet: Android Studio 2.3;

Um zu starten, verwenden Sie Android Studio, um ein neues Projekt mit einer leeren Aktivität zu erstellen. Dann fügen wir der App einige einfache Funktionen hinzu, die wir testen können: Wir fügen eine Schaltfläche hinzu, die beim Klicken "Hello World" in einer Textansicht anzeigt.

Der Aktivitätscode sieht folgendermaßen aus:

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!");
            }
        });
    }
}

Und das activity_main Layout für diese Aktivität sieht folgendermaßen aus:

<?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>

Nun wollen wir das Verhalten dieser neu erstellten App mit Espresso testen. Im Allgemeinen ist der Code für Ihre Anwendung selbst innerhalb der ist main Unit - Tests sind im Inneren test und die Espresso Instrumentierung Tests sind in der androidTest Paket. Wenn Sie ein neues leeres Aktivitätsprojekt mit Android Studio erstellen, sollten diese Pakete und Klassen bereits erstellt worden sein und folgendermaßen aussehen:

So starten Sie mit Espresso müssen wir sicherstellen , dass die espresso-core - Abhängigkeit in der enthalten ist build.gradle Datei (beachten Sie, dass es nicht mit der kommentierten wird compile Schlüsselwort , sondern mit androidTestCompile ). Die Abhängigkeiten in der build.gradle Datei, die von Android Studio erstellt wurde, sollten folgendermaßen aussehen:

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'
}

Nun, da alles eingerichtet ist, können wir mit dem eigentlichen Test beginnen: Öffnen Sie die Datei ExampleInstrumentationTest , und Sie sehen, dass bereits ein useAppContext Test darin generiert wurde. Wir werden diese Testklasse ändern und einen Test erstellen, um unser App-Verhalten zu überprüfen:

@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!")));
    }
}

Starten Sie den Test, indem Sie die ExampleInstrumentedTest Klasse ExampleInstrumentedTest . Dieser Test führt dann drei Dinge aus:

1. Es prüft, ob die Textansicht eine leere Zeichenfolge ("") enthält.
2. Es klickt auf die Schaltfläche in unserem Layout
3. Der Text der Textansicht wird erneut geprüft, ob "Hello World!"

Die ActivityTestRule oben definiert, welche Aktivität getestet wird, und startet sie zu Beginn des Tests. (Sie können den automatischen Start einer Aktivität auch abschalten und stattdessen manuell in jedem Test starten.)

Die Testregeln sind ziemlich einfach:

• onView(withId(R.id.textView)) sucht eine Ansicht innerhalb des aktuellen Bildschirms anhand der ID der Ansicht in unserer activity_main Layoutdatei.
• .check(matches(withText(""))); führt dann einen Testfall für diese Ansicht aus.
• .perform(click()) führt eine Aktion für eine Ansicht aus: Diese Aktionen können Klicks, lange Klicks oder Wischbewegungen oder mehr sein.

Dies war ein Tutorial für Android Espresso Instrumentation Tests, ich hoffe es hat Ihnen einige Einblicke gegeben!