Firebase Demo Day is here! Watch demos of how to build and grow AI-powered, full stack apps using the best of Google.

Diese Seite wurde von der Cloud Translation API übersetzt.

Beginnen Sie mit Instrumentierungstests

In dieser Anleitung wird beschrieben, wie Sie einen Instrumentierungstest mit Firebase Test Lab vorbereiten und ausführen. Um dieses Handbuch verwenden zu können, benötigen Sie einen Instrumentierungstest (von Ihnen oder Ihrem Team geschrieben), der die Android-Testframeworks Espresso oder UI Automator verwendet. Instrumentierungstests können auf physischen Geräten bis zu 45 Minuten und auf virtuellen Geräten bis zu 60 Minuten dauern.

In den späteren Schritten laden Sie die APK Ihrer App und die APK Ihres Tests in Firebase hoch.

(Optional) Fügen Sie die Screenshot-Bibliothek zu Ihrer App hinzu

Firebase Test Lab enthält eine Bibliothek (testlab-instr-lib), mit der Sie alle Screenshots verarbeiten können, die Sie mit ScreenCapture von AndroidX erstellen, wenn Sie Instrumentierungstests ausführen, z. B. Tests, die mit dem Espresso-Testframework geschrieben wurden. In diesem Abschnitt wird beschrieben, wie Sie ScreenCapture Objekte mit der AndroidX-Bibliothek erstellen und diese mit testlab-instr-lib verarbeiten.

Nachdem Ihr Instrumentierungstest ausgeführt wurde, können Sie die erfassten Screenshots in der Firebase-Konsole anzeigen.

Probieren Sie eine Beispiel-App aus

Laden Sie die NotePad-Beispiel-App herunter, um diese Funktionalität auszuprobieren. Die Möglichkeit, Screenshots zu erstellen, ist bereits im NotePad-Projekt integriert.

Schritt 1. Fügen Sie die Screenshot-Bibliothek zu Ihrem Projekt hinzu

Fügen Sie in der Gradle-Datei mit den Root-Einstellungen Ihres Testprojekts ( settings.gradle.kts oder settings.gradle ) das Maven-Repository von Google zu jedem repositories Abschnitt hinzu:

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()
    }
}
// ...

Fügen Sie in Ihrer Modul-Gradle-Datei (auf App-Ebene) (normalerweise <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle ) eine Abhängigkeit für das Testlabor hinzu Screenshot-Bibliothek.
```
dependencies {
  // ...
  // Add Test Lab's instrumentation test screenshot library:
  androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
  // ...
```

Registrieren Sie in der AndroidManifest.xml Datei Ihres Tests den FirebaseScreenCaptureProcessor in einem Metadaten-Tag innerhalb des <instrumentation> -Elements. Sie können den Prozessor stattdessen auch als Argument in AndroidJUnitRunner angeben (Anweisungen dazu finden Sie in der Referenzdokumentation zu AndroidJUnitRunner ).

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

Fügen Sie in der AndroidManifest.xml Datei Ihrer App die folgenden Zeilen innerhalb des <manifest> -Elements hinzu:
```
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```
Geben Sie in Ihrer AndroidManifest.xml Datei Systemberechtigungen für Ihre App an, indem Sie die folgenden Zeilen innerhalb des <manifest> -Tags hinzufügen. Wenn Sie auf Android 10 (API-Ebene 29) oder höher testen, lassen Sie die Berechtigung WRITE_EXTERNAL_STORAGE weg (Ihre App benötigt diese Berechtigung nicht, um Screenshots auf dem Gerät zu lesen und zu schreiben).
```
<manifest ... >
    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>
```

Schritt 2: Machen Sie während Ihres Tests Screenshots

Rufen Sie an jedem Punkt Ihres Tests, an dem Sie einen Screenshot erstellen möchten, die Methode Screenshot.capture() aus der AndroidX-Bibliothek auf. Dadurch wird ein ScreenCapture Objekt erstellt. Wenn Sie process() für das ScreenCapture Objekt aufrufen, wird es mithilfe des ScreenCaptureProcessor verarbeitet, der in Ihrer AndroidManifest.xml registriert ist. Beachten Sie, dass der BasicScreenCaptureProcessor verwendet wird, wenn keine Prozessoren registriert sind. Da Sie FirebaseScreenCaptureProcessor registriert haben, werden Ihre Screenshots über FirebaseScreenCaptureProcessor verarbeitet und stehen Ihnen mit Ihren Ergebnissen zur Verfügung, wenn Sie Ihren Test mit Firebase Test Lab ausführen.

Beispielhafte Anwendungsfälle für die Erstellung eines `ScreenCapture` :

Machen Sie eine vollständige Bildschirmaufnahme mit einer API Build.VERSION_CODES.JELLY_BEAN_MR2 und höher:
```
Screenshot.capture()
```
Machen Sie eine ScreenCapture der Aktivität auf einer beliebigen API-Ebene. Beachten Sie, dass dies die einzige Option für Geräte ist, die unter Build.VERSION_CODES.JELLY_BEAN_MR2 liegen.
```
@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...
```

Beispielhafte Anwendungsfälle für die Verarbeitung eines ScreenCaptures

Verarbeiten Sie ein ScreenCapture über den FirebaseScreenCaptureProcessor :
```
Screenshot.capture().process();
```

Verarbeiten Sie ein ScreenCapture über einen angegebenen ScreenCaptureProcessor (dadurch können Sie die Registrierung des Prozessors überspringen):

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

Legen Sie den Namen und das Format des ScreenCapture fest und verarbeiten Sie es mit dem registrierten Prozessor:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

Schritt 3: Erstellen Sie Ihren Test und führen Sie ihn aus

Erstellen Sie Ihre App und testen Sie APKs (Anweisungen finden Sie unter Testen Ihrer App ).
Laden Sie die APK-Dateien in das Test Lab-Dashboard der Firebase-Konsole hoch.
Führen Sie abschließend Ihren Test durch.

Schritt 4. Sehen Sie sich Ihre Test-Screenshots an

Nachdem Ihr Test abgeschlossen ist, können Sie alle Screenshots anzeigen, die in der Firebase-Konsole erstellt wurden.

Wählen Sie auf der Registerkarte „Tests“ Ihren abgeschlossenen Test aus und klicken Sie dann auf die Registerkarte „Ergebnisse“ .
Wählen Sie Ihren Test erneut aus und klicken Sie dann auf die angezeigte Registerkarte Screenshots .

(Optional) Aktivieren Sie zusätzliche Testfunktionen

Sie können die folgenden Funktionen in Ihrem Test aktivieren, bevor Sie ihn mit Test Lab ausführen:

Aktivieren Sie Orchestrator

Android Test Orchestrator ist ein Tool, das jeden Instrumentierungstest Ihrer App unabhängig ausführt. Test Lab verwendet immer die neueste Version von Orchestrator.

Um Orchestrator für Test Lab zu aktivieren, klicken Sie im Instrumentierungstest-Setup auf Zusätzliche Optionen > Mit Orchestrator ausführen .

Wenn Sie Orchestrator verwenden, profitieren Sie von Folgendem:

Kein gemeinsamer Status. Jeder Test wird in einer eigenen Instrumentierungsinstanz ausgeführt, sodass sich bei allen Tests kein gemeinsamer Status ansammelt.
Vereinzelte Abstürze. Wenn ein Test abstürzt, wird nur diese Instrumentierung beendet und andere Tests in Ihrer Suite können weiterhin ausgeführt werden.

Beachten Sie, dass bei Verwendung von Orchestrator jeder Test seine eigene Instrumentierungsinstanz ausführt, was bedeutet, dass der App-Prozess nach jedem Testfall neu gestartet wird. Die daraus resultierenden längeren Laufzeiten können sich auf Ihre Kontingentnutzung oder die in Rechnung gestellte Zeit auswirken und dazu führen, dass Sie die Timeout-Grenzwerte Ihrer Geräte überschreiten. Wenn Sie die Startzeit Ihrer App verkürzen, verringert sich dieser Mehraufwand.

Um zusätzliche Optionen für Orchestrator festzulegen, geben Sie diese über das Feld environmentVariables an. Um beispielsweise clearPackageData zu verwenden, verwenden Sie diese Option in gcloud:

--environment-variables clearPackageData=true

Sharding aktivieren

Beim Test-Sharding wird eine Reihe von Tests in Untergruppen (Shards) unterteilt, die separat und isoliert ausgeführt werden. Test Lab führt jeden Shard automatisch parallel auf mehreren Geräten aus und schließt den gesamten Testsatz in kürzerer Zeit ab.

Wenn Sie beispielsweise N Shards erstellen, startet Test Lab für jedes ausgewählte Gerät N identische Geräte und führt auf jedem Gerät eine Teilmenge der Tests aus. Dies bedeutet, dass geteilte Testfälle zu mehreren Testausführungen pro Gerät führen können. Nicht-sharded-Testfälle führen jedoch zu einer Testausführung pro Gerät. Informationen zu Testlaborkonzepten finden Sie unter Schlüsselkonzepte .

Führen Sie die folgenden Schritte aus, um Test-Sharding in der Firebase-Konsole zu aktivieren:

Klicken Sie im Instrumentierungstest-Setup auf Zusätzliche Optionen .
Geben Sie im Abschnitt Sharding die Anzahl der Shards ein, die Sie ausführen möchten.

Abrechnung für Test-Shards

Test Lab implementiert Ihre Shards durch Nutzung des integrierten Sharding-Mechanismus von AndroidJUnitRunner. Um zu vermeiden, dass für das Hochfahren leerer Shards (Shards ohne zugewiesene Testfälle) Gebühren anfallen, sollte die Anzahl der von Ihnen erstellten Shards geringer sein als die Gesamtzahl der Testfälle. Abhängig davon, wie lange die Ausführung jedes Testfalls dauert, ist es normalerweise eine gute Idee, 2–10 Testfälle pro Shard zuzuweisen.

Weitere Informationen zur Abrechnung finden Sie unter Nutzung, Kontingente und Abrechnung .