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.
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:
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:
ViewMatchers - hiermee kunt u de weergave vinden in de huidige weergavehiërarchie
ViewActions - maakt het mogelijk om acties uit te voeren op de views
ViewAssertions - hiermee kunt u de status van een weergave bevestigen
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))
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:
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:
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!
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