Tworzenie testów jednostek lokalnych

Test lokalny jest uruchamiany bezpośrednio na Twojej stacji roboczej, a nie na urządzeniu z Androidem czy emulatorze. Dlatego do przeprowadzania testów używa lokalnej maszyny wirtualnej Java (JVM), a nie urządzenia z Androidem. Testy lokalne umożliwiają szybszą ocenę logiki aplikacji. Brak możliwości interakcji z platformą Androida ogranicza jednak typy testów, które można przeprowadzić.

Test jednostkowy sprawdza działanie niewielkiej części kodu, czyli testowanej jednostki. W tym celu uruchamia kod i sprawdza wynik.

Testy jednostkowe są zwykle proste, ale ich konfiguracja może być problematyczna, jeśli testowana jednostka nie została zaprojektowana z myślą o testowaniu:

  • Kod, który chcesz zweryfikować, musi być dostępny z testu. Nie można na przykład bezpośrednio przetestować metody prywatnej. Zamiast tego testujesz klasę, korzystając z jej publicznych interfejsów API.
  • Aby przeprowadzić testy jednostkowe w izolacji, zależności testowanej jednostki muszą zostać zastąpione komponentami, które kontrolujesz, takimi jak fałszywe lub inne dublety testowe. Jest to szczególnie problematyczne, jeśli kod zależy od platformy Androida.

Aby dowiedzieć się więcej o typowych strategiach testowania jednostkowego na Androidzie, przeczytaj artykuł Co testować.

Lokalizacja testów lokalnych

Domyślnie pliki źródłowe lokalnych testów jednostkowych są umieszczane w folderze module-name/src/test/. Ten katalog jest już utworzony, gdy tworzysz nowy projekt w Android Studio.

Dodawanie zależności testowych

Musisz też skonfigurować zależności testowe dla projektu, aby używać standardowych interfejsów API udostępnianych przez platformę testową JUnit.

Aby to zrobić, otwórz plik build.gradle modułu aplikacji i określ te biblioteki jako zależności. Użyj funkcji testImplementation, aby wskazać, że dotyczą one lokalnego zbioru źródeł testowych, a nie aplikacji:

dependencies {
  // Required -- JUnit 4 framework
  testImplementation "junit:junit:$jUnitVersion"
  // Optional -- Robolectric environment
  testImplementation "androidx.test:core:$androidXTestVersion"
  // Optional -- Mockito framework
  testImplementation "org.mockito:mockito-core:$mockitoVersion"
  // Optional -- mockito-kotlin
  testImplementation "org.mockito.kotlin:mockito-kotlin:$mockitoKotlinVersion"
  // Optional -- Mockk framework
  testImplementation "io.mockk:mockk:$mockkVersion"
}

Tworzenie lokalnej klasy testu jednostkowego

Klasę lokalnego testu jednostkowego pisze się jako klasę testową JUnit 4.

W tym celu utwórz klasę zawierającą co najmniej 1 metodę testową, zwykle w module-name/src/test/. Metoda testowa zaczyna się od adnotacji @Test i zawiera kod do wykonania i zweryfikowania pojedynczego aspektu komponentu, który chcesz przetestować.

Poniższy przykład pokazuje, jak wdrożyć lokalną klasę testu jednostkowego. Metoda testowa emailValidator_correctEmailSimple_returnsTrue() próbuje zweryfikować metodę isValidEmail(), która jest metodą w aplikacji. Funkcja testowa zwróci wartość true, jeśli isValidEmail() również zwróci wartość true.

Kotlin

import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test

class EmailValidatorTest {
  @Test fun emailValidator_CorrectEmailSimple_ReturnsTrue() {
    assertTrue(EmailValidator.isValidEmail("name@email.com"))
  }

}

Java

import org.junit.Test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

class EmailValidatorTest {
  @Test
  public void emailValidator_CorrectEmailSimple_ReturnsTrue() {
    assertTrue(EmailValidator.isValidEmail("name@email.com"));
  }
}

Należy tworzyć czytelne testy, które sprawdzają, czy komponenty aplikacji zwracają oczekiwane wyniki. Zalecamy używanie biblioteki asercji, takiej jak junit.Assert, Hamcrest lub Truth. Powyższy fragment kodu to przykład użycia junit.Assert.

Biblioteka Androida z możliwością tworzenia obiektów testowych

Gdy wykonujesz lokalne testy jednostkowe, wtyczka Androida do Gradle zawiera bibliotekę ze wszystkimi interfejsami API platformy Androida, odpowiednią dla wersji używanej w projekcie. Biblioteka zawiera wszystkie publiczne metody i klasy tych interfejsów API, ale kod wewnątrz metod został usunięty. Jeśli zostanie wywołana dowolna z metod, test zwróci wyjątek.

Dzięki temu można tworzyć testy lokalne, gdy odwołujesz się do klas w platformie Androida, takich jak Context. Co ważniejsze, umożliwia korzystanie z platformy do testów pozorowanych z klasami Androida.

Symulowanie zależności Androida

Typowym problemem jest to, że klasa używa zasobu tekstowego. Zasoby tekstowe możesz uzyskać, wywołując metodę getString() w klasie Context. Test lokalny nie może jednak używać klasy Context ani żadnej z jej metod, ponieważ należą one do platformy Androida. Najlepiej byłoby przenieść wywołanie getString() poza klasę, ale nie zawsze jest to możliwe. Rozwiązaniem jest utworzenie makiety lub namiastki Context, która zawsze zwraca tę samą wartość, gdy wywoływana jest metoda getString().

Dzięki bibliotece Mockable Android i środowiskom do tworzenia obiektów imitujących, takim jak Mockito czy MockK, możesz zaprogramować zachowanie obiektów imitujących klas Androida w testach jednostkowych.

Aby dodać obiekt testowy do lokalnego testu jednostkowego za pomocą Mockito, postępuj zgodnie z tym modelem programowania:

  1. Uwzględnij zależność biblioteki Mockito w pliku build.gradle, jak opisano w artykule Konfigurowanie środowiska testowego.
  2. Na początku definicji klasy testu jednostkowego dodaj adnotację @RunWith(MockitoJUnitRunner.class). Ta adnotacja informuje moduł uruchamiający testy Mockito, że ma sprawdzić, czy używasz platformy w prawidłowy sposób, i ułatwia inicjowanie obiektów makiety.
  3. Aby utworzyć obiekt makiety dla zależności Androida, dodaj adnotację @Mock przed deklaracją pola.
  4. Aby zastąpić zachowanie zależności, możesz określić warunek i wartość zwracaną, gdy warunek jest spełniony, za pomocą metod when() i thenReturn().

Poniższy przykład pokazuje, jak utworzyć test jednostkowy, który używa obiektu imitacji Context w języku Kotlin utworzonego za pomocą Mockito-Kotlin.

import android.content.Context
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.Mock
import org.mockito.junit.MockitoJUnitRunner
import org.mockito.kotlin.doReturn
import org.mockito.kotlin.mock

private const val FAKE_STRING = "HELLO WORLD"

@RunWith(MockitoJUnitRunner::class)
class MockedContextTest {

  @Mock
  private lateinit var mockContext: Context

  @Test
  fun readStringFromContext_LocalizedString() {
    // Given a mocked Context injected into the object under test...
    val mockContext = mock<Context> {
        on { getString(R.string.name_label) } doReturn FAKE_STRING
    }

    val myObjectUnderTest = ClassUnderTest(mockContext)

    // ...when the string is returned from the object under test...
    val result: String = myObjectUnderTest.getName()

    // ...then the result should be the expected one.
    assertEquals(result, FAKE_STRING)
  }
}

Więcej informacji o korzystaniu z platformy Mockito znajdziesz w dokumentacji interfejsu Mockito API i w klasie SharedPreferencesHelperTest w przykładowym kodzie. Wypróbuj też ćwiczenie z testowania aplikacji na Androida.

Błąd: „Metoda … nie została zasymulowana”

Jeśli spróbujesz uzyskać dostęp do dowolnej metody biblioteki Mockable Android, zostanie wygenerowany wyjątek z komunikatem Error: "Method ... not mocked.

Jeśli zgłaszane wyjątki są problematyczne dla testów, możesz zmienić zachowanie, tak aby metody zwracały wartość null lub zero, w zależności od zwracanego typu. Aby to zrobić, dodaj tę konfigurację w pliku build.gradle najwyższego poziomu projektu w Groovy:

android {
  ...
  testOptions {
    unitTests.returnDefaultValues = true
  }