Ta strona została przetłumaczona przez Cloud Translation API.

Zacznij od testów oprzyrządowania

W tym przewodniku opisano, jak przygotować i przeprowadzić test instrumentacji za pomocą Firebase Test Lab. Aby skorzystać z tego przewodnika, potrzebujesz testu oprzyrządowania (napisanego przez Ciebie lub Twój zespół), który korzysta ze środowiska testowego Espresso lub UI Automator Android. Testy oprzyrządowania mogą trwać do 45 minut na urządzeniach fizycznych i do 60 minut na urządzeniach wirtualnych .

W kolejnych krokach prześlesz plik APK swojej aplikacji i plik APK testu do Firebase.

(Opcjonalnie) Dodaj bibliotekę zrzutów ekranu do swojej aplikacji

Firebase Test Lab zawiera bibliotekę (testlab-instr-lib), której możesz użyć do przetwarzania zrzutów ekranu zrobionych za pomocą ScreenCapture AndroidX podczas przeprowadzania testów oprzyrządowania, takich jak testy napisane przy użyciu platformy testowej Espresso . W tej sekcji opisano, jak tworzyć obiekty ScreenCapture za pomocą biblioteki AndroidX i jak je przetwarzać za pomocą testlab-instr-lib.

Po uruchomieniu testu instrumentacji możesz wyświetlić przechwycone zrzuty ekranu w konsoli Firebase.

Wypróbuj przykładową aplikację

Pobierz przykładową aplikację Notatnik , aby wypróbować tę funkcję. Możliwość robienia zrzutów ekranu jest już włączona do projektu NotePad.

Krok 1. Dodaj bibliotekę zrzutów ekranu do swojego projektu

W głównym pliku ustawień projektu testowego Gradle ( settings.gradle.kts lub settings.gradle ) dodaj repozytorium Google Maven do każdej sekcji 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()
    }
}
// ...

W pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle ) dodaj zależność dla laboratorium testowego biblioteka zrzutów ekranu.
```
dependencies {
  // ...
  // Add Test Lab's instrumentation test screenshot library:
  androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
  // ...
```

W pliku AndroidManifest.xml testu zarejestruj FirebaseScreenCaptureProcessor w tagu metadanych w elemencie <instrumentation> . Zamiast tego możesz również określić procesor jako argument w AndroidJUnitRunner (zobacz dokumentację referencyjną AndroidJUnitRunner , aby dowiedzieć się, jak to zrobić).

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

W pliku AndroidManifest.xml aplikacji dodaj następujące wiersze w elemencie <manifest> :
```
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```
W pliku AndroidManifest.xml określ uprawnienia systemowe dla swojej aplikacji, dodając następujące wiersze w tagu <manifest> . Jeśli testujesz na Androidzie 10 (poziom interfejsu API 29) lub nowszym , pomiń uprawnienie WRITE_EXTERNAL_STORAGE (Twoja aplikacja nie wymaga tego pozwolenia, aby odczytywać i zapisywać zrzuty ekranu na urządzeniu).
```
<manifest ... >
    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>
```

Krok 2. Zrób zrzuty ekranu podczas testu

W dowolnym momencie testu, w którym chcesz zrobić zrzut ekranu, wywołaj metodę Screenshot.capture() z biblioteki AndroidX. Spowoduje to utworzenie obiektu ScreenCapture . Wywołanie process() na obiekcie ScreenCapture powoduje jego przetworzenie przy użyciu metody ScreenCaptureProcessor zarejestrowanej w pliku AndroidManifest.xml . Należy zauważyć, że BasicScreenCaptureProcessor jest używany, jeśli nie zarejestrowano żadnych procesorów. Ponieważ zarejestrowałeś FirebaseScreenCaptureProcessor , Twoje zrzuty ekranu będą przetwarzane przez FirebaseScreenCaptureProcessor i będą dostępne wraz z wynikami po uruchomieniu testu w Firebase Test Lab.

Przykładowe przypadki użycia do tworzenia `ScreenCapture` :

Wykonaj pełny zrzut ekranu na interfejsie API Build.VERSION_CODES.JELLY_BEAN_MR2 i nowszym:
```
Screenshot.capture()
```
Wykonaj ScreenCapture działania na dowolnym poziomie interfejsu API. Pamiętaj, że jest to jedyna opcja dla urządzeń poniżej Build.VERSION_CODES.JELLY_BEAN_MR2.
```
@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...
```

Przykładowe przypadki użycia do przetwarzania ScreenCapture

Przetwórz ScreenCapture za pomocą FirebaseScreenCaptureProcessor :
```
Screenshot.capture().process();
```

Przetwórz ScreenCapture za pomocą określonego ScreenCaptureProcessor (pozwala to pominąć rejestrację procesora):

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

Ustaw nazwę i format ScreenCapture i przetwórz je przy użyciu zarejestrowanego procesora:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

Krok 3. Zbuduj i uruchom test

Utwórz aplikację i przetestuj pliki APK (instrukcje znajdziesz w sekcji Testowanie aplikacji ).
Prześlij pliki APK do pulpitu nawigacyjnego Test Lab w konsoli Firebase.
Na koniec uruchom test.

Krok 4. Wyświetl zrzuty ekranu z testów

Po zakończeniu testu możesz wyświetlić wykonane zrzuty ekranu w konsoli Firebase.

Na karcie Testy wybierz ukończony test, a następnie kliknij kartę Wyniki .
Wybierz test ponownie, a następnie kliknij wyświetloną kartę Zrzuty ekranu .

(Opcjonalnie) Włącz dodatkowe funkcje testowe

Możesz włączyć następujące funkcje w swoim teście przed uruchomieniem go w Test Lab:

Włącz Orchestratora

Android Test Orchestrator to narzędzie, które niezależnie przeprowadza testy oprzyrządowania aplikacji. Test Lab zawsze używa najnowszej wersji programu Orchestrator.

Aby włączyć program Orchestrator for Test Lab, w konfiguracji testu Instrumentacji kliknij opcję Dodatkowe opcje > Uruchom z programem Orchestrator .

Korzystając z programu Orchestrator, korzystasz z następujących korzyści:

Brak wspólnego stanu. Każdy test jest uruchamiany we własnym wystąpieniu Instrumentacji, więc stan udostępniony nie jest kumulowany między testami.
Pojedyncze awarie. Jeśli test ulegnie awarii, tylko ta instrumentacja zostanie zakończona, a inne testy w pakiecie mogą nadal działać.

Należy pamiętać, że w przypadku korzystania z programu Orchestrator każdy test uruchamia własne wystąpienie instrumentacji, co oznacza, że proces aplikacji jest uruchamiany ponownie po każdym przypadku testowym. Wynikający z tego wydłużony czas działania może mieć wpływ na wykorzystanie limitu lub rozliczony czas i może spowodować przekroczenie limitów czasu działania urządzeń. Jeśli skrócisz czas uruchamiania aplikacji, ten narzut ulegnie skróceniu.

Aby ustawić dodatkowe opcje programu Orchestrator, określ je za pomocą pola environmentVariables . Na przykład, aby użyć clearPackageData , użyj tej opcji w gcloud:

--environment-variables clearPackageData=true

Włącz sharding

Podział testów na fragmenty dzieli zestaw testów na podgrupy (odłamki), które są uruchamiane oddzielnie w izolacji. Test Lab automatycznie uruchamia każdy fragment równolegle przy użyciu wielu urządzeń i wykonuje cały zestaw testów w krótszym czasie.

Na przykład, jeśli utworzysz N fragmentów, dla każdego wybranego urządzenia Test Lab uruchamia N identycznych urządzeń i przeprowadza podzbiór testów na każdym urządzeniu. Oznacza to, że podzielone przypadki testowe mogą skutkować wykonaniem wielu testów na urządzeniu. Jednak przypadki testowe niepodzielone na fragmenty powodują wykonanie jednego testu na urządzenie. Aby zapoznać się z pojęciami dotyczącymi laboratorium testowego, zobacz Kluczowe pojęcia .

Aby włączyć fragmentację testów w konsoli Firebase, wykonaj te czynności:

W konfiguracji testu oprzyrządowania kliknij opcję Dodatkowe opcje .
W sekcji Sharding wprowadź liczbę fragmentów, które chcesz uruchomić.

Rozliczanie za fragmenty testowe

Test Lab implementuje Twoje shardy, wykorzystując wbudowany mechanizm shardingu AndroidJUnitRunner. Aby uniknąć naliczania opłat za obracanie pustych fragmentów (fragmentów bez przypisanych przypadków testowych), liczba tworzonych fragmentów powinna być mniejsza niż łączna liczba przypadków testowych. W zależności od tego, jak długo trwa uruchamianie każdego przypadku testowego, zwykle dobrym pomysłem jest przypisanie 2-10 przypadków testowych na fragment.

Aby uzyskać więcej informacji na temat rozliczeń, przeczytaj artykuł Użycie, limity i rozliczenia .