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:

Atrybut Opis
id Pełna liczba, która pomaga śledzić ten skrypt Robo w wynikach indeksowania. Robo ma wbudowane skrypty Robo z własnymi id. Chociaż ta sama id w różnych skryptach Robo nie wpływa na ich działanie, rozróżnianie działań w wynikach indeksowania może być trudne. Aby uniknąć konfliktów, zalecamy przypisanie do skryptów Robo unikalnego id o wartości 1000 lub wyższej.
description Podobne do id, ale bardziej opisowe.
crawlStage Etap indeksowania, na którym Robo stosuje ten skrypt. Domyślnie jest to główny etap indeksowania.
priority Priorytet tego skryptu robota w porównaniu z innymi skryptami robota. Domyślnie wszystkie skrypty robota mają priorytet 1.
maxNumberOfRuns Określa, ile razy robot może wykonać ten skrypt podczas indeksowania. Domyślnie Robo może wykonać skrypt Robo tylko raz.
contextDescriptor Opisuje kontekst lub warunek, który uruchamia ten skrypt Robo. Jeśli go pominiesz, warunek wywołania skryptu Robo zostanie uznany za zawsze spełniony. Innymi słowy, skrypt Robo będzie bezwarunkowy.
actions Wszystkie działania tego skryptu Robo.

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:

Atrybut Opis
"condition": "always" Zawsze uruchamia skrypt Robo.
"condition": "element_present" Sprawdza, czy na ekranie jest widoczny widżet interfejsu użytkownika, który pasuje do elementDescriptors lub tekstu określonego przez visionText.
"condition": "element_disabled" Sprawdza, czy na ekranie jest widżet interfejsu użytkownika zgodny z elementDescriptors, z którym nie można wchodzić w interakcję.
"condition": "element_checked" Sprawdza, czy na ekranie jest widoczny element interfejsu odpowiadający parametrowi elementDescriptors i czy jest zaznaczony.
"condition": "app_under_test_shown" Sprawdzanie, czy testowana aplikacja jest uruchomiona na pierwszym planie.
"condition": "default_launcher_shown" Sprawdzanie, czy wyświetlany jest ekran główny urządzenia, co oznacza, że żadne aplikacje nie są uruchomione na pierwszym planie.
"condition": "non_roboscript_action_performed" Sprawdza, czy ostatnie nonRoboscriptActionCount kolejne działania wykonane przez test Robo nie są działaniami skryptu Robo.
negateCondition Jeśli ma wartość true, neguje wartość condition. Za pomocą tego atrybutu możesz sprawdzić, czy na ekranie NIE ma widżetu interfejsu lub czy testowana aplikacja NIE działa na pierwszym planie.
elementDescriptors Co najmniej 1 element opisu, który identyfikuje widżet interfejsu na ekranie. Jest używany w połączeniu z warunkami element_present, element_disabled i element_checked. Wzajemnie wyklucza się z opcją visionText. Więcej informacji znajdziesz w opisach elementów.
visionText Tekst na ekranie jest wykrywany za pomocą interfejsu API optycznego rozpoznawania znaków (OCR). visionText jest używany w połączeniu z warunkiem element_present. Wzajemnie się wykluczają z opcją elementDescriptors.
nonRoboscriptActionCount Liczba kolejnych działań skryptu, które nie są wykonywane przez Robo. Jest on używany w połączeniu z warunkiem non_roboscript_action_performed do uruchamiania skryptu Robo po każdym działaniu nonRoboscriptActionCount Robo. Domyślnie jest to 1.

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:

Atrybut Opis
eventType Określa typ działania, np. kliknięcie, zmiana tekstu itp. Wymagane w przypadku każdego działania.
elementDescriptors Deskryptory identyfikujące element interfejsu. Wymagane w przypadku wszystkich działań, które mają docelowy element interfejsu użytkownika, np. kliknięcie określonego przycisku.
optional Jeśli ustawiona jest wartość true, to działanie jest pomijane, gdy nie można go wykonać. Na przykład to działanie jest pomijane, gdy nie można znaleźć docelowego widżetu interfejsu na ekranie, ale nie powoduje to błędu w skrypcie Robo. Domyślna wartość to false.
replacementText Tekst do wpisania w docelowym elemencie interfejsu. Wymagane w przypadku czynności edycji tekstu.
swipeDirection Określa kierunek przesunięcia. Wymagane w przypadku działań przesuwania.
delayTime Określa czas oczekiwania w milisekundach. Wymagany w przypadku działań typu wait.
pointTapXCoordinate i pointTapYCoordinate Współrzędne X i Y klikniętego punktu w pikselach. Współwyklucza się z tagami pointTapXPercent i pointTapYPercent. Wymagane w przypadku działań dotyczących kliknięcia punktu.
pointTapXPercent i pointTapYPercent Współrzędne X i Y w procentach dotkniętego punktu. Wzajemnie wyklucza się z opcjami pointTapXCoordinate i pointTapYCoordinate. Wymagane w przypadku działań dotyczących kliknięcia punktu.

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:

Atrybut Opis
className –
ancestorClassName Nazwa klasy przodka elementu w hierarchii interfejsu. Przodek to dowolny z węzłów nadrzędnych w hierarchii interfejsu elementu, w tym sam element.
resourceId –
resourceIdRegex Wyrażenie regularne Java pasujące do resourceId.
contentDescription –
contentDescriptionRegex Wyrażenie regularne Java pasujące do contentDescription.
text (pojawia się na ekranie) –
textRegex Wyrażenie regularne Java pasujące do text.
groupViewChildPosition, recyclerViewChildPosition lub adapterViewChildPosition Reprezentuje pozycję podrzędnego elementu interfejsu użytkownika w zależności od rodzaju nadrzędnego elementu interfejsu użytkownika.

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:

Technika Opis
Dopasowanie częściowe Jeśli bieżące działanie skryptu Robo nie może zostać w pełni dopasowane, kryteria dopasowania są łagodzone i ponowne próby dopasowania są podejmowane. Dopasowanie częściowe nie uwzględnia zewnętrznego opisu elementu podczas dopasowywania docelowego elementu interfejsu działania skryptu Robo.

Jeśli dopasowanie częściowe się powiedzie, odpowiednie działanie skryptu Robo zostanie wykonane w zwykły sposób. Ta metoda obsługuje scenariusze, w których struktura aplikacji zmienia się, na przykład między wersjami aplikacji, gdy elementy ekranu są przestawiane.

Pomiń bieżące działanie Jeśli bieżące działanie skryptu Robo nie może zostać dopasowane w pełni lub częściowo, Robo próbuje dopasować następne działanie skryptu Robo. Jeśli następna akcja w pełni lub częściowo pasuje, test Robo pomija (i nigdy nie wraca do) bieżącej czynności w skrypcie Robo i wykonuje następną.

Ta metoda jest przydatna w sytuacjach, gdy zachowanie aplikacji zmienia się między wersjami lub jest niestabilne, np. gdy podczas nagrywania lub odtwarzania skryptu Robo w różnych miejscach pojawiają się przerwy w dialogu.

Zawieś Jeśli ani bieżące, ani kolejne działania skryptu Robo nie mogą być dopasowane w pełni lub częściowo, skrypt Robo jest tymczasowo zawieszony, a test Robo wybiera działanie do wykonania za pomocą innych strategii. Po zakończeniu tej czynności test Robo wznawia wykonywanie skryptu Robo.

Dopóki nie uda się dopasować bieżących lub kolejnych działań skryptu Robo, skrypt Robo pozostanie zawieszony dla dowolnej liczby działań. Dlatego skrypty Robo nie muszą być wstępem do testu Robo, a działania skryptu Robo możesz przeplatać ze standardowymi działaniami testu Robo. Ta technika sprawdza się w sytuacjach, gdy zachowanie aplikacji jest niestabilne lub gdy zmiany między wersjami aplikacji są na tyle duże, że test Robo musi „uzupełnić luki” za pomocą standardowych działań.

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:

Etap indeksowania Opis
pre_crawl Zanim Robo uruchomi i zacznie indeksować testowaną aplikację.
post_crawl Gdy robot skończy indeksowanie testowanej aplikacji. post_crawlSkrypt robota nie może trwać dłużej niż 15 sekund, w przeciwnym razie indeksowanie może zostać przerwane z powodu przekroczenia limitu czasu.
crawl Główny etap indeksowania, na którym Robo indeksuje testowaną aplikację.
close_screen Gdy robot próbuje wrócić (cofać się) z danego ekranu, po zbadaniu wszystkich możliwych działań na tym ekranie. Domyślnie Robo naciska przycisk Wstecz, co w niektórych przypadkach jest niepożądane.

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:

Atrybut Opis
priority Priorytet tego działania warunkowego w porównaniu z innymi działaniami warunkowymi w zawierającym go skrypcie Robo. Domyślnie wszystkie akcje warunkowe mają priorytet 1.
maxNumberOfRuns Ile razy ta czynność warunkowa może zostać wykonana podczas jednego wykonania skryptu Robo, który ją zawiera. Domyślnie wszystkie działania warunkowe mogą być wykonywane maksymalnie raz w ramach pojedynczego wykonania skryptu Robo, który je zawiera.
contextDescriptor Kontekst lub warunek, który powoduje to działanie warunkowe. Ma tę samą strukturę i oferuje podobne możliwości jak contextDescriptor w skrypcie 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:

Atrybut Opis
"eventType": "ASSERTION" --
contextDescriptor Opisuje zadeklarowany kontekst lub warunek. Ma ona tę samą strukturę i oferuje podobne możliwości co contextDescriptor w skrypcie Robo.

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:

Atrybut Opis
eventType Określa typ działania skryptu Robo.
"eventType": "VIEW_CLICKED" Klika element docelowy w testowanej aplikacji.
"eventType": "SOFT_KEYBOARD_CLICK" Klika docelowy element klawiatury ekranowej.
"eventType": "SOFT_KEYBOARD_RANDOM_CLICK" Klika losowe elementy klawiatury ekranowej do maxNumberOfRuns razy.
"eventType": "LIST_ITEM_CLICKED" Służy do klikania elementów listy przez rejestrator skryptu Robo w Android Studio.
elementDescriptors Identyfikuje kliknięty element interfejsu użytkownika za pomocą hierarchii interfejsu Androida. Wzajemnie wyklucza się z opcją visionText.
visionText Wykorzystując OCR, rozpoznaje element, na który użytkownik kliknął. Wzajemnie się wykluczają z opcją elementDescriptors.
matchIndex Określa indeks wystąpienia dopasowanego elementu docelowego, gdy element docelowy jest identyfikowany za pomocą visionText. Jeśli to 0, działanie skryptu Robo wybiera pierwszy pasujący element, jeśli to 1, działanie skryptu Robo wybiera drugi pasujący element itd. Kolejność jest określana od lewej do prawej i od góry do dołu. Wartością domyślną jest 0 (wybierany jest pierwszy pasujący element).
maxNumberOfRuns Określa, ile razy kliknąć losowy element klawiatury ekranowej, gdy eventType = SOFT_KEYBOARD_RANDOM_CLICK. Wartością domyślną jest 1.

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:

Atrybut Opis
"eventType": "DISABLE_KEYBOARD" --

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

{
  "eventType": "DISABLE_KEYBOARD"
}

Wykonywanie polecenia powłoki adb

Wymagane atrybuty:

Atrybut Opis
"eventType": "ADB_SHELL_COMMAND" --
command Polecenie w powłoce Android Debug Bridge (adb), które ma zostać wykonane.

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:

Atrybut Opis
"eventType": "PERMISSIONS_REQUEST" --

Ignoruj wszystkie elementy na ekranie

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

Wymagane atrybuty:

Atrybut Opis
"eventType": "ALL_ELEMENTS_IGNORED" --

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:

Atrybut Opis
"eventType": "ELEMENT_IGNORED" --
elementDescriptors Identyfikuje pomijane widżety interfejsu za pomocą hierarchii interfejsu Androida.

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:

Atrybut Opis
eventType Określa typ działania skryptu Robo.
"eventType": "VIEW_TEXT_CHANGED" Wpisuje podany tekst w docelowym elemencie interfejsu.
"eventType": "ENTER_TEXT" wstawia podany tekst w docelowym elemencie interfejsu użytkownika, a potem wysyła do niego zdarzenie KEYCODE_ENTER.
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu Androida.
replacementText Tekst do wpisania w docelowym elemencie interfejsu.

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:

Atrybut Opis
"eventType": "VIEW_LONG_CLICKED" --
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu Androida. Wzajemnie wykluczające się z visionText.
visionText Wykorzystując OCR, rozpoznaje element, na którym użytkownik kliknął i przytrzymał. Wzajemnie się wykluczają z opcją elementDescriptors.
matchIndex Określa indeks wystąpienia dopasowanego elementu docelowego, gdy element docelowy jest identyfikowany za pomocą visionText. Jeśli to 0, działanie skryptu Robo wybiera pierwszy pasujący element, jeśli to 1, działanie skryptu Robo wybiera drugi pasujący element itd. Kolejność jest określana od lewej do prawej i od góry do dołu. Wartością domyślną jest 0 (wybierany jest pierwszy pasujący element).

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:

Atrybut Opis
"eventType": "ONE_POINT_GESTURE" --
coordinates Dwie współrzędne dla gestu jednopunktowego, sformatowane jako „(x1,y1)->(x2,y2)” w procentach lub pikselach.

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:

Atrybut Opis
"eventType": "TWO_POINT_GESTURE" --
coordinates 4 współrzędne gestu dwupunktowego w formacie „(x1,y1)->(x2,y2),(x3,y3)->(x4,y4)” w procentach lub pikselach.

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:

Atrybut Opis
"eventType": "PRESSED_EDITOR_ACTION" --
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu Androida.

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:

Atrybut Opis
eventType Określa typ działania skryptu Robo.
"eventType": "PRESSED_BACK" Wysyła na urządzenie zdarzenie KEYCODE_BACK.
"eventType": "PRESSED_BACK_EMULATOR_28" Służy do obsługi przycisku Wstecz w rejestratorze skryptu Robo w Android Studio na emulatorach z interfejsem API 28.

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:

Atrybut Opis
"eventType": "GO_HOME" --

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:

Atrybut Opis
"eventType": "ELEMENT_SCROLL_INTO_VIEW" --
elementDescriptors Określa element interfejsu użytkownika, który został przescrollowany, korzystając z hierarchii interfejsu użytkownika Androida.
childElementDescriptors Określa element interfejsu, do którego ma się przewinąć, korzystając z hierarchii interfejsu Androida.

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:

Atrybut Opis
"eventType": "VIEW_SWIPED" --
swipeDirection Określa kierunek przesunięcia:
  • Left
  • Right
  • Up
  • Down
  • Forward – wartość Down lub Right w zależności od tego, czy docelowy element interfejsu użytkownika można przewijać w poziomie czy w pionie.
  • Backward – może być Up lub Leftw zależności od tego, czy docelowy element interfejsu użytkownika umożliwia przewijanie w pionie czy w poziomie.
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu Androida.

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:

Atrybut Opis
"eventType": "TAKE_SCREENSHOT" --
screenshotName Określa nazwę pliku z rzutem ekranu.

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:

Atrybut Opis
"eventType": "POINT_TAP" --
pointTapXCoordinate Pikselowa współrzędna X klikniętego punktu. Wzajemnie wyklucza się z tagami pointTapXPercent i pointTapYPercent.
pointTapYCoordinate Pikselowa współrzędna Y klikniętego punktu. Wzajemnie wyklucza się z tagami pointTapXPercent i pointTapYPercent.
pointTapXPercent Współrzędna X klikniętego punktu w procentach. Wzajemnie wyklucza się z tagami pointTapXCoordinate i pointTapYCoordinate.
pointTapYPercent Współrzędna Y klikniętego punktu w procentach. Wzajemnie wyklucza się z tagami pointTapXCoordinate i pointTapYCoordinate.

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:

Atrybut Opis
"eventType": "POINT_TAP_ELEMENT" --
pointTapXPercent Współrzędna X elementu docelowego w procentach.
pointTapYPercent Współrzędna Y w procentach w obrębie elementu docelowego.
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu użytkownika Androida.

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:

Atrybut Opis
"eventType": "TERMINATE_CRAWL" --

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

{
  "eventType": "TERMINATE_CRAWL"
}

Czekaj

Wymagane atrybuty:

Atrybut Opis
"eventType": "DELAYED_MESSAGE_POSTED" --
delayTime Określa czas oczekiwania w milisekundach.

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:

Atrybut Opis
"eventType": "WAIT_FOR_ELEMENT" --
delayTime Określa czas oczekiwania w milisekundach.
elementDescriptors Identyfikuje oczekiwany widget interfejsu użytkownika za pomocą hierarchii interfejsu użytkownika Androida.

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