Tworzenie testów instrumentalnych

Testy instrumentowane są przeprowadzane na urządzeniach z Androidem niezależnie od tego, czy są fizyczne czy emulowane. Jako dzięki czemu mogą korzystać z interfejsów Android Framework API. Testy instrumentalne więc zapewniają większą dokładność niż lokalne testy, chociaż przeprowadzają powoli.

Zalecamy używanie testów instrumentowanych tylko w przypadkach, gdy trzeba sprawdzić działania prawdziwego urządzenia. AndroidX Test udostępnia kilka bibliotek które w razie potrzeby ułatwiają pisanie testów instrumentalnych.

Konfigurowanie środowiska testowego

W projekcie Android Studio przechowujesz pliki źródłowe na potrzeby instrumentacji testów w module-name/src/androidTest/java/. Ten katalog już istnieje, gdy utworzysz nowy projekt, który zawiera przykładowy test z instrumentacją.

Najpierw dodaj interfejsy Test API AndroidX, które pozwalają szybko tworzyć i uruchamiać zinstrumentowany kod do testów aplikacji. AndroidX Test obejmuje Uruchamianie testów JUnit 4 AndroidJUnitRunner oraz interfejsy API do testów funkcjonalnych interfejsu takich jak Espresso, Automator UI i test tworzenia wiadomości.

Musisz też skonfigurować w projekcie zależności testowe Androida, aby użyj narzędzia do uruchamiania testów i interfejsów API reguł dostępnych w narzędziu AndroidX Test.

W pliku build.gradle najwyższego poziomu aplikacji musisz określić te biblioteki jako zależności:

dependencies {
    androidTestImplementation "androidx.test:runner:$androidXTestVersion"
    androidTestImplementation "androidx.test:rules:$androidXTestVersion"
    // Optional -- UI testing with Espresso
    androidTestImplementation "androidx.test.espresso:espresso-core:$espressoVersion"
    // Optional -- UI testing with UI Automator
    androidTestImplementation "androidx.test.uiautomator:uiautomator:$uiAutomatorVersion"
    // Optional -- UI testing with Compose
    androidTestImplementation "androidx.compose.ui:ui-test-junit4:$compose_version"
}

Najnowsze wersje znajdziesz w informacjach o wersji AndroidaX oraz w sekcji Compose Informacje o wersji interfejsu

Aby korzystać z klas testowych JUnit 4 i mieć dostęp do funkcji takich jak filtrowanie testów, pamiętaj, aby określić AndroidJUnitRunner jako domyślną instrumentację testową. w swoim projekcie, dodając to ustawienie do plik build.gradle na poziomie modułu:

android {
    defaultConfig {
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
}

Tworzenie zinstrumentowanych zajęć testowych

Twoja klasa testowa powinna być klasą testową JUnit 4 podobną do zajęcia opisane w sekcji dotyczącej tworzenia testów lokalnych.

Aby utworzyć zinstruowaną klasę testową JUnit 4, podaj AndroidJUnit4 jako domyślny kreator testów.

Poniższy przykład pokazuje, jak napisać zinstrumentowany test, aby zweryfikować że interfejs Parcelable jest prawidłowo zaimplementowany Zajęcia LogHistory:

Kotlin

import android.os.Parcel
import android.text.TextUtils.writeToParcel
import androidx.test.filters.SmallTest
import androidx.test.runner.AndroidJUnit4
import com.google.common.truth.Truth.assertThat
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith

const val TEST_STRING = "This is a string"
const val TEST_LONG = 12345678L

// @RunWith is required only if you use a mix of JUnit3 and JUnit4.
@RunWith(AndroidJUnit4::class)
@SmallTest
class LogHistoryAndroidUnitTest {
    private lateinit var logHistory: LogHistory

    @Before
    fun createLogHistory() {
        logHistory = LogHistory()
    }

    @Test
    fun logHistory_ParcelableWriteRead() {
        val parcel = Parcel.obtain()
        logHistory.apply {
            // Set up the Parcelable object to send and receive.
            addEntry(TEST_STRING, TEST_LONG)

            // Write the data.
            writeToParcel(parcel, describeContents())
        }

        // After you're done with writing, you need to reset the parcel for reading.
        parcel.setDataPosition(0)

        // Read the data.
        val createdFromParcel: LogHistory = LogHistory.CREATOR.createFromParcel(parcel)
        createdFromParcel.getData().also { createdFromParcelData: List<Pair<String, Long>> ->

            // Verify that the received data is correct.
            assertThat(createdFromParcelData.size).isEqualTo(1)
            assertThat(createdFromParcelData[0].first).isEqualTo(TEST_STRING)
            assertThat(createdFromParcelData[0].second).isEqualTo(TEST_LONG)
        }
    }
}

Java

import android.os.Parcel;
import android.util.Pair;
import androidx.test.runner.AndroidJUnit4;
import com.google.common.truth.Truth.assertThat;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith is required only if you use a mix of JUnit3 and JUnit4.
@RunWith(AndroidJUnit4.class)
public class LogHistoryAndroidUnitTest {

    public static final String TEST_STRING = "This is a string";
    public static final long TEST_LONG = 12345678L;
    private LogHistory mLogHistory;

    @Before
    public void createLogHistory() {
        mLogHistory = new LogHistory();
    }

    @Test
    public void logHistory_ParcelableWriteRead() {
        // Set up the Parcelable object to send and receive.
        mLogHistory.addEntry(TEST_STRING, TEST_LONG);

        // Write the data.
        Parcel parcel = Parcel.obtain();
        mLogHistory.writeToParcel(parcel, mLogHistory.describeContents());

        // After you're done with writing, you need to reset the parcel for reading.
        parcel.setDataPosition(0);

        // Read the data.
        LogHistory createdFromParcel = LogHistory.CREATOR.createFromParcel(parcel);
        List<Pair<String, Long>> createdFromParcelData
                = createdFromParcel.getData();

        // Verify that the received data is correct.
        assertThat(createdFromParcelData.size()).isEqualTo(1);
        assertThat(createdFromParcelData.get(0).first).isEqualTo(TEST_STRING);
        assertThat(createdFromParcelData.get(0).second).isEqaulTo(TEST_LONG);
    }
}

Przeprowadzanie testów instrumentowanych

Testy instrumentowane można przeprowadzać na prawdziwych urządzeniach lub na emulatorach. Na urządzeniu z Androidem W przewodniku po Studio znajdziesz te informacje:

Dodatkowe materiały

Testy interfejsu to zazwyczaj testy instrumentalne, które weryfikują prawidłowe działanie oraz interfejs użytkownika. Korzystają z takich platform jak Espresso lub Compose Test. Aby się uczyć więcej informacji znajdziesz w przewodniku dotyczącym testowania interfejsu.

Więcej informacji o korzystaniu z testów z instrumentacją znajdziesz tutaj: i zasobami Google Cloud.

Próbka

Ćwiczenia z programowania