Criar testes instrumentados

Testes de instrumentação são executados em dispositivos Android, físicos ou emulados. Dessa forma, eles podem aproveitar as APIs do framework do Android. Portanto, os testes instrumentados oferecem mais fidelidade do que os testes locais, embora sejam executados muito mais lentamente.

Recomendamos o uso de testes instrumentados apenas nos casos em que você precisa testar o comportamento de um dispositivo real. O AndroidX Test oferece várias bibliotecas que facilitam a criação de testes instrumentados quando necessário.

Configurar o ambiente de teste

No projeto do Android Studio, você armazena os arquivos de origem para testes instrumentados em module-name/src/androidTest/java/. Esse diretório já existe quando você cria um novo projeto e contém um exemplo de teste instrumentado.

Antes de começar, adicione as APIs do AndroidX Test, que permitem criar e executar rapidamente um código de teste de instrumentação para seus apps. O AndroidX Test inclui um executor de testes JUnit 4, AndroidJUnitRunner, e APIs para testes funcionais da interface, como Espresso, UI Automator e teste do Compose.

Também é necessário configurar as dependências de teste do Android para que seu projeto use o executor de testes e as APIs de regras fornecidas pelo AndroidX Test.

No arquivo build.gradle de nível superior do app, é necessário especificar estas bibliotecas como dependências:

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

Você pode encontrar as versões mais recentes nas Notas da versão do AndroidX e nas Notas da versão da interface do Compose.

Para usar classes de teste do JUnit 4 e ter acesso a recursos como filtragem de testes, especifique AndroidJUnitRunner como o executor de instrumentação de teste padrão no projeto incluindo a seguinte configuração no arquivo build.gradle de nível de módulo do app:

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

Criar uma classe de teste instrumentado

A classe de teste de instrumentação precisa ser uma classe de teste do JUnit 4 semelhante à classe descrita na seção sobre como criar testes locais.

Para criar uma classe de teste de instrumentação do JUnit 4, especifique AndroidJUnit4 como o executor de teste padrão.

O exemplo abaixo mostra como criar um teste de instrumentação para verificar se a interface Parcelable foi implementada corretamente para a classe 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);
    }
}

Executar testes de instrumentação

Testes de instrumentação podem ser executados em dispositivos reais ou emuladores. No guia do Android Studio, você pode aprender a:

Outros recursos

Os testes de interface geralmente são testes de instrumentação que verificam o comportamento correto da interface. Eles usam frameworks como Espresso ou Compose Test. Para saber mais, leia o Guia de teste de interface.

Para mais informações sobre como usar testes de instrumentação, consulte os recursos a seguir.

Exemplo

Codelabs