Diese Seite wurde von der Cloud Translation API übersetzt.

Beginnen Sie mit Instrumentierungstests

In diesem Leitfaden 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 von Espresso oder UI Automator verwendet. Instrumentierungstests können bis zu 45 Minuten auf physischen Geräten und bis zu 60 Minuten auf virtuellen Geräten ausgeführt werden.

In den folgenden Schritten laden Sie das APK Ihrer App und das APK Ihres Tests auf Firebase hoch.

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

Firebase Test Lab enthält eine Bibliothek (testlab-instr-lib), die Sie verwenden können, um alle Screenshots zu verarbeiten, die Sie mit ScreenCapture von AndroidX aufnehmen, wenn Sie Instrumentierungstests ausführen, z. B. Tests, die mit dem Espresso-Testframework geschrieben wurden. Dieser Abschnitt beschreibt, wie ScreenCapture Objekte mit der AndroidX-Bibliothek erstellt und mit testlab-instr-lib verarbeitet werden.

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 Funktion auszuprobieren. Die Möglichkeit, Screenshots zu machen, ist bereits in das NotePad-Projekt integriert.

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

Fügen Sie in der Gradle-Datei auf Stammebene (Projektebene) Ihres Testprojekts ( build.gradle ) das Maven-Repository von Google zu jedem Repository-Abschnitt hinzu:

buildscript {

  repositories {
    // Add the following line:
    google()  // Google's Maven repository
  }

  dependencies {
    // ...

    // Check that you have the following line (if not, add it):
    classpath 'com.google.gms:google-services:4.3.8'  // Google Services plugin
  }
}

allprojects {
  // ...

  repositories {
    // Add the following line:
    google()  // Google's Maven repository
    // ...
  }
}

Fügen Sie in Ihrer Modul-Gradle-Datei (auf App-Ebene) (normalerweise app/build.gradle ) eine Abhängigkeit für die Screenshot-Bibliothek von Test Lab hinzu.

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 AndroidJUnitRunner-Referenzdokumentation ).

<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 Screenshots während Ihres Tests

Rufen Sie an jedem Punkt Ihres Tests, an dem Sie einen Screenshot machen möchten, die Methode Screenshot.capture() aus der AndroidX-Bibliothek auf. Dies erzeugt ein ScreenCapture Objekt . 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.

Beispielanwendungsfälle zum Erstellen eines `ScreenCapture` :

Machen Sie eine vollständige ScreenCapture auf einem 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 unter Build.VERSION_CODES.JELLY_BEAN_MR2 ist.
```
@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...
```

Beispielanwendungsfälle für die Verarbeitung einer ScreenCapture

Verarbeiten Sie eine 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 aufgenommen 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:

Orchestrator aktivieren

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

Um Orchestrator for 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 Zustand. Jeder Test wird in seiner eigenen Instrumentierungsinstanz ausgeführt, sodass sich ein gemeinsamer Zustand nicht testübergreifend 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.

Denken Sie daran, 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 resultierende längere Laufzeit kann sich auf Ihre Kontingentnutzung oder in Rechnung gestellte Zeit auswirken und dazu führen, dass Sie die Timeout-Limits Ihrer Geräte überschreiten. Wenn Sie die Startzeit Ihrer App verkürzen, verringert sich dieser Overhead.

Um zusätzliche Optionen für Orchestrator festzulegen, geben Sie sie ü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 mit 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 eine Teilmenge der Tests auf jedem Gerät aus. Dies bedeutet, dass fragmentierte Testfälle zu mehreren Testausführungen pro Gerät führen können. Nicht aufgeteilte Testfälle führen jedoch zu einer Testausführung pro Gerät. Informationen zu den Konzepten von Test Lab 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, indem es den integrierten Sharding-Mechanismus von AndroidJUnitRunner nutzt. Um zu vermeiden, dass für das Hochfahren leerer Shards (Shards ohne zugewiesene Testfälle) Gebühren erhoben werden, sollte die Anzahl der von Ihnen erstellten Shards geringer sein als die Gesamtzahl der Testfälle. Je nachdem, wie lange die Ausführung jedes Testfalls dauert, empfiehlt es sich normalerweise, 2–10 Testfälle pro Shard zuzuweisen.

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