android-espressoAan de slag met Android-espresso


Opmerkingen

Deze sectie geeft een overzicht van wat Android-espresso is en waarom een ontwikkelaar het misschien wil gebruiken.

Het moet ook alle grote onderwerpen in Android-espresso vermelden en naar de gerelateerde onderwerpen verwijzen. Omdat de documentatie voor Android-espresso nieuw is, moet u mogelijk eerste versies van die gerelateerde onderwerpen maken.

Espresso installatie-instructies

  • Stel uw testomgeving in
  • Espresso downloaden
  • Stel de instrumentatierunner in
  • Voorbeeld build.gradle-bestand
  • Analytics
  • Voeg de eerste test toe
  • Tests uitvoeren Deze handleiding behandelt het installeren van Espresso met behulp van SDK Manager en het bouwen met behulp van Gradle. Android Studio wordt aanbevolen.

Stel uw testomgeving in

Om schilfers te voorkomen, raden we u ten zeerste aan om systeemanimaties uit te schakelen op de virtuele of fysieke apparaten die worden gebruikt voor het testen.

Schakel op uw apparaat onder Instellingen-> Opties voor ontwikkelaars de volgende 3 instellingen uit:

  • Venster animatieschaal
  • Overgang animatieschaal
  • Animator duur schaal

Espresso downloaden

  • Zorg ervoor dat u de nieuwste Android Support Repository hebt geïnstalleerd onder Extra's (zie instructies).

  • Open het build.gradle-bestand van uw app. Dit is meestal niet het hoofdbestand build.gradle maar app / build.gradle.

  • Voeg de volgende regels toe binnen afhankelijkheden:

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

  • Zie de downloadsectie voor meer artefacten (espresso-contrib, espresso-web, etc.)

  • Stel de instrumentatierunner in

Voeg aan hetzelfde build.gradle-bestand de volgende regel toe in android.defaultConfig: testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" Voorbeeld build.gradle-bestand

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

Om ervoor te zorgen dat we bij elke nieuwe release op de goede weg zijn, verzamelt de testagent analyses. Meer specifiek uploadt het een hash van de pakketnaam van de te testen applicatie voor elke aanroep. Hiermee kunnen we zowel het aantal unieke pakketten met Espresso als het gebruiksvolume meten.

Als u deze gegevens niet wilt uploaden, kunt u zich afmelden door het volgende argument aan de testagent door te geven: disableAnalytics "true" (zie hoe u aangepaste argumenten doorgeeft).

Voeg de eerste test toe

Android Studio maakt standaard tests in src / androidTest / java / com.example.package /

Voorbeeld JUnit4-test met regels:

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

Lopende testen

In Android Studio

Maak een testconfiguratie

In Android Studio:

  • Open het menu Uitvoeren -> Configuraties bewerken

  • Voeg een nieuwe Android-testconfiguratie toe

  • Kies een module

  • Voeg een specifieke instrumentatierunner toe:

    android.support.test.runner.AndroidJUnitRunner

Voer de nieuw gemaakte configuratie uit.

Van opdrachtregel via Gradle

uitvoeren

./gradlew connectedAndroidTest
 

Espresso heeft in principe drie componenten:

  1. ViewMatchers - hiermee kunt u de weergave vinden in de huidige weergavehiërarchie

  2. ViewActions - maakt het mogelijk om acties uit te voeren op de views

  3. ViewAssertions - hiermee kunt u de status van een weergave bevestigen

Base Espresso-test

onView(ViewMatcher)       -- 1     
 .perform(ViewAction)     -- 2
   .check(ViewAssertion); -- 3
 
  1. Vindt het uitzicht
  2. Voert een actie uit op de weergave
  3. Valideert een bewering

Items in een optiemenu controleren (met behulp van Spoon to taake 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()));
    }
}
 

Zoek een weergave op ID

onView(withId(R.id.pay))
 

Zoeken naar tekst

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

Hallo wereld Espresso-voorbeeld

Dit is een tutorial om een voorbeeld van een hallo wereld te maken: Gebruikt voor dit voorbeeld: Android Studio 2.3;

Start Android Studio om een nieuw project met een lege activiteit te maken. Vervolgens voegen we enkele eenvoudige functionaliteit toe aan de app die we kunnen testen: we voegen een knop toe die bij klikken "Hallo wereld" weergeeft in een tekstweergave.

De activiteitscode ziet er zo uit:

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

En de layout van activity_main voor deze activiteit ziet er als volgt uit:

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

Nu willen we het gedrag van deze nieuw gecreëerde app testen met behulp van espresso. Over het algemeen de code voor uw app zelf is binnen de main pakket, Unit Tests zijn in test en de espresso instrumentatie tests zijn in de androidTest pakket. Als u een nieuw leeg activiteitenproject maakt met Android Studio, zou die pakketten en klassen al gemaakt moeten zijn en het zou er zo uit moeten zien:

voer hier de afbeeldingsbeschrijving in

Om te beginnen met espresso moeten we ervoor zorgen dat de afhankelijkheid van de espresso-core is opgenomen in het bestand build.gradle (merk op dat deze niet is geannoteerd met het compile maar in plaats daarvan met androidTestCompile ). De afhankelijkheden in het build.gradle bestand gemaakt door Android studio zouden er als volgt uit moeten zien:

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

Nu alles is ingesteld, kunnen we beginnen met de eigenlijke test: open het bestand ExampleInstrumentationTest en u ziet dat er al een gegenereerde useAppContext test binnen is. We zullen deze testklasse wijzigen en een test maken om ons app-gedrag te controleren:

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

Start de test door de klasse ExampleInstrumentedTest . Deze test doet dan drie dingen:

  1. Het controleert of de tekstweergave een lege string ("") bevat
  2. Het klikt op de knop in onze lay-out
  3. Het controleert opnieuw de tekst van de tekstweergave als deze "Hallo wereld!"

De ActivityTestRule bovenaan definieert welke activiteit wordt getest en start deze aan het begin van de test. (U kunt ook de automatische start van een activiteit uitschakelen en deze in elke test handmatig starten)

De testregels zijn vrij eenvoudig:

  • onView(withId(R.id.textView)) zoekt een weergave in het huidige scherm op aan de hand van de ID van de weergave in ons layout-bestand activity_main .
  • .check(matches(withText(""))); voert vervolgens een testcase uit in die weergave.
  • .perform(click()) voert een actie uit op een weergave: Deze acties kunnen klikken, lange klikken of swipes zijn of wat meer.

Dit was een tutorial om te beginnen met android espresso instrumentatietests, ik hoop dat het je wat inzichten heeft gegeven!

Bekijk 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