Catch up on highlights from Firebase at Google I/O 2023. Learn more

Guide de référence des scripts Robo

Ce document fournit des informations de référence sur les scripts Robo, y compris la structure, les capacités, l'utilisation, l'enregistrement et les actions. Les scripts robotiques sont des tests qui automatisent les tâches manuelles d'assurance qualité (QA) pour les applications mobiles et permettent l'intégration continue (CI) et les stratégies de test de pré-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.
  • Créez le script Robo manuellement.
  • Enregistrez le script Robo, puis modifiez-le manuellement.

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

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

Voici un exemple de script Robo qui connecte un utilisateur à une application, qui est déclenchée 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, alors vous pouvez spécifier le script Robo dans un fichier en utilisant un format plus simple - juste 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"
      }
    ]
  }
]

Structure

Un script Robo a 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.
description Similaire à id mais plus descriptif.
crawlStage L'étape d'un crawl Robo applique ce script Robo à. Par défaut, il s'agit de l'étape de crawl principale.
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 pendant 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/la condition qui déclenche ce script Robo. Si elle est omise, 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'un crawl :

[
  {
    "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/la condition qui déclenche un script Robo à l'aide d'un ou d'une combinaison de plusieurs attributs :

Attribut Description
"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 qui correspond à elementDescriptors est présent à l'écran et qu'il est impossible d'interagir avec lui.
"condition": "element_checked" Vérifie qu'un widget d'interface utilisateur qui correspond à elementDescriptors est présent à l'écran et est coché.
"condition": "app_under_test_shown" Vérifie que l'application en cours de test s'exécute au premier plan.
"condition": "default_launcher_shown" Vérifie que l'écran d'accueil d'un appareil s'affiche, ce qui signifie qu'aucune application n'est en cours d'exécution au premier plan.
"condition": "non_roboscript_action_performed" Vérifie que la dernière action effectuée par le test Robo n'est pas une action de script Robo.
negateCondition Si défini sur 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ément 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, voir 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 .

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 d'un script Robo est représentée sous la forme d'un ensemble d'une ou plusieurs paires attribut-valeur, qui sont 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. Requis 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 contenant. Par défaut, la valeur est false .
replacementText Le texte à saisir dans le widget d'interface utilisateur cible. Obligatoire pour les actions d'édition de texte.
swipeDirection Spécifie la direction du balayage. Obligatoire pour les actions de balayage.
delayTime Spécifie le temps d'attente, en millisecondes. Obligatoire pour les actions d'attente.
pointTapXCoordinate et pointTapYCoordinate Coordonnées pixel X et Y du point tapé. Mutuellement exclusif avec pointTapXPercent et pointTapYPercent . Requis pour les actions d'appui ponctuel.
pointTapXPercent et pointTapYPercent Coordonnées X et Y en pourcentage du point tapé. Mutuellement exclusif avec pointTapXCoordinate et pointTapYCoordinate . Requis pour les actions d'appui ponctuel.

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 de l'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 pour correspondre à resourceId .
contentDescription –
contentDescriptionRegex Expression régulière Java pour correspondre à contentDescription .
text (qui apparaît à l'écran) –
textRegex Expression régulière Java pour faire 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 et 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, la différenciation entre les éléments d'une liste n'est généralement possible qu'en utilisant leurs différentes positions enfant 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 sorte que le premier corresponde au widget d'interface utilisateur cible, le second corresponde au widget parent du widget d'interface utilisateur cible, et ainsi de suite. Le widget d'interface utilisateur cible d'une action est mis en correspondance lorsque tous ses descripteurs d'élément correspondent à la sous-hiérarchie de widget d'interface utilisateur correspondante.

Voici un exemple de script Robo avec un changement de texte et des actions de clic, qui nécessitent tous deux que vous identifiiez le widget d'interface utilisateur cible à l'aide des descripteurs d'élément 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"
      }
    ]
  }
]

Possibilités 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 Robo 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 :
  • postscript - options d'exécution appliquées après la fin d'un script Robo :
    • terminate - si défini sur true , le test Robo arrête l'exploration une fois le script Robo terminé.

Voici un exemple de script Robo exécuté en mode strict qui dort pendant trois secondes, après quoi l'exploration s'arrête :

"roboscript": {
  "executionMode": {
    "strict": true
  },
  "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 de modèle sont précédés d'un double trait de soulignement suivi d'un signe de pourcentage et sont postfixés d'un signe de pourcentage suivi d'un double trait de soulignement.

Les scripts Robo 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
Appariement partiel Si l'action de script Robo actuelle ne peut pas être entièrement mise en correspondance, les critères de correspondance sont assouplis et la mise en 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 correspondre entièrement ou partiellement, Robo essaie de faire correspondre l'action de script Robo suivante. Si l'action suivante correspond entièrement ou partiellement, le test Robo ignore (et ne revient jamais) l'action de script Robo actuelle et exécute la suivante.

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

Suspendre Si aucune des actions de script Robo actuelles ou ultérieures ne peut correspondre entièrement ou partiellement, le script Robo est temporairement suspendu et le test Robo sélectionne une action à effectuer à l'aide de ses autres stratégies. Une fois cette action terminée, le test Robo reprend l'exécution du script Robo.

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

Priorités

Si un script Robo atteint son maxNumberOfRuns , il ne peut plus être déclenché dans un crawl donné. 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 avec trois scripts Robo qui effectuent la même action et sont déclenchés par la même condition - l'application sous 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 en cours de test est au premier plan, Robo déclenche les actions 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.

Courses répétées

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

Voici un exemple de script Robo qui met l'application en cours de test 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'un crawl Robo donné :

Étape d'exploration Description
pre_crawl Avant que Robo ne se lance et ne 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 d'exploration principale, 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 en arrière, ce qui n'est pas souhaitable dans certains scénarios.

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

Voici un exemple de script Robo qui efface les données utilisateur de l'application en cours de test 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 La priorité de cette action conditionnelle par rapport aux autres actions conditionnelles dans son script Robo contenant. Par défaut, toutes les actions conditionnelles ont une priorité de 1 .
maxNumberOfRuns Combien de fois cette action conditionnelle peut être effectuée lors d'une exécution de son script Robo contenant. Par défaut, toutes les actions conditionnelles peuvent être exécutées au plus une fois dans une seule exécution de leur script Robo contenant.
contextDescriptor Le contexte/la condition qui déclenche cette action conditionnelle. Il a la même structure et offre des fonctionnalités similaires au [contextDescriptor du script Robo](#context-descriptor).

Lorsqu'il est déclenché, un script Robo exécute ses actions non conditionnelles une par une dans l'ordre d'apparition. Si un script Robo contient des actions conditionnelles, elles sont 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 restantes, le script Robo exécute cette action conditionnelle. Sinon, le script Robo exécute 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 s'affichent à 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 ignorées 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 du script Robo qui les contient correspond à un écran lors d'une analyse Robo, quelles que soient les valeurs des attributs priority et maxNumberOfRuns .

Voici un exemple de fichier avec deux scripts Robo. Le premier script Robo oblige Robo à 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 permet à Robo d'ignorer 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 balayages de l'écran actuel. Étant donné que la taille d'un écran et le nombre de balayages nécessaires pour atteindre cet enfant sont différents pour différents facteurs de forme d'appareil, il est beaucoup plus robuste de s'appuyer sur la position des données de l'enfant, qui est absolue. C'est une approche moins robuste de compter sur le nombre de balayages nécessaires pour amener cet enfant à l'écran, puis d'utiliser sa position à l'écran.

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

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

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

  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 dans 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 parcourt d'abord 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 robotique

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 peut ê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 sous test 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 utilisant 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 de 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 logiciel.
"eventType": "SOFT_KEYBOARD_RANDOM_CLICK" Clique sur des éléments aléatoires du clavier logiciel 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 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 avec 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 utilisant 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 logiciel :

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

{
  "eventType": "DISABLE_KEYBOARD"
}

Exécuter la commande shell adb

Le tableau suivant répertorie les attributs requis :

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

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 Robo accorde toutes les autorisations à l'application sous test au début de chaque analyse, et par conséquent, cette action est une non-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 d'un écran

Cette action fait que Robo ignore tous les éléments sur n'importe quel écran qui déclenche 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 d'un écran :

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

Ignorer un élément

Cette action oblige Robo à ignorer un élément (ou des é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 ou les widgets d'interface utilisateur ignorés à l'aide de la hiérarchie de l'interface utilisateur Android.

Voici un exemple d'action de script Robo qui oblige Robo à ignorer tous les éléments dont les descriptions de contenu commencent 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 de script Robo.
"eventType": "VIEW_TEXT_CHANGED" Entre 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.

L'attribut suivant est facultatif :

  • delayTime - spécifie la durée de la pression d'un long clic, 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 à un point, au format "(x1,y1)->(x2,y2)" en pourcentages ou en pixels.

L'attribut suivant est facultatif :

  • dragAndDrop - si 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 à deux points, au format "(x1,y1)->(x2,y2),(x3,y3)->(x4,y4)" en pourcentages ou en 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 en cours, par exemple, suivant, terminé et rechercher, 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 exécute 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 de script Robo.
"eventType": "PRESSED_BACK" Envoie un événement KEYCODE_BACK à l'appareil.
"eventType": "PRESSED_BACK_EMULATOR_28" Utilisé par l'enregistreur de script Robo dans Android Studio pour appuyer sur les émulateurs API 28.

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

{
  "eventType": "PRESSED_BACK"
}

Appuyez sur accueil

Cette action envoie un événement KEYCODE_HOME à l'appareil.

Le tableau suivant répertorie les attributs requis :

Attribut Description
"eventType": "GO_HOME" --

Voici un exemple d'action de script Robo qui appuie sur home :

{
  "eventType": "GO_HOME"
}

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

Cette action permet à Robo de faire 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 correspondant 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éfilant à l'aide de la hiérarchie de l'interface utilisateur Android.
childElementDescriptors Identifie le widget de l'interface utilisateur à parcourir à l'aide de la hiérarchie de l'interface utilisateur Android.

Voici un exemple d'action de script Robo qui fait défiler le widget UI avec l'ID de ressource "my.app.package:id/scrollable_card_container" jusqu'à ce que le widget UI avec le texte "Orange" soit présent à l'écran (ou plus aucun défilement ne peut être exécuté, ou le nombre maximum de 50 défilements 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 vertical ou horizontal du widget d'interface utilisateur cible.
  • Backward - Up ou Left en fonction de la possibilité de 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 balaye 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 Robo qui prend une capture d'écran :

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

Appuyez sur un point de l'écran

Le tableau suivant répertorie les attributs requis :

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

Voici un exemple d'action de script Robo qui touche 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 La coordonnée X en pourcentage dans l'élément cible.
pointTapYPercent La coordonnée Y en pourcentage dans l'élément cible.
elementDescriptors Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie d'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 le temps 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 oblige le test Robo à attendre qu'un élément apparaisse à l'écran jusqu'au délai 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