Robo-Script-Referenzhandbuch

Dieses Dokument enthält Referenzinformationen zu Robo-Scripts, einschließlich Struktur, Funktionen, Verwendung, Aufzeichnung und Aktionen. Robo-Skripts sind Tests, die manuelle Aufgaben zur Qualitätssicherung (QA) für mobile Apps automatisieren und Strategien für Continuous Integration (CI) und Pre-Launch-Tests ermöglichen. Ein Roboscript ist eine JSON-Datei, die eine Abfolge von Benutzeroberfläche (UI) und anderen Aktionen beschreibt.

So erstellen Sie ein Robo-Script:

  • Verwenden Sie die Funktion zum Aufzeichnen von Robo-Scripts. (nur Android)

  • Erstellen Sie das Robo-Script manuell. (Android und iOS und höher)

  • Nehmen Sie das Robo-Script auf und bearbeiten Sie es dann manuell. (Nur Android)

Weitere Informationen zur Verwendung von Robo-Scripts finden Sie unter Robo-Script ausführen.

Einführung

Das Robo-Script wird zusammen mit anderen Eingaben wie dem Android-Anwendungspaket (APK) der zu testenden App für den Robo-Test bereitgestellt.

Im Folgenden finden Sie ein Beispiel für ein Robo-Script, mit dem ein Nutzer in einer App angemeldet wird. Es wird ausgelöst, wenn die getestete App gestartet wird:

[
  {
    "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"
          }
        ]
      }
    ]
  }
]

Wenn sich in einer Datei ein einzelnes Robo-Skript befindet und es die Standard-Auslösebedingung app_under_test_shown wie im obigen Beispiel hat, können Sie das Robo-Skript in einer Datei in einem einfacheren Format angeben, genau wie bei den Aktionen:

[
  {
    "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"
      }
    ]
  }
]

iOS+ Unterstützung für Robo-Scripts

Robo for iOS+ (Beta) bietet eingeschränkte Unterstützung für Robo-Scripts. Die Robo-Script-Syntax für iOS und höher ist mit der Android-Syntax identisch und die unterstützten iOS- und höher-Funktionen verhalten sich ähnlich wie ihre Android-Entsprechungen.

Die folgenden Aktionen werden unter iOS und höher unterstützt:

  • Behauptung
  • Klick
  • Langes Drücken
  • Wischen
  • Alle Elemente ignorieren
  • Warten
  • Screenshot erstellen
  • Crawling beenden

Die folgenden identifizierenden Attribute in Elementbeschreibungen werden unter iOS und höher unterstützt:

  • Klassenname
  • Name der übergeordneten Klasse
  • Inhaltsbeschreibung (und regulärer Ausdruck)
  • Text (und Regex)

Die folgenden Triggerbedingungen in Kontextdeskriptoren werden in iOS+ unterstützt:

  • Zu testende App angezeigt
  • Element vorhanden
  • Ausführung einer anderen Script-Aktion als Robo

Struktur

Ein Robo-Script hat mehrere Attribute, die beschreiben, wie Robo es ausführt. Die meisten dieser Attribute sind optional und haben vordefinierte Standardwerte:

Attribut Beschreibung
id Eine Ganzzahl, mit der sich dieses Robo-Script in Crawling-Ausgaben verfolgen lässt. Robo hat integrierte Robo-Scripts mit eigenen ids. Obwohl dieselbe id in verschiedenen Robo-Scripts deren Verhalten nicht beeinflusst, kann es schwierig sein, Aktionen aus diesen Robo-Scripts in Crawling-Ausgaben zu unterscheiden. Wir empfehlen, Ihren Robo-Scripts eine eindeutige id von 1000 oder höher zuzuweisen, um Konflikte zu vermeiden.
description Ähnlich wie id, aber aussagekräftiger.
crawlStage Die Phase eines Crawlings, in der Robo dieses Robo-Script anwendet. Standardmäßig ist dies die Hauptcrawlphase.
priority Die Priorität dieses Robo-Scripts im Vergleich zu anderen Robo-Scripts. Standardmäßig haben alle Robo-Scripts die Priorität 1.
maxNumberOfRuns Gibt an, wie oft Robo dieses Robo-Script während eines Crawlings ausführen kann. Standardmäßig kann Robo ein Robo-Script nur einmal ausführen.
contextDescriptor Beschreibt den Kontext oder die Bedingung, die dieses Robo-Script auslöst. Wenn keine Angabe gemacht wird, wird die Auslösebedingung dieses Robo-Skripts als immer erfüllt angesehen. Mit anderen Worten, das Robo-Skript ist unbedingt.
actions Alle Aktionen dieses Robo-Scripts.

Eine einzelne Datei enthält eine Sammlung von einem oder mehreren Robo-Skripts.

Das folgende Beispiel zeigt eine Datei mit zwei bedingungslosen Robo-Skripts, jedes mit einer einzelnen Aktion, die einmal zu Beginn eines Crawlings ausgeführt wird:

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

Kontextdeskriptor

Ein Kontextbeschreiber definiert den Kontext oder die Bedingung, die ein Roboscript mit einem oder einer Kombination mehrerer Attribute auslöst:

Attribut Beschreibung
"condition": "always" Löst immer ein Robo-Script aus.
"condition": "element_present" Prüft, ob ein UI-Widget auf dem Bildschirm vorhanden ist, das mit elementDescriptors oder dem durch visionText angegebenen Text übereinstimmt.
"condition": "element_disabled" Prüft, ob ein UI-Widget, das mit elementDescriptors übereinstimmt, auf dem Bildschirm angezeigt wird und nicht interaktiv ist.
"condition": "element_checked" Prüft, ob ein UI-Widget, das mit elementDescriptors übereinstimmt, auf dem Bildschirm vorhanden und angeklickt ist.
"condition": "app_under_test_shown" Prüft, ob die getestete App im Vordergrund ausgeführt wird.
"condition": "default_launcher_shown" Prüft, ob der Startbildschirm eines Geräts angezeigt wird, d. h., ob keine Apps im Vordergrund ausgeführt werden.
"condition": "non_roboscript_action_performed" Prüft, ob die letzten nonRoboscriptActionCount aufeinanderfolgenden Aktionen des Robo-Tests keine Robo-Script-Aktionen sind.
negateCondition Wenn true festgelegt ist, wird condition negiert. Mit diesem Attribut können Sie beispielsweise prüfen, ob ein UI-Widget NICHT auf dem Bildschirm angezeigt wird oder ob die getestete App NICHT im Vordergrund ausgeführt wird.
elementDescriptors Ein oder mehrere Elementdeskriptoren, die ein UI-Widget auf dem Bildschirm identifizieren. Sie wird in Kombination mit den Bedingungen element_present, element_disabled und element_checked verwendet. Schließt sich mit visionText gegenseitig aus. Weitere Informationen finden Sie unter Elementdeskriptoren.
visionText Text auf dem Bildschirm wird mithilfe der Optical Character Recognition API (OCR) erkannt. visionText wird in Kombination mit der Bedingung element_present verwendet. Schließt sich mit elementDescriptors gegenseitig aus.
nonRoboscriptActionCount Die Anzahl der zuvor ausgeführten Nicht-Robo-Skript-Aktionen. Sie wird in Kombination mit der Bedingung non_roboscript_action_performed verwendet, um nach jeder nonRoboscriptActionCount-Robo-Aktion ein Robo-Script auszulösen. Standardmäßig ist das 1.

Im folgenden Beispiel wird ein Robo-Script durch ein UI-Widget mit der Ressourcen-ID "my.app.package:id/page_header" auf dem Bildschirm ausgelöst:

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

Im folgenden Beispiel wird ein Robo-Script durch "Privacy Policy" ausgelöst, das mithilfe der optischen Zeichenerkennung (OCR) erkannt wird:

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

Im folgenden Beispiel wird nach jeder Robo-Aktion, die nicht im Script enthalten ist, 5 Sekunden gewartet:

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

Aktionen

Jede Aktion in einem Robo-Script wird als Bündel aus einem oder mehreren Attribut-Wert-Paaren dargestellt, die in der folgenden Tabelle beschrieben werden:

Attribut Beschreibung
eventType Gibt den Aktionstyp an, z. B. Klick, Textbearbeitung usw. Für jede Aktion erforderlich.
elementDescriptors Beschreibungen, die ein UI-Widget identifizieren. Erforderlich für alle Aktionen, die ein Ziel-UI-Widget haben, z. B. das Klicken auf eine bestimmte Schaltfläche.
optional Ist das Flag auf true gesetzt, wird diese Aktion übersprungen, wenn sie nicht ausgeführt werden kann. Diese Aktion wird beispielsweise übersprungen, wenn das Ziel-UI-Widget auf einem Bildschirm nicht gefunden wird, ohne dass das enthaltene RoboScript fehlschlägt. Der Standardwert ist false.
replacementText Der Text, der in das Ziel-UI-Widget eingegeben werden soll. Erforderlich für Aktionen zur Textbearbeitung.
swipeDirection Gibt die Richtung der Wischbewegung an. Erforderlich für Wischaktionen.
delayTime Gibt an, wie lange gewartet werden soll, in Millisekunden. Erforderlich für Warteaktionen.
pointTapXCoordinate und pointTapYCoordinate Die X- und Y-Koordinaten des Pixels des angetippten Punkts. Schließt sich gegenseitig mit pointTapXPercent und pointTapYPercent aus. Erforderlich für Aktionen vom Typ „Punkt antippen“.
pointTapXPercent und pointTapYPercent Die X- und Y-Koordinaten des angetippten Punkts in Prozent. Schließt sich mit pointTapXCoordinate und pointTapYCoordinate gegenseitig aus. Erforderlich für Aktionen beim Punkttippen.

Das folgende Beispiel zeigt ein Robo-Skript mit zwei Aktionen ohne Ziel-UI-Widgets. Das bedeutet, dass diese Aktionen nicht auf einem bestimmten UI-Widget ausgeführt werden:

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

Elementdeskriptoren

Ein Element-Descriptor identifiziert ein UI-Widget anhand eines oder mehrerer der folgenden identifizierenden Attribute:

Attribut Beschreibung
className –
ancestorClassName Klassenname des übergeordneten Elements in der UI-Hierarchie. Ein übergeordnetes Element ist jeder übergeordnete Knoten in der UI-Hierarchie des Elements, einschließlich des Elements selbst.
resourceId –
resourceIdRegex Java-regulärer Ausdruck, der mit resourceId übereinstimmen soll.
contentDescription –
contentDescriptionRegex Regulärer Java-Ausdruck für contentDescription.
text (wird auf dem Bildschirm angezeigt) –
textRegex Regulärer Java-Ausdruck für text.
groupViewChildPosition, recyclerViewChildPosition oder adapterViewChildPosition Stellt die untergeordnete Position eines UI-Widgets dar, je nach Art des übergeordneten Widgets.

Häufig sind diese Attribute nicht definiert. Eine Schaltfläche hat beispielsweise möglicherweise keine Text- und Inhaltsbeschreibung. Auch wenn einige Attributwerte vorhanden sind, sind sie auf einem bestimmten App-Bildschirm (einschließlich resourceId) möglicherweise nicht eindeutig.

Beispielsweise ist es in der Regel nur möglich, zwischen Elementen einer Liste zu unterscheiden, indem die verschiedenen untergeordneten Positionen im übergeordneten Widget verwendet werden. Das bedeutet, dass die Verwendung nur eines Elementdeskriptors zur Identifizierung eines UI-Widgets in der Regel nicht ausreicht. Das elementDescriptors-Attribut einer Aktion enthält daher eine Sequenz von Elementbeschreibern, die so angeordnet sind, dass der erste dem Ziel-UI-Widget entspricht, der zweite dem übergeordneten Widget des Ziel-UI-Widgets usw. Das Ziel-UI-Widget einer Aktion wird zugeordnet, wenn alle ihre Elementdeskriptoren mit der entsprechenden untergeordneten Hierarchie des UI-Widgets übereinstimmen.

Im folgenden Beispiel wird ein Robo-Script mit einer Textänderung und Klickaktionen gezeigt. Für beide Aktionen müssen Sie das Ziel-UI-Widget anhand der bereitgestellten Elementbeschreibungen identifizieren:

[
  {
    "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"
      }
    ]
  }
]

Ausführungsoptionen

Optional können Sie der Liste der Aktionen in einem Robo-Skript ein JSON-Objekt voranstellen, das die Ausführungsoptionen für dieses Robo-Skript angibt. Dieser Konfigurationsheader beginnt mit dem Schlüsselwort roboscript, gefolgt von einer JSON-Darstellung der gewünschten Ausführungsoptionen.

Robo-Scripts unterstützen die folgenden Ausführungsoptionen:

  • executionMode: Ausführungsoptionen, die beim Ausführen eines Robo-Scripts angewendet werden:
    • strict: Wenn diese Option auf true festgelegt ist, werden im Robo-Script keine teilweisen Übereinstimmungen, das Überspringen der aktuellen Aktion und die Aussetzung verwendet. Das heißt, das Robo-Skript wird als regulärer Instrumentierungstest ausgeführt und schlägt fehl, sobald eine seiner Aktionen nicht ausgeführt werden kann. Der Standardwert ist false.
    • dismiss_popups: Wenn diese Option auf true festgelegt ist, schließt der Robo-Test alle unerwarteten Dialoge beim Ausführen des Robo-Scripts auch im strict-Modus. Diese Option hat keine Auswirkungen, wenn Sie sich nicht im strict-Modus befinden. Standardmäßig ist das false.
    • notify: Wenn das Robo-Script auf false gesetzt ist, zeigt es zu Beginn und am Ende der Ausführung keine Bildschirmbenachrichtigungen an. Standardmäßig ist das true.
  • postscript – Ausführungsoptionen, die nach Abschluss eines Robo-Scripts angewendet werden:
    • terminate: Wenn diese Option auf true gesetzt ist, wird das Crawling nach Abschluss des Robo-Scripts beendet. Der Standardwert ist false.

Im Folgenden finden Sie ein Beispiel für ein Robo-Script, das im strict-Modus ohne Benachrichtigungen auf dem Bildschirm ausgeführt wird und drei Sekunden lang inaktiv ist, bevor das Crawling beendet wird:

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

Vorlagenparameter

Ein Vorlageparameter ist ein Platzhalter in einem Robo-Script, der durch den tatsächlichen Wert ersetzt wird, wenn das Robo-Script für die Ausführung vom Robo-Test geladen wird. Vorlagenparameter beginnen mit einem doppelten Unterstrich, gefolgt von einem Prozentzeichen, und enden mit einem Prozentzeichen, gefolgt von einem doppelten Unterstrich.

Robo-Scripts unterstützen die folgenden Vorlagenparameter:

  • __%APP_PACKAGE_NAME%__: Paketname der getesteten App.

Im Folgenden finden Sie ein Beispiel für ein Robo-Script, mit dem der Prozess der zu testenden App angehalten wird:

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

Kommentare

Ein Robo-Script kann Kommentarzeilen enthalten, bei denen es sich um Zeilen handelt, die mit # oder // beginnen.

Im Folgenden finden Sie ein Beispiel für ein Robo-Script mit einigen Kommentaren:

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

Leistungsspektrum

Standardmäßig bleibt das Robo-Script aktiv, bis alle Aktionen eines Robo-Scripts abgeschlossen sind (oder zumindest versucht wurden). Der Robo-Test versucht immer wieder, eine Robo-Script-Aktion abzugleichen, wenn er eine auszuführende Aktion auswählt. Das Robo-Script verwendet die folgenden Techniken, um die Robustheit zu erhöhen:

Technik Beschreibung
Teilweise Übereinstimmung Wenn die aktuelle Robo-Script-Aktion nicht vollständig übereinstimmt, werden die Abgleichskriterien gelockert und der Abgleich wird wiederholt. Bei der teilweisen Übereinstimmung wird der äußerste Elementbeschreiber nicht berücksichtigt, wenn das Ziel-UI-Widget einer Robo-Script-Aktion abgeglichen wird.

Wenn die teilweise Übereinstimmung erfolgreich ist, wird die entsprechende Robo-Script-Aktion wie gewohnt ausgeführt. Diese Methode unterstützt Szenarien, in denen sich die App-Struktur ändert, z. B. zwischen App-Versionen, wenn Bildschirmelemente neu angeordnet werden.

Aktuelle Aktion überspringen Wenn die aktuelle Robo-Script-Aktion nicht vollständig oder teilweise übereinstimmt, versucht Robo, die nachfolgende Robo-Script-Aktion abzugleichen. Wenn die nachfolgende Aktion vollständig oder teilweise übereinstimmt, überspringt der Robo-Test die aktuelle Robo-Skriptaktion (und kehrt nie wieder zurück) und führt die nachfolgende Aktion aus.

Diese Methode unterstützt Szenarien, in denen sich das App-Verhalten zwischen den Versionen ändert oder instabil ist, z. B. wenn ein Dialogfeld während der Aufzeichnung und der Wiedergabe eines Robo-Scripts auf verschiedenen Bildschirmen erscheint.

Anhalten Wenn weder die aktuellen noch die nachfolgenden Robo-Script-Aktionen vollständig oder teilweise abgeglichen werden können, wird das Robo-Script vorübergehend angehalten und der Robo-Test wählt eine Aktion aus, die mithilfe der anderen Strategien ausgeführt werden soll. Nach Abschluss dieser Aktion wird die Ausführung des Robo-Scripts im Robo-Test fortgesetzt.

Solange aktuelle oder nachfolgende Robo-Script-Aktionen nicht abgeglichen werden können, bleibt das Robo-Script für eine beliebige Anzahl von Aktionen ausgesetzt. Robo-Scripts müssen also nicht unbedingt ein Prolog für einen Robo-Test sein. Sie können Robo-Script-Aktionen auch mit Standard-Robo-Test-Aktionen kombinieren. Diese Technik unterstützt Szenarien, in denen das App-Verhalten instabil ist oder wenn die Änderungen zwischen den App-Versionen so groß sind, dass der Robo-Test die Lücken mit den Standardaktionen füllen muss.

Prioritäten

Wenn ein Robo-Script seinen maxNumberOfRuns erreicht, kann es in einem bestimmten Crawling nicht mehr ausgelöst werden. Wenn durch den aktuellen Kontext mehrere Robo-Scripts ausgelöst werden können, wird das Robo-Script mit der folgenden Priorität ausgewählt:

  1. Hat ein contextDescriptor-Attribut.
  2. Hat die höchste priority. Standardmäßig haben alle Robo-Scripts dieselbe Ausführungs-priority von 1.
  3. Erscheint am frühesten in der Liste der Robo-Skripte, wenn die Prioritäten der Robo-Skripte identisch sind.

Das folgende Beispiel zeigt eine Datei mit drei Robo-Skripts, die dieselbe Aktion ausführen und durch dieselbe Bedingung ausgelöst werden – die zu testende App im Vordergrund:

[
  {
    "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
      }
    ]
  }
]

Wenn sich die zu testende App im Vordergrund befindet, löst Robo in der Reihenfolge Folgendes aus:

  1. "Robo script 2", da er die höchste Priorität hat.
  2. "Robo script 1", da es unter den verbleibenden anwendbaren Robo-Scripts mit derselben Priorität früher erscheint.
  3. "Robo script 3" als letztes anwendbares Robo-Script.

Wiederholte Ausführungen

Standardmäßig löst Robo während eines Crawlings höchstens einmal ein Robo-Script aus. Dies kann über das Attribut maxNumberOfRuns angepasst werden.

Im folgenden Beispiel wird ein Robo-Script verwendet, mit dem die getestete App bis zu zehnmal im Hintergrund ausgeführt wird:

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

Crawling-Phase

Robo-Scripts können in verschiedenen Phasen eines bestimmten Robo-Crawlings angewendet werden:

Crawling-Phase Beschreibung
pre_crawl Bevor Robo startet und mit dem Crawlen der zu testenden App beginnt
post_crawl Nachdem Robo das Crawling der zu testenden App abgeschlossen hat. Ein post_crawl-Roboscript darf eine Dauer von 15 Sekunden nicht überschreiten, da der Crawlingvorgang andernfalls aufgrund eines Zeitlimits beendet wird.
crawl Die Haupt-Crawling-Phase, in der Robo die zu testende App crawlt.
close_screen Wenn Robo versucht, von einem bestimmten Bildschirm zurückzukehren (Backtracking), werden alle möglichen Aktionen auf diesem Bildschirm geprüft. Standardmäßig drückt Robo auf die Schaltfläche „Zurück“, was in einigen Fällen nicht gewünscht ist.

Wenn das Attribut crawlStage eines Robo-Skripts nicht angegeben ist, wird es als crawl angenommen.

Im Folgenden finden Sie ein Beispiel für ein Robo-Script, mit dem die Nutzerdaten der getesteten App gelöscht werden, bevor Robo mit dem Crawling beginnt:

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

Im folgenden Beispiel wird ein Robo-Script gezeigt, das Robo anweist, auf "Cancel" zu klicken, wenn es versucht, von einem Bestätigungsdialogfeld zurückzukehren:

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

Mit Bedingungen verknüpfte Aktionen

Ein Robo-Script kann bedingte Aktionen enthalten. Bedingte Aktionen haben drei zusätzliche Attribute, die beschreiben, wie Robo sie ausführt:

Attribut Beschreibung
priority Die Priorität dieser bedingten Aktion im Vergleich zu anderen bedingten Aktionen im zugehörigen Robo-Script. Standardmäßig haben alle bedingten Aktionen die Priorität 1.
maxNumberOfRuns Gibt an, wie oft diese bedingte Aktion bei einer Ausführung des enthaltenen Robo-Scripts ausgeführt werden kann. Standardmäßig können alle bedingten Aktionen bei einer einzelnen Ausführung des zugehörigen Robo-Scripts höchstens einmal ausgeführt werden.
contextDescriptor Der Kontext/die Bedingung, die diese bedingte Aktion auslöst. Es hat dieselbe Struktur und bietet ähnliche Funktionen wie der Kontextdeskriptor des Robo-Skripts.

Wenn ein Robo-Script ausgelöst wird, führt es seine nicht bedingten Aktionen nacheinander in der Reihenfolge aus, in der sie vorkommen. Wenn ein Robo-Script bedingte Aktionen enthält, werden diese jedes Mal berücksichtigt, bevor eine nicht bedingte Aktion ausgewählt wird. Wenn eine bedingte Aktion ausgelöst und basierend auf ihrer Priorität und der verbleibenden Anzahl von Ausführungen ausgewählt wird, führt das Robo-Script diese bedingte Aktion aus. Andernfalls führt das Robo-Script die folgende nicht bedingte Aktion aus. Ein Robo-Script muss mindestens eine nicht bedingte Aktion enthalten, um gültig zu sein.

Das folgende Beispiel zeigt ein bedingungsloses Robo-Script mit einer bedingten Aktion, mit der Pop-up-Dialogfelder geschlossen werden, wenn sie während der Ausführung des Robo-Skripts angezeigt werden:

{
  "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
    }
}

Ignorierte Aktionen

Ein Robo-Script kann Anweisungen für Robo enthalten, bestimmte UI-Widgets oder alle UI-Widgets auf einem bestimmten Bildschirm zu ignorieren. In dieser Anleitung werden „Aktionen“ mit eventType ELEMENT_IGNORED und ALL_ELEMENTS_IGNORED ignoriert.

Wenn das contextDescriptor-Attribut eines Robo-Scripts mit ignorierten Aktionen mit einem bestimmten Bildschirm übereinstimmt, interagiert Robo nicht mit UI-Widgets, auf die die ignorierten Aktionen ausgerichtet sind, es sei denn, eine andere Robo-Script-Aktion veranlasst Robo, eine Aktion auf einem der ignorierten UI-Widgets auszuführen.

Ein Robo-Script kann eine Mischung aus ignorierenden, bedingten und nicht bedingten Aktionen enthalten. Im Gegensatz zu anderen Robo-Script-Aktionen werden ignorierende Aktionen angewendet, solange das contextDescriptor des enthaltenen Robo-Scripts während eines Robo-Crawlings mit einem Bildschirm übereinstimmt, unabhängig von den Werten der Attribute priority und maxNumberOfRuns.

Im Folgenden finden Sie ein Beispiel für eine Datei mit zwei Robo-Skripten. Durch das erste Robo-Skript ignoriert Robo alle UI-Widgets auf einem Bildschirm, der ein UI-Widget mit der Ressourcen-ID "my.app.package:id/ignored_screen" enthält. Im zweiten Robo-Script wird Robo angewiesen, UI-Widgets zu ignorieren, deren Ressourcen-IDs mit dem Java-Regex ".*:id/done" auf einem Bildschirm mit einem UI-Widget mit der Ressourcen-ID "my.app.package:id/main_screen" übereinstimmen:

[
  {
    "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"
          }
        ]
      }
    ]
  }
]

Unterstützung für RecyclerView und AdapterView

Untergeordnete Elemente von RecyclerView- und AdapterView-Widgets werden dynamisch geladen und können sich viele Wischbewegungen vom aktuellen Bildschirm entfernt befinden. Da die Größe eines Bildschirms und die Anzahl der Wischbewegungen, die zum Erreichen dieses untergeordneten Elements erforderlich sind, je nach Formfaktor des Geräts variieren, ist es viel robuster, sich auf die absolute Datenposition des untergeordneten Elements zu verlassen. Weniger robust ist es, sich auf die Anzahl der Wischbewegungen zu verlassen, die erforderlich sind, um dieses untergeordnete Element auf dem Bildschirm zu sehen, und dann seine Position auf dem Bildschirm zu verwenden.

Daher erfasst das Robo-Script die absoluten Datenpositionen der RecyclerView-Kinder, die Ziele von Robo-Script-Aktionen sind, als recyclerViewChildPosition. Robo-Script erfasst auch die absoluten Datenpositionen von AdapterView-Untergeordneten, die Ziele von Robo-Script-Aktionen als adapterViewChildPosition sind.

Aktionen für untergeordnete RecyclerView- und AdapterView-Elemente werden in den folgenden Schritten ausgeführt:

  1. Durch den Robo-Test wird sichergestellt, dass das entsprechende untergeordnete Element über eine Positionierungsaktion auf dem enthaltenden RecyclerView oder AdapterView auf dem Bildschirm angezeigt wird.

  2. Beim Robo-Test wird die aufgezeichnete Aktion direkt auf dem untergeordneten Element ausgeführt, da es bereits auf dem Bildschirm angezeigt wird.

Das folgende Beispiel zeigt eine Klickaktion für ein untergeordnetes AdapterView-Element (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
    }
  ]
}

Im Folgenden finden Sie ein Beispiel für eine Klickaktion auf ein untergeordnetes 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
    }
  ]
}

Zeichne ein Robo-Script in Android Studio auf und führe es in Test Lab aus

Sie können in Android Studio ein Robo-Script erstellen, das als JSON-Datei gespeichert wird. Anschließend können Sie die JSON-Datei mit der Anwendung in Firebase Test Lab hochladen und den Test entsprechend ausführen.

Wenn Sie einen Robo-Test mit einem angehängten Script ausführen, führt der Robo-Test zuerst die vordefinierten Aktionen aus und prüft dann die App wie gewohnt.

Führen Sie die Schritte unter Robo-Script mit Test Lab in Android Studio aufzeichnen aus, um eine Robo-Script-JSON-Datei in Android Studio zu erstellen.

Robo-Script-Aktionen

Das folgende optionale Attribut gilt für alle Aktionen:

  • description: Hilft, die Ausführung dieser Robo-Script-Aktion in den Robo-Testausgaben zu verfolgen.

Behauptung

Wenn die behauptete Bedingung wahr ist, fährt das Robo-Script mit der nächsten Aktion fort, die eine weitere Behauptung sein kann. Andernfalls wird die Ausführung des Robo-Scripts aufgrund einer fehlgeschlagenen Assertion angehalten.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "ASSERTION" --
contextDescriptor Beschreibt den beanspruchten Kontext oder die Bedingung. Sie hat dieselbe Struktur und bietet ähnliche Funktionen wie der contextDescriptor des Robo-Scripts.

Im folgenden Beispiel wird mit einer Robo-Script-Bestätigung geprüft, ob sich die zu testende App im Vordergrund befindet:

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

Im folgenden Beispiel wird mit einer Robo-Script-Bestätigung geprüft, ob ein UI-Widget mit der Ressourcen-ID "com.google.samples.apps.topeka:id/done" auf einem Bildschirm vorhanden ist:

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

Im folgenden Beispiel wird mit einer Robo-Script-Bestätigung geprüft, ob "Settings" mithilfe von OCR NICHT auf einem Bildschirm erkannt wird:

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

Klick

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
eventType Gibt den Typ der Robo-Script-Aktion an.
"eventType": "VIEW_CLICKED" Klickt auf das Zielelement der getesteten App.
"eventType": "SOFT_KEYBOARD_CLICK" Klickt auf das Zielelement der Soft-Tastatur.
"eventType": "SOFT_KEYBOARD_RANDOM_CLICK" Klickt bis zu maxNumberOfRuns Mal auf zufällige Elemente der Soft-Tastatur.
"eventType": "LIST_ITEM_CLICKED" Wird vom Robo-Script-Recorder in Android Studio zum Klicken auf Listenelemente verwendet.
elementDescriptors Identifiziert das angeklickte UI-Widget anhand der Android-UI-Hierarchie. Schließt sich mit visionText gegenseitig aus.
visionText Das angeklickte Element wird mithilfe von OCR identifiziert. Schließt sich gegenseitig mit elementDescriptors aus.
matchIndex Gibt den Index des Vorkommens des übereinstimmenden Zielelements an, wenn das Zielelement mit visionText identifiziert wird. Wenn 0 ausgewählt ist, wählt die Robo-Skriptaktion das erste übereinstimmende Element aus. Ist es 1, wählt die Robo-Skript-Aktion das zweite übereinstimmende Element aus und so weiter. Die Reihenfolge wird von links nach rechts und von oben nach unten bestimmt. Der Standardwert ist 0 (die erste Übereinstimmung wird ausgewählt).
maxNumberOfRuns Gibt an, wie oft auf ein zufälliges Element der Soft-Tastatur geklickt werden soll, wenn eventType = SOFT_KEYBOARD_RANDOM_CLICK ist. Der Standardwert ist 1.

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, bei der auf eine Schaltfläche mit der Ressourcen-ID "com.google.samples.apps.topeka:id/done" geklickt wird:

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

Das folgende Beispiel zeigt eine Robo-Script-Aktion, bei der auf das zweite Vorkommen des Wortes "Search" geklickt wird, das mit OCR auf einem Bildschirm erkannt wurde:

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

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, bei der auf ein Softkeyboard-Element mit einer Inhaltsbeschreibung "Emoji button" geklickt wird:

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

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, bei der bis zu fünfmal auf zufällige Elemente der Soft-Tastatur geklickt wird:

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

Bildschirmtastatur deaktivieren

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "DISABLE_KEYBOARD" --

Im Folgenden finden Sie ein Beispiel für eine Robo-Script-Aktion, mit der die Soft-Tastatur deaktiviert wird:

{
  "eventType": "DISABLE_KEYBOARD"
}

adb-Shell-Befehl ausführen

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "ADB_SHELL_COMMAND" --
command Der auszuführende ADB-Shell-Befehl (Android Debug Bridge).

Das folgende Attribut ist optional:

  • expectedOutputRegex: Die erwartete Ausgabe des Befehls als Java-regulärer Ausdruck. Wenn die Ausgabe nicht übereinstimmt, schlägt die Robo-Script-Aktion fehl. Standardmäßig ist dies ein leerer String, d. h., die Ausgabe wird nicht geprüft.

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, mit der die Nutzerdaten der getesteten App gelöscht werden:

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

Berechtigungen erteilen

Diese Aktion wird vom Robo-Script-Recorder in Android Studio aufgezeichnet, um die Abwärtskompatibilität mit dem Espresso Test Recorder zu gewährleisten. Beim Robo-Test werden der zu testenden App zu Beginn jedes Crawlings alle Berechtigungen gewährt. Daher ist diese Aktion wirkungslos. Verwenden Sie diese Aktion NICHT in Ihren Robo-Scripts.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "PERMISSIONS_REQUEST" --

Alle Elemente auf einem Bildschirm ignorieren

Durch diese Aktion ignoriert Robo alle Elemente auf einem Bildschirm, die das enthaltene Robo-Script auslösen.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "ALL_ELEMENTS_IGNORED" --

Das folgende Beispiel zeigt eine Robo-Skriptaktion, die Robo dazu bringt, alle Elemente auf einem Bildschirm zu ignorieren:

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

Elemente ignorieren

Mit dieser Aktion ignoriert Robo ein Element (oder mehrere Elemente), das bzw. die mit der angegebenen elementDescriptors übereinstimmt.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "ELEMENT_IGNORED" --
elementDescriptors Identifiziert die ignorierten UI-Widgets anhand der Android-UI-Hierarchie.

Das folgende Attribut ist optional:

  • ignoreChildren: Wenn diese Option auf true gesetzt ist, ignoriert Robo auch alle Nachkommen der ignorierten UI-Widgets. Der Standardwert ist false.

Das folgende Beispiel zeigt eine Robo-Skriptaktion, die dafür sorgt, dass Robo alle Elemente ignoriert, deren Inhaltsbeschreibungen mit "Avatar" beginnen:

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

Eingabetext

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
eventType Gibt den Typ der Robo-Script-Aktion an.
"eventType": "VIEW_TEXT_CHANGED" Gibt den angegebenen Text in das Ziel-UI-Widget ein.
"eventType": "ENTER_TEXT" gibt den gegebenen Text in das Ziel-UI-Widget ein und sendet dann ein KEYCODE_ENTER-Ereignis an dieses UI-Widget.
elementDescriptors Identifiziert das Ziel-UI-Widget anhand der Android-UI-Hierarchie.
replacementText Der Text, der in das Ziel-UI-Widget eingegeben werden soll.

Das folgende Beispiel zeigt eine Robo-Script-Aktion, die "John" mit der Ressourcen-ID "com.google.samples.apps.topeka:id/first_name" in ein UI-Widget eingibt:

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

Langes Drücken

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "VIEW_LONG_CLICKED" --
elementDescriptors Identifiziert das Ziel-UI-Widget anhand der Android-UI-Hierarchie. Schließt sich gegenseitig mit visionText aus.
visionText Das Element, auf das lange geklickt wurde, wird mithilfe von OCR identifiziert. Schließt sich gegenseitig mit elementDescriptors aus.
matchIndex Gibt den Index des Vorkommens des übereinstimmenden Zielelements an, wenn das Zielelement mit visionText identifiziert wird. Wenn 0 ausgewählt ist, wählt die Robo-Skriptaktion das erste übereinstimmende Element aus. Ist es 1, wählt die Robo-Skript-Aktion das zweite übereinstimmende Element aus und so weiter. Die Reihenfolge wird von links nach rechts und von oben nach unten festgelegt. Der Standardwert ist 0 (die erste Übereinstimmung wird ausgewählt).

Das folgende Attribut ist optional:

  • delayTime: Gibt an, wie lange das Drücken bei einem langen Klick in Millisekunden dauert.

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, bei der fünf Sekunden lang auf ein UI-Widget mit der Inhaltsbeschreibung "Avatar 8" geklickt wird:

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

Führe eine Ein-Punkt-Geste aus

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "ONE_POINT_GESTURE" --
coordinates Zwei Koordinaten für eine Geste mit einem Punkt, formatiert als „(x1,y1)->(x2,y2)“ als Prozentsätze oder Pixel.

Das folgende Attribut ist optional:

  • dragAndDrop: Wenn diese Option auf true gesetzt ist, wird durch die Geste mit einem Punkt eine Drag-and-drop-Aktion ausgeführt. Der Standardwert ist false.

Das folgende Beispiel zeigt eine Robo-Script-Touch-Geste mit einem Punkt, bei der ein Wischen nach unten ausgeführt wird:

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

Zwei-Punkt-Geste ausführen

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "TWO_POINT_GESTURE" --
coordinates Vier Koordinaten für eine Zwei-Punkt-Geste im Format „(x1,y1)->(x2,y2),(x3,y3)->(x4,y4)“ in Prozent oder Pixeln.

Im Folgenden finden Sie ein Beispiel für eine Robo-Script-Aktion, bei der eine Auseinander-Zoomgeste ausgeführt wird:

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

IME-Aktion ausführen

Bei dieser Aktion wird die aktuelle Aktionsschaltfläche im Eingabemethoden-Editor (IME) des angegebenen Ziel-UI-Widgets gedrückt, z. B. Weiter, Fertig und Suche.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "PRESSED_EDITOR_ACTION" --
elementDescriptors Identifiziert das Ziel-UI-Widget anhand der Android-UI-Hierarchie.

Im Folgenden finden Sie ein Beispiel für eine Robo-Script-Aktion, bei der eine IME-Aktion auf einem UI-Widget mit der Ressourcen-ID "com.google.samples.apps.topeka:id/first_name" ausgeführt wird:

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

Drücken Sie die Schaltfläche „Zurück“.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
eventType Gibt den Typ der Robo-Skriptaktion an.
"eventType": "PRESSED_BACK" Es wird ein KEYCODE_BACK-Ereignis an das Gerät gesendet.
"eventType": "PRESSED_BACK_EMULATOR_28" Wird vom Robo-Skriptrekorder in Android Studio verwendet, um die Emulator-API 28 zurückzusetzen.

Im Folgenden finden Sie ein Beispiel für eine Robo-Script-Aktion, bei der die Schaltfläche „Zurück“ gedrückt wird:

{
  "eventType": "PRESSED_BACK"
}

Startbildschirmtaste drücken

Durch diese Aktion wird ein KEYCODE_HOME-Ereignis an das Gerät gesendet.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "GO_HOME" --

Im Folgenden finden Sie ein Beispiel für eine Robo-Script-Aktion, bei der die Home-Taste gedrückt wird:

{
  "eventType": "GO_HOME"
}

Elemente in die Ansicht scrollen

Durch diese Aktion scrollt der Robo-Test im UI-Widget, das der angegebenen elementDescriptors entspricht, vorwärts, bis das UI-Widget, das dem angegebenen childElementDescriptors entspricht, auf dem Bildschirm vorhanden ist, das gescrollte Widget nicht mehr gescrollt werden kann oder die maximale Anzahl von 50 Scrollvorgängen erreicht ist.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "ELEMENT_SCROLL_INTO_VIEW" --
elementDescriptors Identifiziert das gescrollte UI-Widget anhand der Android-UI-Hierarchie.
childElementDescriptors Gibt das UI-Widget an, zu dem mithilfe der Android-UI-Hierarchie gescrollt werden soll.

Im Folgenden finden Sie ein Beispiel für eine Robo-Script-Aktion, bei der das UI-Widget mit der Ressourcen-ID "my.app.package:id/scrollable_card_container" so lange gescrollt wird, bis das UI-Widget mit dem Text "Orange" auf dem Bildschirm angezeigt wird (oder kein weiteres Scrollen möglich ist oder die maximale Anzahl von 50 Scrollvorgängen erreicht wird):

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

Wischen

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "VIEW_SWIPED" --
swipeDirection Gibt die Wischrichtung an:
  • Left
  • Right
  • Up
  • Down
  • Forward – entweder Down oder Right, je nach vertikaler oder horizontaler Scrollbarkeit des Ziel-UI-Widgets.
  • Backward – entweder Up oder Left, je nachdem, ob das Ziel-UI-Widget vertikal oder horizontal scrollbar ist
elementDescriptors Identifiziert das Ziel-UI-Widget anhand der Android-UI-Hierarchie.

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, bei der ein UI-Widget mit der Ressourcen-ID "my.app.package:id/custom_content" nach oben wischt:

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

Screenshot erstellen

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "TAKE_SCREENSHOT" --
screenshotName Gibt den Namen der Screenshotdatei an.

Im Folgenden finden Sie ein Beispiel für eine Robo-Script-Aktion, mit der ein Screenshot erstellt wird:

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

Punkt auf dem Bildschirm antippen

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "POINT_TAP" --
pointTapXCoordinate Die Pixel-X-Koordinate des angetippten Punkts. Schließt sich mit pointTapXPercent und pointTapYPercent gegenseitig aus.
pointTapYCoordinate Die Y-Pixelkoordinate des angetippten Punkts. Schließt sich gegenseitig mit pointTapXPercent und pointTapYPercent aus.
pointTapXPercent Die prozentuale X-Koordinate des getippten Punkts. Schließt sich gegenseitig mit pointTapXCoordinate und pointTapYCoordinate aus.
pointTapYPercent Die Y-Koordinate in Prozent des angetippten Punkts. Schließt sich gegenseitig mit pointTapXCoordinate und pointTapYCoordinate aus.

Im Folgenden finden Sie ein Beispiel für eine Robo-Script-Aktion, bei der in der Mitte eines Bildschirms getippt wird:

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

Auf einen Punkt innerhalb eines Elements tippen

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "POINT_TAP_ELEMENT" --
pointTapXPercent Die prozentuale X-Koordinate innerhalb des Zielelements.
pointTapYPercent Die prozentuale Y-Koordinate innerhalb des Zielelements.
elementDescriptors Identifiziert das Ziel-UI-Widget anhand der Android-UI-Hierarchie.

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, mit der der Schieberegler einer Wiedergabeleiste nach rechts bewegt wird:

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

Crawling beenden

Dadurch wird der Robo-Test beendet.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "TERMINATE_CRAWL" --

Das folgende Beispiel zeigt eine Robo-Script-Aktion, die einen Robo-Test stoppt:

{
  "eventType": "TERMINATE_CRAWL"
}

Warten

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "DELAYED_MESSAGE_POSTED" --
delayTime Gibt an, wie lange gewartet werden soll, in Millisekunden.

Im folgenden Beispiel wird eine Robo-Script-Aktion verwendet, die drei Sekunden wartet:

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

Auf ein Element warten

Durch diese Aktion wartet der Robo-Test bis zum angegebenen Zeitlimit, bis ein Element auf dem Bildschirm erscheint.

In der folgenden Tabelle sind die erforderlichen Attribute aufgeführt:

Attribut Beschreibung
"eventType": "WAIT_FOR_ELEMENT" --
delayTime Gibt das Zeitlimit für die Wartezeit in Millisekunden an.
elementDescriptors Identifiziert das UI-Widget, auf das gewartet wurde, mithilfe der Android-UI-Hierarchie.

Im folgenden Beispiel wird bei einer Robo-Script-Aktion bis zu 30 Sekunden lang gewartet, bis ein UI-Widget mit der Ressourcen-ID "my.app.package:id/confirmation_button" auf dem Bildschirm erscheint:

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

Nächste Schritte