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

android-espressoIniziare con Android-espresso


Osservazioni

Questa sezione fornisce una panoramica di cosa sia Android-espresso e perché uno sviluppatore potrebbe volerlo utilizzare.

Dovrebbe anche menzionare qualsiasi argomento di grandi dimensioni all'interno di android-espresso e collegarsi agli argomenti correlati. Poiché la documentazione di android-espresso è nuova, potrebbe essere necessario creare versioni iniziali di tali argomenti correlati.

Istruzioni per l'installazione dell'espresso

  • Configura il tuo ambiente di test
  • Scarica Espresso
  • Imposta il corridore della strumentazione
  • Esempio di file build.gradle
  • analitica
  • Aggiungi il primo test
  • Esecuzione di test Questa guida spiega come installare Espresso utilizzando l'SDK Manager e costruendolo utilizzando Gradle. Si consiglia Android Studio.

Configura il tuo ambiente di test

Per evitare difetti, ti consigliamo vivamente di disattivare le animazioni di sistema sui dispositivi virtuali o fisici utilizzati per il test.

Sul dispositivo, in Impostazioni-> Opzioni sviluppatore, disattiva le seguenti 3 impostazioni:

  • Scala di animazione della finestra
  • Scala di animazione di transizione
  • Scala della durata dell'animatore

Scarica Espresso

  • Assicurati di aver installato l'ultimo repository di supporto Android sotto Extra (vedi istruzioni).

  • Apri il file build.gradle dell'app. Questo di solito non è il file build.gradle di livello superiore ma app / build.gradle.

  • Aggiungi le seguenti linee all'interno delle dipendenze:

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

  • Vedi la sezione download per più artefatti (espresso-contrib, espresso-web, ecc.)

  • Imposta il corridore della strumentazione

Aggiungi allo stesso file build.gradle la seguente riga in android.defaultConfig: testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" Esempio di file 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'
}
 

analitica

Per essere sicuri di essere sulla strada giusta con ogni nuova versione, il test runner raccoglie i dati analitici. Più specificamente, carica un hash del nome del pacchetto dell'applicazione in prova per ogni chiamata. Questo ci consente di misurare sia il numero di pacchetti unici che utilizzano Espresso, sia il volume di utilizzo.

Se non si desidera caricare questi dati, è possibile annullare la trasmissione passando il seguente argomento al runner di test: disableAnalytics "true" (vedere come passare argomenti personalizzati).

Aggiungi il primo test

Android Studio crea test di default in src / androidTest / java / com.example.package /

Esempio di test JUnit4 utilizzando le regole:

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

Esecuzione di test

In Android Studio

Crea una configurazione di prova

In Android Studio:

  • Aprire il menu Esegui -> Modifica configurazioni

  • Aggiungi una nuova configurazione di test Android

  • Scegli un modulo

  • Aggiungi un corridore di strumentazione specifico:

    android.support.test.runner.AndroidJUnitRunner

Esegui la configurazione appena creata.

Dalla riga di comando tramite Gradle

Eseguire

./gradlew connectedAndroidTest
 

L'espresso ha fondamentalmente tre componenti:

  1. ViewMatchers: consente di trovare la vista nella gerarchia della vista corrente

  2. ViewActions: consente di eseguire azioni sulle viste

  3. ViewAssertions: consente di affermare lo stato di una vista

Espresso Base Test

onView(ViewMatcher)       -- 1     
 .perform(ViewAction)     -- 2
   .check(ViewAssertion); -- 3
 
  1. Trova la vista
  2. Esegue un'azione sulla vista
  3. Valida un assertioin

Controllo degli elementi del menu Opzioni (utilizzando Spoon per catturare screenshot)

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

Trova una vista per ID

onView(withId(R.id.pay))
 

Trova vista dal testo

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

Ciao esempio World Espresso

Questo è un tutorial per creare un esempio di ciao mondo: utilizzato per questo esempio: Android Studio 2.3;

Per iniziare usa Android Studio per creare un nuovo progetto con un'attività vuota. Quindi aggiungiamo alcune semplici funzionalità all'App che possiamo testare: aggiungiamo un pulsante che quando i clic mostrano "Hello World" in una visualizzazione testuale.

Il codice attività è simile al seguente:

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

E il layout activity_main per questa attività è simile al seguente:

<?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>
 

Ora vogliamo testare il comportamento di questa nuova app creata usando l'espresso. Generalmente il codice per la tua app si trova all'interno del pacchetto main , i test di unità sono all'interno del test e i test della strumentazione per l'espresso si trovano all'interno del pacchetto androidTest . Se crei un nuovo progetto di attività vuoto con Android Studio, dovrebbe già aver creato quei pacchetti e classi e dovrebbe assomigliare a questo:

inserisci la descrizione dell'immagine qui

Per iniziare con l'espresso dobbiamo assicurarci che la dipendenza espresso-core sia inclusa nel file build.gradle (si noti che non è annotato con la parola chiave compile ma con androidTestCompile ). Le dipendenze nel file build.gradle creato da Android studio dovrebbero assomigliare a questo:

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'
}
 

Ora che tutto è pronto, possiamo iniziare con il test effettivo: apri il file ExampleInstrumentationTest e vedi che c'è già un test useAppContext generato all'interno. Modificheremo questa classe di test e creeremo un test per verificare il comportamento della nostra app:

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

Avvia il test eseguendo la classe ExampleInstrumentedTest . Questo test quindi fa tre cose:

  1. Controlla se la textview contiene una stringa vuota ("")
  2. Fa clic sul pulsante nel nostro layout
  3. Controlla nuovamente il testo della textview se contiene "Hello World!"

L' ActivityTestRule in alto definisce quale attività viene testata e la avvia all'inizio del test. (Puoi anche disattivare l'avvio automatico di un'attività e avviarla manualmente all'interno di ciascun test)

Le regole del test sono piuttosto semplici:

  • onView(withId(R.id.textView)) cerca una vista all'interno della schermata corrente tramite l'ID della vista all'interno del nostro file di layout activity_main .
  • .check(matches(withText(""))); quindi esegue un test case su quella vista.
  • .perform(click()) esegue un'azione su una vista: queste azioni potrebbero essere clic, clic lunghi o passaggi o altro.

Questo è stato un tutorial per iniziare con i test di strumentazione per android, spero che ti abbia dato alcuni spunti!

Guarda il 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