Przewodnik po skryptach Robo

Ten dokument zawiera informacje referencyjne o skryptach Robo, w tym o ich strukturze, możliwościach, zastosowaniu, nagrywaniu i działaniach. Skrypty Robo to testy, które automatyzują ręczne zadania związane z zapewnianiem jakości aplikacji mobilnych oraz umożliwiają stosowanie strategii ciągłej integracji i testowania przed opublikowaniem. Skrypt Robo to plik JSON, który opisuje sekwencję działań w interfejsie i innych działań.

Skrypt Robo możesz utworzyć na te sposoby:

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

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

• Nagraj skrypt Robo, a następnie 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 dostarczany do testu Robo wraz z innymi danymi wejściowymi, takimi jak Android Application Package (APK) testowanej aplikacji.

Poniżej znajduje się przykładowy skrypt Robo, który loguje użytkownika w aplikacji i jest uruchamiany po uruchomieniu testowanej 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 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 na iOS+

Testy Robo na iOS+ (beta) mają ograniczoną obsługę skryptów Robo. Składnia skryptu Robo na iOS+ jest identyczna ze składnią na Androida, a obsługiwane funkcje na iOS+ działają podobnie jak ich odpowiedniki na Androidzie.

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

• Asercja
• Kliknij
• Kliknięcie i przytrzymanie
• Przesuń
• Ignoruj wszystkie elementy
• Czekaj
• Zapisz zrzut ekranu
• Zakończ indeksowanie

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

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

W iOS+ obsługiwane są te warunki aktywacji w deskryptorach kontekstu:

• Wyświetlana jest testowana aplikacja
• Element występuje
• Wykonano działanie skryptu innego niż 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 wstępnie zdefiniowane wartości domyślne:

Pojedynczy plik zawiera kolekcję co najmniej 1 skryptu Robo.

Poniżej znajduje się 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 definiuje kontekst lub warunek, który aktywuje skrypt Robo, używając co najmniej jednego z tych atrybutów:

Poniżej znajdziesz przykład skryptu Robo, który jest uruchamiany, gdy na ekranie pojawia się widżet interfejsu o identyfikatorze zasobu "my.app.package:id/page_header":

{
  "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 aktywowany przez element "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"
    }
  ]
}

Poniżej znajdziesz 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" : "WAIT",
      "delayTime" : 5000
    }]
}

Działania

Każde działanie w skrypcie Robo jest reprezentowane jako pakiet składający się z co najmniej 1 pary atrybut–wartość, które opisano w tabeli poniżej:

Poniżej znajdziesz przykład skryptu Robo z 2 działaniami bez docelowych widżetów interfejsu, co oznacza, że te działania nie są wykonywane na konkretnym widżecie interfejsu:

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

Deskryptory elementów

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

Często te atrybuty są niezdefiniowane, np. przycisk może nie mieć tekstu ani 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 użycie ich różnych pozycji podrzędnych w widżecie nadrzędnym. Oznacza to, że użycie tylko jednego deskryptora elementu do zidentyfikowania widżetu interfejsu jest zwykle niewystarczające. 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 – widżetowi nadrzędnemu 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 z działaniami polegającymi na zmianie tekstu i kliknięciu. W obu przypadkach musisz zidentyfikować docelowy widżet interfejsu 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

Możesz opcjonalnie poprzedzić listę działań w skrypcie Robo obiektem JSON, który określa opcje wykonywania tego skryptu. Ten nagłówek konfiguracji zaczyna się od słowa kluczowego roboscript, po którym następuje reprezentacja JSON żądanych opcji wykonywania.

Skrypty Robo obsługują te opcje wykonywania:

• executionMode – opcje wykonywania stosowane podczas działania skryptu Robo:
  • strict – jeśli ustawisz wartość true, skrypt Robo nie będzie używać dopasowania częściowego, pomijania bieżącego działania ani zawieszania. Oznacza to, że skrypt Robo jest wykonywany jako zwykły test z instrumentacją i kończy się niepowodzeniem, gdy tylko nie uda się wykonać któregoś z działań. Domyślnie jest to false.
  • dismiss_popups – jeśli ustawisz wartość true, test Robo będzie odrzucać wszystkie nieoczekiwane okna podczas wykonywania skryptu Robo, nawet w trybie strict. Ta opcja nie działa, gdy nie jesteś w trybie strict. Domyślnie jest to false.
  • notify – jeśli ustawisz wartość false, skrypt Robo nie będzie wyświetlać powiadomień na ekranie na początku i na końcu wykonywania. Domyślna wartość to true.
• postscript – opcje wykonywania stosowane po zakończeniu skryptu Robo:
  • terminate – jeśli ustawisz wartość true, test Robo przestanie indeksować po zakończeniu skryptu Robo. Domyślnie jest to false.

Oto przykład skryptu Robo wykonywanego w trybie strict bez powiadomień na ekranie, który czeka 3 sekundy, po czym indeksowanie zostaje zatrzymane:

"roboscript": {
  "executionMode": {
    "strict": true,
    "notify": false
  },
  "postscript": {
    "terminate": true
  }
}
[
  {
    "eventType": "WAIT",
    "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 i znakiem procentu, a na końcu mają znak procentu i podwójne podkreślenie.

Skrypty Robo obsługują ten parametr szablonu:

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

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

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

Komentarze

Skrypt Robo może zawierać wiersze komentarzy, które zaczynają się od # 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"
      }
    ]
  }
]

Uprawnienia

Domyślnie skrypt Robo pozostaje aktywny, dopóki nie zostaną wykonane (lub przynajmniej podjęte) wszystkie jego działania. Test Robo próbuje dopasować działanie skryptu Robo za każdym razem, gdy wybiera działanie do wykonania. Skrypt Robo wykorzystuje te techniki, aby zwiększyć niezawodność:

Priorytety

Jeśli skrypt Robo osiągnie limit maxNumberOfRuns, nie będzie już mógł zostać uruchomiony podczas danego indeksowania. Jeśli w bieżącym kontekście można uruchomić więcej niż 1 skrypt Robo, priorytet jest określany przez wybranie w następującej kolejności skryptu Robo, który:

1. ma atrybut contextDescriptor,
2. ma najwyższy priority (domyślnie wszystkie skrypty Robo mają ten sam priority wykonania wynoszący 1).
3. Pojawia się najwcześniej na liście skryptów Robo, jeśli priorytety skryptów Robo są takie same.

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

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

Gdy testowana aplikacja działa na pierwszym planie, Robo uruchamia kolejno:

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.

Powtarzane uruchomienia

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

Oto 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 Robo można stosować na różnych etapach danego indeksowania Robo:

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

Poniżej znajduje się przykład skryptu Robo, który czyści dane użytkownika testowanej aplikacji, zanim Robo zacznie ją indeksować:

{
  "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, aby kliknął "Cancel", gdy próbuje wrócić z okna 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ą, jak Robo je wykonuje:

Po uruchomieniu skrypt Robo wykonuje działania bezwarunkowe jedno po drugim 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 do wykonania. Jeśli zostanie wywołane i wybrane dowolne działanie warunkowe na podstawie jego priorytetu i pozostałej liczby uruchomień, skrypt Robo wykona to działanie warunkowe. W przeciwnym razie skrypt Robo wykona następne 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 okienka, jeśli pojawią się w dowolnym momencie 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": "WAIT",
      "delayTime": 10000
    },
    {
      "description": "Screen on",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 82"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "WAIT",
      "delayTime": 10000
    }
}

Ignorowanie działań

Skrypt Robo może zawierać instrukcje, które nakazują Robo ignorowanie określonych widżetów interfejsu lub wszystkich widżetów interfejsu na danym ekranie. Te instrukcje są reprezentowane jako ignorowanie „działań” odpowiednio za pomocą 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, które są celem działań ignorowania (chyba że inne działanie skryptu Robo sprawi, że Robo wykona działanie na jednym z ignorowanych widżetów interfejsu).

Skrypt Robo może zawierać kombinację działań ignorowanych, warunkowych i bezwarunkowych. W przeciwieństwie do innych działań skryptu Robo działania ignorowania są stosowane, dopóki contextDescriptor skryptu Robo, który je zawiera, 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 o identyfikatorze zasobu "my.app.package:id/ignored_screen". Drugi skrypt Robo sprawia, że Robo ignoruje widżety interfejsu, których identyfikatory zasobów pasują do wyrażenia regularnego Javy ".*: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 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. Ponieważ rozmiar ekranu i liczba przesunięć wymaganych do dotarcia do tego elementu podrzędnego różnią się w zależności od formatu urządzenia, znacznie lepiej jest polegać na pozycji danych elementu podrzędnego, która jest bezwzględna. Mniej niezawodne jest poleganie na liczbie przesunięć wymaganych do wyświetlenia tego elementu podrzędnego na ekranie, a następnie użycie jego pozycji na ekranie.

Dlatego skrypt Robo rejestruje bezwzględne pozycje danych elementów podrzędnych 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ą obiektami docelowymi 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 odpowiedni element podrzędny jest wyświetlany na ekranie, wykonując działanie pozycjonowania na zawierającym go elemencie RecyclerView lub AdapterView.

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

Oto przykład działania kliknięcia na 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 elementu podrzędnego 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
    }
  ]
}

Nagrywanie skryptu Robo w Android Studio i uruchamianie go w Test Lab

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

Gdy uruchamiasz test Robo z dołączonym skryptem, test Robo najpierw wykonuje działania określone w skrypcie, a następnie sprawdza aplikację w zwykły sposób.

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

Działania skryptu Robo

Do wszystkich działań ma zastosowanie ten wspólny atrybut opcjonalny:

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

Asercja

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

W tabeli poniżej znajdziesz wymagane atrybuty:

Oto przykład asercji skryptu Robo, która sprawdza, czy testowana aplikacja działa na pierwszym planie:

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

Poniżej znajdziesz przykład asercji skryptu Robo, która sprawdza, czy na ekranie znajduje się widżet interfejsu o identyfikatorze 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 asercji skryptu Robo, która sprawdza, czy "Settings" NIE jest wykrywany na ekranie za pomocą OCR:

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

Kliknij

W tabeli poniżej znajdziesz wymagane atrybuty:

Poniżej znajduje się przykład działania skryptu Robo, które klika przycisk o identyfikatorze zasobu "com.google.samples.apps.topeka:id/done":

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

Poniżej znajduje się przykład działania skryptu Robo, które klika drugie wystąpienie słowa "Search" wykrytego na ekranie za pomocą OCR:

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

Poniżej znajdziesz przykład działania skryptu Robo, które klika element klawiatury ekranowej 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ę ekranową

W tabeli poniżej znajdziesz wymagane atrybuty:

Poniżej znajdziesz przykład działania skryptu Robo, które wyłącza klawiaturę ekranową:

{
  "eventType": "DISABLE_KEYBOARD"
}

Wykonaj polecenie powłoki adb

W tabeli poniżej znajdziesz wymagane atrybuty:

Ten atrybut jest opcjonalny:

• expectedOutputRegex – oczekiwane dane wyjściowe polecenia jako wyrażenie regularne w języku Java. Jeśli dane wyjściowe nie będą się zgadzać, działanie skryptu Robo zakoń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 powoduje wyczyszczenie danych użytkownika testowanej aplikacji:

{
  "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, aby zapewnić zgodność wsteczną z Espresso Test Recorder. Test Robo przyznaje wszystkie uprawnienia testowanej aplikacji na początku każdego indeksowania, więc to działanie nie ma żadnego efektu. NIE używaj tego działania w skryptach Robo.

W tabeli poniżej znajdziesz wymagane atrybuty:

Ignorowanie wszystkich elementów na ekranie

To działanie sprawia, że Robo ignoruje wszystkie elementy na każdym ekranie, który aktywuje zawierający je skrypt Robo.

W tabeli poniżej znajdziesz wymagane atrybuty:

Oto 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 sprawia, że Robo ignoruje element (lub elementy) pasujące do określonego elementDescriptors.

W tabeli poniżej znajdziesz wymagane atrybuty:

Ten atrybut jest opcjonalny:

• ignoreChildren – jeśli ustawisz wartość true, Robo będzie ignorować też wszystkie elementy podrzędne ignorowanych widżetów interfejsu. Domyślnie jest to false.

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

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

Wprowadzany tekst

W tabeli poniżej znajdziesz wymagane atrybuty:

Poniżej znajduje się przykład działania skryptu Robo, które wprowadza "John" do widżetu interfejsu 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

W tabeli poniżej znajdziesz wymagane atrybuty:

Ten atrybut jest opcjonalny:

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

Poniżej znajduje się 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 jednym punktem

W tabeli poniżej znajdziesz wymagane atrybuty:

Ten atrybut jest opcjonalny:

• dragAndDrop – jeśli ustawisz wartość true, gest jednym palcem będzie wykonywać działanie przeciągania i upuszczania. Domyślnie jest to false.

Oto przykład działania gestu jednopunktowego w skrypcie Robo, które powoduje przesunięcie palcem w dół:

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

Wykonaj gest dwoma palcami

W tabeli poniżej znajdziesz wymagane atrybuty:

Oto przykład działania skryptu Robo, które wykonuje gest rozciągania:

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

wykonywanie działań IME,

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

W tabeli poniżej znajdziesz wymagane atrybuty:

Poniżej znajduje się przykład działania skryptu Robo, które wykonuje działanie IME na widżecie interfejsu 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 przycisk Wstecz.

W tabeli poniżej znajdziesz wymagane atrybuty:

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

{
  "eventType": "PRESSED_BACK"
}

Naciśnij przycisk ekranu głównego

To działanie wysyła do urządzenia zdarzenie KEYCODE_HOME.

W tabeli poniżej znajdziesz wymagane atrybuty:

Oto przykład działania skryptu Robo, które naciska przycisk ekranu głównego:

{
  "eventType": "GO_HOME"
}

Przewijanie elementu do widoku

To działanie powoduje, że test Robo przewija do przodu widżet interfejsu pasujący do określonego elementu elementDescriptors, dopóki widżet interfejsu pasujący do określonego elementu childElementDescriptors nie pojawi się na ekranie, dopóki nie będzie można już przewijać widżetu lub dopóki nie zostanie osiągnięta maksymalna liczba 50 przewinięć.

W tabeli poniżej znajdziesz wymagane atrybuty:

Oto przykład działania skryptu Robo, które przewija widżet interfejsu o identyfikatorze zasobu "my.app.package:id/scrollable_card_container", dopóki na ekranie nie pojawi się widżet interfejsu z tekstem "Orange" (lub dopóki nie będzie można już przewijać albo 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"
    }
  ]
}

Przesuń

W tabeli poniżej znajdziesz wymagane atrybuty:

Poniżej znajduje się 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"
    }
  ]
}

Zapisz zrzut ekranu

W tabeli poniżej znajdziesz wymagane atrybuty:

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

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

Kliknij punkt na ekranie.

W tabeli poniżej znajdziesz wymagane atrybuty:

Oto przykład działania skryptu Robo, które klika środek ekranu:

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

Kliknij punkt w obrębie elementu.

W tabeli poniżej znajdziesz wymagane atrybuty:

Poniżej znajduje się 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 spowoduje zatrzymanie testu Robo.

W tabeli poniżej znajdziesz wymagane atrybuty:

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

{
  "eventType": "TERMINATE_CRAWL"
}

Czekaj

W tabeli poniżej znajdziesz wymagane atrybuty:

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

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

Czekanie na element

To działanie powoduje, że test Robo czeka na pojawienie się elementu na ekranie przez określony czas.

W tabeli poniżej znajdziesz wymagane atrybuty:

Poniżej znajduje się przykład działania skryptu Robo, które czeka maksymalnie 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

• Dowiedz się, jak uruchomić skrypt Robo