Ya está disponible la segunda Vista previa para desarrolladores de Android 11; pruébala y comparte tus comentarios.

Cómo compilar pruebas de unidades instrumentadas

Las pruebas de unidades instrumentadas son pruebas que se ejecutan en dispositivos físicos y emuladores, y pueden aprovechar las API del marco de trabajo de Android y las API compatibles, como AndroidX Test. Las pruebas instrumentadas proporcionan más fidelidad que las pruebas unitarias locales, pero se ejecutan con mayor lentitud. Por lo tanto, recomendamos el uso de pruebas de unidades instrumentadas solo en casos en los que sea necesario probar el comportamiento de un dispositivo real. AndroidX Test proporciona varias bibliotecas que facilitan la escritura de pruebas de unidades instrumentadas cuando es necesario. Por ejemplo, las clases de Android Builder facilitan la creación de objetos de datos de Android que, de otro modo, serían difíciles de compilar.

Nota: Si las pruebas dependen de tus propias dependencias, proporciona tus propias emulaciones o simula las dependencias con un marco de trabajo ficticio, como Mockito.

Cómo configurar el entorno de prueba

En el proyecto de Android Studio, debes almacenar los archivos fuente para las pruebas instrumentadas en module-name/src/androidTest/java/. Este directorio ya existe cuando creas un nuevo proyecto y contiene un ejemplo de prueba instrumentada.

Antes de comenzar, debes agregar las API de AndroidX Test, que te permiten crear y ejecutar rápidamente código de prueba instrumentado para tus apps. AndroidX Test incluye un panel de prueba JUnit 4 (AndroidJUnitRunner) y API para pruebas de IU funcionales (Espresso y UI Automator).

También debes configurar las dependencias de prueba de Android para que tu proyecto use el panel de prueba y las API de reglas que proporciona AndroidX Test. Para simplificar el desarrollo de las pruebas, también debes incluir la biblioteca de Hamcrest, que te permite crear afirmaciones más flexibles con las API del comparador de Hamcrest.

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

    dependencies {
        androidTestImplementation 'androidx.test:runner:1.1.0'
        androidTestImplementation 'androidx.test:rules:1.1.0'
        // Optional -- Hamcrest library
        androidTestImplementation 'org.hamcrest:hamcrest-library:1.3'
        // Optional -- UI testing with Espresso
        androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.0'
        // Optional -- UI testing with UI Automator
        androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.2.0'
    }
    

Para usar las clases de prueba JUnit 4, asegúrate de especificar AndroidJUnitRunner como el comparador de instrumentación de prueba predeterminado en tu proyecto, incluida la siguiente configuración en el archivo build.gradle de nivel de módulo de la app:

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

Cómo crear una clase de prueba de unidad instrumentada

La clase de prueba de unidad instrumentada debe ser una clase de prueba JUnit 4 similar a la clase descrita en la sección sobre Cómo crear una clase de prueba de unidad local.

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

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

En el siguiente ejemplo, se muestra cómo escribir una prueba de unidad instrumentada para verificar que la interfaz Parcelable se ha implementado 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.filters.SmallTest;
    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)
    @SmallTest
    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);
        }
    }
    

Crea un conjunto de pruebas

Para organizar la ejecución de las pruebas de unidades instrumentadas, puedes agrupar una colección de clases de prueba en una clase de conjunto de pruebas y ejecutarlas juntas. Los conjuntos de pruebas se pueden anidar y pueden agrupar otros conjuntos de pruebas y ejecutar en conjunto todas las clases de prueba d componentes.

Los conjuntos de prueba se encuentran dentro de los paquetes de prueba, de manera similar al paquete principal de la app. Por convención, el nombre del paquete del conjunto de prueba, en general, termina con el sufijo .suite (por ejemplo, com.example.android.testing.mysample.suite).

Para crear un conjunto de pruebas para las pruebas de unidades, importa las clases RunWith y Suite de JUnit. En el conjunto de pruebas, agrega las anotaciones @RunWith(Suite.class) y @Suite.SuitClasses(). En la anotación @Suite.SuiteClasses(), enumera las clases de prueba individuales o los conjuntos de prueba como argumentos.

En el siguiente ejemplo, se muestra cómo implementar un conjunto de pruebas denominado UnitTestSuite que agrupa y ejecuta las clases de prueba CalculatorInstrumentationTest y CalculatorAddParameterizedTest juntas.

Kotlin

    import com.example.android.testing.mysample.CalculatorAddParameterizedTest
    import com.example.android.testing.mysample.CalculatorInstrumentationTest
    import org.junit.runner.RunWith
    import org.junit.runners.Suite

    // Runs all unit tests.
    @RunWith(Suite::class)
    @Suite.SuiteClasses(CalculatorInstrumentationTest::class,
            CalculatorAddParameterizedTest::class)
    class UnitTestSuite
    

Java

    import com.example.android.testing.mysample.CalculatorAddParameterizedTest;
    import com.example.android.testing.mysample.CalculatorInstrumentationTest;
    import org.junit.runner.RunWith;
    import org.junit.runners.Suite;

    // Runs all unit tests.
    @RunWith(Suite.class)
    @Suite.SuiteClasses({CalculatorInstrumentationTest.class,
            CalculatorAddParameterizedTest.class})
    public class UnitTestSuite {}
    

Cómo ejecutar pruebas de unidades instrumentadas

Para ejecutar las pruebas instrumentadas, sigue estos pasos:

  1. Asegúrate de que tu proyecto esté sincronizado con Gradle. Para ello, haz clic en la opción Sync Project de la barra de herramientas.
  2. Ejecuta tu prueba de una de las siguientes maneras:
    • Para ejecutar una sola prueba, abre la ventana Project y, a continuación, haz clic con el botón derecho en una prueba y, luego, haz clic en Run .
    • Para probar todos los métodos de una clase, haz clic con el botón derecho en una clase o método en el archivo de prueba y luego haz clic en Run .
    • Para ejecutar todas las pruebas de un directorio, haz clic con el botón derecho en el directorio y selecciona Run tests .

El complemento de Android para Gradle compila el código de prueba instrumentado ubicado en el directorio predeterminado (src/androidTest/java/), crea un APK de prueba y un APK de producción, instala ambos APK en el dispositivo o el emulador conectado y ejecuta las pruebas. A continuación, Android Studio muestra los resultados de la ejecución de la prueba instrumentada en la ventana Run.

Ejecuta las pruebas con Firebase Test Lab

Con Firebase Test Lab, puedes probar simultáneamente tu app en muchos dispositivos Android y configuraciones de dispositivos populares (configuración regional, orientación, tamaño de pantalla y versión de plataforma). Estas pruebas se ejecutan en dispositivos físicos y virtuales, en centros de datos remotos de Google. Puedes implementar apps en Test Lab directamente desde Android Studio o desde la línea de comandos. Los resultados de la prueba proporcionan registros de prueba e incluyen los detalles de cualquier falla en la app.

Antes de comenzar a usar Firebase Test Lab, debes hacer lo siguiente a menos que ya tengas una cuenta de Google y un proyecto de Firebase:

  1. Crea una cuenta de Google, si ya no tienes una.
  2. En la consola de Firebase, haz clic en Crear proyecto nuevo.

    Puedes probar tu app sin cargo con Test Lab dentro de la cuota diaria gratuita del plan Spark.

Configura una matriz de prueba y ejecuta una prueba

Android Studio proporciona herramientas integradas que te permiten configurar cómo quieres implementar las pruebas en Firebase Test Lab. Después de crear un proyecto de Firebase con la facturación del plan Blaze, puedes crear una configuración de prueba y ejecutar las pruebas:

  1. Haz clic en Run > Edit Configurations en el menú principal.
  2. Haz clic en Add New Configuration y selecciona Android Tests.
  3. En el diálogo de configuración de Android Test:
    1. Ingresa o selecciona los detalles de la prueba, como el nombre, el tipo de módulo, el tipo de prueba y la clase de prueba.
    2. En el menú desplegable Target, en Development Target Options selecciona Firebase Test Lab Device Matrix.
    3. Si no iniciaste sesión, haz clic en Connect to Google Cloud Platform y permite que Android Studio acceda a tu cuenta.
    4. Junto a Cloud Project, haz clic en el botón y selecciona tu proyecto de Firebase de la lista.
  4. Crea y configura una matriz de prueba:
    1. Junto a la lista desplegable Matrix Configuration, haz clic en Open Dialog .
    2. Haz clic en Add New Configuration (+).
    3. En el campo Nombre, ingresa un nombre para la nueva configuración.
    4. Selecciona los dispositivos, las versiones de Android, las configuraciones regionales y las orientaciones de pantalla con las que quieres probar tu app. Firebase Test Lab probará tu app con cada combinación de selecciones al cuando genere los resultados de la prueba.
    5. Haz clic en OK para guardar la configuración.
  5. Haz clic en OK en el diálogo Run/Debug Configurations para salir.
  6. Para ejecutar las pruebas, haz clic en Ejecutar. .

Figura 1: Creación de una configuración de prueba para Firebase Test Lab

Analiza los resultados de la prueba

Cuando Firebase Test Lab haya completado la ejecución de las pruebas, se abrirá la ventana de Run para mostrar los resultados, como se muestra en la Figura 2. Es posible que debas hacer clic en Show Passed para ver todas las pruebas ejecutadas.

Figura 2: Visualización de los resultados de las pruebas instrumentadas con Firebase Test Lab

También puedes analizar las pruebas en la Web siguiendo el vínculo que se muestra al inicio del registro de ejecución de pruebas en la ventana Run.

Lecturas adicionales

Para obtener más información sobre cómo interpretar los resultados web, consulta Cómo analizar los resultados de Android en Firebase Test Lab.

Recursos adicionales

Para obtener más información sobre cómo usar Espresso en las pruebas de Android, consulta los siguientes recursos.

Ejemplos

Codelabs