Créer des tests instrumentés

Les tests d'instrumentation s'exécutent sur des appareils Android, qu'ils soient physiques ou émulés. Ils peuvent ainsi bénéficier des API du framework Android. Les tests d'instrumentation offrent donc plus de fidélité que les tests locaux, bien qu'ils s'exécutent beaucoup plus lentement.

Nous vous recommandons de n'utiliser des tests d'instrumentation que dans les cas où vous devez tester le comportement d'un appareil réel. AndroidX Test fournit plusieurs bibliothèques qui facilitent l'écriture de tests d'instrumentation si nécessaire.

Configurer votre environnement de test

Dans votre projet Android Studio, vous stockez les fichiers sources des tests d'instrumentation dans module-name/src/androidTest/java/. Ce répertoire existe déjà lorsque vous créez un projet et contient un exemple de test d'instrumentation.

Avant de commencer, vous devez ajouter les API de test AndroidX, qui vous permettent de compiler et d'exécuter rapidement du code de test d'instrumentation pour vos applications. AndroidX Test inclut un exécuteur de test JUnit 4, AndroidJUnitRunner, ainsi que des API permettant de tester l'interface utilisateur fonctionnelle, comme Espresso, UI Automator et Test Compose.

Vous devez également configurer les dépendances de test Android pour votre projet afin d'utiliser le lanceur de test et les API de règles fournies par AndroidX Test.

Dans le fichier build.gradle de premier niveau de votre application, vous devez spécifier ces bibliothèques en tant que dépendances:

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

Vous trouverez les dernières versions dans les notes de version d'AndroidX et dans les notes de version de l'UI Compose.

Pour utiliser les classes de test JUnit 4 et avoir accès à des fonctionnalités telles que le filtrage des tests, veillez à spécifier AndroidJUnitRunner comme exécuteur d'instrumentation de test par défaut dans votre projet en incluant le paramètre suivant dans le fichier build.gradle au niveau du module de l'application:

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

Créer une classe de test d'instrumentation

Votre classe de test d'instrumentation doit être une classe de test JUnit 4 semblable à la classe décrite dans la section Créer des tests en local.

Pour créer une classe de test JUnit 4 instrumentée, spécifiez AndroidJUnit4 comme lanceur de test par défaut.

L'exemple suivant montre comment écrire un test d'instrumentation pour vérifier que l'interface Parcelable est correctement implémentée pour la classe 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);
    }
}

Exécuter des tests d'instrumentation

Les tests d'instrumentation peuvent être exécutés sur des appareils réels ou des émulateurs. Dans le guide Android Studio, vous pouvez apprendre à:

Ressources supplémentaires

Les tests d'interface utilisateur sont généralement des tests d'instrumentation qui vérifient le comportement correct de l'interface utilisateur. Elles utilisent des frameworks comme Espresso ou Compose Test. Pour en savoir plus, consultez le guide des tests de l'interface utilisateur.

Pour en savoir plus sur l'utilisation des tests d'instrumentation, consultez les ressources suivantes.

Exemples

Ateliers de programmation