Pierwsze kroki z testami narzędzi

Z tego przewodnika dowiesz się, jak przygotować i przeprowadzić test z narzędziami w Laboratorium Firebase. Aby skorzystać z tego przewodnika, musisz przygotować test instrumentu (tworzony przez Ciebie lub Twój zespół), który wykorzystuje platformy testowe Espresso lub UI Automator Android. Testy z instrumentacją mogą trwać do 45 minut na urządzeniach fizycznych i do 60 minut na urządzeniach wirtualnych.

Później możesz przesłać do Firebase plik APK aplikacji i plik APK testu.

Uwaga: Laboratorium nie obsługuje już platformy testowej Robotium na Androida.

(Opcjonalnie) Dodawanie biblioteki zrzutów ekranu do aplikacji

Laboratorium Firebase zawiera bibliotekę (testlab-instr-lib), która pozwala przetworzyć zrzuty ekranu wykonane za pomocą funkcji ScreenCapture w AndroidzieX podczas wykonywania testów z instrumentacją, np. testów napisanych w platformie Espresso. Z tej sekcji dowiesz się, jak tworzyć obiekty ScreenCapture za pomocą biblioteki AndroidX i przetwarzać je za pomocą testulab-instr-lib.

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

Wypróbuj przykładową aplikację

Aby wypróbować tę funkcję, pobierz przykładową aplikację NotePad. Projekt NotePad umożliwia już wykonywanie zrzutów ekranu.

Krok 1. Dodawanie biblioteki zrzutów ekranu do projektu

1. W pliku Gradle 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ść do biblioteki zrzutów ekranu z Laboratorium.

   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>. Możesz też określić procesor jako argument w AndroidJUnitRunner (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>
   ...
   

4. W pliku AndroidManifest.xml aplikacji dodaj te wiersze w elemencie <manifest>:

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
   

5. W pliku AndroidManifest.xml określ uprawnienia systemowe aplikacji, dodając te wiersze w tagu <manifest>. Jeśli testujesz na Androidzie 10 (poziom interfejsu API 29) lub nowszym, pomiń uprawnienie WRITE_EXTERNAL_STORAGE (Twoja aplikacja nie wymaga tego uprawnienia do odczytu i zapisu zrzutów 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. Robienie zrzutów ekranu podczas testu

W dowolnym momencie testu, w którym chcesz zrobić zrzut ekranu, wywołaj metodę Screenshot.capture() z biblioteki AndroidaX. Spowoduje to wygenerowanie obiektu ScreenCapture. Gdy wywołujesz process() w obiekcie ScreenCapture, jest on przetwarzany przy użyciu ScreenCaptureProcessor zarejestrowanego w AndroidManifest.xml. Pamiętaj, że jeśli nie zarejestrowano żadnych procesorów, jest używany BasicScreenCaptureProcessor. Ponieważ jesteś zarejestrowanym użytkownikiem FirebaseScreenCaptureProcessor, Twoje zrzuty ekranu będą przetwarzane przez FirebaseScreenCaptureProcessor. Wyniki będą dostępne po uruchomieniu testu w Laboratorium Firebase.

Przykładowe przypadki użycia funkcji ScreenCapture:

• Wykonaj pełny zrzut ekranu w kompilacji API.VERSION_CODES.JELLY_BEAN_MR2 lub więcej:

  Screenshot.capture()
  

• Wykonaj ScreenCapture aktywności na dowolnym poziomie interfejsu API. Jest to jedyna opcja w przypadku urządzeń poniżej kompilacji.VERSION_CODES.JELLY_BEAN_MR2.

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

Przykłady użycia zrzutu ekranu

• 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 karty ScreenCapture i przetwórz ją za pomocą zarejestrowanego podmiotu przetwarzającego:

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

Krok 3. Tworzenie i przeprowadzanie testu

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

2. Prześlij pliki APK do panelu Laboratorium w konsoli Firebase.

3. Na koniec przeprowadź test.

Krok 4. Wyświetlanie testowych zrzutów ekranu

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

1. Na karcie Testy wybierz ukończony test i kliknij kartę Wyniki.

2. Ponownie wybierz test i kliknij kartę Zrzuty ekranu, która się wyświetli.

(Opcjonalnie) Włącz dodatkowe funkcje testowe

Zanim przeprowadzisz test w Laboratorium, możesz włączyć w nim te funkcje:

Włącz narzędzie Symphony

Android Test Analysistor to narzędzie, które niezależnie uruchamia testy instrumentacji aplikacji. Laboratorium zawsze używa najnowszej wersji narzędzia Artisttor.

Aby włączyć narzędzie narzędzie w Laboratorium dla Laboratorium, w konfiguracji testu instrumentu kliknij Dodatkowe opcje > Uruchom za pomocą narzędzia narzędzia w organizacji.

Uwaga: aby uniknąć wydatków na testy związane z nieprawidłowym działaniem lub naliczania opłat za testy, przed wypróbowaniem tego narzędzia w Laboratorium uruchom narzędzie Narzędziekońcowe lokalnie. Sprawdź, czy narzędzie Orchestrator działa w Twojej aplikacji, wykonując test na własnym komputerze przed przesłaniem pliku APK. Pamiętaj, że testowanie w orkietrze trwa nieco dłużej niż bez niego i może mieć wpływ na płatności lub spowodować przekroczenie limitu czasu oczekiwania przez testy.

Korzystanie z tego narzędzia daje następujące korzyści:

• Brak udostępnionego stanu. Każdy test jest uruchamiany we własnej instancji instrumentu, więc wspólny stan nie kumuluje się w ramach testów.
• Pojedyncze awarie. W przypadku awarii testowej tylko to narzędzie zostanie zakończone, a inne testy pakietu będą wciąż działać.

Pamiętaj, że gdy korzystasz z narzędzia w usłudze Academytor, każdy test uruchamia własną instancję instrumentu, co oznacza, że proces aplikacji jest wznawiany po każdym przypadku testowego. Wydłużone czasy działania mogą mieć wpływ na wykorzystanie limitu lub czas rozliczeń i przekroczenie limitów czasu oczekiwania urządzeń. Jeśli skrócisz czas uruchamiania aplikacji, nakład pracy się skróci.

Aby ustawić dodatkowe opcje narzędzia Sessiontor, określ je w polu environmentVariables. Aby na przykład użyć polecenia clearPackageData, użyj tej opcji w gcloud:

--environment-variables clearPackageData=true

Włącz fragmentację

Fragmentacja testowa dzieli zestaw testów na podgrupy (fragmenty), które są uruchamiane niezależnie od siebie. Laboratorium automatycznie uruchamia każdy fragment równolegle na wielu urządzeniach i w krótszym czasie wykonuje cały zestaw testów.

Jeśli na przykład utworzysz N fragmentów, dla każdego wybranego urządzenia Laboratorium uruchomi N identycznych urządzeń i przeprowadzi podzbiór testów na każdym urządzeniu. Oznacza to, że pofragmentowane przypadki testowe mogą powodować wiele wykonań testów na jednym urządzeniu. Przypadki testowe niepodzielone na fragmenty skutkują jednak 1 wykonaniem testu na urządzenie. Aby poznać pojęcia związane z Laboratorium, zobacz Kluczowe pojęcia.

Aby włączyć fragmentację testową w konsoli Firebase, wykonaj te czynności:

1. W sekcji Konfiguracja testu instrumentu kliknij Dodatkowe opcje.

2. W sekcji Fragmentacja wpisz liczbę fragmentów, które chcesz uruchomić.

Płatności za fragmenty testowe

Laboratorium implementuje fragmenty, wykorzystując wbudowany mechanizm fragmentacji AndroidaJUnitRunner. Aby uniknąć opłat za utworzenie pustych fragmentów (fragmentów bez przypisanych przypadków testowych), liczba tworzonych fragmentów powinna być mniejsza od łącznej liczby przypadków testowych. W zależności od czasu trwania każdego przypadku testowego dobrze jest przypisać od 2 do 10 przypadków testowych na fragment.

Uwaga: testy fragmentacji mogą kosztować więcej. Chociaż fragmentacja testowa skraca czas potrzebny do przeprowadzenia wszystkich testów, narzut związany z uruchamianiem aplikacji na każdym fragmencie może zwiększyć czas trwania poszczególnych urządzeń (czyli czasu, jaki zajmuje urządzenie na przeprowadzenie testów). Opłaty za każdy fragment są obliczane co minutę, więc całkowite opłaty mogą wzrosnąć. Dodatkowo fragmenty są wliczane do limitu dziennego wykonywania testów.

Więcej informacji o rozliczeniach znajdziesz w artykule Wykorzystanie, limity i płatności.