Fique por dentro dos destaques do Firebase no Google I/O 2023. Saiba mais

Esta página foi traduzida pela API Cloud Translation.

Comece com testes de instrumentação

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

Nas etapas seguintes, 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ê poderá visualizar as capturas de tela capturadas no console do Firebase.

Experimente um aplicativo de exemplo

Baixe o aplicativo de amostra NotePad para experimentar essa funcionalidade. A capacidade de fazer capturas de tela já está incorporada ao projeto NotePad.

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

No arquivo Gradle de configurações de nível raiz do seu 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()
    }
}
// ...

No arquivo Gradle do módulo (nível do aplicativo) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle ), adicione uma dependência para o Test Lab biblioteca de capturas de tela.
```
dependencies {
  // ...
  // Add Test Lab's instrumentation test screenshot library:
  androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
  // ...
```

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>
...

No arquivo AndroidManifest.xml do seu aplicativo, adicione as seguintes linhas ao elemento <manifest> :
```
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```
No 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 exige essa permissão para ler e gravar capturas de tela no dispositivo).
```
<manifest ... >
    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>
```

Passo 2. Faça capturas de tela durante o teste

A qualquer momento do teste em que você queira 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 BasicScreenCaptureProcessor será usado se nenhum processador estiver registrado. Como você registrou o FirebaseScreenCaptureProcessor , suas capturas de tela serão processadas por meio FirebaseScreenCaptureProcessor e estarão disponíveis para você com seus resultados quando você executar o teste com o Firebase Test Lab.

Exemplos de casos de uso para criar um `ScreenCapture` :

Faça uma captura de tela completa em uma API Build.VERSION_CODES.JELLY_BEAN_MR2 e superior:
```
Screenshot.capture()
```

Faça uma ScreenCapture 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 um ScreenCapture

Processe um ScreenCapture por meio do FirebaseScreenCaptureProcessor :
```
Screenshot.capture().process();
```

Processe um ScreenCapture por meio de um ScreenCaptureProcessor especificado (isso permite ignorar o registro do processador):

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

Defina o nome e 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

Crie seu aplicativo e teste APKs (consulte Testar seu aplicativo para obter instruções).
Faça upload dos arquivos APK para o painel do Test Lab do console do Firebase.
Finalmente, execute seu teste.

Etapa 4. Veja as capturas de tela do teste

Após a conclusão do teste, você poderá visualizar todas as capturas de tela feitas no console do Firebase.

Na guia Testes , selecione o teste concluído e clique na guia Resultados .
Selecione seu teste novamente e clique na guia Capturas de tela que aparece.

(Opcional) Habilite recursos de teste adicionais

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

Habilitar 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 para Test Lab, na configuração do teste de instrumentação, clique em Opções adicionais > Executar com Orchestrator .

Ao usar o Orchestrator, você se beneficia do seguinte:

Nenhum estado compartilhado. Cada teste é executado em sua própria instância de instrumentação, portanto, um estado compartilhado não se acumula entre os testes.
Falhas isoladas. Se um teste falhar, apenas essa instrumentação será encerrada e outros testes do seu conjunto ainda poderão ser executados.

Tenha em mente que quando você usa o Orchestrator, cada teste executa sua própria instância de instrumentação, o que significa que o processo do aplicativo é reiniciado após cada caso de teste. O aumento dos tempos de execução resultante pode afetar o uso da sua cota ou o tempo cobrado e fazer com que você exceda os limites de tempo limite dos seus dispositivos. Se você reduzir o tempo de inicialização do seu aplicativo, essa sobrecarga diminuirá.

Para definir opções adicionais para o Orchestrator, especifique-as por meio do campo environmentVariables . Por exemplo, para usar clearPackageData , use esta opção no gcloud:

--environment-variables clearPackageData=true

Habilitar fragmentação

A fragmentação de teste divide um conjunto de testes em subgrupos (fragmentos) 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.

Por exemplo, se você criar N fragmentos, para cada dispositivo selecionado, o Test Lab ativará N dispositivos idênticos e executará um subconjunto de testes em cada dispositivo. Isso significa que os casos de teste fragmentados podem resultar em múltiplas execuções de testes por dispositivo. Os casos de teste não fragmentados, entretanto, resultam em uma execução de teste por dispositivo. Para aprender os conceitos do Test Lab, consulte Conceitos principais .

Para ativar a fragmentação de teste no console do Firebase, siga estas etapas:

Na configuração do teste de instrumentação, clique em Opções adicionais .
Na seção Fragmento , insira o número de fragmentos que você deseja executar.

Faturamento de fragmentos de teste

O Test Lab implementa seus fragmentos aproveitando o mecanismo de fragmentação integrado do AndroidJUnitRunner. Para evitar ser cobrado por gerar fragmentos vazios (fragmentos sem casos de teste atribuídos), o número de fragmentos 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, normalmente é uma boa ideia atribuir de 2 a 10 casos de teste por fragmento.

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