Commencez avec les tests d'instrumentation

Ce guide décrit 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 des appareils physiques et jusqu'à 60 minutes sur des appareils virtuels .

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

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

Firebase Test Lab comprend une bibliothèque (testlab-instr-lib) que vous pouvez utiliser pour traiter toutes les captures d'écran que vous prenez avec ScreenCapture d'AndroidX lors de l'exécution de tests d'instrumentation, tels que des tests écrits à l'aide du framework de test Espresso . Cette section décrit comment créer des objets ScreenCapture avec la bibliothèque 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.

Essayez un exemple d'application

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

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

  1. Dans le fichier Gradle des paramètres au niveau racine de votre projet de test ( settings.gradle.kts ou settings.gradle ), ajoutez le référentiel 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()
        }
    }
    // ...
    
  2. 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 le laboratoire de test. bibliothèque de captures d'écran.

    dependencies {
      // ...
      // Add Test Lab's instrumentation test screenshot library:
      androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
      // ...
    
  3. 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 comme argument dans AndroidJUnitRunner (voir 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>
    ...
    
  4. 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"/>
    
  5. Dans votre fichier AndroidManifest.xml , spécifiez les autorisations système pour votre application en ajoutant les lignes suivantes dans la balise <manifest> . Si vous testez sur Android 10 (API niveau 29) ou supérieur , omettez l'autorisation WRITE_EXTERNAL_STORAGE (votre application n'a pas besoin de cette autorisation pour lire et écrire des captures d'écran sur l'appareil).

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

Étape 2. Prenez des captures d'écran pendant votre test

À tout moment de votre test où vous souhaitez prendre une capture d'écran, appelez la méthode Screenshot.capture() depuis la bibliothèque AndroidX. Cela produit un objet ScreenCapture . Lorsque vous appelez process() sur l'objet ScreenCapture , il est traité à l'aide du ScreenCaptureProcessor enregistré dans votre AndroidManifest.xml . Notez que BasicScreenCaptureProcessor est utilisé si aucun processeur n'est enregistré. Depuis que vous avez enregistré FirebaseScreenCaptureProcessor , vos captures d'écran seront traitées via FirebaseScreenCaptureProcessor et seront disponibles pour vous 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 supérieure :

    Screenshot.capture()
    
  • Effectuez une ScreenCapture de l'activité à n'importe quel niveau d'API. Notez qu'il s'agit de la seule option pour les appareils infé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'une capture d'écran

  • Traitez une 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 et traitez-le à l'aide du processeur enregistré :

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

Étape 3. Créez et exécutez votre test

  1. Créez votre application et testez les APK (voir Testez votre application pour obtenir des instructions).

  2. Téléchargez les fichiers APK sur le tableau de bord Test Lab de la console Firebase.

  3. Enfin, lancez votre test.

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

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

  1. Dans l'onglet Tests , sélectionnez votre test terminé, puis cliquez sur l'onglet Résultats .

  2. Sélectionnez à nouveau votre test, puis cliquez sur l'onglet Captures d'écran qui apparaît.

(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'orchestrateur

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 des tests d'instrumentation, cliquez sur Options supplémentaires > Exécuter avec Orchestrator .

Lorsque vous utilisez Orchestrator, vous bénéficiez des avantages suivants :

  • Aucun état partagé. Chaque test s'exécute dans sa propre instance d'instrumentation, de sorte qu'un état partagé ne s'accumule pas entre les tests.
  • Crashs isolés. Si un test plante, seule cette instrumentation est interrompue et les autres tests de votre suite peuvent toujours s'exécuter.

Gardez à l'esprit que lorsque vous utilisez Orchestrator, chaque test exécute sa propre instance d'instrumentation, ce qui signifie que le processus d'application est redémarré après chaque scénario de test. L'augmentation des temps d'exécution qui en résulte peut avoir un impact sur l'utilisation de votre quota ou sur le temps facturé et peut vous amener à dépasser les limites de délai d'expiration de vos appareils. Si vous réduisez le temps de démarrage de votre application, cette surcharge diminuera.

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 le partitionnement

Le partage de tests divise un ensemble de tests en sous-groupes (partitions) qui s'exécutent séparément de manière isolée. Test Lab exécute automatiquement chaque partition en parallèle à l'aide de plusieurs appareils et réalise l'ensemble des tests en moins de temps.

Par exemple, si vous créez N partitions, pour chaque appareil que vous sélectionnez, Test Lab fait tourner N appareils identiques et exécute un sous-ensemble de tests sur chaque appareil. Cela signifie que les cas de test fragmentés peuvent entraîner plusieurs exécutions de tests par appareil. Toutefois, les cas de test non fragmentés entraînent une exécution de test par appareil. Pour découvrir les concepts de Test Lab, voir Concepts clés .

Pour activer le partage de test dans la console Firebase, procédez comme suit :

  1. Dans la configuration du test d'instrumentation, cliquez sur Options supplémentaires .

  2. Dans la section Sharding , entrez le nombre de fragments que vous souhaitez exécuter.

Facturation des fragments de test

Test Lab implémente vos partitions en tirant parti du mécanisme de partitionnement intégré d'AndroidJUnitRunner. Pour éviter d'être facturé pour la création de fragments vides (fragments sans scénarios de test attribués), le nombre de fragments 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 2 à 10 scénarios de test par partition.

Pour plus d'informations sur la facturation, lisez Utilisation, quotas et facturation .