Comece a fazer testes de instrumentação

Neste guia, descrevemos como preparar e executar um teste de instrumentação usando Firebase Test Lab: Para usar este guia, você vai precisar de um teste de instrumentação (escrito por você ou sua equipe) que usa o Espresso ou frameworks de teste do UI Automator para Android. Os testes de instrumentação podem ser executados por até 45 minutos em dispositivos físicos e por até 60 minutos em dispositivos virtuais.

Nas etapas posteriores, você fará upload do APK do app e do APK de teste ao Firebase.

(Opcional) Adicionar a biblioteca de capturas de tela ao app

O Firebase Test Lab inclui uma biblioteca (testlab-instr-lib) que pode ser usada para processar capturas de tela feitas com o ScreenCapture do AndroidX ao executar testes de instrumentação, como testes escritos, usando o framework de teste Espresso. Veja nesta seção como criar objetos ScreenCapture com a biblioteca AndroidX e como fazer o processamento deles usando testlab-instr-lib.

Depois que o teste de instrumentação tiver sido executado, você poderá ver as capturas de tela realizadas no console do Firebase.

Testar um app de exemplo

Faça o download do app de exemplo do NotePad para testar essa funcionalidade. A função de fazer capturas de tela já está incorporada ao projeto do Bloco de notas.

Etapa 1. Adicionar a biblioteca de captura de tela ao projeto

  1. No arquivo Gradle das configurações no nível raiz do projeto de teste (settings.gradle.kts ou settings.gradle), adicione o repositório Maven do Google a cada seção repositories:

    pluginManagement {
    repositories {
        // Add the following line:
        google() // Google's Maven repository
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        // Add the following line:
        google() // Google's Maven repository
        mavenCentral()
    }
}
// ...

  2. No arquivo Gradle do módulo (nível do app) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), adicione uma dependência para biblioteca de capturas de tela do Test Lab.

    dependencies {
  // ...
  // Add Test Lab's instrumentation test screenshot library:
  androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
  // ...

  3. No arquivo AndroidManifest.xml do teste, registre o FirebaseScreenCaptureProcessor em uma tag de metadados no elemento <instrumentation>. Também é possível especificar o processador como um argumento no AndroidJUnitRunner. Consulte a documentação de referência do AndroidJUnitRunner para ver instruções sobre como fazer isso.

    <instrumentation
  // Check that you have the following line (if not, add it):
  android:name="androidx.test.runner.AndroidJUnitRunner" // Specifies AndroidJUnitRunner as the test runner
  android:targetPackage="com.your.package.name">

// Add the following:
<meta-data
  android:name="screenCaptureProcessors"
  android:value="com.google.firebase.testlab.screenshot.FirebaseScreenCaptureProcessor" />
</instrumentation>
...

  4. No arquivo AndroidManifest.xml do seu app, adicione as seguintes linhas no elemento <manifest>:

     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

  5. No arquivo AndroidManifest.xml, especifique as permissões do sistema para o app adicionando as seguintes linhas na tag <manifest>. Se você estiver testando no Android 10 (API de nível 29) ou posterior, omita a permissão WRITE_EXTERNAL_STORAGE. Seu app não exige essa permissão para ler e gravar capturas de tela no dispositivo.

    <manifest ... >
    <!-- WRITE_EXTERNAL_STORAGE is not needed on Android 10 (API level 29) or higher. -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>

Etapa 2. Fazer capturas de tela durante o teste

A qualquer momento no teste em que você quer fazer uma captura de tela, chame o método Screenshot.capture() da biblioteca do AndroidX. Isso produz um objeto ScreenCapture. Quando você chama process() no objeto ScreenCapture, ele é processado usando o ScreenCaptureProcessor registrado no seu AndroidManifest.xml. BasicScreenCaptureProcessor será usado se nenhum processador estiver registrado. Como você registrou o FirebaseScreenCaptureProcessor, suas capturas de tela serão processadas por FirebaseScreenCaptureProcessor e estarão disponíveis com os resultados ao executar o teste com Firebase Test Lab.

Exemplos de casos de uso para criar um ScreenCapture:

  • Faça uma captura de tela completa em uma versão de API Build.VERSION_CODES.JELLY_BEAN e posterior:

    Screenshot.capture()

  • Faça uma ScreenCapture da atividade em qualquer nível da API. Essa é a única opção para dispositivos abaixo de Build.VERSION_CODES.JELLY_BEAN_MR2.

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

Exemplos de casos de uso para processar um ScreenCapture

  • Processe um ScreenCapture usando FirebaseScreenCaptureProcessor:

    Screenshot.capture().process();

  • Processe um ScreenCapture com um ScreenCaptureProcessor especificado. Isso permite pular o registro do processador:

    Set<ScreenCaptureProcessor> processors = new HashSet<>();
processors.add(new FirebaseScreenCaptureProcessor());
Screenshot.capture().process(processors);

  • Defina o nome e o formato da ScreenCapture e processe-o usando o processador registrado:

    Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();

Etapa 3. Criar e executar o teste

  1. Compile seu app e teste APKs (consulte Testar seu app para ver instruções).

  2. Faça upload dos arquivos APK para o painel do Test Lab. do console do Firebase.

  3. Por fim, execute o teste.

Etapa 4. Ver capturas de tela do teste

Depois que o teste for concluído, você poderá ver as capturas de tela feitas no console do Firebase.

  1. Na guia Testes, selecione o teste concluído e clique na guia Resultados.

  2. Selecione seu teste novamente e clique na guia Capturas de tela exibida.

(Opcional) Ativar recursos de teste adicionais

É possível ativar os seguintes recursos no teste antes de executá-los com o Test Lab:

Ativar o Orchestrator

O Android Test Orchestrator é uma ferramenta que executa cada um dos testes de instrumentação do app de forma independente. O Test Lab sempre usa a versão mais recente do Orchestrator.

Para ativar o Orquestrador no Test Lab, na configuração do teste de instrumentação, clique em Opções adicionais > Executar com o Orquestrador.

Ao usar o Orchestrator, você recebe os seguintes benefícios:

  • Nenhum estado compartilhado: cada teste é executado em uma instância de instrumentação própria. Assim, um estado compartilhado não se acumula em todos os testes.
  • Falhas isoladas: se um teste falha, ele encerra apenas a própria instrumentação. Os outros testes continuam em execução.

Quando você usa o Orchestrator, cada teste executa a própria instância de instrumentação, o que significa que o processo do app é reiniciado após cada caso de teste. O aumento no tempo de execução pode afetar o uso da cota ou o período faturado e fazer com que você exceda os tempos limite dos dispositivos. Se você reduzir o tempo de inicialização do app, essa overhead será reduzida.

Para definir outras opções para o Orchestrator, especifique-as no campo environmentVariables. Por exemplo, para usar clearPackageData, utilize esta opção na gcloud:

--environment-variables clearPackageData=true

Ativar a fragmentação

A fragmentação de testes divide um conjunto de testes em subgrupos (fragmentos) que são executados separadamente e de forma isolada. O Test Lab executa automaticamente cada fragmento em paralelo usando vários dispositivos e conclui todo o conjunto de testes em menos tempo.

Por exemplo, se você criar N fragmentos para cada dispositivo selecionado, o Test Lab vai ativar N dispositivos idênticos e executar um subconjunto dos testes em cada dispositivo. Isso significa que casos de teste fragmentados podem resultar em várias execuções de teste por dispositivo. No entanto, os casos de teste não fragmentados resultam em uma execução de teste por dispositivo. Para aprender os conceitos de Test Lab, consulte Principais conceitos.

Para ativar a fragmentação de testes no Console do Firebase, siga estas instruções:

  1. Na configuração do teste de instrumentação, clique em Opções adicionais.

  2. Na seção Fragmentação, digite o número de fragmentos que você quer executar.

Faturamento por fragmentos de teste

Test Lab implementa seus fragmentos usando o recurso integrado do AndroidJUnitRunner de fragmentação de dados. Para evitar ser cobrado por gerar fragmentos vazios (fragmentos sem casos de teste designados), o número de fragmentos que você cria deve ser menor que o número total de casos de teste. Dependendo de quanto tempo cada caso de teste leva para ser executado, geralmente é uma boa ideia atribuir de 2 a 10 casos de teste por fragmento.

Para mais informações sobre faturamento, leia Uso, cotas e faturamento.