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.
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:
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:
ViewMatchers - gör det möjligt att hitta vy i den aktuella visningshierarkin
ViewActions - gör det möjligt att utföra åtgärder på vyerna
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
/**
* @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))
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:
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:
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!
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