Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Pierwsze kroki z testami narzędzi

Z tego przewodnika dowiesz się, jak przygotować i uruchomić test instrumentacji za pomocą Firebase Test Lab. Aby korzystać z tego przewodnika, musisz mieć test instrumentacji (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 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 robionych za pomocą ScreenCapture z AndroidX podczas przeprowadzania testów instrumentacji, np. testów napisanych przy użyciu 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 instrumentacji możesz wyświetlić zrobione zrzuty ekranu w konsoli Firebase.

Wypróbowanie 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. 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 po uruchomieniu testu w Firebase Test Lab.

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

Zrobienie pełnego zrzutu ekranu na urządzeniu z Androidem w wersji API Build.VERSION_CODES.JELLY_BEAN_MR2 lub nowszej:
```
Screenshot.capture()
```
Zrobienie ScreenCapture aktywności na dowolnym poziomie interfejsu API. Pamiętaj, że jest to jedyna opcja w przypadku urządzeń z Androidem w wersji starszej 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.

(Opcjonalnie) Włączanie dodatkowych funkcji testowania

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

Włączanie Orchestratora

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

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

Korzystając z Orchestratora, 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 Orchestratora, każdy test jest uruchamiany w osobnej instancji instrumentacji, co oznacza, że proces aplikacji jest restartowany po każdym przypadku testowym. Wydłużony czas działania może mieć wpływ na wykorzystanie limitu lub czas rozliczany i może spowodować przekroczenie limitów czasu 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 dzielenia na fragmenty

Dzielenie testów na fragmenty 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 podzbiór testów na każdym urządzeniu. 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 na fragmenty 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 testów

Test Lab implementuje fragmenty, korzystając z wbudowanego mechanizmu dzielenia na fragmenty 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.