Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

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 API del framework de Android y API auxiliares, como AndroidX Test. Las pruebas instrumentadas proporcionan más fidelidad que las pruebas de unidades locales, pero se ejecutan mucho más lentamente. Por lo tanto, recomendamos el uso de pruebas de unidades instrumentadas solo en casos en los que sea imprescindible probar el comportamiento de un dispositivo real. AndroidX Test proporciona varias bibliotecas que facilitan la escritura de pruebas de unidades instrumentadas cuando son necesarias. 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 emplean tus propias dependencias, provee dependencias ficticias o simúlalas con un framework para pruebas, como Mockito.

Cómo configurar el entorno de pruebas

En tu 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 pruebas instrumentadas para tus apps. AndroidX Test incluye un ejecutor de pruebas de 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 ejecutor de pruebas y las API de reglas que proporciona AndroidX Test. A fin de simplificar el desarrollo de las pruebas, además debes incluir la biblioteca de Hamcrest, que te permite crear aserciones más flexibles con las API del comparador de Hamcrest.

En el archivo build.gradle de nivel superior de tu 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'
    }
    

A fin de usar las clases de prueba de JUnit 4, asegúrate de especificar AndroidJUnitRunner como ejecutor de instrumentación de prueba predeterminado en tu proyecto; para ello, incluye 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 unidades instrumentada

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

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

Nota: Si tu conjunto de pruebas depende de una combinación de bibliotecas de JUnit 3 y JUnit 4, agrega la anotación @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 unidades instrumentada para verificar que la interfaz Parcelable se haya 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; además permiten agrupar otros conjuntos de pruebas y ejecutar en conjunto todas sus clases de prueba de componentes.

Los conjuntos de prueba se encuentran dentro de paquetes de prueba, similares al paquete principal de la aplicación. Por convención, el nombre del paquete del conjunto de pruebas generalmente termina con el sufijo .suite (por ejemplo, com.example.android.testing.mysample.suite).

A fin de crear un conjunto de pruebas para tus 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 como argumentos los conjuntos de pruebas o las clases de prueba individuales.

En el siguiente ejemplo, se muestra cómo implementar un conjunto de pruebas llamado 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 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 la prueba de una de las siguientes maneras:
    • Para ejecutar una sola prueba, abre la ventana Project, haz clic con el botón derecho en una prueba y luego con el botón izquierdo 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 con el botón izquierdo en Run .
    • Para ejecutar todas las pruebas en 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 instrumentada 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 conectado o emulador, 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 Firebase console, haz clic en Create New Project.

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

Configura una matriz de pruebas y ejecuta una prueba

Android Studio proporciona herramientas integradas que te permiten configurar cómo 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 cuadro de diálogo de configuración de Android Test, haz lo siguiente:
    1. Ingresa o selecciona los detalles de la prueba, como nombre, tipo de módulo, tipo de prueba y 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. Cómo crear y configurar una matriz de pruebas:
    1. Junto a la lista desplegable Matrix Configuration, haz clic en Open Dialog .
    2. Haz clic en Add New Configuration (+).
    3. En el campo Name, ingresa un nombre para la nueva configuración.
    4. Selecciona los dispositivos, versiones de Android, configuraciones regionales y orientaciones de pantalla con los que quieras probar la app. Firebase Test Lab probará tu app con cada combinación de selecciones cuando genere los resultados de la prueba.
    5. Haz clic en OK para guardar la configuración.
  5. Haz clic en OK en el cuadro de diálogo Run/Debug Configurations para salir.
  6. Para ejecutar las pruebas, haz clic en Run .

Figura 1: Cómo crear una configuración de prueba para Firebase Test Lab

Cómo analizar los resultados de la prueba

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

Figura 2: Cómo ver los resultados de las pruebas instrumentadas con Firebase Test Lab

También puedes analizar tus pruebas en la Web siguiendo el vínculo que se muestra al comienzo 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 Firebase Test Lab for Android.

Recursos adicionales

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

Muestra

Codelabs