Pierwsze kroki z testami narzędzi

Z tego przewodnika dowiesz się, jak przygotować i uruchomić test z instrumentacją za pomocą Firebase Test Lab. Aby korzystać z tego przewodnika, musisz mieć test z instrumentacją (napisany przez Ciebie lub Twój zespół), który korzysta z platform testowych na 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 dalszych krokach prześlesz do Firebase plik APK aplikacji i plik APK testu.

(Opcjonalne) 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 robionych za pomocą ScreenCapture z AndroidX podczas przeprowadzania testów instrumentacji, np. testów napisanych za pomocą platformy testowej Espresso. W tej sekcji opisujemy, jak tworzyć obiekty ScreenCapture za pomocą biblioteki AndroidX i jak je przetwarzać za pomocą testlab-instr-lib.

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

Wypróbowywanie przykładowej aplikacji

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

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 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ść od 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 an argument w AndroidJUnitRunner (instrukcje znajdziesz w dokumentacji referencyjnej 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 dla aplikacji dodając te wiersze w tagu <manifest>. Jeśli testujesz na Androidzie 10 (poziom interfejsu API 29) lub nowszym, pomiń WRITE_EXTERNAL_STORAGE uprawnienie (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 metodę process() na obiekcie ScreenCapture, zostanie on przetworzony za pomocą ScreenCaptureProcessor zarejestrowanego w pliku AndroidManifest.xml. Pamiętaj, że jeśli nie zarejestrujesz żadnych procesorów, zostanie użyty BasicScreenCaptureProcessor. Ponieważ zarejestrowałeś FirebaseScreenCaptureProcessor, zrzuty ekranu będą przetwarzane za pomocą FirebaseScreenCaptureProcessor i będą dostępne w wynikach, gdy uruchomisz test w Firebase Test Lab.

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

Robienie pełnego zrzutu ekranu w przypadku interfejsu API Build.VERSION_CODES.JELLY_BEAN_MR2 i nowszego:
```
Screenshot.capture()
```
Robienie ScreenCapture aktywności na dowolnym poziomie interfejsu API. Pamiętaj, że jest to jedyna opcja w przypadku urządzeń z wersją starszą 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 do przetwarzania zrzutu ekranu

Przetwarzanie ScreenCapture za pomocą 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);

Ustawianie nazwy i formatu ScreenCapture oraz przetwarzanie go za pomocą zarejestrowanego procesora:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

Krok 3. Kompilowanie i uruchamianie testu

Skompiluj pliki APK aplikacji i testu (instrukcje znajdziesz w sekcji Testowanie aplikacji ).
W konsoli Firebase otwórz DevOps i zaangażowanie > Laboratorium testów i prześlij pliki APK.
Na koniec uruchom test.

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

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

W konsoli Firebase otwórz DevOps i zaangażowanie > Laboratorium testów.
Na karcie Testy wybierz ukończony test, a następnie kliknij kartę Wyniki.
Ponownie wybierz test, a następnie kliknij kartę Zrzuty ekranu.

(Opcjonalne) Włączanie dodatkowych funkcji testowania

Przed uruchomieniem testu w Laboratorium testów możesz włączyć te funkcje: Test Lab

Włączanie aranżera

Android Test Orchestrator to narzędzie, które uruchamia każdy test instrumentacji aplikacji niezależnie. Test Lab zawsze używa najnowszej wersji aranżera.

Aby włączyć Orchestrator w Test Lab, w konfiguracji testu z instrumentacją, kliknij Dodatkowe opcje > Uruchom z Orchestratorem.

Korzystając z aranżera, możesz skorzystać z tych zalet:

Brak stanu współdzielonego. Każdy test jest uruchamiany w osobnej instancji instrumentacji, więc stan współdzielony nie jest gromadzony w testach.
Izolowane awarie. Jeśli test ulegnie awarii, zostanie zakończona tylko ta instrumentacja, a inne testy w zestawie będą mogły być nadal uruchamiane.

Pamiętaj, że gdy używasz aranżera, każdy test uruchamia własną instancję instrumentacji, co oznacza, że proces aplikacji jest restartowany po każdym przypadku testowym. W rezultacie wydłużony czas działania może mieć wpływ na wykorzystanie limitu lub czas rozliczany oraz spowodować przekroczenie limitów czasu urządzeń. Jeśli skrócisz czas uruchamiania aplikacji, ten narzut się zmniejszy.

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

--environment-variables clearPackageData=true

Włączanie dzielenia

Dzielenie testów dzieli zestaw testów na podgrupy (fragmenty), które są uruchamiane oddzielnie w izolacji. 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 uruchomi na każdym z nich podzbiór testów. Oznacza to, że przypadki testowe podzielone na fragmenty mogą powodować wielokrotne wykonanie testu na urządzeniu. Jednak przypadki testowe niepodzielone na fragmenty powodują jedno wykonanie testu na urządzeniu. Aby poznać koncepcje Test Lab, zapoznaj się z sekcją Kluczowe pojęcia.

Aby włączyć dzielenie testów w konsoli Firebase:

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

Rozliczenia za fragmenty testów

Test Lab implementuje fragmenty, wykorzystując wbudowany mechanizm dzielenia AndroidJUnitRunner's. 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 tego, jak długo trwa uruchomienie każdego przypadku testowego, zwykle warto przypisać 2–10 przypadków testowych na fragment.

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