Criar testes instrumentados

As execuções de teste instrumentadas são executadas em dispositivos Android, sejam físicos ou emulados. Assim, eles podem aproveitar as APIs do framework do Android. Portanto, os testes instrumentados oferecem mais fidelidade do que os testes locais, embora sejam executados de forma muito mais lenta.

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

Configurar o ambiente de teste

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

Antes de começar, adicione as APIs de teste do AndroidX, que permitem criar e executar rapidamente códigos de teste de instrumentação para seus apps. O AndroidX Test inclui um executor de teste JUnit 4, AndroidJUnitRunner, e APIs para testes funcionais de 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 teste e as APIs de regras fornecidas pelo AndroidX Test.

No arquivo build.gradle de nível superior do app, é necessário especificar essas 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"
}

Confira as versões mais recentes nas Notas da versão do AndroidX e nas Notas da versão da interface do Compose.

Para usar as 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 seu projeto, incluindo a seguinte configuração no arquivo build.gradle do módulo do app:

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

Criar uma classe de teste de instrumentação

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

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

O exemplo abaixo mostra como escrever 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

Os testes instrumentados podem ser executados em dispositivos reais ou emuladores. No guia do Android Studio, você aprende a:

Outros recursos

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

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

Exemplo