Watch demos on how to build & run AI-powered apps with Firebase at Demo Day '24. Watch now.

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

Pierwsze kroki z testami narzędzi

Z tego przewodnika dowiesz się, jak przygotować i przeprowadzić test instrumentacji za pomocą Firebase Test Lab. Aby skorzystać z tego przewodnika, musisz mieć test wewnątrz aplikacji (napisany przez Ciebie lub Twój zespół), który korzysta z ramek testów Androida Espresso lub UI Automator. Testy instrumentacji 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 pliku 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ą funkcji ScreenCapture w AndroidX podczas uruchamiania testów pomiarowych, takich jak testy napisane za pomocą ramy testów Espresso. W tej sekcji opisaliśmy, jak tworzyć obiekty ScreenCapture za pomocą biblioteki AndroidX i jak je przetwarzać za pomocą testlab-instr-lib.

Po uruchomieniu testu pomiarowego 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 NotePad.

Krok 1. Dodawanie biblioteki zrzutów ekranu do projektu

W pliku Gradle (settings.gradle.kts lub settings.gradle) z ustawieniami na poziomie katalogu głównego projektu testowego dodaj repozytorium Maven firmy 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ść z biblioteką Test Lab do tworzenia 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 tag metadanych FirebaseScreenCaptureProcessor w elemencie <instrumentation>. Zamiast tego możesz podać procesor jako argument w AndroidJUnitRunner (szczegółowe 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 Androida 10 (poziom interfejsu API 29) lub nowszego, pomiń uprawnienie WRITE_EXTERNAL_STORAGE (Twoja 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. Spowoduje to utworzenie obiektu ScreenCapture. Gdy wywołasz funkcję process() obiektu ScreenCapture, jest on przetwarzany za pomocą zarejestrowanego w obiekcie AndroidManifest.xml komponentu ScreenCaptureProcessor. Pamiętaj, że jeśli nie ma zarejestrowanych procesorów, używana jest wartość BasicScreenCaptureProcessor. Ponieważ zarejestrowałeś/zarejestrowałaś FirebaseScreenCaptureProcessor, Twoje zrzuty ekranu będą przetwarzane za pomocą FirebaseScreenCaptureProcessor i będą dostępne dla Ciebie wraz z wynikami, gdy wykonasz test za pomocą Firebase Test Lab.

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

Zrób pełny zrzut ekranu na urządzeniu z API Build.VERSION_CODES.JELLY_BEAN_MR2 lub nowszym:
```
Screenshot.capture()
```

ScreenCapture aktywności na dowolnym poziomie interfejsu API. Pamiętaj, że jest to jedyna opcja na urządzeniach z wersją Build.VERSION_CODES.JELLY_BEAN_MR2 i starszą.

@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...

Przykładowe przypadki użycia przechwytywania ekranu

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

Przetwarzanie ScreenCapture za pomocą określonego ScreenCaptureProcessor (umożliwia pominięcie rejestracji procesora):

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

Ustaw nazwę i format ScreenCapture oraz przetwórz go za pomocą zarejestrowanego procesora:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

Krok 3. Tworzenie i uruchamianie testu

Utwórz aplikację i przetestuj pliki APK (aby uzyskać instrukcje, zapoznaj się z artykułem Testowanie aplikacji).
Prześlij pliki APK na panel Test Lab konsoli Firebase.
Na koniec uruchom test.

Krok 4. Wyświetlanie testowych zrzutów ekranu

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

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

(Opcjonalnie) Włącz dodatkowe funkcje testów

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

Włączanie aranżera

Android Test Orchestrator to narzędzie, które niezależnie uruchamia poszczególne testy z instrumentacji aplikacji. Test Lab zawsze korzysta z najnowszej wersji Orchestratora.

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

Korzystając z Orchestratora, możesz:

Brak udostępnionego stanu. Każdy test jest wykonywany w ramach własnego wystąpienia instrumentacji, więc stan wspólny nie kumuluje się w ciągu testów.
Pojedyncze awarie. Jeśli test ulegnie awarii, zostanie zakończona tylko ta część instrumentation, a inne testy w kompletnym teście będą mogły się nadal wykonywać.

Pamiętaj, że podczas korzystania z usługi Orchestrator każdy test uruchamia własny egzemplarz narzędzia do pomiaru wydajności, co oznacza, że proces aplikacji jest ponownie uruchamiany po każdym teście. W efekcie wydłużony czas działania może mieć wpływ na wykorzystanie limitu przydziałów lub naliczany czas oraz spowodować przekroczenie limitów limitów czasowych urządzeń. Jeśli skrócisz czas uruchamiania aplikacji, ten czas będzie krótszy.

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

--environment-variables clearPackageData=true

Włączanie podziału na fragmenty

Testowanie z użyciem podziału dzieli zestaw testów na podgrupy (fragmenty), które są uruchamiane osobno. Test Lab automatycznie uruchamia każdy fragment równolegle na wielu urządzeniach i kończy 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 uruchomi podzbiór testów. Oznacza to, że podział przypadków testowych może spowodować wielokrotne wykonanie testu na jednym urządzeniu. Niedzielone przypadki testowe dają jednak w wyniku jedno wykonanie testu na urządzenie. Aby dowiedzieć się więcej o koncepcjach Test Lab, przeczytaj artykuł Najważniejsze pojęcia.

Aby włączyć testowe dzielenie na segmenty w konsoli Firebase:

W konfiguracji testu instrumentacji kliknij Dodatkowe opcje.
W sekcji Dzielenie na fragmenty wpisz liczbę fragmentów, które chcesz uruchomić.

Rozliczenia za fragmenty testowe

Test Lab wdraża fragmenty, korzystając z wbudowanego mechanizmu podziału AndroidJUnitRunner. Aby uniknąć opłat za uruchamianie pustych fragmentów (fragmentów bez przypisanych przypadków testowych), liczba utworzonych fragmentów powinna być mniejsza niż łączna liczba przypadków testowych. W zależności od czasu trwania poszczególnych przypadków testowych warto przypisać 2–10 przypadków testowych do każdego fragmentu.

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