Esta página foi traduzida pela API Cloud Translation.

AndroidJUnitRunner

A classe AndroidJUnitRunner é um executor de testes JUnit que permite executar testes JUnit 4 instrumentados em dispositivos Android, inclusive aqueles que usam os frameworks de teste Espresso, UI Automator e Compose.

O executor de testes processa o carregamento do pacote e do app em questão em um dispositivo, a execução dos testes e o relatório de resultados.

O executor é compatível com várias tarefas de teste comuns, incluindo:

criação de testes do JUnit;
Como acessar o contexto do app
filtragem de testes;
fragmentação de testes.

Programar testes do JUnit

O snippet de código a seguir mostra como programar um teste de instrumentação do JUnit 4 para validar se a operação changeText na classe ChangeTextBehavior funciona corretamente:

Kotlin

@RunWith(AndroidJUnit4::class)
@LargeTest // Optional runner annotation
class ChangeTextBehaviorTest {
 val stringToBeTyped = "Espresso"
 // ActivityTestRule accesses context through the runner
 @get:Rule
 val activityRule = ActivityTestRule(MainActivity::class.java)

 @Test fun changeText_sameActivity() {
 // Type text and then press the button.
 onView(withId(R.id.editTextUserInput))
 .perform(typeText(stringToBeTyped), closeSoftKeyboard())
 onView(withId(R.id.changeTextBt)).perform(click())

 // Check that the text was changed.
 onView(withId(R.id.textToBeChanged))
 .check(matches(withText(stringToBeTyped)))
 }
}

Java

@RunWith(AndroidJUnit4.class)
@LargeTest // Optional runner annotation
public class ChangeTextBehaviorTest {

    private static final String stringToBeTyped = "Espresso";

    @Rule
    public ActivityTestRule<MainActivity>; activityRule =
            new ActivityTestRule<>;(MainActivity.class);

    @Test
    public void changeText_sameActivity() {
        // Type text and then press the button.
        onView(withId(R.id.editTextUserInput))
                .perform(typeText(stringToBeTyped), closeSoftKeyboard());
        onView(withId(R.id.changeTextBt)).perform(click());

        // Check that the text was changed.
        onView(withId(R.id.textToBeChanged))
                .check(matches(withText(stringToBeTyped)));
    }
}

Acessar o contexto do aplicativo

Ao usar AndroidJUnitRunner para executar os testes, é possível acessar o contexto do app em teste chamando o método ApplicationProvider.getApplicationContext() estático. Se você criou uma subclasse personalizada de Application no app, esse método retorna o contexto da subclasse personalizada.

Se você implementa ferramentas, pode acessar APIs de teste de baixo nível usando a classe InstrumentationRegistry. Essa classe inclui o objeto Instrumentation, o objeto Context do app de destino, o objeto Context do app de teste e os argumentos da linha de comando transmitidos para o teste.

Filtrar testes

Nos testes JUnit 4.x, é possível usar anotações para configurar a execução dos testes. Esse recurso minimiza a necessidade de adicionar código clichê e condicional nos testes. Além das anotações padrão compatíveis com o JUnit 4, o executor de testes também oferece suporte a anotações específicas do Android, incluindo as seguintes:

@RequiresDevice: especifica que o teste será executado apenas em dispositivos físicos, não em emuladores.
@SdkSuppress: suprime a execução do teste em uma API do Android de nível inferior ao especificado. Por exemplo, para suprimir a execução dos testes em todos os níveis de API inferiores a 23, use a anotação @SDKSuppress(minSdkVersion=23).
@SmallTest, @MediumTest e @LargeTest: classificam o tempo de execução e, consequentemente, a frequência de um teste. Você pode usar essa anotação para filtrar quais testes serão executados, definindo a propriedade android.testInstrumentationRunnerArguments.size:

-Pandroid.testInstrumentationRunnerArguments.size=small

Fragmentar testes

Se você precisar paralelizar a execução dos testes, compartilhando-os em vários servidores para que sejam executados mais rapidamente, divida-os em grupos ou fragmentos. O executor de testes oferece suporte à divisão de um único pacote de testes em vários fragmentos. Assim, você pode executar facilmente testes pertencentes ao mesmo fragmento como um grupo. Cada fragmento é identificado por um número de índice. Ao executar testes, use a opção -e numShards para especificar o número de fragmentos separados a serem criados e a opção -e shardIndex para especificar qual fragmento será executado.

Por exemplo, para dividir o pacote de testes em 10 fragmentos e executar apenas os testes agrupados no segundo fragmento, use o seguinte comando adb:

adb shell am instrument -w -e numShards 10 -e shardIndex 2

Usar o Android Test Orchestrator

O Android Test Orchestrator permite executar cada um dos testes do app na própria invocação de Instrumentation. Ao usar o AndroidJUnitRunner versão 1.0 ou mais recente, você tem acesso ao Android Test Orchestrator.

O Android Test Orchestrator oferece as seguintes vantagens para seu ambiente de teste:

Estado compartilhado mínimo:cada teste é executado na própria instância Instrumentation. Portanto, se os testes compartilharem o estado do app, a maior parte desse estado compartilhado será removida da CPU ou da memória do dispositivo após cada teste. Para remover todo o estado compartilhado da CPU e da memória do dispositivo depois de cada teste, use a flag clearPackageData. Consulte a seção Ativar no Gradle para conferir um exemplo.
Falhas isoladas:mesmo que um teste falhe, ele só remove a própria instância de Instrumentation. Isso significa que os outros testes do seu conjunto ainda são executados, fornecendo resultados completos.

Esse isolamento resulta em um possível aumento no tempo de execução do teste, já que o Android Test Orchestrator reinicia o aplicativo após cada teste.

O Android Studio e o Firebase Test Lab vêm com o Android Test Orchestrator pré-instalado, embora você precise ativar o recurso no Android Studio.

Ativar no Gradle

Para ativar o Android Test Orchestrator usando a ferramenta de linha de comando do Gradle, siga estas etapas:

Etapa 1: modifique o arquivo do Gradle. Adicione as seguintes declarações ao arquivo build.gradle do projeto:

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

  // The following argument makes the Android Test Orchestrator run its
  // "pm clear" command after each test invocation. This command ensures
  // that the app's state is completely cleared between tests.
  testInstrumentationRunnerArguments clearPackageData: 'true'
 }

 testOptions {
  execution 'ANDROIDX_TEST_ORCHESTRATOR'
 }
}

dependencies {
 androidTestImplementation 'androidx.test:runner:1.1.0'
 androidTestUtil 'androidx.test:orchestrator:1.1.0'
}

Etapa 2: execute o Android Test Orchestrator com este comando:

./gradlew connectedCheck

Ativar no Android Studio

Para ativar o Android Test Orchestrator no Android Studio, adicione as declarações mostradas em Ativar no Gradle ao arquivo build.gradle do app.

Ativar na linha de comando

Para usar o Android Test Orchestrator na linha de comando, execute os seguintes comandos em uma janela de terminal:

DEVICE_API_LEVEL=$(adb shell getprop ro.build.version.sdk)

FORCE_QUERYABLE_OPTION=""
if [[ $DEVICE_API_LEVEL -ge 30 ]]; then
   FORCE_QUERYABLE_OPTION="--force-queryable"
fi

# uninstall old versions
adb uninstall androidx.test.services
adb uninstall androidx.test.orchestrator

# Install the test orchestrator.
adb install $FORCE_QUERYABLE_OPTION -r path/to/m2repository/androidx/test/orchestrator/1.4.2/orchestrator-1.4.2.apk

# Install test services.
adb install $FORCE_QUERYABLE_OPTION -r path/to/m2repository/androidx/test/services/test-services/1.4.2/test-services-1.4.2.apk

# Replace "com.example.test" with the name of the package containing your tests.
# Add "-e clearPackageData true" to clear your app's data in between runs.
adb shell 'CLASSPATH=$(pm path androidx.test.services) app_process / \
 androidx.test.services.shellexecutor.ShellMain am instrument -w -e \
 targetInstrumentation com.example.test/androidx.test.runner.AndroidJUnitRunner \
 androidx.test.orchestrator/.AndroidTestOrchestrator'

Como mostra a sintaxe do comando, instale o Android Test Orchestrator e use-o diretamente.

adb shell pm list instrumentation

Usar toolchains diferentes

Se você usa um conjunto de ferramentas diferente para testar o app, ainda pode usar o Android Test Orchestrator seguindo estas etapas:

Inclua os pacotes necessários no arquivo de build do app.
Ative o Android Test Orchestrator na linha de comando.

Arquitetura

O APK de serviço do Orchestrator é armazenado em um processo separado do APK de teste e do APK do app em teste:

O orquestrador permite controlar testes JUnit — **Figura 1**: estrutura do APK do Android Test Orchestration.

O Android Test Orchestrator coleta testes do JUnit no início da execução do pacote de testes, mas depois os executa separadamente, na própria instância de Instrumentation.

Mais informações

Para saber mais sobre o uso do AndroidJUnitRunner, consulte a referência da API.

Outros recursos

Para saber mais sobre como usar AndroidJUnitRunner, consulte os recursos a seguir.

Amostras

AndroidJunitRunnerSample: mostra anotações de teste, testes parametrizados e criação de pacote de testes.