AndroidJUnitRunner

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

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

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

Programar testes do JUnit

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

Kotlin


@RunWith(AndroidJUnit4::class) // Only needed when mixing JUnit 3 and 4 tests
@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) // Only needed when mixing JUnit 3 and 4 tests
@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 seus testes, é possível acessar o contexto do app em teste chamando o método estático ApplicationProvider.getApplicationContext(). Se você criou uma subclasse personalizada de Application no app, esse método retorna o contexto dela.

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 boilerplate e condicional aos testes. Além das anotações padrão com suporte no JUnit 4, o executor de testes também é compatível com anotações específicas do Android, incluindo: estas:

  • @RequiresDevice: especifica que o teste precisa ser executado apenas em dispositivos físicos, não em emuladores.
  • @SdkSuppress: suprime a execução do teste em um nível de API do Android anterior ao nível especificado. Por exemplo, para suprimir a execução de testes em todos os níveis de API anteriores ao 23, use a anotação @SDKSuppress(minSdkVersion=23).
  • @SmallTest, @MediumTest e @LargeTest: classifiquem quanto tempo um teste precisa levar para ser executado e, consequentemente, com que frequência é possível executá-lo. É possível 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 carregar a execução dos testes em paralelo, compartilhando-os em vários servidores para acelerar a execução, divida-os em grupos ou fragmentos. O executor de testes é compatível com a divisão de um único pacote de testes em vários fragmentos. Assim, é possível 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 os benefícios abaixo 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 após cada teste, use a sinalização clearPackageData. Consulte a seção Ativar no Gradle para conferir um exemplo.
  • Falhas são isoladas:mesmo que um teste falhe, ele só remove a própria instância de Instrumentation. Isso significa que os outros testes do conjunto ainda serã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, mas você precisa 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 instruçõ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 instruçõ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 de comando, instale o Android Test Orchestrator e use-o diretamente.

adb shell pm list instrumentation

Como usar diferentes conjuntos de ferramentas

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

  1. Inclua os pacotes necessários no arquivo de build do app.
  2. 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 do JUnit
Figura 1: estrutura do APK da orquestração de teste do Android.

O Android Test Orchestrator coleta testes do JUnit no início da execução do pacote de testes, mas depois executa cada teste 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 mais informações sobre o uso de AndroidJUnitRunner, consulte os recursos a seguir.

Exemplos