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

android-espressoRozpoczęcie pracy z Androidem-Espresso


Uwagi

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.

Instrukcje konfiguracji espresso

  • Skonfiguruj środowisko testowe
  • Pobierz Espresso
  • Ustaw prowadnicę oprzyrządowania
  • Przykładowy plik build.gradle
  • Analityka
  • Dodaj pierwszy test
  • Uruchamianie testów Niniejszy przewodnik obejmuje instalację Espresso przy użyciu Menedżera SDK i budowanie jej przy użyciu Gradle. Zalecane jest Android Studio.

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:

  • Skala animacji okna
  • Skala animacji przejścia
  • Skala czasu trwania animatora

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:

  1. ViewMatchers - pozwala znaleźć widok w bieżącej hierarchii widoków

  2. ViewActions - pozwala wykonywać działania na widokach

  3. ViewAssertions - pozwala potwierdzić stan widoku

Podstawowy test espresso

onView(ViewMatcher)       -- 1     
 .perform(ViewAction)     -- 2
   .check(ViewAssertion); -- 3
 
  1. Znajduje widok
  2. Wykonuje akcję w widoku
  3. Sprawdza asertywność

Sprawdzanie elementów menu opcji (używanie Łyżki do robienia zrzutów ekranu)

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

Znajdź widok według ID

onView(withId(R.id.pay))
 

Znajdź widok według tekstu

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

Przykład Hello World Espresso

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:

wprowadź opis zdjęcia tutaj

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:

  1. Sprawdza, czy widok tekstu zawiera pusty ciąg („”)
  2. Klika przycisk w naszym układzie
  3. Ponownie sprawdza tekst widoku tekstu, jeśli zawiera „Hello World!”

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!

Zobacz 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