AndroidJUnitRunner

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.

Observação: AndroidJUnitRunner não é necessário para testes locais. Leia sobre a diferença entre testes instrumentados e locais nos conceitos básicos de testes (link em inglês).

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)));
    }
}

Observação: evite misturar código de teste JUnit 3 e JUnit 4 no mesmo pacote. porque isso pode causar resultados inesperados. Se você estiver criando um modelo para ser executada em um dispositivo ou emulador, sua classe de teste precisa ser prefixada com a anotação @RunWith(AndroidJUnit4::class) no Kotlin, que em Java é @RunWith(AndroidJUnit4.class).

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 Propriedade android.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 flag clearPackageData. 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.

Observação: o executor de instrumentação de teste descontinuado, InstrumentationTestRunner, não é compatível com o Android Test Orchestrator. Se você usar InstrumentationTestRunner, talvez seja necessário usar uma instrumentação diferente runner para usar a orquestração no dispositivo.

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.

Observação: se você não souber sua instrumentação de destino, pesquise execute este comando:

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:

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 o APK de teste e o APK do app em teste:

Figura 1: estrutura do APK de orquestração de testes do Android.

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.