Cette page a été traduite par l'API Cloud Translation.

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 avez besoin d'un test d'instrumentation (rédigés par vous ou votre équipe) qui utilise le Espresso ou UI Automator Frameworks de test Android. Les tests d'instrumentation peuvent exécuter jusqu'à 45 tests minutes sur les appareils physiques et jusqu'à 60 minutes sur les appareils virtuels.

Lors des étapes suivantes, vous importerez l'APK de votre application et l'APK de votre test vers 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 pour traiter les captures d'écran que vous prenez avec AndroidX Capture d'écran lorsque vous exécutez des tests d'instrumentation, tels que des tests écrits à l'aide de la classe Framework de test Espresso. Cette section explique comment créer des objets ScreenCapture avec AndroidX. et comment les traiter à l'aide de testlab-instr-lib.

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

Essayer une application exemple

Téléchargez l'application exemple Notepad pour tester cette fonctionnalité. La possibilité de prendre 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 de 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 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 <instrumentation>. Vous pouvez également spécifier le processeur dans AndroidJUnitRunner à la place (consultez les Documentation de référence sur AndroidJUnitRunner pour obtenir des instructions).

<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 entre les balises Élément <manifest>:
```
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```
Dans le fichier AndroidManifest.xml, spécifiez les autorisations système pour votre application. en ajoutant les lignes suivantes dans la balise <manifest>. Si vous effectuez un test sur Android 10 (niveau d'API 29) ou version ultérieure, omettez WRITE_EXTERNAL_STORAGE (votre application ne nécessite pas cette autorisation pour lire et 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 : Effectuer des captures d'écran pendant le test

À tout moment du test pour lequel vous souhaitez effectuer une capture d'écran, appelez la méthode Screenshot.capture() de la bibliothèque AndroidX. Cela permet d'obtenir Objet ScreenCapture. Lorsque vous appelez process() sur l'objet ScreenCapture, il est traité. à l'aide de 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 sera traité via FirebaseScreenCaptureProcessor et sera disponible avec vos résultats lorsque vous exécutez votre test avec Firebase Test Lab.

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

Effectuer une capture d'écran en plein écran sur un build.VERSION_CODES.JELLY_BEAN_MR2 d'API ci-dessus:
```
Screenshot.capture()
```
Prenez un ScreenCapture de l'activité à n'importe quel niveau d'API. Notez qu'il s'agit uniquement pour les appareils dont la version est inférieure à 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'une capture d'écran

Traitez une ScreenCapture via 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 de la méthode sous-traitant enregistré:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

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

Créez votre application et testez des APK (consultez Tester votre application pour obtenir des instructions).
Importez les fichiers APK dans le tableau de bord Test Lab de la console Firebase.
Enfin, exécutez votre test.

Étape 4. Afficher vos captures d'écran de test

Une fois le test terminé, vous pouvez afficher les captures d'écran prises dans la console Firebase.

Dans l'onglet Tests, sélectionnez votre test terminé. puis cliquez sur l'onglet Results (Résultats).
Sélectionnez à nouveau votre test, puis cliquez sur l'onglet Captures d'écran qui s'affiche.

(Facultatif) Activer d'autres fonctionnalités de test

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

Activer Orchestrator

Android Test Orchestrator est un outil qui exécute chacun des tests d'instrumentation de votre application indépendamment. 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 Options supplémentaires > Exécuter avec Orchestrator.

Avec Orchestrator, vous bénéficiez des avantages suivants:

Aucun état partagé. Chaque test s'exécute une instance d'instrumentation, de sorte qu'un état partagé ne s'accumule pas entre les tests.
Plantages isolés. En cas de plantage d'un test, l'instrumentation est interrompue, et les autres tests de votre suite peuvent toujours s'exécuter.

N'oubliez pas que lorsque vous utilisez Orchestrator, chaque test exécute son propre une instance d'instrumentation, ce qui signifie que le processus de l'application est redémarré après chaque scénario de test. L'augmentation des durées d'exécution qui en résulte peut avoir un impact sur l'utilisation du quota ou le temps de facturation, et peuvent entraîner un dépassement les délais avant expiration. Si vous réduisez le nombre au démarrage, ce qui réduira cette surcharge.

Pour définir des options supplémentaires pour Orchestrator, spécifiez-les via Champ environmentVariables. Par exemple, pour utiliser clearPackageData, utilisez ceci 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 en utilisant plusieurs appareils et effectue l'ensemble des tests en moins de temps.

Par exemple, si vous créez N segments, pour chaque appareil que vous sélectionnez, Test Lab génère N segments. 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 qui ne sont pas segmentés ne donnent qu'un seul résultat appareil. Pour découvrir les concepts de Test Lab, consultez Concepts clés.

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

Dans la configuration des tests d'instrumentation, cliquez sur Options supplémentaires.
Dans la section Division en fragments, saisissez le nombre de fragments que vous souhaitez exécuter.

Facturation des fragments de test

Test Lab implémente vos segments à l'aide de l'outil intégré d'AndroidJUnitRunner de segmentation. Pour éviter d'être facturé pour la création de segments vides (segments sans attribution scénarios de test), le nombre de segments ne doit pas dépasser le nombre total de scénarios de test. Selon la façon dont de temps pour exécuter chaque scénario de test, il est conseillé d'attribuer entre 2 et 10 cas par segment.

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