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:
- 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 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 propriedadeandroid.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çãoclearPackageData
. 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:
- 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 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
- AndroidJunitRunnerSample: mostra anotações de teste, testes parametrizados e criação de conjuntos de testes.