Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Comece com testes de instrumentação

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Este guia descreve 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 as estruturas de teste Espresso ou UI Automator Android. Os testes de instrumentação podem durar até 45 minutos em dispositivos físicos e até 60 minutos em dispositivos virtuais .

Nas etapas posteriores, você fará upload do APK do seu aplicativo e do APK do seu teste para o Firebase.

(Opcional) Adicione a biblioteca de capturas de tela ao seu aplicativo

O Firebase Test Lab inclui uma biblioteca (testlab-instr-lib) que você pode usar para processar qualquer captura de tela feita com o ScreenCapture do AndroidX ao executar testes de instrumentação, como testes escritos usando a estrutura de teste Espresso . Esta seção descreve como criar objetos ScreenCapture com a biblioteca AndroidX e como processá-los usando testlab-instr-lib.

Após a execução do teste de instrumentação, você pode visualizar as capturas de tela capturadas no console do Firebase.

Experimente um aplicativo de amostra

Baixe o aplicativo de exemplo NotePad para experimentar essa funcionalidade. A capacidade de tirar screenshots já está incorporada ao projeto NotePad.

Etapa 1. Adicione a biblioteca de capturas de tela ao seu projeto

  1. No arquivo Gradle de nível raiz (nível de projeto) do seu projeto de teste ( build.gradle ), 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 Gradle do módulo (nível do aplicativo) (geralmente app/build.gradle ), adicione uma dependência para a 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 seu teste, registre o FirebaseScreenCaptureProcessor em uma tag de metadados dentro do elemento <instrumentation> . Você também pode especificar o processador como um argumento no AndroidJUnitRunner (consulte a documentação de referência do AndroidJUnitRunner para obter instruções sobre como).

    <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 dentro do elemento <manifest> :

     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    
  5. Em seu arquivo AndroidManifest.xml , especifique as permissões do sistema para seu aplicativo adicionando as seguintes linhas na tag <manifest> . Se você estiver testando no Android 10 (API de nível 29) ou superior , omita a permissão WRITE_EXTERNAL_STORAGE (seu aplicativo não requer 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. Faça capturas de tela durante o teste

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

Exemplos de casos de uso para criar um ScreenCapture :

  • Faça um ScreenCapture completo em um API Build.VERSION_CODES.JELLY_BEAN_MR2 e superior:

    Screenshot.capture()
    
  • Faça uma ScreenCapture de tela da atividade em qualquer nível de API. Observe que esta é 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 uma captura de tela

  • Processe um ScreenCapture por meio do FirebaseScreenCaptureProcessor :

    Screenshot.capture().process();
    
  • Processe uma ScreenCapture por meio de um ScreenCaptureProcessor especificado (isso permite que você pule o registro do processador):

    Set<ScreenCaptureProcessor> processors = new HashSet<>();
    processors.add(new FirebaseScreenCaptureProcessor());
    Screenshot.capture().process(processors);
    
  • Defina o nome e o formato do ScreenCapture e processe-o usando o processador registrado:

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

Etapa 3. Crie e execute seu teste

  1. Crie seu aplicativo e teste os APKs (consulte Testar seu aplicativo para obter instruções).

  2. Carregue os arquivos APK no painel Test Lab do console Firebase.

  3. Por fim, execute seu teste.

Etapa 4. Veja suas capturas de tela de teste

Após a conclusão do teste, 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 que aparece.

(Opcional) Habilitar recursos de teste adicionais

Você pode habilitar os seguintes recursos em seu teste antes de executá-lo com o Test Lab:

Ativar orquestrador

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

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

Vantagens e desvantagens

  • Benefício: Nenhum estado compartilhado. Cada teste é executado em sua própria instância de instrumentação para que um estado compartilhado não se acumule entre os testes.
  • Benefício: Falhas isoladas. Se um teste travar, apenas essa instrumentação será encerrada e outros testes em seu conjunto ainda poderão ser executados.
  • Desvantagem: Tempos de execução mais longos . Cada teste executa sua própria instância de instrumentação, o que significa que o processo de teste demora um pouco mais no geral. Se não for marcada, os tempos de execução aumentados podem afetar seu uso de cota ou tempo faturado e fazer com que você atinja os limites de tempo limite de seus dispositivos .

Ativar fragmentação

A fragmentação de teste divide um conjunto de testes em subgrupos (estilhaços) que são executados separadamente e isoladamente. 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 teste

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 teste fragmentados podem resultar em várias execuções de teste por dispositivo, ao contrário dos casos de teste não fragmentados, que sempre resultam em uma execução de teste por dispositivo (para obter uma visão geral rápida dos conceitos-chave no Laboratório de teste, consulte Conceitos-chave ).

Você pode ativar a fragmentação de teste no console do Firebase:

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

  2. Na seção Sharding , insira o número de shards que deseja executar.

Cobrança por fragmentos de teste

O Test Lab implementa seus shards aproveitando o mecanismo de sharding integrado do AndroidJUnitRunner. Para evitar ser cobrado por girar estilhaços vazios (estilhaços sem casos de teste atribuídos), o número de estilhaços criados 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 estilhaço.

Para obter mais informações sobre cobrança, leia Uso, cotas e cobrança .