Cómo compilar pruebas instrumentadas

Las pruebas de instrumentación se ejecutan en dispositivos Android, ya sean físicos o emulados. Como para que puedan aprovechar las APIs del framework de Android. Pruebas instrumentadas por lo tanto, proporcionan más fidelidad que las pruebas locales, aunque se ejecutan mucho más lentamente.

Recomendamos usar pruebas instrumentadas solo en los casos en los que debas realizar pruebas el comportamiento de un dispositivo real. AndroidX Test proporciona varias bibliotecas. que facilitan la escritura de pruebas instrumentadas cuando es necesario.

Cómo configurar el entorno de prueba

En tu proyecto de Android Studio, almacenas los archivos de origen de los pruebas en module-name/src/androidTest/java/. Este directorio ya existe cuando cuando creas un proyecto nuevo y contiene un ejemplo de prueba instrumentada.

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

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

En el archivo build.gradle de nivel superior de tu 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 Compose Notas de la versión de la IU

Para usar las clases de prueba de JUnit 4 y tener acceso a funciones como el filtrado de pruebas, asegúrate de especificar AndroidJUnitRunner como la instrumentación de prueba predeterminada. Runner de tu proyecto incluyendo la siguiente configuración en el directorio Archivo build.gradle a nivel del módulo:

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

Cómo crear una clase de prueba instrumentada

Tu 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 tu ejecutor de pruebas predeterminado.

En el siguiente ejemplo, se muestra cómo escribir una prueba instrumentada para verificar que la interfaz Parcelable esté implementada correctamente para el 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 o emuladores reales. En Android En esta guía de estudio, aprenderás a hacer lo siguiente:

Recursos adicionales

Las pruebas de la IU suelen ser pruebas instrumentadas que verifican el comportamiento correcto de la IU. Usan frameworks como Espresso o Compose Test. Para aprender más información, lee la guía de pruebas de la IU.

Para obtener más información sobre el uso de las pruebas de instrumentación, consulta lo siguiente: de Google Cloud.

Muestra

Codelabs