Questa risposta è per le persone che hanno appena iniziato a testare Android. Fornirò due semplici esempi per aiutarti a vedere come funzionano i test. Se segui per i prossimi 10 minuti, sarai pronto per iniziare ad aggiungere i tuoi test alla tua app. Penso che sarai sorpreso di quanto sia facile. Certamente lo ero.
Introduzione ai test Android
Ci sono due diversi tipi di test che farai.
- Test unitari locali. Questi vengono eseguiti localmente sulla JVM (Java Virtual Machine). Dato che sono locali, sono veloci. Puoi usarli per testare le parti del tuo codice che richiedono solo Java e non le API Android. (A volte puoi creare un falso oggetto API per testare più cose a livello locale. Questo è chiamato mocking . Un mock
Contextè un esempio.)
- Test strumentati. Questi test vengono eseguiti su un dispositivo reale o nell'emulatore. Ciò li rende più lenti dei test locali. Tuttavia, sono più flessibili perché hai a disposizione l'API Android completa.
Crea un nuovo progetto e vedrai le seguenti cartelle predefinite.
Tutto è già lì e ti aspetta per creare i tuoi test. È già tutto pronto!
Come creare test unitari locali
Apri il ExampleUnitTestfile mostrato nell'immagine sopra. Dovrebbe assomigliare a qualcosa di simile a questo:
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
assertEquals(4, 2 + 2);
}
}
Premere la doppia freccia verde per eseguire tutti i test o la singola freccia verde per eseguirne solo uno. (In questo caso c'è solo un test quindi entrambi fanno la stessa cosa.)
Dovrebbe passare (a patto che 2 + 2sia fermo 4quando stai leggendo questa risposta). Congratulazioni, hai appena eseguito il tuo primo test!
Fare il tuo test
Scriviamo il nostro test. Per prima cosa aggiungi questa classe al progetto dell'app principale in modo da avere qualcosa da testare:
public class MyClass {
public int add(int a, int b) {
return a + b;
}
}
Ora cambia il addition_isCorrect()metodo nella classe di test in modo che sia come il codice seguente (o aggiungi semplicemente un altro metodo con un nome diverso):
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
MyClass myClass = new MyClass();
int result = myClass.add(2, 2);
int expected = 4;
assertEquals(expected, result);
}
}
Eseguilo di nuovo e dovresti vederlo passare. Congratulazioni, hai appena creato il tuo primo test! (Beh, immagino che tecnicamente fosse mio, ma, ehi, abbastanza vicino. Ciò che è mio è tuo.)
Come creare test strumentati
Apri il ExampleInstrumentedTestfile. Dovrebbe assomigliare a qualcosa di simile a questo:
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() throws Exception {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getTargetContext();
assertEquals("com.example.myapp", appContext.getPackageName());
}
}
Premi di nuovo uno di quei pulsanti verdi.
Finché hai un dispositivo reale connesso o l'emulatore configurato, dovrebbe averlo avviato ed eseguire la tua app. Congratulazioni, hai appena eseguito il tuo primo test strumentale!
Fare il tuo test
I test strumentati utilizzano Espresso per eseguire i test. È un po 'come il tuo piccolo utente robot che puoi fare testare la tua app. Puoi dirgli di fare qualcosa come premere un pulsante o leggere le proprietà di un TextView.
Puoi scrivere le istruzioni su come eseguire il test a mano, ma poiché siamo solo agli inizi, usiamo la funzione di registrazione automatica . È semplicissimo.
Per prima cosa aggiungi un pulsante alla tua interfaccia utente in modo da avere qualcosa con cui lavorare. L'ho fatto:
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="com.example.myapp.MainActivity">
<Button
android:id="@+id/myButton"
android:text="Click me"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
</android.support.constraint.ConstraintLayout>
Quindi premere Run> Record Espresso Test nel menu.
Dopo l'avvio, fare clic sul pulsante nell'emulatore e quindi, per terminare, scegliere OK nella finestra di dialogo Registra. Dovrebbe generare automaticamente il seguente codice di test.
@LargeTest
@RunWith(AndroidJUnit4.class)
public class MainActivityTest {
@Rule
public ActivityTestRule<MainActivity> mActivityTestRule = new ActivityTestRule<>(MainActivity.class);
@Test
public void mainActivityTest() {
ViewInteraction appCompatButton = onView(
allOf(withId(R.id.myButton), withText("Click me"), isDisplayed()));
appCompatButton.perform(click());
}
}
Grande! Hai appena creato il tuo primo test strumentale! È stato semplicissimo. Probabilmente dovresti aggiungere un'affermazione per renderlo un vero test, ma anche questo è abbastanza facile da fare con il registratore. Guarda questo video per andare un po 'più a fondo.
Ulteriori studi
Prima guardavo i video e poi leggevo la documentazione. È tutto molto utile. L'ultimo collegamento è a una serie di articoli che trattano alcune cose importanti a cui pensare quando si sceglie cosa testare.
