Catch up on everthing we announced at this year's Firebase Summit. Learn more

Primeiros passos com testes de instrumentação

Veja neste guia como preparar e executar um teste de instrumentação usando o Firebase Test Lab. Para usar este guia, você precisará de um teste de instrumentação (escrito por você ou sua equipe) que usa o Espresso ou frameworks de teste do Android UI Automator 2.0. 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 processá-los 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 do Gradle (build.gradle) no nível raiz (para envolvidos no projeto) do projeto de teste, adicione o repositório Maven do Google a cada seção de repositórios:

    buildscript {
    
      repositories {
        // Add the following line:
        google()  // Google's Maven repository
      }
    
      dependencies {
        // ...
    
        // Check that you have the following line (if not, add it):
        classpath 'com.google.gms:google-services:4.3.8'  // Google Services plugin
      }
    }
    
    allprojects {
      // ...
    
      repositories {
        // Add the following line:
        google()  // Google's Maven repository
        // ...
      }
    }
  2. No arquivo do Gradle (geralmente app/build.gradle) do módulo (nível do app), adicione uma dependência para a biblioteca de capturas de tela do Test Lab.

    dependencies {
      // ...
      // Add Test Lab's instrumentation test screenshot library:
      androidTestCompile `com.google.firebase:testlab-instr-lib:02`
      // ...
    }
  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 aplicativo, 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 usando FirebaseScreenCaptureProcessor e estarão disponíveis para você com seus resultados quando executar seu teste com o 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 por meio do FirebaseScreenCaptureProcessor:

    Screenshot.capture().process();
    
  • Processe um ScreenCapture por meio de 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 o upload dos arquivos do APK para o painel do Test Lab no 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 Orchestrator no Test Lab, na configuração do teste de instrumentação, clique em Opções adicionais > Executar com o Orquestrador.

Benefícios e desvantagens

  • Benefício: nenhum estado compartilhado. cada teste é executado em uma instância de instrumentação própria. Assim, o estado compartilhado não se acumula em todos os testes.
  • Benefício: falhas isoladas. Se um teste falha, ele encerra apenas a própria instrumentação. Os outros testes continuam em execução.
  • Desvantagem: tempos de execução mais longos. Cada teste executa a própria instância de instrumentação. Isso significa que o processo de teste leva um pouco mais tempo em geral. Se não for verificado, o aumento nos tempos de execução pode afetar o uso da cota ou o período faturado e fazer com que você atinja o tempo limite dos dispositivos.

Ativar fragmentação

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

Como funciona a fragmentação de testes

Digamos que você crie N fragmentos. Para cada dispositivo selecionado, o Test Lab cria N dispositivos idênticos e executa um subconjunto dos testes em cada dispositivo. Isso significa que os casos de testes fragmentados podem resultar em várias execuções de testes por dispositivo. Ao contrário dos casos de testes não fragmentados, que sempre resultam na execução de um teste por dispositivo. Para uma visão geral rápida dos principais conceitos do Test Lab, consulte Conceitos chave.

É possível ativar a fragmentação de testes no Console do Firebase:

  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

O Test Lab implementa os fragmentos usando o mecanismo de fragmentação interno do AndroidJUnitRunner. 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.