Guide de référence des scripts Robo

Ce document fournit des informations de référence sur les scripts Robo, notamment la structure, les fonctionnalités, l'utilisation, l'enregistrement et les actions. Les scripts robots sont des tests qui automatisent les tâches manuelles d'assurance qualité (AQ) pour les applications mobiles et permettent des stratégies d'intégration continue (CI) et de tests préalables au lancement. Un script Robo est un fichier JSON qui décrit une séquence d'interface utilisateur (UI) et d'autres actions.

Vous pouvez créer un script Robo des manières suivantes :

  • Utilisez la fonction d'enregistrement de script Robo. (Android uniquement)

  • Créez le script Robo manuellement. (Android et iOS+)

  • Enregistrez le script Robo, puis modifiez-le manuellement. (Android uniquement)

Pour en savoir plus sur l'utilisation des scripts Robo, consultez Exécuter un script Robo .

Introduction

Le script Robo est fourni au test Robo avec d'autres entrées telles que le package d'application Android (APK) en cours de test.

Voici un exemple de script Robo qui connecte un utilisateur à une application, qui est déclenché lorsque l'application en cours de test est lancée :

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

S'il y a un seul script Robo dans un fichier et qu'il a la condition de déclenchement par défaut app_under_test_shown , comme dans l'exemple ci-dessus, vous pouvez alors spécifier le script Robo dans un fichier en utilisant un format plus simple - simplement comme une séquence de ses 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"
      }
    ]
  }
]

Prise en charge iOS+ pour les scripts Robo

Robo pour iOS+ (bêta) offre une prise en charge limitée des scripts Robo. La syntaxe du script Robo pour iOS+ est identique à la syntaxe Android et les fonctionnalités iOS+ prises en charge se comportent de la même manière que leurs homologues Android.

Les actions suivantes sont prises en charge dans iOS+ :

  • Affirmation
  • Cliquez sur
  • Clic long
  • Glisser
  • Ignorer tous les éléments
  • Attendez
  • Prendre une capture d'écran
  • Terminer l'exploration

Les attributs d'identification suivants dans les descripteurs d'éléments sont pris en charge dans iOS+ :

  • Nom du cours
  • Nom de classe d'ancêtre
  • Description du contenu (et regex)
  • Texte (et regex)

Les conditions de déclenchement suivantes dans les descripteurs de contexte sont prises en charge dans iOS+ :

  • Application en cours de test affichée
  • Élément présent
  • Action de script non-Robo effectuée

Structure

Un script Robo possède plusieurs attributs qui décrivent comment Robo l'exécute. La plupart de ces attributs sont facultatifs avec des valeurs par défaut prédéfinies :

Attribut Description
id Un nombre entier qui permet de suivre ce script Robo dans les sorties d'analyse. Robo a des scripts Robo intégrés avec leurs propres id . Bien que le même id dans différents scripts Robo n'affecte pas leur comportement, distinguer les actions de ces scripts Robo dans les sorties d'analyse peut être difficile. Nous vous recommandons d'attribuer un id unique de 1000 ou plus à vos scripts Robo afin d'éviter tout conflit.
description Similaire à id mais plus descriptif.
crawlStage L'étape d'une analyse à laquelle Robo applique ce script Robo. Par défaut, il s'agit de l'étape principale d'analyse.
priority La priorité de ce script Robo par rapport aux autres scripts Robo. Par défaut, tous les scripts Robo ont une priorité de 1 .
maxNumberOfRuns Spécifie combien de fois au cours d'une analyse Robo peut exécuter ce script Robo. Par défaut, Robo peut exécuter un script Robo une seule fois.
contextDescriptor Décrit le contexte ou la condition qui déclenche ce script Robo. En cas d'omission, la condition de déclenchement de ce script Robo est considérée comme toujours remplie ; en d’autres termes, le script Robo est inconditionnel.
actions Toutes les actions de ce script Robo.

Un seul fichier contient une collection d'un ou plusieurs scripts Robo.

Voici un exemple de fichier avec deux scripts Robo inconditionnels, chacun avec une seule action exécutée une fois au début d'une analyse :

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

Descripteur de contexte

Un descripteur de contexte définit le contexte ou la condition qui déclenche un script Robo à l'aide d'un ou d'une combinaison de plusieurs attributs :

Attribut Description
"condition": "always" Déclenche toujours un script Robo.
"condition": "element_present" Vérifie qu'un widget d'interface utilisateur qui correspond elementDescriptors ou au texte spécifié par visionText est présent à l'écran.
"condition": "element_disabled" Vérifie qu'un widget d'interface utilisateur correspondant elementDescriptors est présent à l'écran et ne peut pas interagir avec.
"condition": "element_checked" Vérifie qu'un widget d'interface utilisateur correspondant elementDescriptors est présent à l'écran et est coché.
"condition": "app_under_test_shown" Vérifie que l’application testée s’exécute au premier plan.
"condition": "default_launcher_shown" Vérifie que l'écran d'accueil d'un appareil est affiché, ce qui signifie qu'aucune application n'est exécutée au premier plan.
"condition": "non_roboscript_action_performed" Vérifie que les dernières actions consécutives nonRoboscriptActionCount effectuées par Robo test ne sont pas des actions de script Robo.
negateCondition Si la valeur est true , annule la condition . Par exemple, vous pouvez utiliser cet attribut pour vérifier si un widget d'interface utilisateur n'est PAS présent à l'écran ou si l'application en cours de test ne s'exécute PAS au premier plan.
elementDescriptors Un ou plusieurs descripteurs d'éléments qui identifient un widget d'interface utilisateur à l'écran. Il est utilisé en combinaison avec les conditions element_present , element_disabled et element_checked . Mutuellement exclusif avec visionText . Pour plus d'informations, consultez Descripteurs d'éléments .
visionText Le texte à l'écran est détecté à l'aide de l'API de reconnaissance optique de caractères (OCR). visionText est utilisé en combinaison avec la condition element_present . Mutuellement exclusif avec elementDescriptors .
nonRoboscriptActionCount Nombre d'actions consécutives de script non-Robo effectuées auparavant. Il est utilisé en combinaison avec la condition non_roboscript_action_performed pour déclencher un script Robo après chaque action Robo nonRoboscriptActionCount . Par défaut, c'est 1 .

Voici un exemple de script Robo déclenché par un widget d'interface utilisateur avec un ID de ressource "my.app.package:id/page_header" présent à l'écran :

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

Voici un exemple de script Robo déclenché par "Privacy Policy" détectée par la reconnaissance optique de caractères (OCR) :

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

Voici un exemple de script Robo qui attend 5 secondes après chaque action Robo non script :

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

Actions

Chaque action dans un script Robo est représentée comme un ensemble d'une ou plusieurs paires attribut-valeur, décrites dans le tableau suivant :

Attribut Description
eventType Spécifie le type de l'action, par exemple, clic, modification de texte, etc. Obligatoire pour chaque action.
elementDescriptors Descripteurs qui identifient un widget d'interface utilisateur. Obligatoire pour toutes les actions qui ont un widget d'interface utilisateur cible, comme cliquer sur un bouton particulier.
optional Si la valeur est true , cette action est ignorée lorsqu'elle ne peut pas être effectuée. Par exemple, cette action est ignorée lorsqu'elle ne trouve pas son widget d'interface utilisateur cible sur un écran, sans faire échouer le script Robo qui le contient. Par défaut, la valeur est false .
replacementText Le texte à saisir dans le widget d'interface utilisateur cible. Requis pour les actions d’édition de texte.
swipeDirection Spécifie la direction du balayage. Requis pour les actions de balayage.
delayTime Spécifie la durée d'attente, en millisecondes. Obligatoire pour les actions d’attente.
pointTapXCoordinate et pointTapYCoordinate Les coordonnées X et Y des pixels du point exploité. Mutuellement exclusif avec pointTapXPercent et pointTapYPercent . Requis pour les actions de pointage.
pointTapXPercent et pointTapYPercent Le pourcentage des coordonnées X et Y du point exploité. Mutuellement exclusif avec pointTapXCoordinate et pointTapYCoordinate . Requis pour les actions de pointage.

Voici un exemple de script Robo avec deux actions sans widgets d'interface utilisateur cibles, ce qui signifie que ces actions ne fonctionnent pas sur un widget d'interface utilisateur spécifique :

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

Descripteurs d'éléments

Un descripteur d'élément identifie un widget d'interface utilisateur à l'aide d'un ou plusieurs des attributs d'identification suivants :

Attribut Description
className –
ancestorClassName Nom de classe de l’ancêtre de la hiérarchie d’interface utilisateur de l’élément. Un ancêtre est l'un des nœuds parents dans la hiérarchie de l'interface utilisateur de l'élément, y compris l'élément lui-même.
resourceId –
resourceIdRegex Expression régulière Java correspondant à resourceId .
contentDescription –
contentDescriptionRegex Expression régulière Java correspondant à contentDescription .
text (qui apparaît à l'écran) –
textRegex Expression régulière Java pour correspondre text .
groupViewChildPosition , recyclerViewChildPosition ou adapterViewChildPosition Représente la position enfant d'un widget d'interface utilisateur en fonction du type de son widget parent.

Souvent, ces attributs ne sont pas définis, par exemple, un bouton peut ne pas avoir de texte ni de description de contenu. Même si certaines valeurs d'attribut sont présentes, elles peuvent ne pas être uniques sur un écran d'application donné (y compris resourceId ).

Par exemple, différencier les éléments d'une liste n'est généralement possible qu'en utilisant leurs différentes positions enfants dans leur widget parent. Cela signifie que l’utilisation d’un seul descripteur d’élément pour identifier un widget d’interface utilisateur est généralement insuffisante. Par conséquent, l'attribut elementDescriptors d'une action contient une séquence de descripteurs d'éléments qui sont ordonnés de telle sorte que le premier corresponde au widget d'interface utilisateur cible, le second correspond au widget parent du widget d'interface utilisateur cible, et ainsi de suite. Le widget d'interface utilisateur cible d'une action correspond lorsque tous ses descripteurs d'éléments correspondent à la sous-hiérarchie du widget d'interface utilisateur correspondante.

Voici un exemple de script Robo avec des actions de modification de texte et de clic, qui nécessitent toutes deux d'identifier le widget d'interface utilisateur cible à l'aide des descripteurs d'éléments fournis :

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

Options d'exécution

Vous pouvez éventuellement préfixer la liste des actions dans un script Robo avec un objet JSON qui spécifie les options d'exécution pour ce script Robo. Cet en-tête de configuration commence par le mot-clé roboscript suivi d'une représentation JSON des options d'exécution souhaitées.

Les scripts robots prennent en charge les options d'exécution suivantes :

  • executionMode - options d'exécution appliquées lorsqu'un script Robo est en cours d'exécution :
    • strict - s'il est défini sur true , le script Robo n'utilise pas de correspondance partielle, d'ignorance de l'action en cours et de suspension . Autrement dit, le script Robo est exécuté comme un test d'instrumentation régulier et échoue dès qu'une de ses actions ne peut pas être effectuée. Par défaut, c'est false .
    • notify - s'il est défini sur false , le script Robo n'affiche pas de notifications à l'écran au début et à la fin de son exécution. Par défaut, c'est true .
  • postscript - options d'exécution appliquées une fois un script Robo terminé :
    • terminate - s'il est défini sur true , le test Robo arrête l'exploration une fois le script Robo terminé. Par défaut, c'est false .

Voici un exemple de script Robo exécuté en mode strict sans notifications à l'écran et qui reste en veille pendant trois secondes, après quoi l'exploration s'arrête :

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

Paramètres du modèle

Un paramètre de modèle est un espace réservé dans un script Robo qui est remplacé par la valeur réelle lorsque le test Robo charge ce script Robo pour exécution. Les paramètres du modèle sont préfixés par un double trait de soulignement suivi d'un signe de pourcentage, et sont suivis d'un signe de pourcentage suivi d'un double trait de soulignement.

Les scripts robots prennent en charge le paramètre de modèle suivant :

  • __%APP_PACKAGE_NAME%__ - le nom du package de l'application en cours de test.

Voici un exemple de script Robo qui arrête le processus d'application en cours de test :

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

commentaires

Un script Robo peut contenir des lignes de commentaires, qui sont des lignes commençant par # ou // .

Voici un exemple de script Robo avec quelques commentaires :

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

Capacités

Par défaut, jusqu'à ce que toutes les actions d'un script Robo soient terminées (ou au moins tentées), le script Robo reste actif. Le test Robo continue d'essayer de faire correspondre une action de script Robo chaque fois qu'il sélectionne une action à effectuer. Le script Robo utilise les techniques suivantes pour augmenter la robustesse :

Technique Description
Correspondance partielle Si l'action actuelle du script Robo ne peut pas être entièrement mise en correspondance, les critères de correspondance sont assouplis et la correspondance est réessayée. La correspondance partielle ne prend pas en compte le descripteur d'élément le plus externe lors de la correspondance avec le widget d'interface utilisateur cible d'une action de script Robo.

Si la correspondance partielle réussit, l'action de script Robo correspondante est exécutée comme d'habitude. Cette technique prend en charge les scénarios dans lesquels la structure de l'application change, par exemple entre les versions de l'application, lorsque les éléments de l'écran sont réorganisés.

Ignorer l'action en cours Si l'action de script Robo actuelle ne peut pas être entièrement ou partiellement mise en correspondance, Robo essaie de faire correspondre l'action de script Robo suivante. Si l'action suivante correspond entièrement ou partiellement, Robo test ignore (et n'y revient jamais) l'action de script Robo actuelle et exécute la suivante.

Cette technique prend en charge les scénarios dans lesquels le comportement de l'application change entre les versions ou est irrégulier, par exemple, lorsqu'une boîte de dialogue intermittente peut apparaître sur différents écrans pendant l'enregistrement ou la relecture d'un script Robo.

Suspendre Si aucune action de script Robo actuelle ou ultérieure ne peut être entièrement ou partiellement mise en correspondance, le script Robo est temporairement suspendu et le test Robo sélectionne une action à effectuer en utilisant ses autres stratégies. Une fois cette action terminée, Robo test reprend l'exécution du script Robo.

Tant que les actions de script Robo actuelles ou ultérieures ne peuvent pas correspondre, le script Robo reste suspendu pour un certain nombre d'actions. Ainsi, les scripts Robo ne doivent pas nécessairement être un prologue pour un test Robo, et vous pouvez intercaler les actions de script Robo avec les actions de test Robo standard. Cette technique prend en charge les scénarios dans lesquels le comportement de l'application est instable ou lorsque les changements entre les versions de l'application sont suffisamment importants pour que Robo test doive « combler les lacunes » avec ses actions standard.

Priorités

Si un script Robo atteint son maxNumberOfRuns , il ne peut plus être déclenché lors d'une analyse donnée. Si plusieurs scripts Robo peuvent être déclenchés par le contexte actuel, la priorité est donnée en choisissant, dans l'ordre suivant, le script Robo qui :

  1. Possède un attribut contextDescriptor .
  2. A la priority la plus élevée (par défaut, tous les scripts Robo ont la même priority d'exécution de 1 ).
  3. Apparaît en premier dans la liste des scripts Robo, si les priorités des scripts Robo sont les mêmes.

Voici un exemple de fichier contenant trois scripts Robo qui effectuent la même action et sont déclenchés par la même condition - l'application en cours de test étant au premier plan :

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

Lorsque l'application testée est au premier plan, Robo déclenche les opérations suivantes, dans l'ordre :

  1. "Robo script 2" car il a la priorité la plus élevée.
  2. "Robo script 1" car il apparaît plus tôt parmi les scripts Robo applicables restants avec la même priorité.
  3. "Robo script 3" comme dernier script Robo applicable.

Exécutions répétées

Par défaut, Robo déclenche un script Robo au maximum une fois lors d'une analyse. Cela peut être ajusté via l'attribut maxNumberOfRuns .

Voici un exemple de script Robo qui fait passer l'application testée en arrière-plan jusqu'à 10 fois :

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

Étape d'exploration

Les scripts Robo sont applicables à différentes étapes d'une analyse Robo donnée :

Étape d'exploration Description
pre_crawl Avant que Robo ne se lance et commence à explorer l'application en cours de test.
post_crawl Une fois que Robo a fini d'explorer l'application en cours de test.
crawl L'étape principale d'analyse, lorsque Robo explore l'application en cours de test.
close_screen Lorsque Robo essaie de revenir en arrière (backtrack) à partir d'un écran donné, lorsque toutes les actions possibles sur cet écran sont explorées. Par défaut, Robo appuie, ce qui n'est pas souhaitable dans certains scénarios.

Si l'attribut crawlStage d'un script Robo n'est pas spécifié, il est implicite qu'il s'agit de crawl .

Voici un exemple de script Robo qui efface les données utilisateur de l'application testée avant que Robo ne commence à l'explorer :

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

Voici un exemple de script Robo qui demande à Robo de cliquer sur "Cancel" chaque fois qu'il tente de revenir en arrière (retour en arrière) à partir d'une boîte de dialogue de confirmation :

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

Actions conditionnelles

Un script Robo peut contenir des actions conditionnelles. Les actions conditionnelles ont trois attributs supplémentaires qui décrivent comment Robo les exécute :

Attribut Description
priority Priorité de cette action conditionnelle par rapport aux autres actions conditionnelles dans le script Robo qui le contient. Par défaut, toutes les actions conditionnelles ont une priorité de 1 .
maxNumberOfRuns Combien de fois cette action conditionnelle peut être effectuée au cours d’une exécution du script Robo qui le contient. Par défaut, toutes les actions conditionnelles peuvent être effectuées au plus une fois en une seule exécution du script Robo qui les contient.
contextDescriptor Le contexte/condition qui déclenche cette action conditionnelle. Il a la même structure et offre des fonctionnalités similaires à celles du [contextDescriptor du script Robo] (#context-descriptor).

Lorsqu'il est déclenché, un script Robo exécute ses actions non conditionnelles une par une par ordre d'apparition. Si un script Robo contient des actions conditionnelles, elles sont alors prises en compte à chaque fois avant de choisir une action non conditionnelle à effectuer. Si une action conditionnelle est déclenchée et sélectionnée en fonction de sa priorité et du nombre d'exécutions restant, le script Robo exécute cette action conditionnelle. Sinon, le script Robo effectue l'action non conditionnelle suivante. Pour être valide, un script Robo doit contenir au moins une action non conditionnelle.

Voici un exemple de script Robo inconditionnel avec une action conditionnelle qui ferme les boîtes de dialogue contextuelles si elles apparaissent à tout moment pendant l'exécution du script Robo :

{
  "id": 1000,
  "actions": [
    {
      "description": "Dismiss popup",
      "maxNumberOfRuns": 100,
      "contextDescriptor": {
        "condition": "default_launcher_shown",
        "negateCondition": true
      },
      "eventType": "GO_HOME"
    },
    {
      "description": "Screen off",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 26"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "DELAYED_MESSAGE_POSTED",
      "delayTime": 10000
    },
    {
      "description": "Screen on",
      "eventType": "ADB_SHELL_COMMAND",
      "command": "input keyevent 82"
    },
    {
      "description": "Wait for 10 seconds",
      "eventType": "DELAYED_MESSAGE_POSTED",
      "delayTime": 10000
    }
}

Ignorer les actions

Un script Robo peut contenir des instructions permettant à Robo d'ignorer des widgets d'interface utilisateur spécifiques ou tous les widgets d'interface utilisateur sur un écran particulier. Ces instructions sont représentées comme ignorant les "actions" avec eventType ELEMENT_IGNORED et ALL_ELEMENTS_IGNORED en conséquence.

Chaque fois que l'attribut contextDescriptor d'un script Robo contenant des actions d'ignorance correspond à un écran donné, Robo n'interagit avec aucun widget d'interface utilisateur ciblé par ses actions d'ignorance (à moins qu'une autre action de script Robo oblige Robo à effectuer une action sur l'un des widgets d'interface utilisateur ignorés).

Un script Robo peut contenir un mélange d'actions ignorées, conditionnelles et non conditionnelles. Contrairement aux autres actions de script Robo, les actions ignorées sont appliquées tant que contextDescriptor qu'elles contiennent correspond à un écran lors d'une analyse Robo, quelles que soient les valeurs des attributs priority et maxNumberOfRuns .

Ce qui suit est un exemple de fichier avec deux scripts Robo. Le premier script Robo permet à Robo d'ignorer tous les widgets d'interface utilisateur sur un écran contenant un widget d'interface utilisateur avec un ID de ressource "my.app.package:id/ignored_screen" . Le deuxième script Robo fait que Robo ignore les widgets d'interface utilisateur dont les ID de ressource correspondent à l'expression régulière Java ".*:id/done" sur un écran contenant un widget d'interface utilisateur avec un ID de ressource "my.app.package:id/main_screen" :

[
  {
    "id": 1000,
    "contextDescriptor": {
      "condition": "element_present",
      "elementDescriptors": [
        {
          "resourceId": "my.app.package:id/ignored_screen"
        }
      ]
    },
    "actions": [
      {
        "eventType": "ALL_ELEMENTS_IGNORED"
      }
    ]
  },
  {
    "id": 1001,
    "contextDescriptor": {
      "condition": "element_present",
      "elementDescriptors": [
        {
          "resourceId": "my.app.package:id/main_screen"
        }
      ]
    },
    "actions": [
      {
        "eventType": "ELEMENT_IGNORED",
        "elementDescriptors": [
          {
            "resourceIdRegex": ".*:id/done"
          }
        ]
      }
    ]
  }
]

Prise en charge de RecyclerView et AdapterView

Les enfants des widgets RecyclerView et AdapterView sont chargés dynamiquement et peuvent être affichés à plusieurs reprises depuis l'écran actuel. Étant donné que la taille d'un écran et le nombre de balayages requis pour accéder à cet enfant sont différents selon les facteurs de forme de l'appareil, il est beaucoup plus robuste de s'appuyer sur la position des données de l'enfant, qui est absolue. Il est moins robuste de s'appuyer sur le nombre de balayages nécessaires pour amener cet enfant à l'écran, puis d'utiliser sa position sur l'écran.

Par conséquent, le script Robo capture les positions absolues des données des enfants RecyclerView qui sont les cibles des actions du script Robo en tant que recyclerViewChildPosition . Le script Robo capture également les positions absolues des données des enfants AdapterView qui sont les cibles des actions du script Robo en tant que adapterViewChildPosition .

Les actions sur les enfants RecyclerView et AdapterView sont effectuées selon les étapes suivantes :

  1. Le test robot garantit que l'enfant correspondant est affiché à l'écran via une action de positionnement sur son contenant RecyclerView ou AdapterView.

  2. Robo test effectue l'action enregistrée directement sur l'élément enfant, puisqu'il est déjà affiché à l'écran.

Voici un exemple d'action de clic sur un enfant 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
    }
  ]
}

Voici un exemple d'action de clic sur un enfant 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
    }
  ]
}

Enregistrez un script Robo dans Android Studio et exécutez-le dans Test Lab

Vous pouvez créer un script Robo dans Android Studio, qui enregistre le script sous forme de fichier JSON. Vous pouvez ensuite télécharger le fichier JSON sur Firebase Test Lab avec l'application et exécuter le test en conséquence.

Lorsque vous exécutez un test Robo avec un script joint, le test Robo passe d'abord en revue vos actions pré-scriptées, puis explore l'application comme d'habitude.

Pour créer un fichier JSON de script Robo dans Android Studio, suivez les étapes décrites dans Enregistrer un script Robo à l'aide de Test Lab dans Android Studio .

Actions de script robot

L'attribut facultatif commun suivant s'applique à toutes les actions :

  • description - permet de suivre l'exécution de cette action de script Robo dans les sorties de test Robo.

Affirmation

Si la condition affirmée est vraie, le script Robo passe à l'action suivante, qui pourrait être une autre assertion. Sinon, l'exécution du script Robo est interrompue en raison d'un échec d'assertion.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "ASSERTION" --
contextDescriptor Décrit le contexte ou la condition affirmée. Il a la même structure et offre des fonctionnalités similaires à celles du contextDescriptor du script Robo .

Voici un exemple d'assertion de script Robo qui vérifie que l'application testée est au premier plan :

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

Voici un exemple d'assertion de script Robo qui vérifie qu'un widget d'interface utilisateur avec l'ID de ressource "com.google.samples.apps.topeka:id/done" est présent sur un écran :

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

Voici un exemple d'assertion de script Robo qui vérifie que "Settings" n'est PAS détecté sur un écran à l'aide de l'OCR :

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

Cliquez sur

Le tableau suivant répertorie les attributs requis :

Attribut Description
eventType Spécifie le type d'action du script Robo.
"eventType": "VIEW_CLICKED" Clique sur l'élément cible de l'application en cours de test.
"eventType": "SOFT_KEYBOARD_CLICK" Clique sur l'élément cible du clavier virtuel.
"eventType": "SOFT_KEYBOARD_RANDOM_CLICK" Clique sur des éléments aléatoires du clavier virtuel jusqu'à maxNumberOfRuns fois.
"eventType": "LIST_ITEM_CLICKED" Utilisé par l'enregistreur de script Robo dans Android Studio pour cliquer sur les éléments de la liste.
elementDescriptors Identifie le widget d'interface utilisateur sur lequel vous avez cliqué à l'aide de la hiérarchie de l'interface utilisateur Android. Mutuellement exclusif avec visionText .
visionText Identifie l'élément cliqué à l'aide de l'OCR. Mutuellement exclusif avec elementDescriptors .
maxNumberOfRuns Spécifie combien de fois cliquer sur un élément aléatoire du clavier logiciel, lorsque eventType est SOFT_KEYBOARD_RANDOM_CLICK . La valeur par défaut est 1 .

Voici un exemple d'action de script Robo qui clique sur un bouton portant l'ID de ressource "com.google.samples.apps.topeka:id/done" :

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

Voici un exemple d'action de script Robo qui clique sur "Privacy Policy" détectée sur un écran à l'aide de l'OCR :

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

Voici un exemple d'action de script Robo qui clique sur un élément de clavier logiciel avec une description de contenu "Emoji button" :

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

Voici un exemple d'action de script Robo qui clique jusqu'à cinq fois sur des éléments aléatoires du clavier virtuel :

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

Désactiver le clavier logiciel

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "DISABLE_KEYBOARD" --

Voici un exemple d'action de script Robo qui désactive le clavier virtuel :

{
  "eventType": "DISABLE_KEYBOARD"
}

Exécuter la commande adb shell

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "ADB_SHELL_COMMAND" --
command La commande shell Android Debug Bridge (adb) à exécuter.

L'attribut suivant est facultatif :

  • expectedOutputRegex - la sortie attendue de la commande sous forme d'expression régulière Java. Si le résultat ne correspond pas, l’action du script Robo échoue. Par défaut, il s'agit d'une chaîne vide, ce qui signifie que la sortie n'est pas vérifiée.

Voici un exemple d'action de script Robo qui efface les données utilisateur de l'application en cours de test :

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

Accorder des autorisations

Cette action est enregistrée par l'enregistreur de script Robo dans Android Studio pour une compatibilité descendante avec Espresso Test Recorder . Le test robot accorde toutes les autorisations à l'application testée au début de chaque analyse et, par conséquent, cette action n'est pas une opération. N'utilisez PAS cette action dans vos scripts Robo.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "PERMISSIONS_REQUEST" --

Ignorer tous les éléments sur un écran

Cette action fait que Robo ignore tous les éléments de n'importe quel écran qui déclenchent le script Robo contenant.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "ALL_ELEMENTS_IGNORED" --

Voici un exemple d'action de script Robo qui oblige Robo à ignorer tous les éléments sur un écran :

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

Ignorer un élément

Cette action oblige Robo à ignorer un ou plusieurs éléments qui correspondent aux elementDescriptors spécifiés.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "ELEMENT_IGNORED" --
elementDescriptors Identifie le(s) widget(s) d'interface utilisateur ignoré(s) à l'aide de la hiérarchie de l'interface utilisateur Android.

L'attribut suivant est facultatif :

  • ignoreChildren - s'il est défini sur true , Robo ignore également tous les descendants du ou des widgets d'interface utilisateur ignorés. Par défaut, c'est false .

Voici un exemple d'action de script Robo qui oblige Robo à ignorer tous les éléments dont la description du contenu commence par "Avatar" :

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

Texte de saisie

Le tableau suivant répertorie les attributs requis :

Attribut Description
eventType Spécifie le type d'action du script Robo.
"eventType": "VIEW_TEXT_CHANGED" Saisit le texte donné dans le widget d'interface utilisateur cible.
"eventType": "ENTER_TEXT" entre le texte donné dans le widget d'interface utilisateur cible, puis envoie un événement KEYCODE_ENTER à ce widget d'interface utilisateur.
elementDescriptors Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android.
replacementText Le texte à saisir dans le widget d'interface utilisateur cible.

Voici un exemple d'action de script Robo qui saisit "John" dans un widget d'interface utilisateur avec l'ID de ressource "com.google.samples.apps.topeka:id/first_name" :

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

Clic long

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "VIEW_LONG_CLICKED" --
elementDescriptors Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android. Mutuellement exclusif avec visionText .
visionText Identifie l'élément cliqué longuement à l'aide de l'OCR. Mutuellement exclusif avec elementDescriptors .

L'attribut suivant est facultatif :

  • delayTime - spécifie la durée de la pression exercée sur un clic long, en millisecondes.

Voici un exemple d'action de script Robo qui effectue un clic de cinq secondes sur un widget d'interface utilisateur avec la description de contenu "Avatar 8" :

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

Effectuer un geste en un point

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "ONE_POINT_GESTURE" --
coordinates Deux coordonnées pour un geste en un point, formatées comme "(x1,y1)->(x2,y2)" sous forme de pourcentages ou de pixels.

L'attribut suivant est facultatif :

  • dragAndDrop - s'il est défini sur true , le geste en un point effectue une action de glisser-déposer. Par défaut, c'est false .

Voici un exemple d'action gestuelle en un point de script Robo qui effectue un balayage vers le bas :

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

Effectuer un geste en deux points

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "TWO_POINT_GESTURE" --
coordinates Quatre coordonnées pour un geste en deux points, formatées comme "(x1,y1)->(x2,y2),(x3,y3)->(x4,y4)" sous forme de pourcentages ou de pixels.

Voici un exemple d'action de script Robo qui effectue un geste de pincement :

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

Effectuer une action IME

Cette action appuie sur le bouton d'action actuel, par exemple, suivant, terminé et recherche, sur l'éditeur de méthode d'entrée (IME) pour le widget d'interface utilisateur cible spécifié.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "PRESSED_EDITOR_ACTION" --
elementDescriptors Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android.

Voici un exemple d'action de script Robo qui effectue une action IME sur un widget d'interface utilisateur avec l'ID de ressource "com.google.samples.apps.topeka:id/first_name" :

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

Refouler

Le tableau suivant répertorie les attributs requis :

Attribut Description
eventType Spécifie le type d'action du script Robo.
"eventType": "PRESSED_BACK" Envoie un événement KEYCODE_BACK au périphérique.
"eventType": "PRESSED_BACK_EMULATOR_28" Utilisé par l'enregistreur de script Robo dans Android Studio pour appuyer sur l'API 28 des émulateurs.

Voici un exemple d'action de script Robo qui revient en arrière :

{
  "eventType": "PRESSED_BACK"
}

Accueil presse

Cette action envoie un événement KEYCODE_HOME au périphérique.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "GO_HOME" --

Voici un exemple d'action de script Robo qui appuie sur le point d'origine :

{
  "eventType": "GO_HOME"
}

Faire défiler un élément dans la vue

Cette action fait que Robo test fait défiler vers l'avant le widget d'interface utilisateur qui correspond aux elementDescriptors spécifiés jusqu'à ce que le widget d'interface utilisateur qui correspond aux childElementDescriptors spécifiés soit présent à l'écran, ou que le widget défilé ne puisse plus défiler, ou que le nombre maximum de 50 défilements soit atteint.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "ELEMENT_SCROLL_INTO_VIEW" --
elementDescriptors Identifie le widget d'interface utilisateur défilé à l'aide de la hiérarchie de l'interface utilisateur Android.
childElementDescriptors Identifie le widget d'interface utilisateur vers lequel faire défiler à l'aide de la hiérarchie de l'interface utilisateur Android.

Ce qui suit est un exemple d'action de script Robo qui fait défiler le widget d'interface utilisateur avec l'ID de ressource "my.app.package:id/scrollable_card_container" jusqu'à ce que le widget d'interface utilisateur avec le texte "Orange" soit présent à l'écran (ou plus aucun défilement ne peut être effectué). être effectué, ou le nombre maximum de 50 parchemins est atteint) :

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

Glisser

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "VIEW_SWIPED" --
swipeDirection Spécifie la direction du balayage :
  • Left
  • Right
  • Up
  • Down
  • Forward : vers Down ou Right en fonction de la capacité de défilement verticale ou horizontale du widget d'interface utilisateur cible.
  • Backward : Up ou Left en fonction du défilement vertical ou horizontal du widget d'interface utilisateur cible.
elementDescriptors Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android.

Voici un exemple d'action de script Robo qui fait glisser vers le haut un widget d'interface utilisateur avec l'ID de ressource "my.app.package:id/custom_content" :

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

Prendre une capture d'écran

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "TAKE_SCREENSHOT" --
screenshotName Spécifie le nom du fichier de capture d'écran.

Voici un exemple d'action de script robot qui prend une capture d'écran :

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

Appuyez sur un point sur l'écran

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "POINT_TAP" --
pointTapXCoordinate La coordonnée X du pixel du point tapé. Mutuellement exclusif avec pointTapXPercent et pointTapYPercent .
pointTapYCoordinate La coordonnée Y du pixel du point exploité. Mutuellement exclusif avec pointTapXPercent et pointTapYPercent .
pointTapXPercent La coordonnée X en pourcentage du point tapé. Mutuellement exclusif avec pointTapXCoordinate et pointTapYCoordinate .
pointTapYPercent Coordonnée Y en pourcentage du point exploité. Mutuellement exclusif avec pointTapXCoordinate et pointTapYCoordinate .

Voici un exemple d'action de script Robo qui tape au milieu d'un écran :

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

Appuyez sur un point dans un élément

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "POINT_TAP_ELEMENT" --
pointTapXPercent Coordonnée X en pourcentage dans l'élément cible.
pointTapYPercent Coordonnée Y en pourcentage dans l'élément cible.
elementDescriptors Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android.

Voici un exemple d'action de script Robo qui déplace le curseur d'une barre de recherche vers la droite :

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

Terminer l'exploration

Cette action arrête le test Robo.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "TERMINATE_CRAWL" --

Voici un exemple d'action de script Robo qui arrête un test Robo :

{
  "eventType": "TERMINATE_CRAWL"
}

Attendez

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "DELAYED_MESSAGE_POSTED" --
delayTime Spécifie la durée d'attente, en millisecondes.

Voici un exemple d'action de script Robo qui attend trois secondes :

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

Attendre un élément

Cette action fait que Robo test attend qu'un élément apparaisse à l'écran jusqu'au délai d'expiration spécifié.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "WAIT_FOR_ELEMENT" --
delayTime Spécifie le délai d'attente, en millisecondes.
elementDescriptors Identifie le widget d'interface utilisateur attendu à l'aide de la hiérarchie de l'interface utilisateur Android.

Voici un exemple d'action de script Robo qui attend jusqu'à 30 secondes qu'un widget d'interface utilisateur avec l'ID de ressource "my.app.package:id/confirmation_button" apparaisse à l'écran :

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

Prochaines étapes