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

android-espressoKomma igång med Android-espresso


Anmärkningar

Det här avsnittet ger en översikt över vad android-espresso är och varför en utvecklare kanske vill använda den.

Det bör också nämna alla stora ämnen inom Android-espresso och koppla till relaterade ämnen. Eftersom dokumentationen för Android-espresso är ny kan du behöva skapa initialversioner av relaterade ämnen.

Espresso installationsinstruktioner

  • Ställ in din testmiljö
  • Ladda ner Espresso
  • Ställ in instrumenteringslöparen
  • Exempel build.gradle-fil
  • Analytics
  • Lägg till det första testet
  • Körningstester Den här guiden behandlar installation av Espresso med SDK Manager och bygga den med Gradle. Android Studio rekommenderas.

Ställ in din testmiljö

För att undvika fläckighet rekommenderar vi starkt att du stänger av systemanimationer på de virtuella eller fysiska enheter som används för testning.

Avaktivera följande tre inställningar på din enhet under Inställningar-> Utvecklaralternativ:

  • Fönsteranimationsskala
  • Övergångsanimationsskala
  • Animatorns varaktighetsskala

Ladda ner Espresso

  • Se till att du har installerat det senaste Android Support Repository under Extras (se instruktioner).

  • Öppna appens build.gradle-fil. Detta är vanligtvis inte den översta build.gradle-filen utan app / build.gradle.

  • Lägg till följande rader inom beroenden:

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

  • Se nedladdningsavsnittet för mer artefakter (espressobidrag, espresso-web, etc.)

  • Ställ in instrumenteringslöparen

Lägg till samma build.gradle-fil följande rad i android.defaultConfig: testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" Exempel build.gradle-fil

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

För att säkerställa att vi är på rätt spår med varje ny utgåva, samlar testlöparen analys. Mer specifikt laddar den upp en hash med paketnamnet på applikationen som testas för varje åkallelse. Detta gör att vi kan mäta såväl antalet unika paket som använder Espresso som användningsvolymen.

Om du inte vill ladda upp den här informationen kan du välja bort det här argumentet till testlöparen: disableAnalytics "true" (se hur du skickar anpassade argument).

Lägg till det första testet

Android Studio skapar tester som standard i src / androidTest / java / com.example.package /

Exempel JUnit4-test med regler:

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

Kör tester

I Android Studio

Skapa en testkonfiguration

I Android Studio:

  • Öppna Kör-menyn -> Redigera konfigurationer

  • Lägg till en ny Android Tests-konfiguration

  • Välj en modul

  • Lägg till en specifik instrumenteringslöpare:

    android.support.test.runner.AndroidJUnitRunner

Kör den nyskapade konfigurationen.

Från kommandoraden via Gradle

Kör

./gradlew connectedAndroidTest
 

Espresso har i princip tre komponenter:

  1. ViewMatchers - gör det möjligt att hitta vy i den aktuella visningshierarkin

  2. ViewActions - gör det möjligt att utföra åtgärder på vyerna

  3. ViewAssertions - gör det möjligt att hävda statusen för en vy

Base Espresso Test

onView(ViewMatcher)       -- 1     
 .perform(ViewAction)     -- 2
   .check(ViewAssertion); -- 3
 
  1. Hitta vyn
  2. Utför en åtgärd på vyn
  3. Validerar ett assertioin

Kontrollera ett alternativ Menyalternativ (med Sked för att ta skärmdumpar)

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

Hitta viss vy efter ID

onView(withId(R.id.pay))
 

Hitta vy genom texten

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

Hello World Espresso Exempel

Det här är en tutorial för att skapa ett hejsexempel: Används för detta exempel: Android Studio 2.3;

För att börja använda Android Studio för att skapa ett nytt projekt med en tom aktivitet. Sedan lägger vi till någon enkel funktionalitet till appen som vi kan testa: Vi lägger till en knapp som när klick visar "Hello World" i en textvy.

Aktivitetskoden ser ut så här:

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

Och activity_main layout för denna verksamhet ser ut såhär:

<?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 vill vi testa beteendet hos den nya appen med espresso. Generellt koden för din app i sig är i main enhetstester är inne test och espresso instrumentering testerna är inne i androidTest paketet. Om du skapar ett nytt tomt aktivitetsprojekt med Android Studio borde det redan ha skapat dessa paket och klasser och det skulle se ut så här:

ange bildbeskrivning här

För att börja med espresso måste vi se till att espresso-core build.gradle ingår i filen build.gradle (Observera att den inte är antecknad med compile sökord utan istället med androidTestCompile ). Beroenden i build.gradle filen som skapats av Android studio bör se ut så här:

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 när allt är konfigurerat kan vi börja med det faktiska testet: Öppna filen ExampleInstrumentationTest och du ser att det redan finns ett genererat useAppContext test inuti. Vi kommer att ändra denna testklass och skapa ett test för att kontrollera vårt appbeteende:

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

Starta testet genom att köra klassen ExampleInstrumentedTest . Detta test gör sedan tre saker:

  1. Den kontrollerar om textvisningen innehåller en tom sträng ("")
  2. Det klickar på knappen i vår layout
  3. Den kontrollerar igen texten i textvisningen om den innehåller "Hello World!"

ActivityTestRule överst definierar vilken aktivitet som testas och startar den i början av testet. (Du kan också aktivera den automatiska lanseringen av en aktivitet och istället starta den i varje test manuellt)

Testreglerna är ganska enkla:

  • onView(withId(R.id.textView)) letar upp en vy inuti den aktuella skärmen med ID för vyn i vår activity_main layoutfil.
  • .check(matches(withText(""))); utför sedan ett testfall på den vyn.
  • .perform(click()) utför en åtgärd i en vy: Dessa åtgärder kan vara klick, långa klick eller svep eller något mer.

Detta var en tutorial för att börja med Android-espresso-instrumenttest, jag hoppas att det har gett dig lite insikter!

Visa 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