Ta sekcja zawiera przegląd tego, czym jest android-espresso i dlaczego deweloper może chcieć z niego korzystać.
Powinien również wymieniać wszelkie duże tematy w systemie Android-espresso i link do powiązanych tematów. Ponieważ Dokumentacja dla Androida-espresso jest nowa, może być konieczne utworzenie początkowych wersji tych pokrewnych tematów.
Skonfiguruj środowisko testowe
Aby uniknąć niestabilności, zalecamy wyłączenie animacji systemowych na wirtualnych lub fizycznych urządzeniach używanych do testowania.
Na urządzeniu w obszarze Ustawienia-> Opcje programisty wyłącz następujące 3 ustawienia:
Pobierz Espresso
Upewnij się, że masz zainstalowane najnowsze repozytorium obsługi systemu Android w części Dodatki (zobacz instrukcje).
Otwórz plik build.gradle aplikacji. Zwykle nie jest to plik build.gradle najwyższego poziomu, ale aplikacja / build.gradle.
Dodaj następujące wiersze w zależnościach:
androidTestCompile 'com.android.support.test.espresso: espresso-core: 2.2.2' androidTestCompile 'com.android.support.test: runner: 0.5'
Zobacz sekcję pobrań, aby uzyskać więcej artefaktów (espresso-contrib, espresso-web itp.)
Ustaw prowadnicę oprzyrządowania
Dodaj do tego samego pliku build.gradle następujący wiersz w android.defaultConfig: testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
Przykład pliku 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'
}
Analityka
Aby upewnić się, że podążamy właściwą drogą z każdą nową wersją, tester zbiera dane analityczne. Mówiąc dokładniej, dla każdego wywołania przesyła skrót nazwy pakietu testowanej aplikacji. To pozwala nam mierzyć zarówno liczbę unikalnych opakowań używających Espresso, jak i wielkość zużycia.
Jeśli nie chcesz przesyłać tych danych, możesz zrezygnować, przekazując testerowi następujący argument: disableAnalytics „true” (zobacz, jak przekazywać niestandardowe argumenty).
Dodaj pierwszy test
Android Studio domyślnie tworzy testy w src / androidTest / java / com.example.package /
Przykładowy test JUnit4 z wykorzystaniem reguł:
@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()));
}
}
Uruchamianie testów
W Android Studio
Utwórz konfigurację testową
W Android Studio:
Otwórz menu Uruchom -> Edytuj konfiguracje
Dodaj nową konfigurację testów Androida
Wybierz moduł
Dodaj określony biegacz oprzyrządowania:
android.support.test.runner.AndroidJUnitRunner
Uruchom nowo utworzoną konfigurację.
Z wiersza polecenia za pomocą Gradle
Wykonać
./gradlew connectedAndroidTest
Espresso składa się zasadniczo z trzech składników:
ViewMatchers - pozwala znaleźć widok w bieżącej hierarchii widoków
ViewActions - pozwala wykonywać działania na widokach
ViewAssertions - pozwala potwierdzić stan widoku
Podstawowy test espresso
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))
To jest samouczek, aby utworzyć przykład hello world: Używany w tym przykładzie: Android Studio 2.3;
Aby rozpocząć, użyj Android Studio, aby utworzyć nowy projekt z pustą aktywnością. Następnie dodajemy do aplikacji kilka prostych funkcji, które możemy przetestować: Dodajemy przycisk, który po kliknięciu wyświetla „Hello World” w widoku tekstowym.
Kod działania wygląda następująco:
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!");
}
});
}
}
A activity_main
układ dla tej działalności wygląda następująco:
<?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>
Teraz chcemy przetestować zachowanie tej nowo utworzonej aplikacji za pomocą espresso. Zasadniczo kod samej aplikacji znajduje się w pakiecie main
, testy jednostkowe są w test
wewnętrznym, a testy oprzyrządowania espresso znajdują się w pakiecie androidTest
. Jeśli utworzysz nowy pusty projekt aktywności w Android Studio, powinien on już utworzyć te pakiety i klasy i powinien wyglądać następująco:
Aby zacząć od espresso, musimy upewnić się, że zależność espresso-core
jest zawarta w pliku build.gradle
(zauważ, że nie jest on opatrzony adnotacjami ze słowem kluczowym compile
ale zamiast androidTestCompile
). Zależności w pliku build.gradle
utworzonym przez studio Android powinny wyglądać następująco:
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'
}
Teraz, gdy wszystko jest już skonfigurowane, możemy rozpocząć od rzeczywistego testu: Otwórz plik ExampleInstrumentationTest
i zobaczysz, że jest już jeden wygenerowany test useAppContext
. Zmienimy tę klasę testów i utworzymy test, aby sprawdzić zachowanie naszej aplikacji:
@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!")));
}
}
Rozpocznij test, uruchamiając klasę ExampleInstrumentedTest
. Ten test wykonuje następnie trzy rzeczy:
ActivityTestRule u góry określa, które działanie jest testowane i uruchamia je na początku testu. (Możesz także wyłączyć automatyczne uruchamianie działania i zamiast tego uruchamiać je ręcznie w każdym teście)
Reguły testu są dość proste:
onView(withId(R.id.textView))
patrzy widok wewnątrz bieżącego ekranu przez identyfikator widoku wewnątrz naszej activity_main
pliku układu. .check(matches(withText("")));
następnie wykonuje przypadek testowy dla tego widoku. .perform(click())
wykonuje akcję na widoku: Mogą to być kliknięcia, długie kliknięcia lub przesunięcia lub inne. To był samouczek rozpoczynający testy Instrumentacji na espresso z Androidem. Mam nadzieję, że dał ci pewne informacje!
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