Firebase Test Lab Deprecation

Firebase Test Lab is deprecated and will be fully shut down on September 30, 2027. To maintain your testing workflows, you can migrate to the Developer Device Platform on Google Cloud. See the Developer Device Platform Migration Guide and FAQ for more details.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Premiers pas avec les tests d'instrumentation

Ce guide explique comment préparer et exécuter un test d'instrumentation à l'aide de Firebase Test Lab. Pour utiliser ce guide, vous aurez besoin d'un test d'instrumentation (écrit par vous ou votre équipe) qui utilise les frameworks de test Android Espresso ou UI Automator. Les tests d'instrumentation peuvent durer jusqu'à 45 minutes sur les appareils physiques et jusqu'à 60 minutes sur les appareils virtuels.

Dans les étapes suivantes, vous importerez l'APK de votre application et l'APK de votre test dans Firebase.

(Facultatif) Ajouter la bibliothèque de captures d'écran à votre application

Firebase Test Lab inclut une bibliothèque (testlab-instr-lib) que vous pouvez utiliser pour traiter les captures d'écran que vous effectuez avec ScreenCapture d'AndroidX lors de l'exécution de tests d'instrumentation, tels que les tests écrits à l'aide du framework de test Espresso. Cette section explique comment créer des objets ScreenCapture avec la bibliothèque AndroidX et comment les traiter à l'aide de testlab-instr-lib.

Une fois le test d'instrumentation exécuté, vous pouvez afficher les captures d'écran dans la console Firebase.

Essayez une application exemple

Téléchargez l'application exemple NotePad pour essayer cette fonctionnalité. La possibilité de faire des captures d'écran est déjà intégrée au projet NotePad.

Étape 1 : Ajouter la bibliothèque de captures d'écran à votre projet

Dans le fichier Gradle des paramètres au niveau racine de votre projet de test (settings.gradle.kts ou settings.gradle), ajoutez le dépôt Maven de Google à chaque section 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()
    }
}
// ...

Dans le fichier Gradle de votre module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), ajoutez une dépendance pour la bibliothèque de captures d'écran Test Lab.
```
dependencies {
  // ...
  // Add Test Lab's instrumentation test screenshot library:
  androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
  // ...
```

Dans le fichier AndroidManifest.xml de votre test, enregistrez le FirebaseScreenCaptureProcessor dans une balise de métadonnées au sein de l'élément <instrumentation>. Vous pouvez également spécifier le processeur en tant qu'argument dans AndroidJUnitRunner (consultez la documentation de référence d'AndroidJUnitRunner pour savoir comment procéder).

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

Dans le fichier AndroidManifest.xml de votre application, ajoutez les lignes suivantes dans l'élément <manifest> :
```
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```
Dans votre fichier AndroidManifest.xml, spécifiez les autorisations système de votre application en ajoutant les lignes suivantes dans la balise <manifest>. Si vous effectuez des tests sur Android 10 (niveau d'API 29) ou version ultérieure, omettez l'autorisation WRITE_EXTERNAL_STORAGE (votre application n'en a pas besoin pour lire et écrire des captures d'écran sur l'appareil).
```
<manifest ... >
    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>
```

Étape 2 : Faire des captures d'écran pendant le test

À tout moment de votre test, lorsque vous souhaitez effectuer une capture d'écran, appelez la méthode Screenshot.capture() de la bibliothèque AndroidX. Cela génère un objet ScreenCapture. Lorsque vous appelez process() sur l'objet ScreenCapture, il est traité à l'aide de l'élément ScreenCaptureProcessor enregistré dans votre AndroidManifest.xml. Notez que BasicScreenCaptureProcessor est utilisé si aucun processeur n'est enregistré. Comme vous avez enregistré FirebaseScreenCaptureProcessor, vos captures d'écran seront traitées via FirebaseScreenCaptureProcessor et seront disponibles avec vos résultats lorsque vous exécuterez votre test avec Firebase Test Lab.

Exemples de cas d'utilisation pour créer un `ScreenCapture` :

Effectuez une capture d'écran complète sur une API Build.VERSION_CODES.JELLY_BEAN_MR2 et versions ultérieures :
```
Screenshot.capture()
```
Prenez un ScreenCapture de l'activité à n'importe quel niveau d'API. Notez qu'il s'agit de la seule option pour les appareils antérieurs à Build.VERSION_CODES.JELLY_BEAN_MR2.
```
@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...
```

Exemples de cas d'utilisation pour le traitement d'un ScreenCapture

Traitez un ScreenCapture via le FirebaseScreenCaptureProcessor :
```
Screenshot.capture().process();
```

Traitez un ScreenCapture via un ScreenCaptureProcessor spécifié (cela vous permet d'ignorer l'enregistrement du processeur) :

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

Définissez le nom et le format de ScreenCapture, puis traitez-le à l'aide du processeur enregistré :
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

Étape 3 : Créer et exécuter votre test

Créez votre application et testez les APK (pour obtenir des instructions, consultez Tester votre application).
Dans la console Firebase, accédez à DevOps et engagement > Test Lab, puis importez les fichiers APK.
Enfin, exécutez votre test.

Étape 4 : Afficher les captures d'écran de vos tests

Une fois le test terminé, vous pouvez afficher les captures d'écran qui ont été prises :

Dans la console Firebase, accédez à DevOps et engagement > Test Lab.
Dans l'onglet Tests, sélectionnez votre test terminé, puis cliquez sur l'onglet Résultats.
Sélectionnez à nouveau votre test, puis cliquez sur l'onglet Screenshots (Captures d'écran) qui s'affiche.

(Facultatif) Activer des fonctionnalités de test supplémentaires

Vous pouvez activer les fonctionnalités suivantes dans votre test avant de l'exécuter avec Test Lab :

Activer l'outil d'orchestration

Android Test Orchestrator est un outil qui exécute indépendamment chacun des tests d'instrumentation de votre application. Test Lab utilise toujours la dernière version d'Orchestrator.

Pour activer Orchestrator pour Test Lab, dans la configuration du test d'instrumentation,cliquez sur Additional options > Run with Orchestrator (Options supplémentaires > Exécuter avec Orchestrator).

L'utilisation d'Orchestrator présente les avantages suivants :

Aucun état partagé. Chaque test s'exécute dans sa propre instance d'instrumentation. Un état partagé ne s'accumule donc pas entre les tests.
Plantage isolé. Si un test plante, seule cette instrumentation est arrêtée, et les autres tests de votre suite peuvent toujours s'exécuter.

N'oubliez pas que lorsque vous utilisez Orchestrator, chaque test exécute sa propre instance d'instrumentation, ce qui signifie que le processus de l'application redémarre après chaque scénario de test. L'augmentation des temps d'exécution qui en résulte peut avoir un impact sur votre utilisation des quotas ou votre temps facturé et peut vous amener à dépasser les limites de délai avant expiration de vos appareils. Si vous réduisez le temps de démarrage de votre application, ce délai sera plus court.

Pour définir des options supplémentaires pour Orchestrator, spécifiez-les via le champ environmentVariables. Par exemple, pour utiliser clearPackageData, utilisez cette option dans gcloud :

--environment-variables clearPackageData=true

Activer la segmentation

La segmentation des tests divise un ensemble de tests en sous-groupes (segments) qui s'exécutent séparément de manière isolée. Test Lab exécute automatiquement chaque segment en parallèle sur plusieurs appareils et effectue l'ensemble des tests plus rapidement.

Par exemple, si vous créez N segments, pour chaque appareil que vous sélectionnez, Test Lab lance N appareils identiques et exécute un sous-ensemble des tests sur chaque appareil. Cela signifie que les scénarios de test segmentés peuvent entraîner plusieurs exécutions de test par appareil. En revanche, les scénarios de test non segmentés entraînent une exécution de test par appareil. Pour en savoir plus sur les concepts de Test Lab, consultez Concepts clés.

Pour activer la segmentation des tests dans la console Firebase, procédez comme suit :

Dans Configuration du test d'instrumentation,cliquez sur Options supplémentaires.
Dans la section Segmentation, saisissez le nombre de segments que vous souhaitez exécuter.

Facturation des segments de test

Test Lab implémente vos segments en exploitant le mécanisme de segmentation intégré d'AndroidJUnitRunner. Pour éviter que des segments vides (segments sans scénarios de test attribués) vous soient facturés, le nombre de segments que vous créez doit être inférieur au nombre total de scénarios de test. En fonction de la durée d'exécution de chaque scénario de test, il est généralement judicieux d'attribuer entre 2 et 10 scénarios de test par segment.

Pour en savoir plus sur la facturation, consultez Utilisation, quotas et facturation.