A classe AndroidJUnitRunner
é um executor de testes JUnit que
permite executar testes instrumentados do JUnit 4 em dispositivos Android,
incluindo os que usam o Espresso, UI Automator e Compose
frameworks de teste.
O executor processa o carregamento do pacote de teste e do app em teste para um dispositivo, executar os testes e relatar os resultados deles.
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 JUnit 4 instrumentado.
para confirmar que a operação changeText
no 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 os testes, você pode acessar o contexto
para o aplicativo em teste chamando o
ApplicationProvider.getApplicationContext()
. Se você criou um
de Application
no app, esse método retorna a subclasse personalizada
o contexto da subclasse.
Se você implementa ferramentas, pode acessar APIs de teste de baixo nível usando o
classe InstrumentationRegistry
. Essa classe inclui
objeto Instrumentation
, o objeto Context
do app de destino, o
o objeto Context
do app 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. Isso minimiza a necessidade de adicionar código boilerplate e condicional ao provas. Além das anotações padrão com suporte do JUnit 4, o teste O runner também é compatível com anotações específicas do Android, incluindo a seguintes:
@RequiresDevice
: especifica que o teste será executado apenas em dispositivos físicos. e não em emuladores.@SdkSuppress
: suprime a execução do teste em uma API do Android anterior. nível do que o nível fornecido. Por exemplo, para suprimir testes em todos os níveis de API anteriores da execução, use a anotação@SDKSuppress(minSdkVersion=23)
.@SmallTest
,@MediumTest
e@LargeTest
: classificam a duração de um teste deve levar para ser executado e, consequentemente, com que frequência é possível executar o teste. Você pode usar essa anotação para filtrar quais testes serão executados, definindo o Propriedadeandroid.testInstrumentationRunnerArguments.size
:
-Pandroid.testInstrumentationRunnerArguments.size=small
Fragmentar testes
Caso seja necessário carregar em paralelo a execução dos seus testes, compartilhe-os entre
vários servidores para acelerar a execução, é possível dividi-los em grupos ou
fragmentos. O executor de testes permite dividir um único conjunto de testes em vários
para que você possa executar testes pertencentes ao mesmo fragmento como um
grupo. Cada fragmento é identificado por um número de índice. Ao executar testes, use o
A opção -e numShards
para especificar o número de fragmentos separados a serem criados e 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 agrupadas 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
própria invocação de Instrumentation
. Ao usar o AndroidJUnitRunner versão 1.0
ou superior, você terá acesso ao Android Test Orchestrator.
O Android Test Orchestrator oferece os seguintes benefícios para testes de nuvem:
- Estado compartilhado mínimo:cada teste é executado no próprio
Instrumentation
. instância. Portanto, se os testes compartilham o estado do app, a maior parte dele é compartilhado é removido 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 flagclearPackageData
. Consulte a documentação Ativar no Gradle como exemplo. - Falhas são isoladas:mesmo que um teste falhe, apenas o dele será removido.
instância própria de
Instrumentation
. Isso significa que os outros testes seu pacote ainda em execução, fornecendo resultados de teste 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 depois de cada teste.
O Android Studio e o Firebase Test Lab têm 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, conclua as etapas a seguir: estas etapas:
- Etapa 1: modificar o arquivo do Gradle. Adicione as seguintes declarações ao seu
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 o seguinte comando:
./gradlew connectedCheck
Ativar no Android Studio
Para ativar o Android Test Orchestrator no Android Studio, adicione as instruções mostradas.
Ativar no Gradle para o 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
Como usar diferentes conjuntos de ferramentas
Se você usar um conjunto de ferramentas diferente para testar seu app, ainda poderá usar o Android. Conclua as etapas a seguir para testar o Orchestrator:
- 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 o APK de teste e o APK do app em teste:
O Android Test Orchestrator coleta testes do JUnit no início do seu teste.
em execução, mas depois executa cada teste separadamente, na própria instância do
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 itens a seguir
do Google Cloud.
Amostras
- AndroidJunitRunnerSample: mostra anotações de teste, testes parametrizados e criação de um pacote de testes.