Robo-Script-Referenzhandbuch

Dieses Dokument enthält Referenzinformationen zu Robo-Scripts, einschließlich Struktur, Funktionen, Verwendung, Aufzeichnung und Aktionen. Robo-Scripts sind Tests, die manuelle Aufgaben der Qualitätssicherung für mobile Apps automatisieren und eine kontinuierliche Integration (Continuous Integration, CI) und Teststrategien vor der Markteinführung ermöglichen. Ein Roboscript ist eine JSON-Datei, die eine Abfolge von Benutzeroberflächen 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+)

  • 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 Beispiel wird ein Robo-Script verwendet, das einen Nutzer in einer App anmeldet. 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-Script mit der Standardauslösebedingung app_under_test_shown befindet, wie im Beispiel oben, können Sie das Robo-Script in einer Datei in einem einfacheren Format angeben – einfach als Abfolge der 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"
      }
    ]
  }
]

Unterstützung von Robo-Scripts für iOS und höher

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 Klicken
  • 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 Auslösebedingungen in Kontextbeschreibern werden unter iOS und höher unterstützt:

  • Testierte App wird 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. Wird sie weggelassen, gilt die Auslösebedingung dieses Robo-Scripts als immer erfüllt. Mit anderen Worten: Das Robo-Script ist bedingungslos.
actions Alle Aktionen dieses Robo-Scripts.

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

Im Folgenden finden Sie ein Beispiel für eine Datei mit zwei unbedingten Robo-Scripts, die jeweils eine einzelne Aktion enthalten, 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"
      }
    ]
  }
]

Kontextbeschreiber

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 auf dem Bildschirm ein UI-Widget zu sehen ist, das mit elementDescriptors oder dem von 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 aktiviert 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, die vom Robo-Test ausgeführt wurden, 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 Elementbeschreiber, 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 mit der Optical Character Recognition API (OCR API) erkannt. visionText wird in Kombination mit der Bedingung element_present verwendet. Schließt sich gegenseitig mit elementDescriptors aus.
nonRoboscriptActionCount Die Anzahl der aufeinanderfolgenden Aktionen, die zuvor ausgeführt wurden und keine Robo-Scripts waren. Sie wird in Kombination mit der Bedingung non_roboscript_action_performed verwendet, um nach jeder nonRoboscriptActionCount-Robo-Aktion ein Robo-Script auszulösen. Der Standardwert ist 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"
        }
      ]
    }
  ]
}

Das folgende Beispiel zeigt ein Robo-Script, das durch "Privacy Policy" ausgelöst wird, die 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“ oder „Text bearbeiten“. Erforderlich für jede Aktion.
elementDescriptors Deskriptoren, 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 Wischrichtung 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-Pixelkoordinaten des angetippten Punkts. Schließt sich gegenseitig mit pointTapXPercent und pointTapYPercent aus. Erforderlich für Aktionen vom Typ „Punkt anklicken“.
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 vom Typ „Punkt antippen“.

Im folgenden Beispiel wird ein Robo-Script mit zwei Aktionen ohne Ziel-UI-Widgets gezeigt. Das bedeutet, dass diese Aktionen nicht auf ein bestimmtes UI-Widget angewendet 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 Java-regulärer Ausdruck, der mit contentDescription übereinstimmen soll.
text (wird auf dem Bildschirm angezeigt) –
textRegex Java-regulärer Ausdruck, der mit text übereinstimmen soll.
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 oft nur möglich, zwischen Elementen einer Liste zu unterscheiden, indem ihre verschiedenen untergeordneten Positionen innerhalb des übergeordneten Widgets 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 abgeglichen, wenn alle Elementbeschreibungen mit der entsprechenden UI-Widget-Unterhierarchie ü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-Script ein JSON-Objekt vorangestellt, das die Ausführungsoptionen für dieses Robo-Script angibt. Dieser Konfigurationsheader beginnt mit dem Keyword 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 Robo-Script wird also 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. Der Standardwert ist false.
    • notify: Wenn diese Option auf false gesetzt ist, werden zu Beginn und Ende der Ausführung des Robo-Scripts keine Benachrichtigungen auf dem Bildschirm angezeigt. 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 Beispiel wird ein Robo-Script im strict-Modus ohne Benachrichtigungen auf dem Bildschirm ausgeführt. Es wird eine dreisekündige Pause eingelegt, nach der 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, also Zeilen, 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-Script-Aktion (und kehrt nie dorthin zurück) und führt die nachfolgende 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 Methode unterstützt Szenarien, in denen das App-Verhalten instabil ist oder die Änderungen zwischen den App-Versionen so groß sind, dass der Robo-Test die Lücken mit seinen Standardaktionen schließen muss.

Prioritäten

Wenn ein Robo-Script seine 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. Wird in der Liste der Robo-Scripts zuerst angezeigt, wenn die Prioritäten der Robo-Scripts gleich sind.

Im Folgenden finden Sie ein Beispiel für eine Datei mit drei Robo-Scripts, die dieselbe Aktion ausführen und durch dieselbe Bedingung ausgelöst werden: Die getestete App befindet sich 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 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. Das kann über das Attribut maxNumberOfRuns angepasst werden.

Im folgenden Beispiel wird ein Robo-Script verwendet, mit dem die getestete App bis zu zehnmal in den Hintergrund verschoben 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 gestartet wird und mit dem Crawling 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 crawlStage-Attribut eines Robo-Scripts nicht angegeben ist, wird davon ausgegangen, dass es crawl ist.

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. Sie hat dieselbe Struktur und bietet ähnliche Funktionen wie der contextDescriptor des Robo-Scripts.

Wenn ein Robo-Script ausgelöst wird, führt es seine nicht bedingten Aktionen nacheinander in der Reihenfolge aus, in der sie erscheinen. 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.

Im folgenden Beispiel wird ein unbedingtes Robo-Script mit einer bedingten Aktion gezeigt, die Pop-up-Dialogfelder schließt, wenn sie während der Ausführung des Robo-Scripts 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. Diese Anweisungen werden durch Ignorieren von „Aktionen“ mit eventType, ELEMENT_IGNORED und ALL_ELEMENTS_IGNORED dargestellt.

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-Scripts. Im ersten Robo-Script werden alle UI-Widgets auf einem Bildschirm ignoriert, 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. Das Robo-Script erfasst auch die absoluten Datenpositionen der AdapterView-Unterelemente, die Ziele von Robo-Script-Aktionen sind, als adapterViewChildPosition.

Aktionen auf RecyclerView- und AdapterView-Unterelementen werden in den folgenden Schritten ausgeführt:

  1. Beim Robo-Test wird durch eine Positionierungsaktion auf dem enthaltenen RecyclerView oder AdapterView sichergestellt, dass das entsprechende untergeordnete Element 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.

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

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

Robo-Script in Android Studio aufzeichnen und in Test Lab ausführen

Sie können in Android Studio ein Robo-Script erstellen, das als JSON-Datei gespeichert wird. Sie können die JSON-Datei dann zusammen 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.

Wenn Sie eine JSON-Datei für ein Robo-Script in Android Studio erstellen möchten, folgen Sie der Anleitung unter Robo-Script mit Test Lab in Android Studio aufzeichnen.

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 Kontext oder die Bedingung, die behauptet wird. 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 es 0 ist, wird mit der Robo-Script-Aktion das erste übereinstimmende Element ausgewählt. Bei 1 wird das zweite übereinstimmende Element ausgewählt usw. Die Reihenfolge wird von links nach rechts und von oben nach unten festgelegt. 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"
    }
  ]
}

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, die auf das zweite Vorkommen des Wortes "Search" klickt, das mithilfe der 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
}

Soft-Tastatur 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, was bedeutet, dass die Ausgabe nicht geprüft wird.

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

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, durch die Robo alle Elemente auf einem Bildschirm ignoriert:

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

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, durch die 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 angegebenen 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.

Im folgenden Beispiel wird eine Robo-Script-Aktion gezeigt, bei der "John" in ein UI-Widget mit der Ressourcen-ID "com.google.samples.apps.topeka:id/first_name" eingegeben wird:

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

Langes Klicken

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 mit visionText gegenseitig 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 es 0 ist, wird mit der Robo-Script-Aktion das erste übereinstimmende Element ausgewählt. Bei 1 wird das zweite übereinstimmende Element ausgewählt usw. 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 ein langer Klick gedrückt wird, in Millisekunden.

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
}

Eine Geste mit nur einem Punkt ausführen

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.

Im folgenden Beispiel wird eine Robo-Script-Geste mit nur einem Punkt verwendet, um nach unten wischen zu lassen:

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

Zweipunkt-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 Geste mit zwei Punkten, formatiert als „(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

Mit dieser Aktion wird die aktuelle Aktionsschaltfläche im Eingabemethoden-Editor (IME) für das angegebene Ziel-UI-Widget gedrückt, z. B. „Weiter“, „Fertig“ oder „Suchen“.

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

Attribut Beschreibung
"eventType": "PRESSED_EDITOR_ACTION" --
elementDescriptors Das Ziel-UI-Widget wird anhand der Android-UI-Hierarchie identifiziert.

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-Script-Aktion an.
"eventType": "PRESSED_BACK" Es wird ein KEYCODE_BACK-Ereignis an das Gerät gesendet.
"eventType": "PRESSED_BACK_EMULATOR_28" Wird vom Robo-Script-Aufzeichnungstool in Android Studio verwendet, um in Emulatoren mit API 28 die Schaltfläche „Zurück“ zu drücken.

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

Drücken Sie die Startbildschirmtaste.

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

Bei dieser Aktion scrollt Robo das UI-Widget, das der angegebenen elementDescriptors entspricht, nach vorne, bis das UI-Widget, das der angegebenen childElementDescriptors entspricht, auf dem Bildschirm angezeigt wird, 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 Das Ziel-UI-Widget wird anhand der Android-UI-Hierarchie identifiziert.

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

Auf einen Punkt auf dem Display tippen

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

Attribut Beschreibung
"eventType": "POINT_TAP" --
pointTapXCoordinate Die X-Pixelkoordinate des angetippten Punkts. Schließt sich gegenseitig mit pointTapXPercent und pointTapYPercent 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 prozentuale Y-Koordinate des getippten 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" --

Im Folgenden finden Sie ein Beispiel für eine Robo-Script-Aktion, die einen Robo-Test beendet:

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

Bei dieser Aktion wartet der Robo-Test bis zu dem 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 wird, anhand 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