Cómo compilar pruebas instrumentadas

Las pruebas de instrumentación se ejecutan en dispositivos Android, ya sean físicos o emulados. Por lo tanto, pueden aprovechar las APIs del framework de Android. Por lo tanto, las pruebas de instrumentación proporcionan más fidelidad que las locales, aunque se ejecutan mucho más lento.

Recomendamos el uso de pruebas de instrumentación solo en casos en los que debas evaluar el comportamiento de un dispositivo real. AndroidX Test proporciona varias bibliotecas que facilitan la escritura de pruebas de instrumentación cuando es necesario.

Cómo configurar el entorno de pruebas

En tu proyecto de Android Studio, almacenas los archivos fuente para las pruebas instrumentadas en module-name/src/androidTest/java/. Ese directorio ya existe cuando creas un proyecto nuevo y contiene una prueba de instrumentación de ejemplo.

Antes de comenzar, debes agregar las APIs de AndroidX Test, que te permiten compilar y ejecutar rápidamente código de pruebas instrumentadas para tus apps. AndroidX Test incluye un ejecutor de pruebas de JUnit 4 ,AndroidJUnitRunner, y APIs para pruebas funcionales de IU como Espresso, UI Automator y prueba de Compose.

También debes configurar las dependencias de prueba de Android para que tu proyecto use el ejecutor de pruebas y las APIs de reglas que proporciona AndroidX Test.

En el archivo build.gradle de nivel superior de la app, debes especificar estas bibliotecas como dependencias:

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

Puedes encontrar las versiones más recientes en las Notas de la versión de AndroidX y las Notas de la versión de la IU de Compose.

Para usar clases de prueba de JUnit 4 y tener acceso a funciones como el filtrado de pruebas, asegúrate de especificar AndroidJUnitRunner como el ejecutor de instrumentación de pruebas predeterminado en tu proyecto. Para ello, incluye la siguiente configuración en el archivo build.gradle de nivel de módulo de tu app:

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

Cómo crear una clase de prueba instrumentada

La clase de prueba instrumentada debe ser una clase de prueba JUnit 4 similar a la clase descrita en la sección sobre cómo compilar pruebas locales.

Para crear una clase de prueba JUnit 4 instrumentada, especifica AndroidJUnit4 como el ejecutor de pruebas predeterminado.

En el siguiente ejemplo, se muestra cómo escribir una prueba de instrumentación para verificar que la interfaz Parcelable se implemente correctamente para la clase 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);
    }
}

Cómo ejecutar pruebas instrumentadas

Las pruebas de instrumentación se pueden ejecutar en dispositivos reales o emuladores. En la guía de Android Studio, podrás obtener información para hacer lo siguiente:

Recursos adicionales

Por lo general, las pruebas de la IU son pruebas de instrumentación que verifican el comportamiento correcto de la IU. Usan marcos de trabajo como Espresso o Compose Test. Para obtener más información, lee la guía de prueba de la IU.

Para obtener más información sobre el uso de pruebas de instrumentación, consulta los siguientes recursos.

Muestra

Codelabs