Rozpocznij od testów oprzyrządowania

W tym przewodniku opisano, jak przygotować i przeprowadzić test oprzyrządowania za pomocą laboratorium testowego Firebase. Aby skorzystać z tego przewodnika, potrzebujesz testu oprzyrządowania (napisanego przez Ciebie lub Twój zespół), który korzysta ze struktur testowych Espresso lub UI Automator dla systemu Android. Testy oprzyrządowania mogą trwać do 45 minut na urządzeniach fizycznych i do 60 minut na urządzeniach wirtualnych .

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

(Opcjonalnie) Dodaj bibliotekę zrzutów ekranu do swojej aplikacji

Laboratorium testowe Firebase zawiera bibliotekę (testlab-instr-lib), której można używać do przetwarzania dowolnych zrzutów ekranu zrobionych za pomocą funkcji ScreenCapture systemu AndroidX podczas uruchamiania testów oprzyrządowania, 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ą testlab-instr-lib.

Po przeprowadzeniu testu oprzyrządowania możesz wyświetlić przechwycone zrzuty ekranu w konsoli Firebase.

Wypróbuj przykładową aplikację

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

Krok 1. Dodaj bibliotekę zrzutów ekranu do swojego projektu

  1. W pliku Gradle z ustawieniami na poziomie głównym projektu testowego ( settings.gradle.kts lub settings.gradle ) dodaj repozytorium Google Maven 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()
        }
    }
    // ...
    
  2. 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 laboratorium testowego biblioteka zrzutów ekranu.

    dependencies {
      // ...
      // Add Test Lab's instrumentation test screenshot library:
      androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
      // ...
    
  3. W pliku AndroidManifest.xml testu zarejestruj FirebaseScreenCaptureProcessor w tagu metadanych w elemencie <instrumentation> . Zamiast tego możesz także określić procesor jako argument w AndroidJUnitRunner (instrukcje, jak to zrobić, 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>
    ...
    
  4. W pliku AndroidManifest.xml swojej aplikacji dodaj następujące wiersze w elemencie <manifest> :

     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    
  5. W pliku AndroidManifest.xml określ uprawnienia systemowe dla swojej aplikacji, dodając następujące wiersze w tagu <manifest> . Jeśli testujesz na Androidzie 10 (poziom API 29) lub nowszym , pomiń uprawnienie WRITE_EXTERNAL_STORAGE (Twoja aplikacja nie wymaga tego uprawnienia, aby czytać i zapisywać zrzuty ekranu na urządzeniu).

    <manifest ... >
        <!-- WRITE_EXTERNAL_STORAGE is not needed on Android 10 (API level 29) or higher. -->
        <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
        <uses-permission android:name="android.permission.INTERNET"/>
        ...
    </manifest>

Krok 2. Wykonuj 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 obiektu ScreenCapture . Gdy wywołasz process() na obiekcie ScreenCapture , zostanie on przetworzony przy użyciu ScreenCaptureProcessor zarejestrowanego w pliku AndroidManifest.xml . Należy pamiętać, że BasicScreenCaptureProcessor jest używany, jeśli nie są zarejestrowane żadne procesory. Ponieważ zarejestrowałeś FirebaseScreenCaptureProcessor , Twoje zrzuty ekranu będą przetwarzane przez FirebaseScreenCaptureProcessor i będą dostępne wraz z wynikami po uruchomieniu testu w Firebase Test Lab.

Przykładowe przypadki użycia do tworzenia ScreenCapture :

  • Wykonaj pełny zrzut ekranu w wersji API Build.VERSION_CODES.JELLY_BEAN_MR2 i nowszych:

    Screenshot.capture()
    
  • Zrób ScreenCapture działania na dowolnym poziomie interfejsu API. Uwaga: jest to jedyna opcja dla urządzeń w wersji poniżej 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 ScreenCapture

  • Przetwórz ScreenCapture za pomocą FirebaseScreenCaptureProcessor :

    Screenshot.capture().process();
    
  • Przetwórz 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 ScreenCapture i przetwórz go przy użyciu zarejestrowanego procesora:

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

Krok 3. Zbuduj i uruchom test

  1. Utwórz aplikację i przetestuj pliki APK (instrukcje znajdziesz w sekcji Testowanie aplikacji ).

  2. Prześlij pliki APK do pulpitu laboratorium testowego w konsoli Firebase.

  3. Na koniec uruchom test.

Krok 4. Zobacz swoje zrzuty ekranu testowe

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

  1. Na karcie Testy wybierz ukończony test, a następnie kliknij kartę Wyniki .

  2. Wybierz ponownie test, a następnie kliknij wyświetloną kartę Zrzuty ekranu .

(Opcjonalnie) Włącz dodatkowe funkcje testowe

Przed uruchomieniem testu w laboratorium testowym możesz włączyć następujące funkcje:

Włącz Orchestratora

Android Test Orchestrator to narzędzie, które niezależnie uruchamia każdy test instrumentacji Twojej aplikacji. Laboratorium testowe zawsze korzysta z najnowszej wersji programu Orchestrator.

Aby włączyć program Orchestrator dla laboratorium testowego, w konfiguracji testu oprzyrządowania kliknij Opcje dodatkowe > Uruchom z programem Orchestrator .

Korzystając z programu Orchestrator, zyskujesz następujące korzyści:

  • Brak stanu wspólnego. Każdy test jest uruchamiany we własnej instancji instrumentacji, więc stan udostępniony nie kumuluje się w testach.
  • Pojedyncze awarie. Jeśli test ulegnie awarii, tylko to oprzyrządowanie zostanie zakończone, a inne testy w pakiecie będą nadal mogły być uruchamiane.

Należy pamiętać, że podczas korzystania z programu Orchestrator każdy test uruchamia własną instancję instrumentacji, co oznacza, że ​​proces aplikacji jest uruchamiany ponownie po każdym przypadku testowym. Wynikający z tego wydłużony czas działania może mieć wpływ na wykorzystanie przydziału lub czas rozliczeniowy i może spowodować przekroczenie limitów czasu działania urządzeń. Jeśli skrócisz czas uruchamiania aplikacji, ten narzut ulegnie skróceniu.

Aby ustawić dodatkowe opcje dla programu Orchestrator, określ je w polu environmentVariables . Na przykład, aby użyć clearPackageData , użyj tej opcji w gcloud:

--environment-variables clearPackageData=true

Włącz fragmentowanie

Fragmentowanie testów dzieli zestaw testów na podgrupy (fragmenty), które działają oddzielnie, w izolacji. Laboratorium testowe automatycznie uruchamia każdy fragment równolegle przy użyciu wielu urządzeń i wykonuje cały zestaw testów w krótszym czasie.

Na przykład, jeśli utworzysz N fragmentów, dla każdego wybranego urządzenia Laboratorium testowe uruchomi N identycznych urządzeń i uruchomi podzbiór testów na każdym urządzeniu. Oznacza to, że podzielone przypadki testowe mogą skutkować wieloma wykonaniami testów na urządzeniu. Jednak przypadki testowe nie podzielone na fragmenty powodują wykonanie jednego testu na urządzenie. Aby poznać koncepcje laboratorium testowego, zobacz sekcję Kluczowe pojęcia .

Aby włączyć fragmentowanie testowe w konsoli Firebase, wykonaj następujące kroki:

  1. W konfiguracji testu oprzyrządowania kliknij Opcje dodatkowe .

  2. W sekcji Sharding wprowadź liczbę fragmentów, które chcesz uruchomić.

Rozliczanie fragmentów testowych

Laboratorium testowe implementuje Twoje fragmenty, wykorzystując wbudowany mechanizm fragmentowania 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ż całkowita liczba przypadków testowych. W zależności od tego, jak długo trwa działanie każdego przypadku testowego, zazwyczaj dobrym pomysłem jest przypisanie 2–10 przypadków testowych do każdego fragmentu.

Więcej informacji na temat rozliczeń znajdziesz w artykule Wykorzystanie, limity i rozliczenia .