Przewodnik po skryptach Robo

Ten dokument zawiera informacje referencyjne dotyczące skryptów Robo, w tym ich strukturę, możliwości, użycie, nagrywanie i działania. Skrypty Robo to testy, które automatyzują zadania związane z ręczną kontrolą jakości (QA) w przypadku aplikacji mobilnych. Umożliwiają też korzystanie ze strategii ciągłej integracji (CI) i testów przed opublikowaniem. Skrypt Robo to plik JSON opisujący sekwencję interfejsu użytkownika i innych działań.

Skrypt Robo można utworzyć na następujące sposoby:

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

  • Utwórz skrypt Robo ręcznie. (Android i iOS+)

  • Nagraj skrypt Robo i edytuj go ręcznie. (tylko w Androidzie)

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

Wstęp

Skrypt Robo jest udostępniany na potrzeby testu Robo razem z innymi danymi wejściowymi, takimi jak pakiet aplikacji na Androida (app-under-test).

Poniżej znajduje się przykładowy skrypt Robo, który loguje użytkownika w aplikacji i aktywowany przy uruchamianiu testu aplikacji:

[
  {
    "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 jest jeden skrypt Robo i ma on domyślny warunek wyzwalający app_under_test_shown, jak w przykładzie powyżej, możesz określić go w pliku, używając prostszego formatu, tak jak na sekwencję jego 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 systemie iOS+

Robo na iOS+ (beta) ma ograniczoną obsługę skryptów Robo. Składnia skryptu Robo w przypadku iOS+ jest taka sama jak w przypadku Androida, a obsługiwane funkcje iOS+ działają podobnie do ich odpowiedników na Androida.

W iOS+ obsługiwane są następujące działania:

  • Asercja
  • Kliknij
  • Długie kliknięcie
  • Przesuwanie palcem
  • Ignoruj wszystkie elementy
  • Czekaj
  • Zrób zrzut ekranu
  • Zakończ indeksowanie

W iOS+ obsługiwane są następujące atrybuty identyfikujące w deskryptorach elementów:

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

W iOS+ obsługiwane są następujące warunki uruchamiania w deskryptorach kontekstu:

  • Wyświetlono aplikację w trakcie testowania
  • Element jest
  • Wykonano czynność inną niż Robo

Struktura

Skrypt Robo ma kilka atrybutów opisujących sposób jego wykonywania. Większość z tych atrybutów jest opcjonalna ze wstępnie zdefiniowanymi wartościami domyślnymi:

Atrybut Opis
id Liczba całkowita, która pomaga śledzić ten skrypt Robo w danych wyjściowych indeksowania. Robo ma wbudowane skrypty Robo z własnymi skryptami id. Chociaż ta sama dyrektywa id w różnych skryptach Robo nie ma wpływu na ich działanie, odróżnienie działań od tych skryptów Robo w danych wyjściowych indeksowania może być trudne. Aby uniknąć konfliktów, zalecamy przypisanie do skryptów Robo unikalnej wartości id o wartości 1000 lub większej.
description Podobne do id, ale bardziej opisowe.
crawlStage Na etapie indeksowania Robo stosuje ten skrypt Robo. Domyślnie jest to główny etap indeksowania.
priority Priorytet tego skryptu Robo w porównaniu z innymi skryptami Robo. Domyślnie wszystkie skrypty Robo mają priorytet 1.
maxNumberOfRuns Określa, ile razy podczas indeksowania Robo może wykonać ten skrypt Robo. Domyślnie Robo może jednorazowo uruchomić skrypt Robo.
contextDescriptor Opisuje kontekst lub warunek, który wyzwala ten skrypt Robo. Jeśli go pominiesz, warunek wyzwalający tego skryptu Robo będzie uważany za zawsze spełniony. Oznacza to, że skrypt Robo jest bezwarunkowy.
actions Wszystkie działania tego skryptu Robo.

Pojedynczy plik zawiera kolekcję co najmniej 1 skryptu Robo.

Poniżej znajdziesz przykład pliku z 2 bezwarunkowymi skryptami Robo, z których każdy zawiera 1 działanie, które jest 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 wyzwala skrypt Robo za pomocą jednego lub kilku atrybutów:

Atrybut Opis
"condition": "always" Zawsze aktywuje skrypt Robo.
"condition": "element_present" Sprawdza, czy na ekranie jest widoczny widżet interfejsu zgodny z polem elementDescriptors lub tekst określony przez visionText.
"condition": "element_disabled" Sprawdza, czy na ekranie jest widoczny widżet interfejsu pasujący do: elementDescriptors i nie można go użyć.
"condition": "element_checked" Sprawdza, czy na ekranie znajduje się i jest zaznaczony widżet interfejsu pasujący do: elementDescriptors.
"condition": "app_under_test_shown" Sprawdza, czy test aplikacji działa na pierwszym planie.
"condition": "default_launcher_shown" Sprawdza, czy wyświetlany jest ekran główny urządzenia, co oznacza, że na pierwszym planie nie są uruchomione żadne aplikacje.
"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 condition. Możesz na przykład użyć tego atrybutu, aby sprawdzić, czy widżet interfejsu NIE znajduje się na ekranie lub czy test aplikacji NIE działa na pierwszym planie.
elementDescriptors Jeden lub więcej deskryptorów elementów identyfikujących widżet interfejsu użytkownika na ekranie. Jest używana w połączeniu z warunkami element_present, element_disabled i element_checked. Wzajemnie wyklucza się z: visionText. Więcej informacji znajdziesz w artykule Deskryptory elementu.
visionText Tekst na ekranie jest wykrywany za pomocą interfejsu Optical Character Recognition (OCR) API. Parametr visionText jest używany w połączeniu z warunkem element_present. Wzajemnie wyklucza się z: elementDescriptors.
nonRoboscriptActionCount Liczba kolejnych wykonanych wcześniej działań innych niż skrypt Robo. Jest używany w połączeniu z warunkem non_roboscript_action_performed do aktywowania skryptu Robo po każdym działaniu Robo (nonRoboscriptActionCount). Domyślnie jest to 1.

Poniżej znajdziesz przykładowy skrypt Robo, który jest aktywowany przez widżet interfejsu o identyfikatorze zasobu "my.app.package:id/page_header" widoczny 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 znajduje się przykład skryptu Robo, który jest aktywowany przez metodę "Privacy Policy" wykrytą 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"
    }
  ]
}

Poniżej znajduje się przykładowy skrypt Robo, który czeka 5 sekund po każdym nieskryptowym działaniu Robo:

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

Działania

Każde działanie w skrypcie Robo jest reprezentowane przez pakiet co najmniej 1 pary atrybut-wartość, które zostało opisane w tej tabeli:

Atrybut Opis
eventType Określa rodzaj działania, np. kliknięcie, edycja tekstu itp. Wymagane dla każdej czynności.
elementDescriptors Deskryptory identyfikujące widżet interfejsu użytkownika. Wymagane w przypadku wszystkich działań, które mają docelowy widżet interfejsu, takich jak kliknięcie konkretnego przycisku.
optional Jeśli ma wartość true, to działanie jest pomijane, gdy nie można go wykonać. To działanie jest na przykład pomijane, gdy nie może znaleźć docelowego widżetu interfejsu na ekranie. Nie spowoduje to wystąpienia awarii skryptu Robo. Domyślną wartością jest false.
replacementText Tekst do wpisania w docelowym widżecie interfejsu. Wymagane przy edycji tekstu.
swipeDirection Określa kierunek przesuwania. Wymagane do działania przesuwania.
delayTime Określa czas oczekiwania (w milisekundach). Wymagane dla działań związanych z oczekiwaniem.
pointTapXCoordinate i pointTapYCoordinate Współrzędne X i Y piksela klikniętego punktu. Wzajemnie wyklucza się z pointTapXPercent i pointTapYPercent. Wymagane w przypadku działań wykonywanych za pomocą dotknięcia punktowego.
pointTapXPercent i pointTapYPercent Procentowe współrzędne X i Y klikniętego punktu. Wyłącznie wzajemnie z: pointTapXCoordinate i pointTapYCoordinate. Wymagane w przypadku działań wykonywanych za pomocą dotknięcia punktowego.

Poniżej znajduje się przykład skryptu Robo z 2 działaniami bez docelowych widżetów interfejsu. Oznacza to, że te działania nie działają w konkretnym widżecie interfejsu:

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

Deskryptory elementów

Deskryptor elementu identyfikuje widżet interfejsu za pomocą co najmniej jednego z tych atrybutów identyfikujących:

Atrybut Opis
className –
ancestorClassName Nazwa klasy elementu nadrzędnego hierarchii elementu. Element nadrzędny to dowolny z węzłów nadrzędnych w hierarchii interfejsu użytkownika, 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 (wyświetlana na ekranie) –
textRegex Wyrażenie regularne Java pasujące do text.
groupViewChildPosition, recyclerViewChildPosition lub adapterViewChildPosition Reprezentuje pozycję podrzędną widżetu interfejsu w zależności od rodzaju widżetu nadrzędnego.

Często te atrybuty są nieokreślone – na przykład przycisk może nie mieć tekstu i opisu treści. Nawet jeśli określone 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 wtedy, gdy używasz ich różnych pozycji podrzędnych w widżecie nadrzędnym. Oznacza to, że używanie tylko jednego deskryptora elementu do identyfikowania widżetu interfejsu zwykle nie wystarcza. Dlatego atrybut elementDescriptors działania zawiera sekwencję deskryptorów elementów uporządkowanych w taki sposób, że pierwszy odpowiada docelowemu widżetowi interfejsu, drugi – nadrzędny widżet docelowego widżetu interfejsu itd. Docelowy widżet interfejsu działania jest dopasowywany, gdy wszystkie jego deskryptory elementów pasują do odpowiedniej podhierarchii widżetu interfejsu.

Poniżej znajdziesz przykład skryptu Robo ze zmianą tekstu i działaniami związanymi z kliknięciem. Oba te elementy wymagają wskazania docelowego widżetu interfejsu za pomocą 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 poprzedzić listę działań w skrypcie Robo obiektem JSON określającym opcje wykonania tego skryptu Robo. Nagłówek konfiguracji zaczyna się od słowa kluczowego roboscript, po którym następuje reprezentacja w formacie JSON żądanych opcji wykonania.

Skrypty Robo obsługują te opcje wykonywania:

  • executionMode – opcje wykonywania są stosowane, gdy uruchomiony jest skrypt Robo:
    • strict – jeśli jest ustawiony na true, skrypt Robo nie stosuje dopasowywania częściowego, pomijania bieżącego działania ani zawieszenia. Oznacza to, że skrypt Robo jest wykonywany jako zwykły test instrumentacji i kończy się niepowodzeniem, gdy nie można wykonać żadnego z jego działań. Domyślnie jest to false.
    • dismiss_popups – jeśli ma wartość true, test Robo zamyka wszelkie nieoczekiwane okna dialogowe podczas wykonywania skryptu Robo nawet w trybie strict. Ta opcja nie działa, gdy nie jest w trybie strict. Domyślnie jest to false.
    • notify – jeśli ma wartość false, skrypt Robo nie wyświetla na ekranie powiadomień na początku ani na końcu jego wykonania. Domyślnie jest to true.
  • postscript – opcje wykonywania są stosowane po zakończeniu działania skryptu Robo:
    • terminate – jeśli ma wartość true, test Robo przestaje indeksować po zakończeniu wykonywania skryptu Robo. Domyślnie jest to false.

Poniżej znajdziesz przykład skryptu Robo uruchomionego w trybie strict bez powiadomień na ekranie, który jest uśpiony przez 3 sekundy, po czym indeksowanie się zatrzymuje:

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

Parametry szablonu

Parametr szablonu to obiekt zastępczy w skrypcie Robo, który jest zastępowany rzeczywistą wartością, gdy test Robo wczytuje ten skrypt do wykonania. Parametry szablonu są poprzedzone podwójnym podkreśleniem, po którym następuje znak procentu, i są osadzone znakiem procenta, po którym następuje podwójne podkreślenie.

Skrypty Robo obsługują ten parametr szablonu:

  • __%APP_PACKAGE_NAME%__ – nazwa pakietu aplikacji w trakcie testu.

Poniżej znajduje się przykładowy skrypt Robo, który zatrzymuje proces sprawdzania aplikacji:

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

Komentarze

Skrypt Robo może zawierać wiersze komentarza, które zaczynają się od # lub //.

Poniżej znajduje się przykładowy skrypt 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, dopóki wszystkie działania skryptu Robo nie zostaną ukończone (lub przynajmniej wykonane), skrypt Robo pozostaje aktywny. Test Robo wciąż próbuje dopasować działanie skryptu Robo za każdym razem, gdy wybiera działanie do wykonania. Skrypt Robo stosuje te techniki w celu zwiększenia odporności:

Technika Opis
Dopasowanie częściowe Jeśli nie można w pełni dopasować bieżącej czynności skryptu Robo, kryteria dopasowywania zostają złagodzone i następuje ponowna próba dopasowania. Częściowe dopasowanie nie uwzględnia najbardziej zewnętrznego deskryptora elementu podczas dopasowywania docelowego widżetu interfejsu dla działania skryptu Robo.

Jeśli częściowe dopasowanie się powiedzie, odpowiednia czynność skryptu Robo jest wykonywana w zwykły sposób. Ta technika działa w sytuacjach, gdy struktura aplikacji zmienia się, np. pomiędzy wersjami aplikacji lub zmiana kolejności elementów na ekranie.

Pomiń bieżące działanie Jeśli bieżącego działania skryptu Robo nie można w pełni lub częściowo dopasować, Robo próbuje dopasować następne działanie skryptu Robo. Jeśli kolejne działanie będzie całkowicie lub częściowo zgodne, test Robo pominie bieżące (i nigdy do niego nie wraca) i wykonuje następne.

Ta technika obsługuje scenariusze, w których działanie aplikacji zmienia się między wersjami lub niestabilne, na przykład gdy nieregularne okno dialogowe może wyświetlać się na różnych ekranach podczas nagrywania i ponownego odtwarzania skryptu Robo.

Zawieś Jeśli nie można w pełni lub częściowo dopasować bieżących ani kolejnych działań skryptu Robo, skrypt Robo jest tymczasowo zawieszony, a test Robo wybiera działanie, które ma zostać wykonane przy użyciu innych strategii. Po zakończeniu tego działania test Robo wznowi wykonywanie skryptu Robo.

Dopóki nie będzie można dopasować bieżących lub kolejnych działań skryptu Robo, pozostanie on zawieszony dla dowolnej liczby działań. Dzięki temu skrypty Robo nie muszą być prologiem testu Robo i można łączyć działania skryptu Robo ze standardowymi działaniami testowymi Robo. Ta technika działa w sytuacjach, gdy działanie aplikacji jest niestabilne lub gdy zmiany między wersjami aplikacji są na tyle duże, że test Robo musi „wypełnić luki” standardowymi działaniami.

Priorytety

Jeśli skrypt Robo osiągnie wartość maxNumberOfRuns, nie będzie już mógł zostać aktywowany podczas danego indeksowania. Jeśli w bieżącym kontekście może zostać aktywowany więcej niż 1 skrypt Robo, wybierany jest w tej kolejności ten skrypt, który:

  1. Ma atrybut contextDescriptor.
  2. Ma najwyższy wskaźnik priority (domyślnie wszystkie skrypty Robo mają to samo wykonanie priority o wartości 1).
  3. Pojawia się najwcześniej na liście skryptów Robo, jeśli priorytety skryptów Robo są takie same.

Poniżej znajdziesz przykład pliku z 3 skryptami Robo, które wykonują to samo działanie i są wywoływane przez ten sam warunek – test aplikacji 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 test aplikacji działa na pierwszym planie, Robo wywołuje w 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 odpowiednich skryptów Robo o tym samym priorytecie.
  3. "Robo script 3" jako ostatni odpowiedni skrypt Robo.

Powtórzenia

Domyślnie Robo uruchamia skrypt Robo najwyżej raz podczas indeksowania. Możesz to zmienić za pomocą atrybutu maxNumberOfRuns.

Poniżej znajdziesz przykład skryptu Robo, który nawet 10 razy przenosi test aplikacji w tle:

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

Etap indeksowania

Skrypty Robo mają zastosowanie na różnych etapach danego indeksowania Robo:

Etap indeksowania Opis
pre_crawl Przed uruchomieniem Robo i rozpoczęciem indeksowania aplikacji w trakcie testów.
post_crawl Gdy Robo zakończy indeksowanie aplikacji w trakcie testowania.
crawl Główny etap indeksowania, podczas którego Robo indeksuje aplikację w trakcie testowania.
close_screen Gdy Robo próbuje wrócić do poprzedniego ekranu, sprawdza wszystkie możliwe działania dostępne na tym ekranie. Domyślnie Robo cofa się, co w niektórych sytuacjach jest niepożądane.

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

Poniżej znajduje się przykładowy skrypt Robo, który usuwa dane użytkownika w trakcie testowania aplikacji, zanim Robo rozpocznie ich indeksowanie:

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

Poniżej znajduje się przykładowy skrypt Robo, który instruuje Robo o kliknięciu "Cancel" za każdym razem, gdy próbuje on wrócić (backtrack) w oknie 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 ramach skryptu Robo. Domyślnie wszystkie działania warunkowe mają priorytet 1.
maxNumberOfRuns Ile razy to działanie warunkowe może być wykonywane podczas jednego wykonania zawierającego skrypt Robo. Domyślnie wszystkie działania warunkowe można wykonać maksymalnie raz w ramach jednego wykonania zawierającego skrypt Robo.
contextDescriptor Kontekst/warunek wyzwalający to działanie warunkowe. Ma tę samą strukturę i oferuje podobne funkcje co deskryptor kontekstu skryptu Robo

Po uruchomieniu skrypt Robo wykonuje po kolei działania bezwarunkowe w kolejności występowania. Jeśli skrypt Robo zawiera działania warunkowe, są one brane pod uwagę za każdym razem przed wybraniem działania bezwarunkowego do wykonania. Jeśli dowolne działanie warunkowe zostanie aktywowane i wybranie na podstawie jego priorytetu i pozostałej liczby uruchomień, skrypt Robo wykona to działanie. W przeciwnym razie skrypt Robo wykonuje poniższe działanie bezwarunkowe. Aby skrypt Robo był prawidłowy, musi zawierać co najmniej 1 działanie bezwarunkowe.

Poniżej znajduje się przykład bezwarunkowego skryptu Robo z działaniem warunkowym, które zamyka wyskakujące okna, jeśli pojawią się w jakimkolwiek 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 ignorowania określonych widżetów UI lub wszystkich widżetów interfejsu na danym ekranie. Te instrukcje są wyświetlane jako ignorowanie „działań” odpowiednio do eventType ELEMENT_IGNORED i ALL_ELEMENTS_IGNORED.

Za każdym razem, gdy atrybut contextDescriptor skryptu Robo, który ignoruje działania, pasuje do danego ekranu, Robo nie wchodzi w interakcję z żadnymi widżetami interfejsu, których działania są ignorowane (chyba że jakaś inna akcja skryptu Robo wymusza wykonanie działania na jednym z ignorowanych widżetów interfejsu).

Skrypt Robo może obejmować działania ignorowane, warunkowe i bezwarunkowe. W przeciwieństwie do innych działań skryptu Robo ignorowanie działań jest stosowane, jeśli ich działanie contextDescriptor w skrypcie Robo odpowiada ekranowi podczas indeksowania 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 o identyfikatorze zasobu "my.app.package:id/ignored_screen". Drugi skrypt Robo ignoruje widżety interfejsu Robo, których identyfikatory zasobów pasują do wyrażenia regularnego Java ".*:id/done" na ekranie zawierającym widżet interfejsu 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 obiektów RecyclerView i AdapterView

Elementy podrzędne widżetów RecyclerView i AdapterView są ładowane dynamicznie i mogą być wyświetlane po wielu przesunięciach od bieżącego ekranu. Rozmiar ekranu i liczba przesunięć koniecznych do wyświetlenia tego dziecka są różne w zależności od formatu urządzenia, dlatego dużo trwalsze jest opieranie się na pozycji danych dziecka, która jest wartością bezwzględną. Mniej restrykcyjne podejście polega na liczbie przesunięciach wymaganych do wyświetlenia dziecka na ekranie, a następnie na jego użyciu w wybranej pozycji.

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

Działania na elementach podrzędnych RecyclerView i AdapterView są wykonywane w tych krokach:

  1. Test Robo sprawdza, czy na ekranie wyświetla się odpowiedni element podrzędny za pomocą działania pozycjonującego w elemencie RecyclerView lub AdapterView.

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

Oto przykład działania polegającego na kliknięciu w elemencie podrzędnym 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
    }
  ]
}

Oto przykład działania kliknięcia w elemencie podrzędnym 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
    }
  ]
}

Nagraj skrypt Robo w Android Studio i uruchom go w Laboratorium testów

Możesz utworzyć skrypt Robo w Android Studio, który zapisze go jako plik JSON. Następnie możesz przesłać plik JSON do Laboratorium Firebase z aplikacją i uruchomić odpowiedni test.

Gdy uruchamiasz test Robo z załączonym skryptem, Robo testuje pierwsze kroki przez opracowane przez Ciebie działania, a potem sprawdza aplikację w zwykły sposób.

Aby utworzyć plik JSON skryptu Robo w Android Studio, wykonaj czynności opisane w artykule Nagrywanie skryptu Robo za pomocą Laboratorium w Android Studio.

Działania skryptu Robo

Ten wspólny atrybut opcjonalny ma zastosowanie do wszystkich działań:

  • description – pomaga śledzić wykonanie tego działania skryptu Robo w wynikach testu Robo.

Asercja

Jeśli potwierdzony warunek jest spełniony, skrypt Robo przechodzi do następnej czynności, co może być kolejnym twierdzeniem. W przeciwnym razie wykonanie skryptu Robo zostanie wstrzymane z powodu nieudanego potwierdzenia.

Wymagane atrybuty:

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

Oto przykład asercji skryptu Robo, która sprawdza, czy na pierwszym planie znajduje się test aplikacji:

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

Poniżej znajdziesz przykład potwierdzenia skryptu Robo, który sprawdza, czy widżet UI o identyfikatorze zasobu "com.google.samples.apps.topeka:id/done" jest widoczny na ekranie:

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

Poniżej znajdziesz przykład potwierdzenia skryptu Robo, który sprawdza, czy za pomocą OCR na ekranie nie została wykryta strona "Settings":

{
  "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 aplikacji w trakcie testu.
"eventType": "SOFT_KEYBOARD_CLICK" Klika docelowy element klawiatury programowej.
"eventType": "SOFT_KEYBOARD_RANDOM_CLICK" Klika losowe elementy klawiatury ekranowej maksymalnie maxNumberOfRuns razy.
"eventType": "LIST_ITEM_CLICKED" Używany przez rejestrator skryptów Robo w Android Studio do klikania elementów listy.
elementDescriptors Identyfikuje kliknięty widżet UI za pomocą hierarchii interfejsu Androida. Wzajemnie wyklucza się z: visionText.
visionText Identyfikuje kliknięty element za pomocą OCR. Wzajemnie wyklucza się z: elementDescriptors.
maxNumberOfRuns Określa, ile razy należy kliknąć losowy element klawiatury programowej, gdy eventType ma wartość SOFT_KEYBOARD_RANDOM_CLICK. Wartością domyślną jest 1.

Poniżej znajdziesz przykład działania skryptu Robo, które powoduje kliknięcie 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 polegającego na kliknięciu "Privacy Policy" na ekranie za pomocą OCR:

{
  "eventType": "VIEW_CLICKED",
  "visionText": "Privacy Policy"
}

Oto przykład działania skryptu Robo, które powoduje kliknięcie opcjonalnego elementu klawiatury z opisem treści "Emoji button":

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

Poniżej znajdziesz przykład działania skryptu Robo, które klika losowe elementy klawiatury ekranowej maksymalnie 5 razy:

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

Wyłącz klawiaturę programową

Wymagane atrybuty:

Atrybut Opis
"eventType": "DISABLE_KEYBOARD" --

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

{
  "eventType": "DISABLE_KEYBOARD"
}

Wykonaj polecenie powłoki adb

Wymagane atrybuty:

Atrybut Opis
"eventType": "ADB_SHELL_COMMAND" --
command Polecenie powłoki Android Debug Bridge (adb) do wykonania.

Ten atrybut jest opcjonalny:

  • expectedOutputRegex – oczekiwane dane wyjściowe polecenia w postaci wyrażenia regularnego Java. Jeśli dane wyjściowe nie są zgodne, działanie skryptu Robo kończy się niepowodzeniem. Domyślnie jest to pusty ciąg znaków, co oznacza, że dane wyjściowe nie są sprawdzane.

Poniżej znajdziesz przykład działania skryptu Robo, które usuwa dane użytkownika, który jest objęty testem aplikacji:

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

Przyznawanie uprawnień

To działanie jest rejestrowane przez rejestrator skryptów Robo w Android Studio w celu zapewnienia wstecznej zgodności z Rejestratorem testów Espresso. Test Robo przyznaje wszystkie uprawnienia aplikacji w trakcie testowania na początku każdego indeksowania i dlatego nie jest to działanie. NIE używaj tego działania w skryptach Robo.

Wymagane atrybuty:

Atrybut Opis
"eventType": "PERMISSIONS_REQUEST" --

Ignorowanie wszystkich elementów na ekranie

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

Wymagane atrybuty:

Atrybut Opis
"eventType": "ALL_ELEMENTS_IGNORED" --

Poniżej znajduje się 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), który pasuje do określonego parametru elementDescriptors.

Wymagane atrybuty:

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

Ten atrybut jest opcjonalny:

  • ignoreChildren – jeśli ma wartość true, Robo ignoruje również wszystkie elementy podrzędne ignorowanych widżetów interfejsu. Domyślnie jest to false.

Poniżej znajdziesz przykład działania skryptu Robo, który powoduje, że Robo ignoruje wszystkie elementy, których opis treści zaczyna 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 widżecie interfejsu.
"eventType": "ENTER_TEXT" wstawia dany tekst do docelowego widżetu interfejsu, a następnie wysyła zdarzenie KEYCODE_ENTER do tego widżetu interfejsu.
elementDescriptors Identyfikuje docelowy widżet interfejsu przy użyciu hierarchii interfejsu Androida.
replacementText Tekst do wpisania w docelowym widżecie interfejsu.

Poniżej znajdziesz przykład działania skryptu Robo, które dodaje element "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"
    }
  ]
}

Długie kliknięcie

Wymagane atrybuty:

Atrybut Opis
"eventType": "VIEW_LONG_CLICKED" --
elementDescriptors Identyfikuje docelowy widżet interfejsu przy użyciu hierarchii interfejsu Androida. Wzajemnie wyklucza się z: visionText.
visionText Identyfikuje długo kliknięty element za pomocą OCR. Wzajemnie wyklucza się z: elementDescriptors.

Ten atrybut jest opcjonalny:

  • delayTime – określa, jak długo trwa przytrzymanie długiego kliknięcia (w milisekundach).

Poniżej znajdziesz przykład działania skryptu Robo, które wykonuje 5-sekundowe kliknięcie widżetu interfejsu z opisem treści "Avatar 8":

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

Wykonaj gest jednopunktowy

Wymagane atrybuty:

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

Ten atrybut jest opcjonalny:

  • dragAndDrop – jeśli ma wartość true, gest jednopunktowy powoduje wykonanie działania „przeciągnij i upuść”. Domyślnie jest to false.

Poniżej znajdziesz przykład działania skryptu Robo polegającego na przesuwaniu palcem w dół:

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

Wykonaj gest dwupunktowy

Wymagane atrybuty:

Atrybut Opis
"eventType": "TWO_POINT_GESTURE" --
coordinates Cztery współrzędne gestu dwupunktowego w postaci „(x1,y1)->(x2,y2),(x3,y3)->(x4,y4)” jako procenty lub piksele.

Poniżej znajduje się przykład działania skryptu Robo, które wykonuje gest ściągnięcia palców:

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

Wykonaj działanie IME

To działanie powoduje naciśnięcie bieżącego przycisku polecenia, np. Dalej, Gotowe i wyszukiwanie w edytorze metody wprowadzania (IME) dla określonego docelowego widżetu interfejsu.

Wymagane atrybuty:

Atrybut Opis
"eventType": "PRESSED_EDITOR_ACTION" --
elementDescriptors Identyfikuje docelowy widżet interfejsu przy użyciu hierarchii interfejsu Androida.

Poniżej znajdziesz przykład działania skryptu Robo, które wykonuje działanie IME w 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 zdarzenie KEYCODE_BACK do urządzenia.
"eventType": "PRESSED_BACK_EMULATOR_28" Używany przez rejestrator skryptów Robo w Android Studio do wycofania interfejsu API emulatorów w wersji 28.

Oto przykład działania skryptu Robo, które wraca:

{
  "eventType": "PRESSED_BACK"
}

Naciśnij przycisk ekranu głównego

To działanie powoduje wysłanie zdarzenia KEYCODE_HOME do urządzenia.

Wymagane atrybuty:

Atrybut Opis
"eventType": "GO_HOME" --

Oto przykład działania skryptu Robo, które powoduje naciśnięcie ekranu głównego:

{
  "eventType": "GO_HOME"
}

Przewijanie elementów w widoczny sposób

Spowoduje to, że test Robo przewinie do przodu widżet interfejsu zgodny z określonym parametrem elementDescriptors, aż na ekranie pojawi się widżet interfejsu zgodny z określonym parametrem childElementDescriptors, przewinięcia widżetu nie będzie już można przewinąć lub osiągnięto maksymalną liczbę 50 przewinięć.

Wymagane atrybuty:

Atrybut Opis
"eventType": "ELEMENT_SCROLL_INTO_VIEW" --
elementDescriptors Identyfikuje przewijany widżet UI za pomocą hierarchii UI Androida.
childElementDescriptors Identyfikuje widżet interfejsu do przewinięcia przy użyciu hierarchii interfejsu Androida.

Poniżej znajduje się przykład działania skryptu Robo, które przewija widżet interfejsu o identyfikatorze zasobu "my.app.package:id/scrollable_card_container" do momentu, aż na ekranie pojawi się widżet interfejsu z tekstem "Orange" (lub nie będzie można wykonywać przewijania albo 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 przesuwania:
  • Left
  • Right
  • Up
  • Down
  • Forward – Down lub Right w zależności od możliwości przewijania w pionie lub poziomie docelowego widżetu interfejsu.
  • Backward – Up lub Left w zależności od możliwości przewijania w pionie lub poziomie docelowego widżetu interfejsu.
elementDescriptors Identyfikuje docelowy widżet interfejsu przy użyciu hierarchii interfejsu Androida.

Poniżej znajdziesz przykład działania skryptu Robo, które przesuwa w górę widżet interfejsu o identyfikatorze zasobu "my.app.package:id/custom_content":

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

Zrób zrzut ekranu

Wymagane atrybuty:

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

Oto przykład działania skryptu Robo, które powoduje zrobienie zrzutu ekranu:

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

Kliknij punkt na ekranie.

Wymagane atrybuty:

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

Oto przykład działania skryptu Robo, które klika się na środku ekranu:

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

Kliknij punkt w obrębie elementu

Wymagane atrybuty:

Atrybut Opis
"eventType": "POINT_TAP_ELEMENT" --
pointTapXPercent Procentowa współrzędna X w elemencie docelowym.
pointTapYPercent Procentowa współrzędna Y w elemencie docelowym.
elementDescriptors Identyfikuje docelowy widżet interfejsu za pomocą hierarchii interfejsu Androida.

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

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

Zakończ indeksowanie

To działanie zatrzyma test Robo.

Wymagane atrybuty:

Atrybut Opis
"eventType": "TERMINATE_CRAWL" --

Poniżej znajduje się przykład działania skryptu Robo, które zatrzymuje test Robo:

{
  "eventType": "TERMINATE_CRAWL"
}

Czekaj

Wymagane atrybuty:

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

Poniżej znajdziesz przykład działania skryptu Robo, które czeka 3 sekundy:

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

Poczekaj na element

To działanie powoduje, że test Robo będzie czekać na pojawienie się elementu na ekranie do określonego czasu oczekiwania.

Wymagane atrybuty:

Atrybut Opis
"eventType": "WAIT_FOR_ELEMENT" --
delayTime Określa czas oczekiwania w milisekundach.
elementDescriptors Identyfikuje widżet oczekujący na wyświetlenie za pomocą hierarchii interfejsu Androida.

Poniżej znajdziesz przykład działania skryptu Robo, które czeka na 30 sekund na pojawienie się na ekranie widżetu interfejsu o identyfikatorze zasobu "my.app.package:id/confirmation_button":

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

Dalsze kroki