Firebase Test Lab Deprecation

Firebase Test Lab is deprecated and will be fully shut down on September 30, 2027. To maintain your testing workflows, you can migrate to the Developer Device Platform on Google Cloud. See the Developer Device Platform Migration Guide and FAQ for more details.

Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Pierwsze kroki z testami narzędzi

Z tego przewodnika dowiesz się, jak przygotować i przeprowadzić test z instrumentacją za pomocą Firebase Test Lab. Aby skorzystać z tego przewodnika, musisz mieć test z instrumentacją (napisany przez Ciebie lub Twój zespół), który korzysta z platform testowych Espresso lub UI Automator na Androida. Testy z instrumentacją mogą trwać do 45 minut na urządzeniach fizycznych i do 60 minut na urządzeniach wirtualnych.

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

(Opcjonalnie) Dodawanie biblioteki zrzutów ekranu do aplikacji

Firebase Test Lab zawiera bibliotekę (testlab-instr-lib), której możesz używać do przetwarzania zrzutów ekranu wykonanych za pomocą ScreenCapture AndroidX podczas przeprowadzania testów z instrumentacją, 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ą biblioteki testlab-instr-lib.

Po zakończeniu testu z instrumentacją możesz wyświetlić zrobione zrzuty ekranu w konsoli Firebase.

Wypróbuj przykładową aplikację

Aby wypróbować tę funkcję, pobierz przykładową aplikację NotePad. Możliwość robienia zrzutów ekranu jest już uwzględniona w projekcie Notatnika.

Krok 1. Dodawanie biblioteki zrzutów ekranu do projektu

W pliku Gradle ustawień na poziomie głównym projektu testowego (settings.gradle.kts lub settings.gradle) dodaj repozytorium Maven Google 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 biblioteki zrzutów ekranu Test Lab.
```
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 meta-data w elemencie <instrumentation>. Możesz też określić procesor jako argument w AndroidJUnitRunner (instrukcje znajdziesz w dokumentacji 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>
...

W pliku AndroidManifest.xml aplikacji dodaj te wiersze w elemencie <manifest>:

 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

W pliku AndroidManifest.xml określ uprawnienia systemowe aplikacji, dodając te wiersze w tagu <manifest>. Jeśli testujesz na Androidzie 10 (API na poziomie 29) lub nowszym, pomiń uprawnienie WRITE_EXTERNAL_STORAGE (aplikacja nie wymaga tego uprawnienia do odczytywania i zapisywania zrzutów ekranu na urządzeniu).
```
<manifest ... >
    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>
```

Krok 2. Robienie zrzutów ekranu podczas testu

W dowolnym momencie testu, w którym chcesz zrobić zrzut ekranu, wywołaj metodę Screenshot.capture() z biblioteki AndroidX. W ten sposób powstaje obiekt ScreenCapture. Gdy wywołasz metodę process() na obiekcie ScreenCapture, zostanie ona przetworzona za pomocą obiektu ScreenCaptureProcessor zarejestrowanego w AndroidManifest.xml. Pamiętaj, że jeśli nie zarejestrowano żadnych procesorów, używany jest BasicScreenCaptureProcessor. Ponieważ zarejestrowano FirebaseScreenCaptureProcessor, zrzuty ekranu będą przetwarzane przez FirebaseScreenCaptureProcessor i będą dostępne wraz z wynikami po uruchomieniu testu za pomocą Firebase Test Lab.

Przykładowe przypadki użycia, w których warto utworzyć `ScreenCapture`:

Zrób pełny zrzut ekranu w interfejsie API Build.VERSION_CODES.JELLY_BEAN_MR2 i nowszych:
```
Screenshot.capture()
```
Zrób ScreenCapture aktywności na dowolnym poziomie interfejsu API. Pamiętaj, że jest to jedyna opcja w przypadku urządzeń z systemem starszym niż Build.VERSION_CODES.JELLY_BEAN_MR2.
```
@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...
```

Przykładowe przypadki użycia dotyczące przetwarzania zrzutu ekranu

Przetwarzanie ScreenCapture w FirebaseScreenCaptureProcessor:
```
Screenshot.capture().process();
```

Przetwarzanie 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 pliku ScreenCapture, a następnie przetwórz go za pomocą zarejestrowanego procesora:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

Krok 3. Tworzenie i uruchamianie testu

Skompiluj aplikację i przetestuj pliki APK (instrukcje znajdziesz w artykule Testowanie aplikacji).
W konsoli Firebase kliknij DevOps i zaangażowanie > Test Lab, a następnie prześlij pliki APK.
Na koniec uruchom test.

Krok 4. Wyświetlanie zrzutów ekranu z testów

Po zakończeniu testu możesz wyświetlić wszystkie zrobione zrzuty ekranu:

W konsoli Firebase kliknij DevOps & Engagement > Test Lab.
Na karcie Testy wybierz ukończony test, a potem kliknij kartę Wyniki.
Ponownie wybierz test, a następnie kliknij kartę Zrzuty ekranu, która się pojawi.

(Opcjonalnie) Włączanie dodatkowych funkcji testowych

Przed uruchomieniem testu za pomocą Test Lab możesz włączyć te funkcje:

Włączanie usługi Orchestrator

Android Test Orchestrator to narzędzie, które uruchamia każdy test z instrumentacją aplikacji niezależnie. Test Lab zawsze używa najnowszej wersji Orchestratora.

Aby włączyć Orchestrator dla Test Lab, w konfiguracji testu z instrumentacją kliknij Opcje dodatkowe > Uruchom z Orchestratorem.

Korzystanie z Orchestratora zapewnia te korzyści:

Brak udostępnionego stanu. Każdy test jest uruchamiany we własnej instancji instrumentacji, więc stan współdzielony nie jest gromadzony w testach.
pojedyncze awarie, Jeśli test ulegnie awarii, zostanie zakończona tylko ta instrumentacja, a inne testy w zestawie będą nadal działać.

Pamiętaj, że gdy używasz Orchestratora, każdy test uruchamia własną instancję instrumentacji, co oznacza, że proces aplikacji jest ponownie uruchamiany po każdym elemencie testowania. Wydłużony czas działania może wpłynąć na wykorzystanie limitu lub rozliczany czas i spowodować przekroczenie limitów czasu oczekiwania urządzeń. Jeśli skrócisz czas uruchamiania aplikacji, ten narzut się zmniejszy.

Aby ustawić dodatkowe opcje Orchestratora, określ je w polu environmentVariables. Aby na przykład użyć clearPackageData, użyj tej opcji w gcloud:

--environment-variables clearPackageData=true

Włączanie fragmentowania

Fragmentacja testów polega na podzieleniu zestawu testów na podgrupy (fragmenty), które są uruchamiane osobno. Test Lab automatycznie uruchamia każdy fragment równolegle na wielu urządzeniach i wykonuje cały zestaw testów w krótszym czasie.

Jeśli na przykład utworzysz N fragmentów, dla każdego wybranego urządzenia Test Lab uruchomi N identycznych urządzeń i na każdym z nich przeprowadzi podzbiór testów. Oznacza to, że podzielone na fragmenty elementy testowania mogą skutkować wieloma wykonaniami testu na urządzeniu. W przypadku niepodzielonych elementów testowania na każde urządzenie przypada jedno wykonanie testu. Aby poznać pojęcia związane z Test Lab, zobacz Najważniejsze pojęcia.

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

W konfiguracji testu z instrumentacją kliknij Opcje dodatkowe.
W sekcji Sharding wpisz liczbę fragmentów, które chcesz uruchomić.

Płatności za fragmenty testowe

Test Lab implementuje fragmenty, wykorzystując wbudowany mechanizm fragmentacji AndroidJUnitRunner. Aby uniknąć opłat za uruchamianie pustych fragmentów (fragmentów bez przypisanych elementów testowania), liczba utworzonych fragmentów powinna być mniejsza niż łączna liczba elementów testowania. W zależności od tego, jak długo trwa uruchomienie każdego elementu testowania, zwykle warto przypisać od 2 do 10 elementów testowania na fragment.

Więcej informacji o rozliczeniach znajdziesz w artykule Wykorzystanie, limity i rozliczenia.