Przewodnik po skryptach Robo

Ten dokument zawiera informacje referencyjne dotyczące skryptów Robo, w tym struktury, możliwości, użycia, nagrywania i działań. Skrypty robota to testy, które automatyzują zadania związane z ręcznym kontrolowaniem jakości aplikacji mobilnych, a także umożliwiają ciągłą integrację (CI) i strategię testowania przed publikacją. Skrypt Roboscript to plik JSON opisujący sekwencję interfejsu użytkownika (UI) i innych działań.

Skrypt robota możesz utworzyć na te sposoby:

• Użyj funkcji nagrywania skryptu Robo. (tylko w Androidzie)

• Ręcznie utwórz skrypt Robo. (Android i iOS+)

• Najpierw nagraj skrypt robota, a potem zmodyfikuj go ręcznie. (tylko w Androidzie)

Więcej informacji o korzystaniu ze skryptów Robo znajdziesz w artykule Uruchamianie skryptu Robo.

Wprowadzenie

Skrypt Robo jest udostępniany testowi Robo wraz z innymi danymi wejściowymi, takimi jak testowany pakiet aplikacji na Androida (APK).

Poniżej przedstawiamy przykład skryptu Robo, który loguje użytkownika w aplikacji. Skrypt jest uruchamiany, gdy testowana aplikacja zostanie uruchomiona:

[
  {
    "crawlStage": "crawl",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "VIEW_TEXT_CHANGED",
        "replacementText": "user123",
        "elementDescriptors": [
          {
            "resourceId": "my.app.package:id/username"
          }
        ]
      },
      {
        "eventType": "VIEW_TEXT_CHANGED",
        "replacementText": "12345",
        "elementDescriptors": [
          {
            "resourceId": "my.app.package:id/password"
          }
        ]
      },
      {
        "eventType": "VIEW_CLICKED",
        "elementDescriptors": [
          {
            "resourceId": "my.app.package:id/login"
          }
        ]
      }
    ]
  }
]

Jeśli w pliku znajduje się pojedynczy skrypt Robo i ma on domyślny warunek aktywacji app_under_test_shown, jak w przykładzie powyżej, możesz określić skrypt Robo w pliku, używając prostszego formatu – jako sekwencji działań:

[
  {
    "eventType": "VIEW_TEXT_CHANGED",
    "replacementText": "user123",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/username"
      }
    ]
  },
  {
    "eventType": "VIEW_TEXT_CHANGED",
    "replacementText": "12345",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/password"
      }
    ]
  },
  {
    "eventType": "VIEW_CLICKED",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/login"
      }
    ]
  }
]

Obsługa skryptów Robo w iOS+

Robo na iOS+ (wersja beta) ma ograniczoną obsługę skryptów Robo. Składnia skryptu Robo na iOS+ jest identyczna jak na Androidzie, a obsługiwane funkcje iOS+ działają podobnie jak na Androidzie.

W iOS+ obsługiwane są te działania:

• Asercja
• Kliknij
• Kliknięcie i przytrzymanie
• Przesuwanie palcem
• Ignoruj wszystkie elementy
• Czekaj
• Zrzut ekranu
• Zakończ skanowanie

W iOS+ obsługiwane są te atrybuty identyfikujące w opisie elementu:

• Nazwa zajęć
• Nazwa klasy nadrzędnej
• Opis treści (i wyrażenie regularne)
• Tekst (i wyrażenie regularne)

Na iOS+ obsługiwane są te warunki wyzwalania w opisach kontekstu:

• Wyświetlana aplikacja
• Element obecny
• Wykonano działanie skryptu niebędącego Robo

Struktura

Skrypt Robo ma kilka atrybutów, które opisują sposób jego wykonywania przez Robo. Większość z tych atrybutów jest opcjonalna i ma zdefiniowane wartości domyślne:

Pojedynczy plik zawiera kolekcję co najmniej 1 skryptu Robo.

Oto przykład pliku z 2 bezwarunkowymi skryptami Robo, z których każdy zawiera pojedyncze działanie wykonywane raz na początku indeksowania:

[
  {
    "id": 1000,
    "description": "My first Robo script",
    "actions": [
      {
        "eventType": "DISABLE_KEYBOARD"
      }
    ]
  },
  {
    "id": 1001,
    "description": "My second Robo script",
    "actions": [
      {
        "eventType": "PRESSED_BACK"
      }
    ]
  }
]

Deskryptor kontekstu

Deskryptor kontekstu określa kontekst lub warunek, który uruchamia Roboscripta, za pomocą jednego atrybutu lub kombinacji kilku atrybutów:

Poniżej znajdziesz przykład skryptu Robo, który jest uruchamiany przez element interfejsu użytkownika z identyfikatorem zasobu "my.app.package:id/page_header" widocznym na ekranie:

{
  "id": 1000,
  "contextDescriptor": {
    "condition": "element_present",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/page_header"
      }
    ]
  },
  "actions": [
    {
      "eventType": "VIEW_CLICKED",
      "elementDescriptors": [
        {
          "text": "Settings"
        }
      ]
    }
  ]
}

Poniżej znajdziesz przykład skryptu Robo, który jest uruchamiany przez "Privacy Policy" wykryty przez optyczne rozpoznawanie znaków (OCR):

{
  "id": 1000,
  "description": "Vision text Robo script",
  "contextDescriptor": {
    "condition": "element_present",
    "visionText": "Privacy Policy"
  },
  "actions": [
    {
      "eventType": "VIEW_CLICKED",
      "visionText": "Privacy Policy"
    }
  ]
}

Oto przykład skryptu Robo, który czeka 5 sekund po każdym działaniu Robo, które nie jest skryptem:

{
  "contextDescriptor": {
    "condition": "non_roboscript_action_performed"
  },
  "maxNumberOfRuns" : 1000,
  "actions" : [
    {
      "eventType" : "DELAYED_MESSAGE_POSTED",
      "delayTime" : 5000
    }]
}

Działania

Każda czynność w skrypcie Robo jest reprezentowana jako zbiór co najmniej 1 pary atrybut–wartość, jak opisano w tabeli poniżej:

Poniżej znajdziesz przykład skryptu Robo z 2 działaniami bez docelowych widgetów interfejsu użytkownika, co oznacza, że te działania nie działają na konkretnym elemencie interfejsu użytkownika:

[
  {
    "eventType": "DELAYED_MESSAGE_POSTED",
    "delayTime": 3000
  },
  {
    "eventType": "PRESSED_BACK"
  }
]

Deskryptory elementów

Descriptor elementu identyfikuje element interfejsu za pomocą co najmniej jednego z tych atrybutów:

Często te atrybuty są nie zdefiniowane, np. przycisk może nie mieć tekstu i opisu treści. Nawet jeśli niektóre wartości atrybutów są obecne, mogą nie być unikalne na danym ekranie aplikacji (w tym resourceId).

Na przykład rozróżnianie elementów listy jest zwykle możliwe tylko przez wykorzystanie różnych pozycji podrzędnych w widżecie nadrzędnym. Oznacza to, że do identyfikacji elementu interfejsu zwykle nie wystarczy użycie tylko jednego opisu elementu. Dlatego atrybut elementDescriptors działania zawiera sekwencję deskryptorów elementów uporządkowanych w taki sposób, że pierwszy odpowiada docelowym widżetom interfejsu, drugi – nadrzędnemu widżetowi docelowych widżetów interfejsu itd. Docelowy widget interfejsu użytkownika akcji jest dopasowywany, gdy wszystkie jego opisy elementów pasują do odpowiedniej podhierarchii widgetu interfejsu użytkownika.

Poniżej przedstawiamy przykład skryptu Robo z działaniami zmiany tekstu i kliknięcia, które wymagają zidentyfikowania docelowego elementu interfejsu użytkownika za pomocą podanych deskryptorów elementów:

[
  {
    "eventType": "VIEW_TEXT_CHANGED",
    "replacementText": "John",
    "elementDescriptors": [
      {
        "className": "android.support.v7.widget.AppCompatEditText",
        "groupViewChildPosition": 0,
        "resourceId": "com.google.samples.apps.topeka:id/first_name"
      },
      {
        "className": "android.widget.FrameLayout",
        "groupViewChildPosition": 0
      },
      {
        "className": "android.support.design.widget.TextInputLayout",
        "groupViewChildPosition": 1
      }
    ]
  },
  {
    "eventType": "VIEW_CLICKED",
    "elementDescriptors": [
      {
        "className": "android.support.design.widget.FloatingActionButton",
        "groupViewChildPosition": 1,
        "resourceId": "com.google.samples.apps.topeka:id/done"
      },
      {
        "className": "android.widget.FrameLayout",
        "groupViewChildPosition": 1,
        "resourceId": "com.google.samples.apps.topeka:id/content"
      },
      {
        "className": "android.widget.FrameLayout",
        "groupViewChildPosition": 0,
        "resourceId": "com.google.samples.apps.topeka:id/sign_in_content"
      }
    ]
  }
]

Opcje wykonania

Opcjonalnie możesz dodać przed listą działań w skrypcie Robo prefiks w postaci obiektu JSON, który określa opcje wykonania skryptu. Ten nagłówek konfiguracji zaczyna się od słowa kluczowego roboscript, a następnie zawiera reprezentację w formacie JSON wybranych opcji wykonania.

Skrypty robota obsługują te opcje wykonania:

• executionMode – opcje wykonania stosowane podczas wykonywania skryptu Robo:
  • strict – jeśli ustawisz wartość true, skrypt Robo nie będzie używać częściowego dopasowania, pomijania bieżącego działania ani zawieszania. Oznacza to, że skrypt Robo jest wykonywany jako zwykły test instrumentacji i zawiesza się, gdy nie można wykonać żadnego z jego działań. Domyślnie jest to false.
  • dismiss_popups – jeśli ta opcja ma wartość true, test Robo pomija nieoczekiwane dialogi podczas wykonywania skryptu Robo nawet w trybie strict. Ta opcja nie ma żadnego wpływu, gdy nie jest używany tryb strict. Domyślnie jest to false.
  • notify – jeśli ta opcja jest ustawiona na false, skrypt Robo nie wyświetla powiadomień na ekranie na początku i na końcu wykonania. Domyślnie jest to true.
• postscript – opcje wykonania stosowane po zakończeniu skryptu Robo:
  • terminate – jeśli ta opcja jest ustawiona na true, test Robo przestaje indeksować po zakończeniu wykonywania skryptu Robo. Domyślnie jest to false.

Poniżej znajdziesz przykład skryptu Robo wykonywanego w trybie strict bez powiadomień na ekranie, który czeka przez 3 sekundy, po czym przestaje indeksować:

"roboscript": {
  "executionMode": {
    "strict": true,
    "notify": false
  },
  "postscript": {
    "terminate": true
  }
}
[
  {
    "eventType": "DELAYED_MESSAGE_POSTED",
    "delayTime": 3000
  }
]

Parametry szablonu

Parametr szablonu to symbol zastępczy w skrypcie Robo, który jest zastępowany rzeczywistą wartością, gdy test Robo wczytuje skrypt Robo do wykonania. Parametry szablonu mają przedrostek w postaci podwójnego podkreślenia, po którym następuje znak procenta, oraz mają przyrostek w postaci znaku procenta, po którym następuje podwójne podkreślenie.

Skrypty robocze obsługują te parametry szablonu:

• __%APP_PACKAGE_NAME%__ – nazwa pakietu testowanej aplikacji.

Oto przykład skryptu Robo, który zatrzymuje proces testowania aplikacji:

[
  {
    "eventType": "ADB_SHELL_COMMAND",
    "command": "am force-stop __%APP_PACKAGE_NAME%__"
  }
]

Komentarze

Skrypt Robo może zawierać wiersze komentarzy, czyli wiersze rozpoczynające się od znaku # lub //.

Oto przykład skryptu Robo z kilkoma komentarzami:

# Confirm a user account.
[
  {
    // Click the DONE button.
    "eventType": "VIEW_CLICKED",
    "elementDescriptors": [
      {
        "resourceId": "com.google.samples.apps.topeka:id/done"
      }
    ]
  }
]

Możliwości

Domyślnie skrypt Robo pozostaje aktywny, dopóki nie zostaną wykonane wszystkie jego działania (lub przynajmniej podjęta próba ich wykonania). Test Robo ciągle próbuje dopasować działanie skryptu Robo, gdy wybiera działanie do wykonania. Aby zwiększyć odporność, skrypt Robo stosuje te techniki:

Priorytety

Jeśli skrypt Robo osiągnie wartość maxNumberOfRuns, nie będzie można go już wywołać w ramach danego indeksowania. Jeśli w obecnym kontekście może zostać uruchomiony więcej niż 1 skrypt Robo, priorytet jest przyznawany przez wybór skryptu Robo w tej kolejności:

1. Ma atrybut contextDescriptor.
2. Ma najwyższą wartość priority (domyślnie wszystkie skrypty Robo mają tę samą wartość priority atrybutu 1).
3. Pojawia się na początku listy skryptów robota, jeśli ich priorytety są takie same.

Oto przykład pliku z 3 skryptami Robo, które wykonują to samo działanie i są wywoływane przez ten sam warunek – aplikacja testowana na pierwszym planie:

[
  {
    "id": 1000,
    "description": "Robo script 1",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "DELAYED_MESSAGE_POSTED",
        "delayTime": 3000
      }
    ]
  },
  {
    "id": 1001,
    "description": "Robo script 2",
    "priority": "2",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "DELAYED_MESSAGE_POSTED",
        "delayTime": 3000
      }
    ]
  },
  {
    "id": 1002,
    "description": "Robo script 3",
    "contextDescriptor": {
      "condition": "app_under_test_shown"
    },
    "actions": [
      {
        "eventType": "DELAYED_MESSAGE_POSTED",
        "delayTime": 3000
      }
    ]
  }
]

Gdy testowana aplikacja jest na pierwszym planie, Robo uruchamia te czynności w takiej kolejności:

1. "Robo script 2", ponieważ ma najwyższy priorytet.
2. "Robo script 1", ponieważ pojawia się wcześniej wśród pozostałych skryptów Robo o tym samym priorytecie.
3. "Robo script 3" jako ostatni odpowiedni skrypt Robo.

Powtarzane uruchomienia

Domyślnie Robo uruchamia skrypt Robo najwyżej raz podczas indeksowania. Można go dostosować za pomocą atrybutu maxNumberOfRuns.

Poniżej znajdziesz przykład skryptu Robo, który przenosi testowaną aplikację do tła maksymalnie 10 razy:

{
  "id": 1000,
  "maxNumberOfRuns": 10,
  "contextDescriptor": {
    "condition": "app_under_test_shown"
  },
  "actions": [
    {
      "eventType": "GO_HOME"
    }
  ]
}

Etap indeksowania

Skrypty robota są stosowane na różnych etapach danego indeksowania przez robota:

Jeśli atrybut crawlStage skryptu Robo nie jest określony, przyjmuje się, że jest to crawl.

Oto przykład skryptu Robo, który czyści dane użytkownika testowanej aplikacji, zanim Robo zacznie indeksować aplikację:

{
  "id": 1000,
  "crawlStage": "pre_crawl",
  "actions": [
    {
      "eventType": "ADB_SHELL_COMMAND",
      "command": "pm clear __%APP_PACKAGE_NAME%__"
    }
  ]
}

Oto przykład skryptu Robo, który instruuje Robo, aby klikał "Cancel", gdy spróbuje wrócić (cofnać) z dialogu potwierdzenia:

{
  "id": 1000,
  "crawlStage": "close_screen",
  "maxNumberOfRuns": 999,
  "contextDescriptor": {
    "condition": "element_present",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/confirmation_dialog"
      }
    ]
  },
  "actions": [
    {
      "eventType": "VIEW_CLICKED",
      "elementDescriptors": [
        {
          "text": "Cancel"
        }
      ]
    }
  ]
}

Działania warunkowe

Skrypt Robo może zawierać działania warunkowe. Działania warunkowe mają 3 dodatkowe atrybuty, które opisują sposób ich wykonywania przez Robo:

Po wywołaniu skrypt Robo wykonuje działania bezwarunkowe po kolei w kolejności ich występowania. Jeśli skrypt Robo zawiera działania warunkowe, są one brane pod uwagę za każdym razem przed wybraniem działania bezwarunkowego. Jeśli jakiekolwiek działanie warunkowe zostanie wywołane i wybrane na podstawie swojego priorytetu oraz pozostałej liczby uruchomień, skrypt Robo wykona to działanie warunkowe. W przeciwnym razie skrypt wykona to działanie bezwarunkowe. Aby był ważny, skrypt Robo musi zawierać co najmniej 1 działanie bezwarunkowe.

Oto przykład bezwarunkowego skryptu Robo z działaniem warunkowym, które zamyka okna dialogowe, jeśli pojawią się one w dowolnym momencie podczas wykonywania skryptu Robo:

{
  "id": 1000,
  "actions": [
    {
      "description": "Dismiss popup",
      "maxNumberOfRuns": 100,
      "contextDescriptor": {
        "condition": "default_launcher_shown",
        "negateCondition": true
      },
      "eventType": "GO_HOME"
    },
    {
      "description": "Screen off",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 26"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "DELAYED_MESSAGE_POSTED",
      "delayTime": 10000
    },
    {
      "description": "Screen on",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 82"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "DELAYED_MESSAGE_POSTED",
      "delayTime": 10000
    }
}

Ignorowanie działań

Skrypt Robo może zawierać instrukcje, aby Robo zignorował określone widżety interfejsu użytkownika lub wszystkie widżety interfejsu użytkownika na określonym ekranie. Te instrukcje są reprezentowane jako ignorowanie „działań” z wartością eventType ELEMENT_IGNORED i ALL_ELEMENTS_IGNORED.

Gdy atrybut contextDescriptor skryptu Robo zawierającego działania ignorowania pasuje do danego ekranu, Robo nie wchodzi w interakcję z żadnymi widżetami interfejsu docelowymi dla tych działań ignorowania (chyba że jakieś inne działanie skryptu Robo spowoduje, że Robo wykona działanie na jednym z ignorowanych widżetów interfejsu).

Skrypt robota może zawierać różne działania ignorujące, warunkowe i bezwarunkowe. W odróżnieniu od innych działań skryptu Robo działania ignorowania są stosowane, o ile ich zawierający skrypt Robo contextDescriptor pasuje do ekranu podczas indeksowania przez Robo, niezależnie od wartości atrybutów priority i maxNumberOfRuns.

Poniżej znajdziesz przykład pliku z 2 skryptami Robo. Pierwszy skrypt Robo sprawia, że Robo ignoruje wszystkie widżety interfejsu na ekranie zawierającym widżet interfejsu z identyfikatorem zasobu "my.app.package:id/ignored_screen". Drugi skrypt Robo sprawia, że Robo ignoruje widżety interfejsu użytkownika, których identyfikatory zasobów pasują do wyrażenia regularnego Java ".*:id/done" na ekranie zawierającym widżet interfejsu użytkownika z identyfikatorem zasobu "my.app.package:id/main_screen":

[
  {
    "id": 1000,
    "contextDescriptor": {
      "condition": "element_present",
      "elementDescriptors": [
        {
          "resourceId": "my.app.package:id/ignored_screen"
        }
      ]
    },
    "actions": [
      {
        "eventType": "ALL_ELEMENTS_IGNORED"
      }
    ]
  },
  {
    "id": 1001,
    "contextDescriptor": {
      "condition": "element_present",
      "elementDescriptors": [
        {
          "resourceId": "my.app.package:id/main_screen"
        }
      ]
    },
    "actions": [
      {
        "eventType": "ELEMENT_IGNORED",
        "elementDescriptors": [
          {
            "resourceIdRegex": ".*:id/done"
          }
        ]
      }
    ]
  }
]

Obsługa RecyclerView i AdapterView

Dzieci komponentów RecyclerView i AdapterView są ładowane dynamicznie i mogą być wyświetlane po wielu przesunięciach od bieżącego ekranu. Ponieważ rozmiar ekranu i liczba przesunięć wymaganych do dotarcia do dziecka różnią się w zależności od formatu urządzenia, znacznie bardziej niezawodne jest korzystanie z pozycji danych dziecka, która jest bezwzględna. Nie jest to jednak tak niezawodne rozwiązanie, jak określenie liczby przesunięć, które są wymagane, aby dziecko pojawiło się na ekranie, a następnie określenie jego pozycji na ekranie.

Dlatego skrypt Robo rejestruje bezwzględne pozycje danych elementów potomnych RecyclerView, które są celami działań skryptu Robo, jako recyclerViewChildPosition. Skrypt Robo rejestruje też bezwzględne pozycje danych elementów podrzędnych AdapterView, które są celami działań skryptu Robo, jako adapterViewChildPosition.

Działania na elementach potomnych RecyclerView i AdapterView są wykonywane w tych krokach:

1. Test robota sprawdza, czy odpowiedni element podrzędny jest wyświetlany na ekranie przez działanie pozycjonowania na zawierającym go RecyclerView lub AdapterView.

2. Test robota wykonuje zarejestrowane działanie bezpośrednio na elemencie podrzędnym, ponieważ jest on już wyświetlany na ekranie.

Poniżej znajdziesz przykład działania kliknięcia na potomku AdapterView (android.widget.GridView):

{
  "eventType": "VIEW_CLICKED",
  "elementDescriptors": [
    {
      "className": "com.google.samples.apps.topeka.widget.AvatarView",
      "adapterViewChildPosition": 5,
      "resourceId": "com.google.samples.apps.topeka:id/avatar",
      "contentDescription": "Avatar 6"
    },
    {
      "className": "android.widget.GridView",
      "groupViewChildPosition": 1,
      "resourceId": "com.google.samples.apps.topeka:id/avatars"
    },
    {
      "className": "android.widget.LinearLayout",
      "groupViewChildPosition": 1
    },
    {
      "className": "android.widget.LinearLayout",
      "groupViewChildPosition": 0
    }
  ]
}

Poniżej znajdziesz przykład działania kliknięcia w podrzędnym elemencie RecyclerView (android.support.v7.widget.RecyclerView):

{
  "eventType": "VIEW_CLICKED",
  "elementDescriptors": [
    {
      "className": "android.support.v7.widget.AppCompatTextView",
      "groupViewChildPosition": 1,
      "resourceId": "com.google.samples.apps.topeka:id/category_title"
    },
    {
      "className": "android.widget.FrameLayout",
      "recyclerViewChildPosition": 8,
      "resourceId": "com.google.samples.apps.topeka:id/category_item"
    },
    {
      "className": "android.support.v7.widget.RecyclerView",
      "groupViewChildPosition": 1,
      "resourceId": "com.google.samples.apps.topeka:id/categories"
    },
    {
      "className": "android.widget.FrameLayout",
      "groupViewChildPosition": 1,
      "resourceId": "com.google.samples.apps.topeka:id/category_container"
    },
    {
      "className": "android.widget.LinearLayout",
      "groupViewChildPosition": 0
    }
  ]
}

Zapisz skrypt Robo w Android Studio i uruchom go w Test Lab

W Android Studio możesz utworzyć skrypt Robo, który zostanie zapisany jako plik JSON. Następnie możesz przesłać plik JSON do usługi Firebase Test Lab za pomocą aplikacji i odpowiednio uruchomić test.

Gdy przeprowadzasz test Robo z dołączonym skryptem, robot najpierw wykonuje czynności oskryptowane przez Ciebie, a potem analizuje aplikację według normalnego schematu.

Aby utworzyć plik JSON skryptu Robo w Android Studio, wykonaj czynności opisane w artykule Zarejestruj skrypt Robo za pomocą Test Lab w Android Studio.

Działania skryptu Robo

Do wszystkich działań stosuje się ten wspólny atrybut opcjonalny:

• description – pomaga śledzić wykonanie tej czynności w skrypcie Robo w wynikach testu Robo.

Asercja

Jeśli zadeklarowany warunek jest spełniony, skrypt Robo przechodzi do następnego działania, którym może być kolejne założenie. W przeciwnym razie wykonanie skryptu Robo zostanie wstrzymane z powodu niepowodzenia asercji.

Wymagane atrybuty:

Oto przykład stwierdzenia w skrypcie Robo, które sprawdza, czy testowana aplikacja jest na pierwszym planie:

{
  "eventType": "ASSERTION",
  "contextDescriptor": {
    "condition": "app_under_test_shown"
  }
}

Poniżej przedstawiamy przykład stwierdzenia w skrypcie Robo, które sprawdza, czy na ekranie jest widoczny element interfejsu użytkownika z identyfikatorem zasobu "com.google.samples.apps.topeka:id/done":

{
  "eventType": "ASSERTION",
  "contextDescriptor": {
    "condition": "element_present",
    "elementDescriptors": [
      {
        "resourceId": "com.google.samples.apps.topeka:id/done"
      }
    ]
  }
}

Poniżej znajdziesz przykład stwierdzenia w skrypcie Robo, które sprawdza, czy "Settings" NIE zostało wykryte na ekranie za pomocą OCR:

{
  "eventType": "ASSERTION",
  "contextDescriptor": {
    "condition": "element_present",
    "negateCondition": true,
    "visionText": "Settings"
  }
}

Kliknij

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które polega na kliknięciu przycisku o identyfikatorze zasobu "com.google.samples.apps.topeka:id/done":

{
  "eventType": "VIEW_CLICKED",
  "elementDescriptors": [
    {
      "resourceId": "com.google.samples.apps.topeka:id/done"
    }
  ]
}

Oto przykład działania skryptu Robo, które klika drugie wystąpienie słowa "Search" wykryte na ekranie za pomocą rozpoznawania tekstu:

{
  "eventType": "VIEW_CLICKED",
  "visionText": "Search",
  "matchIndex": 1
}

Oto przykład działania skryptu Robo, które polega na kliknięciu elementu klawiatury ekranowej z opisem treści "Emoji button":

{
  "eventType": "SOFT_KEYBOARD_CLICK",
  "elementDescriptors": [
    {
      "contentDescription": "Emoji button"
    }
  ]
}

Oto przykład działania skryptu Robo, które klika losowe elementy klawiatury dotykowej maksymalnie 5 razy:

{
  "eventType": "SOFT_KEYBOARD_RANDOM_CLICK",
  "maxNumberOfRuns": 5
}

Wyłączanie klawiatury ekranowej

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które wyłącza klawiaturę ekranową:

{
  "eventType": "DISABLE_KEYBOARD"
}

Wykonywanie polecenia powłoki adb

Wymagane atrybuty:

Ten atrybut jest opcjonalny:

• expectedOutputRegex – oczekiwane dane wyjściowe polecenia jako wyrażenie regularne w Javie. Jeśli dane wyjściowe nie pasują, działanie skryptu Robo się nie powiedzie. Domyślnie jest to pusty ciąg znaków, co oznacza, że dane wyjściowe nie są sprawdzane.

Oto przykład działania skryptu Robo, które usuwa dane użytkownika aplikacji testowanej:

{
  "eventType": "ADB_SHELL_COMMAND",
  "command": "pm clear __%APP_PACKAGE_NAME%__"
}

Przyznaj uprawnienia

To działanie jest rejestrowane przez rejestrator skryptów Robo w Android Studio w celu zapewnienia zgodności wstecznej z nagrywarką testów Espresso. Test Robo przyznaje wszystkie uprawnienia testowanej aplikacji na początku każdego indeksowania, więc to działanie jest bezczynne. NIE używaj tego działania w swoich skryptach Robo.

Wymagane atrybuty:

Ignoruj wszystkie elementy na ekranie

To działanie powoduje, że Robo ignoruje wszystkie elementy na dowolnym ekranie, który uruchamia skrypt Robo.

Wymagane atrybuty:

Poniżej przedstawiamy przykład działania skryptu Robo, które powoduje, że Robo ignoruje wszystkie elementy na ekranie:

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

Ignorowanie elementu

To działanie powoduje, że Robo ignoruje element (lub elementy) pasujące do określonego wyrażenia.elementDescriptors

Wymagane atrybuty:

Ten atrybut jest opcjonalny:

• ignoreChildren – jeśli ustawisz wartość true, Robo zignoruje też wszystkie elementy potomne zignorowanych widżetów interfejsu. Domyślnie jest to false.

Poniżej przedstawiamy przykład działania skryptu Robo, które powoduje, że Robo ignoruje wszystkie elementy, których opisy zaczynają się od "Avatar":

{
  "eventType": "ELEMENT_IGNORED",
  "elementDescriptors": [
    {
      "contentDescriptionRegex": "Avatar.*"
    }
  ]
}

Wprowadzany tekst

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które przekazuje dane "John" do widżetu interfejsu użytkownika o identyfikatorze zasobu "com.google.samples.apps.topeka:id/first_name":

{
  "eventType": "VIEW_TEXT_CHANGED",
  "replacementText": "John",
  "elementDescriptors": [
    {
      "resourceId": "com.google.samples.apps.topeka:id/first_name"
    }
  ]
}

Kliknięcie i przytrzymanie

Wymagane atrybuty:

Ten atrybut jest opcjonalny:

• delayTime – określa czas przytrzymania długiego kliknięcia w milisekundach.

Poniżej przedstawiamy przykład działania skryptu Robo, które polega na kliknięciu przez 5 sekund elementu interfejsu użytkownika z opisem treści "Avatar 8":

{
  "eventType": "VIEW_LONG_CLICKED",
  "elementDescriptors": [
    {
      "contentDescription": "Avatar 8"
    }
  ],
  "delayTime": 5000
}

Wykonywanie gestów jednopunktowych

Wymagane atrybuty:

Ten atrybut jest opcjonalny:

• dragAndDrop – jeśli ustawisz wartość true, gest jednopunktowy spowoduje przeciągnięcie i upuszczenie. Domyślnie jest to false.

Oto przykład działania gestu jednopunktowego w skrypcie Robo, który wykonuje gest przesunięcia w dół:

{
  "eventType": "ONE_POINT_GESTURE",
  "coordinates": "(50%,25%)->(50%,75%)"
}

Wykonaj gest dwupunktowy

Wymagane atrybuty:

Oto przykład działania akcji skryptu Robo, która wykonuje gest rozsunięcia palców:

{
  "eventType": "TWO_POINT_GESTURE",
  "coordinates": "(50%,50%)->(25%,50%),(50%,50%)->(75%,50%)"
}

Wykonywanie działania IME

To działanie naciska bieżący przycisk działania, np. Dalej, Gotowe lub Szukaj, w Edytorze metody wprowadzania (IME) dla określonego docelowego elementu interfejsu.

Wymagane atrybuty:

Poniżej znajdziesz przykład działania skryptu Robo, które wykonuje działanie IME na widżecie interfejsu użytkownika o identyfikatorze zasobu "com.google.samples.apps.topeka:id/first_name":

{
  "eventType": "PRESSED_EDITOR_ACTION",
  "elementDescriptors": [
    {
      "resourceId": "com.google.samples.apps.topeka:id/first_name"
    }
  ]
}

Naciśnij Wstecz

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które polega na naciśnięciu przycisku Wstecz:

{
  "eventType": "PRESSED_BACK"
}

Naciśnij przycisk Home

Ta czynność powoduje wysłanie na urządzenie zdarzenia KEYCODE_HOME.

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które polega na naciśnięciu przycisku Wróć do strony głównej:

{
  "eventType": "GO_HOME"
}

Przewijanie elementu, aby go wyświetlić

W ramach tego działania Robo testuje przewijanie do przodu widgetu interfejsu użytkownika odpowiadającego określonemu parametrowi elementDescriptors, aż do momentu, gdy na ekranie pojawi się widget interfejsu użytkownika odpowiadający określonemu parametrowi childElementDescriptors, lub gdy nie będzie można już przewijać widgetu, albo do momentu osiągnięcia maksymalnej liczby 50 przewijań.

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które przewija widget interfejsu z identyfikatorem zasobu "my.app.package:id/scrollable_card_container", aż na ekranie pojawi się widget z tekstem "Orange" (lub do momentu, gdy nie będzie można przewinąć dalej lub nie zostanie osiągnięta maksymalna liczba 50 przewinięć):

{
  "eventType": "ELEMENT_SCROLL_INTO_VIEW",
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/scrollable_card_container"
    }
  ],
  "childElementDescriptors": [
    {
      "text": "Orange"
    }
  ]
}

Przesuwanie palcem

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które przesuwa w górę element interfejsu użytkownika o identyfikator zasobu "my.app.package:id/custom_content":

{
  "eventType": "VIEW_SWIPED",
  "swipeDirection": "Up",
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/custom_content"
    }
  ]
}

Zrzut ekranu

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które polega na zrobieniu zrzutu ekranu:

{
  "eventType": "TAKE_SCREENSHOT",
  "screenshotName": "my_screenshot"
}

Kliknij punkt na ekranie.

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które polega na dotknięciu w środku ekranu:

{
  "eventType": "POINT_TAP",
  "pointTapXPercent": 50,
  "pointTapYPercent": 50
}

Kliknij punkt w elemencie.

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które przesuwa suwak suwaka w prawo:

{
  "eventType": "POINT_TAP_ELEMENT",
  "pointTapXPercent": 80,
  "pointTapYPercent": 50,
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/my_seekbar"
    }
  ]
}

Zakończ skanowanie

To działanie powoduje zatrzymanie testu Robo.

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które powoduje zatrzymanie testu Robo:

{
  "eventType": "TERMINATE_CRAWL"
}

Czekaj

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które czeka 3 sekundy:

{
  "eventType": "DELAYED_MESSAGE_POSTED",
  "delayTime": 3000
}

Poczekaj na element

Dzięki temu test Robo będzie czekać na pojawienie się elementu na ekranie do określonego limitu czasu.

Wymagane atrybuty:

Oto przykład działania skryptu Robo, które czeka maksymalnie 30 sekund na pojawienie się na ekranie widżetu interfejsu z identyfikatorem zasobu"my.app.package:id/confirmation_button":

{
  "eventType": "WAIT_FOR_ELEMENT",
  "delayTime": 30000,
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/confirmation_button"
    }
  ]
}

Dalsze kroki

• Dowiedz się, jak uruchomić skrypt Robo