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

(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 z Androida X podczas przeprowadzania testów instrumentacyjnych, np. testów napisanych przy użyciu platformy testowej Espresso. W tej sekcji opisujemy, jak tworzyć obiekty ScreenCapture za pomocą biblioteki Androida X i jak je przetwarzać za pomocą biblioteki testlab-instr-lib.

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

Wypróbuj przykładową aplikację

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

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ść z biblioteką Test Lab 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>. Możesz też określić procesor jako argument w klasie 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 aplikacji, dodając te wiersze w tagu <manifest>. Jeśli testujesz na Androidzie 10 (poziom API 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. robić 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 ScreenCapture obiektu. Gdy wywołasz funkcję process() na obiekcie ScreenCapture, zostanie ona przetworzona za pomocą zarejestrowanego w AndroidManifest.xml procesora ScreenCaptureProcessor. Pamiętaj, że znak BasicScreenCaptureProcessor jest używany, jeśli nie ma zarejestrowanych procesorów. Ponieważ zarejestrowano FirebaseScreenCaptureProcessor, zrzuty ekranu będą przetwarzane za pomocą FirebaseScreenCaptureProcessor i będą dostępne wraz z wynikami po przeprowadzeniu testu za pomocą Firebase Test Lab.

Przykłady zastosowania tworzenia `ScreenCapture`:

Zrób pełny zrzut ekranu na urządzeniu z API Build.VERSION_CODES.JELLY_BEAN_MR2 lub nowszym:
```
Screenshot.capture()
```
Zrób ScreenCapture aktywności na dowolnym poziomie interfejsu API. Pamiętaj, że jest to jedyna opcja w przypadku urządzeń z wersją niższą 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 przetwarzania zrzutu ekranu

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

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

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

Ustaw nazwę i format ScreenCapture i przetwórz go za pomocą zarejestrowanego procesora:

Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();

Krok 3. Tworzenie i przeprowadzanie testu

Skompiluj aplikację i przetestuj pliki APK (instrukcje znajdziesz w artykule Testowanie aplikacji).
W konsoli Firebase otwórz DevOps i zaangażowanie > Laboratorium, a następnie 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ć zrobione zrzuty ekranu:

W konsoli Firebase otwórz DevOps i zaangażowanie > Laboratorium.
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 testowe

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

Włącz aranżera

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ć Orchestratora w przypadku Test Lab, w konfiguracji testu z instrumentacją kliknij Opcje dodatkowe > Uruchom z Orchestratorem.

Korzystając z narzędzia Orchestrator, zyskujesz te korzyści:

Brak stanu współdzielonego. Każdy test jest uruchamiany w osobnej instancji narzędzia, więc stan współdzielony nie jest gromadzony w różnych testach.
pojedyncze awarie, Jeśli test ulegnie awarii, tylko ta instrumentacja zostanie zakończona, a inne testy w pakiecie 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 restartowany po każdym przypadku testowym. Wynikające z tego wydłużenie czasu działania może wpłynąć na wykorzystanie limitu lub czas rozliczeniowy i spowodować przekroczenie limitów czasu urządzeń. Jeśli skrócisz czas uruchamiania aplikacji, ten narzut zostanie zmniejszony.

Aby ustawić dodatkowe opcje aranżera, określ je w polu environmentVariables. Na przykład, aby 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 shardów, dla każdego wybranego urządzenia Test Lab uruchomi N identycznych urządzeń i przeprowadzi na każdym z nich podzbiór testów. Oznacza to, że podzielone przypadki testowe mogą powodować wielokrotne wykonywanie testów na urządzeniu. W przypadku niepodzielonych przypadków testowych na każde urządzenie przypada jednak 1 wykonanie testu. Aby poznać pojęcia Test Lab, zapoznaj się z artykułem Kluczowe pojęcia.

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

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

Płatności za fragmenty testowe

Test Lab implementuje fragmenty, korzystając z wbudowanego mechanizmu dzielenia na fragmenty w klasie AndroidJUnitRunner. Aby uniknąć opłat za uruchamianie 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, ile czasu zajmuje wykonanie każdego elementu testowania, zwykle warto przypisać do każdego fragmentu 2–10 elementów testowania.

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