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.

Nota: Se inicializan las pruebas de instrumentación, también conocidas como pruebas de instrumentación. en un entorno especial que les da acceso a una instancia de Instrumentación. Esta clase proporciona acceso al contexto de la aplicación y Son APIs para manipular la app que se está probando y asignar su nombre a las pruebas instrumentadas.

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.

Nota: Si tu paquete de pruebas depende de una combinación de bibliotecas JUnit3 y JUnit4, agrega la anotación @RunWith(AndroidJUnit4::class) al comienzo de la prueba definición de la clase.

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);
    }
}

Nota: El uso de acentos graves para nombres de pruebas en Kotlin solo se admite en dispositivos con el nivel de API 30 o superior. Por ejemplo: @Test fun `everything works`() { ... }

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:

• Cómo probar desde Android Studio
• Cómo realizar pruebas desde la línea de comandos

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

• Muestras de código de pruebas de unidades instrumentadas

Codelabs

• Android Testing Codelab