Configurer la machine d'état IDT - AWS IoT Greengrass
Format de la machine d'étatDéfinitions d'états et d'états validesContexte des machines d'étatErreurs d'exécutionExemple de machines d'état

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Configurer la machine d'état IDT

Important

À partir de IDT v4.5.1, cette machine d'état est obsolète. Nous vous recommandons vivement d'utiliser le nouvel orchestrateur de tests. Pour plus d'informations, consultez Configurer l'orchestrateur de test IDT.

Une machine à états est une construction qui contrôle le flux d'exécution de la suite de tests. Il détermine l'état de départ d'une suite de tests, gère les transitions d'état en fonction de règles définies par l'utilisateur et continue de passer par ces états jusqu'à ce qu'il atteigne l'état final.

Si votre suite de tests n'inclut pas de machine à états définie par l'utilisateur, IDT générera une machine d'état pour vous. La machine d'état par défaut remplit les fonctions suivantes :

  • Offre aux coureurs de tests la possibilité de sélectionner et d'exécuter des groupes de tests spécifiques, au lieu de toute la suite de tests.

  • Si des groupes de tests spécifiques ne sont pas sélectionnés, exécute tous les groupes de tests de la suite de tests dans un ordre aléatoire.

  • Génère des rapports et imprime un résumé de la console qui affiche les résultats des tests pour chaque groupe de test et chaque cas de test.

La machine d'état d'une suite de tests IDT doit répondre aux critères suivants :

  • Chaque état correspond à une action que IDT doit entreprendre, par exemple pour exécuter un groupe de test ou un produit un fichier de rapport.

  • La transition vers un état exécute l'action associée à cet état.

  • Chaque état définit la règle de transition pour l'état suivant.

  • L'état final doit êtreSucceedouFail.

Format de la machine d'état

Vous pouvez utiliser le modèle suivant pour configurer le vôtre<custom-test-suite-folder>/suite/state_machine.jsondans le fichier: 

{
  "Comment": "<description>",
  "StartAt": "<state-name>",
  "States": {
    "<state-name>": {
      "Type": "<state-type>",
      // Additional state configuration
    }
    
    // Required states
    "Succeed": {
      "Type": "Succeed"
    },
    "Fail": {
      "Type": "Fail"
    }
  }
}

Tous les champs qui contiennent des valeurs sont requis, comme indiqué ici :

Comment

Description de la machine d'état.

StartAt

Nom de l'état auquel IDT commence à exécuter la suite de tests. PourStartAtdoit être défini sur l'un des états répertoriés dans laStatesobjet.

States

Objet qui mappe les noms d'états définis par l'utilisateur à des états IDT valides. Chaque État.nom d'étatcontient la définition d'un état valide mappé à lanom d'état.

LeStatesl'objet doit inclure leSucceedetFailÉtats. Pour plus d'informations sur les états valides, consultezDéfinitions d'états et d'états valides.

Définitions d'états et d'états valides

Cette section décrit les définitions d'état de tous les états valides pouvant être utilisés dans la machine d'état IDT. Certains des états suivants prennent en charge les configurations au niveau du cas de test. Toutefois, nous vous recommandons de configurer des règles de transition d'état au niveau du groupe de test plutôt qu'au niveau du scénario de test, sauf si cela est absolument nécessaire.

RunTask

LeRunTaskL'état exécute les cas de tests d'un groupe de tests défini dans la suite de tests.

{
    "Type": "RunTask",
    "Next": "<state-name>",
    "TestGroup": "<group-id>",
    "TestCases": [
        "<test-id>"
    ],
    "ResultVar": "<result-name>"
}

Tous les champs qui contiennent des valeurs sont requis, comme indiqué ici :

Next

Nom de l'état auquel passer après avoir exécuté les actions de l'état actuel.

TestGroup

Facultatif. ID du groupe de test à exécuter. Si cette valeur n'est pas spécifiée, IDT exécute le groupe de test sélectionné par le lanceur de test.

TestCases

Facultatif. Tableau d'ID de cas de test du groupe spécifié dansTestGroup. Basé sur les valeurs deTestGroupetTestCases, IDT détermine le comportement d'exécution du test comme suit :

  • Quand les deuxTestGroupetTestCasessont spécifiés, IDT exécute les cas de test spécifiés à partir du groupe de tests.

  • QuandTestCasessont spécifiés maisTestGroupn'est pas spécifié, IDT exécute les cas de test spécifiés.

  • QuandTestGroupest spécifié, maisTestCasesn'est pas spécifié, IDT exécute tous les cas de tests du groupe de tests spécifié.

  • Quand aucun des deuxTestGroupouTestCasesest spécifié, IDT exécute tous les cas de test du groupe de test sélectionné par le lanceur de test dans l'interface de ligne de commande IDT. Pour activer la sélection de groupes pour les coureurs d'essais, vous devez inclure les deuxRunTasketChoiceétats dans votrestate_machine.jsondans le fichier. Pour obtenir un exemple montrant la façon dont cela fonctionne, consultezExemple de machine d'état : Exécuter des groupes de test sélectionnés par l'utilisateur.

    Pour plus d'informations sur l'activation des commandes IDT CLI pour les exécuteurs de tests, consultezActiver les commandes CLI IDT.

ResultVar

Nom de la variable de contexte à définir avec les résultats de l'exécution du test. Ne spécifiez pas cette valeur si vous n'avez pas spécifié de valeur pourTestGroup. IDT définit la valeur de la variable que vous définissez dansResultVarpourtrueoufalsebasé sur les éléments suivants :

  • Si le nom de la variable est du formulairetext_text_passed, la valeur est alors définie sur si tous les tests du premier groupe de test ont réussi ou ont été ignorés.

  • Dans tous les autres cas, la valeur est définie sur si tous les tests de tous les groupes de tests ont réussi ou ont été ignorés.

En général, vous utiliserezRunTaskpour spécifier un ID de groupe de test sans spécifier d'ID de cas de test individuels, de sorte qu'IDT exécute tous les cas de test dans le groupe de test spécifié. Tous les cas de test exécutés par cet état sont exécutés en parallel, dans un ordre aléatoire. Toutefois, si tous les cas de test nécessitent l'exécution d'un périphérique et qu'un seul appareil est disponible, les cas de test seront exécutés de manière séquentielle.

Gestion des erreurs

Si l'un des groupes de test ou des identifiants de cas de test spécifiés n'est pas valide, cet état émet la valeurRunTaskErrorErreur d'exécution. Si l'état rencontre une erreur d'exécution, il définit également le paramètrehasExecutionErrorvariable dans le contexte de la machine à étatstrue.

Choice

LeChoicevous permet de définir dynamiquement l'état suivant vers lequel passer la transition en fonction des conditions définies par l'utilisateur.

{
    "Type": "Choice",
    "Default": "<state-name>", 
    "FallthroughOnError": true | false,
    "Choices": [
        {
            "Expression": "<expression>",
            "Next": "<state-name>"
        }
    ]
}

Tous les champs qui contiennent des valeurs sont requis, comme indiqué ici :

Default

L'état par défaut auquel passer si aucune des expressions définies dansChoicespeuvent être évalués pourtrue.

FallthroughOnError

Facultatif. Spécifie le comportement lorsque l'état rencontre une erreur lors de l'évaluation des expressions. Définissez surtruesi vous souhaitez ignorer une expression si l'évaluation entraîne une erreur. Si aucune expression ne correspond, la machine d'état passe àDefaultÉtat. Si l'icôneFallthroughOnErrorLa valeur n'est pas spécifiée, elle est par défautfalse.

Choices

Tableau d'expressions et d'états permettant de déterminer l'état vers lequel effectuer la transition après avoir exécuté les actions dans l'état actuel.

Choices.Expression

Chaîne d'expression qui correspond à une valeur booléenne. Si l'expression est évaluée àtrue, puis la machine d'état passe à l'état défini dansChoices.Next. Les chaînes d'expression récupèrent les valeurs du contexte de la machine d'état, puis effectuent des opérations sur elles pour obtenir une valeur booléenne. Pour plus d'informations sur l'accès au contexte de la machine d'état, voirContexte des machines d'état.

Choices.Next

Nom de l'état auquel passer si l'expression définie dansChoices.Expressionévalue àtrue.

Gestion des erreurs

LeChoicel'état peut nécessiter la gestion des erreurs dans les cas suivants :

  • Certaines variables des expressions de choix n'existent pas dans le contexte de la machine d'état.

  • Le résultat d'une expression n'est pas une valeur booléenne.

  • Le résultat d'une recherche JSON n'est pas une chaîne, un nombre ou un booléen.

Vous ne pouvez pas utiliser unCatchpour gérer les erreurs de cet état. Si vous souhaitez arrêter l'exécution de la machine d'état en cas d'erreur, vous devez définirFallthroughOnErrorpourfalse. Toutefois, nous vous recommandons de définirFallthroughOnErrorpourtrue, et selon votre cas d'utilisation, effectuez l'une des actions suivantes :

  • Si une variable à laquelle vous accédez ne devrait pas exister dans certains cas, utilisez la valeur deDefaultet d'autresChoicesblocs pour spécifier l'état suivant.

  • Si une variable à laquelle vous accédez doit toujours exister, définissez la valeurDefaultÉtat àFail.

Parallèle

LeParallelvous permet de définir et d'exécuter de nouvelles machines à états parallel les unes aux autres.

{
    "Type": "Parallel",
    "Next": "<state-name>",
    "Branches": [
        <state-machine-definition>
    ]
}

Tous les champs qui contiennent des valeurs sont requis, comme indiqué ici :

Next

Nom de l'état auquel passer après avoir exécuté les actions de l'état actuel.

Branches

Tableau de définitions de machines à états à exécuter. Chaque définition de machine d'état doit contenir la sienneStartAt,Succeed, etFailÉtats. Les définitions de machines d'état de cette baie ne peuvent pas faire référence à des états en dehors de leur propre définition.

Note

Étant donné que chaque machine d'état de branche partage le même contexte de machine d'état, la définition de variables dans une branche, puis la lecture de ces variables à partir d'une autre branche peut entraîner un comportement inattendu.

LeParallelstate passe à l'état suivant uniquement après avoir exécuté toutes les machines d'état de branche. Chaque état nécessitant un appareil attend d'être exécuté jusqu'à ce que l'appareil soit disponible. Si plusieurs appareils sont disponibles, cet état exécute des scénarios de test à partir de plusieurs groupes en parallel. Si suffisamment de périphériques ne sont pas disponibles, les cas de test seront exécutés de manière séquentielle. Étant donné que les cas de test sont exécutés dans un ordre aléatoire lorsqu'ils sont exécutés en parallel, différents périphériques peuvent être utilisés pour exécuter des tests à partir du même groupe de tests.

Gestion des erreurs

Assurez-vous que la machine d'état de branche et la machine d'état parent passent à laFailpour gérer les erreurs d'exécution.

Étant donné que les machines d'état de branche ne transmettent pas d'erreurs d'exécution à la machine d'état parente, vous ne pouvez pas utiliser unCatchpour gérer les erreurs d'exécution dans les machines d'état de branche. Utilisez plutôt lehasExecutionErrorsvaleur dans le contexte de la machine à états partagés. Pour obtenir un exemple montrant la façon dont cela fonctionne, consultezExemple de machine d'état : Exécutez deux groupes de tests en parallel.

Ajouter des fonctionnalités du produit

LeAddProductFeaturesvous permet d'ajouter des fonctionnalités du produit à laawsiotdevicetester_report.xmlfichier généré par IDT.

Une fonctionnalité produit est constituée d'informations définies par l'utilisateur sur des critères spécifiques auxquels un appareil peut répondre. Par exemple, les recettesMQTTpeut indiquer que l'appareil publie correctement les messages MQTT. Dans le rapport, les fonctionnalités du produit sont définies comme suit :supported,not-supported, ou une valeur personnalisée, selon que les tests spécifiés ont réussi ou non.

Note

LeAddProductFeaturesstate ne génère pas de rapports par lui-même. Cet état doit passer à laReportétatpour générer des rapports.

{
    "Type": "Parallel",
    "Next": "<state-name>",
    "Features": [
        {
            "Feature": "<feature-name>", 
            "Groups": [
                "<group-id>"
            ],
            "OneOfGroups": [
                "<group-id>"
            ],
            "TestCases": [
                "<test-id>"
            ],
            "IsRequired": true | false,
            "ExecutionMethods": [
                "<execution-method>"
            ]
        }
    ]
}

Tous les champs qui contiennent des valeurs sont requis, comme indiqué ici :

Next

Nom de l'état auquel passer après avoir exécuté les actions de l'état actuel.

Features

Un éventail de fonctionnalités du produit à afficher dans leawsiotdevicetester_report.xmldans le fichier.

Feature

Nom de la fonction

FeatureValue

Facultatif. La valeur personnalisée à utiliser dans le rapport au lieu desupported. Si cette valeur n'est pas spécifiée, en fonction des résultats des tests, la valeur de l'entité est définie sursupportedounot-supported.

Si vous utilisez une valeur personnalisée pourFeatureValue, vous pouvez tester la même fonction avec des conditions différentes, et IDT concaténe les valeurs des entités pour les conditions prises en charge. Par exemple, l'extrait suivant montre laMyFeatureavec deux valeurs d'entités distinctes :

...
{
    "Feature": "MyFeature",
    "FeatureValue": "first-feature-supported",
    "Groups": ["first-feature-group"]
},
{
    "Feature": "MyFeature",
    "FeatureValue": "second-feature-supported",
    "Groups": ["second-feature-group"]
},
...

Si les deux groupes de test réussissent, la valeur de l'entité est définie surfirst-feature-supported, second-feature-supported.

Groups

Facultatif. Tableau des ID de groupe de test. Tous les tests au sein de chaque groupe de test spécifié doivent réussir pour que la fonctionnalité soit prise en charge.

OneOfGroups

Facultatif. Tableau des ID de groupe de test. Tous les tests au sein d'au moins un des groupes de tests spécifiés doivent réussir pour que la fonctionnalité soit prise en charge.

TestCases

Facultatif. Tableau des ID de cas de test. Si vous spécifiez cette valeur, les éléments suivants s'appliquent :

  • Tous les cas de test spécifiés doivent réussir pour que la fonctionnalité soit prise en charge.

  • GroupsVous devez contenir un seul ID de groupe de tests.

  • OneOfGroupsne doit pas être spécifié.

IsRequired

Facultatif. Définissez surfalsepour marquer cette fonctionnalité comme une fonctionnalité facultative dans le rapport. La valeur par défaut est true.

ExecutionMethods

Facultatif. Un tableau de méthodes d'exécution qui correspondent à laprotocolvaleur spécifiée dans ledevice.jsondans le fichier. Si cette valeur est spécifiée, les exécuteurs de test doivent spécifier unprotocolvaleur qui correspond à l'une des valeurs de ce tableau pour inclure l'entité dans le rapport. Si cette valeur n'est pas spécifiée, l'entité sera toujours incluse dans le rapport.

Pour utiliser le pluginAddProductFeatures, vous devez définir la valeur deResultVardans leRunTaskindique l'une des valeurs suivantes :

  • Si vous avez spécifié des ID de cas de test individuels, définissezResultVarpourgroup-id_test-id_passed.

  • Si vous n'avez pas spécifié d'ID de cas de test individuels, définissezResultVarpourgroup-id_passed.

LeAddProductFeaturesvérifie l'état des résultats des tests de la façon suivante :

  • Si vous n'avez pas spécifié d'ID de cas de test, le résultat de chaque groupe de test est déterminé à partir de la valeur du paramètregroup-id_passedvariable dans le contexte de la machine d'état.

  • Si vous avez spécifié des ID de cas de test, le résultat de chacun des tests est déterminé à partir de la valeur de lagroup-id_test-id_passedvariable dans le contexte de la machine d'état.

Gestion des erreurs

Si un ID de groupe fourni dans cet état n'est pas un ID de groupe valide, cet état génère la valeurAddProductFeaturesErrorErreur d'exécution. Si l'état rencontre une erreur d'exécution, il définit également le paramètrehasExecutionErrorsvariable dans le contexte de la machine à étatstrue.

Rapport

LeReportgénère lesuite-name_Report.xmletawsiotdevicetester_report.xmlfichiers suivants. Cet état diffuse également le rapport vers la console.

{
    "Type": "Report",
    "Next": "<state-name>"
}

Tous les champs qui contiennent des valeurs sont requis, comme indiqué ici :

Next

Nom de l'état auquel passer après avoir exécuté les actions de l'état actuel.

Vous devez toujours passer auReportvers la fin du flux d'exécution du test afin que les coureurs de test puissent afficher les résultats des tests. Généralement, l'état suivant après cet état estSucceed.

Gestion des erreurs

Si cet état rencontre des problèmes lors de la génération des rapports, il émet la commandeReportErrorErreur d'exécution.

Message de journal

LeLogMessagegénère letest_manager.loget transmet le message de journal en continu dans la console.

{
    "Type": "LogMessage",
    "Next": "<state-name>"
    "Level": "info | warn | error"
    "Message": "<message>"
}

Tous les champs qui contiennent des valeurs sont requis, comme indiqué ici :

Next

Nom de l'état auquel passer après avoir exécuté les actions de l'état actuel.

Level

Niveau d'erreur auquel créer le message de journal. Si vous spécifiez un niveau non valide, cet état génère un message d'erreur et le rejette.

Message

Message à enregistrer.

Sélectionner un groupe

LeSelectGroupstate met à jour le contexte de la machine d'état pour indiquer quels groupes sont sélectionnés. Les valeurs définies par cet état sont utilisées par les autresChoiceÉtats.

{
    "Type": "SelectGroup",
    "Next": "<state-name>"
    "TestGroups": [
        <group-id>"
    ]
}

Tous les champs qui contiennent des valeurs sont requis, comme indiqué ici :

Next

Nom de l'état auquel passer après avoir exécuté les actions de l'état actuel.

TestGroups

Tableau de groupes de tests qui seront marqués comme sélectionnés. Pour chaque ID de groupe de test de cette baie, legroup-id_selectedest définie surtruedans le contexte. Assurez-vous de fournir des ID de groupe de test valides, car IDT ne vérifie pas si les groupes spécifiés existent.

Fail

LeFailindique que la machine d'état ne s'est pas exécutée correctement. Il s'agit d'un état final pour la machine à états, et chaque définition de machine d'état doit inclure cet état.

{
    "Type": "Fail"
}

Succeed

LeSucceedindique que la machine d'état a été correctement exécutée. Il s'agit d'un état final pour la machine à états, et chaque définition de machine d'état doit inclure cet état.

{
    "Type": "Succeed"
}

Contexte des machines d'état

Le contexte de la machine d'état est un document JSON en lecture seule qui contient des données disponibles pour la machine à états pendant l'exécution. Le contexte de la machine d'état est accessible uniquement à partir de la machine à états et contient des informations qui déterminent le flux de test. Par exemple, vous pouvez utiliser les informations configurées par les exécuteurs de tests dans leuserdata.jsonpour déterminer si un test spécifique est nécessaire à l'exécution.

Le contexte de la machine d'état utilise le format suivant :

{
    "pool": {
        <device-json-pool-element>
    },
    "userData": {
        <userdata-json-content>
    },
    "config": {
        <config-json-content>
    },
    "suiteFailed": true | false,
    "specificTestGroups": [
        "<group-id>"
    ],
    "specificTestCases": [
        "<test-id>"
    ],
    "hasExecutionErrors": true
}
pool

Informations sur le pool de périphériques sélectionné pour le test. Pour un pool de périphériques sélectionné, ces informations sont extraites de l'élément de tableau de pool de périphériques de niveau supérieur correspondant défini dans ledevice.jsondans le fichier.

userData

Informations dans leuserdata.jsondans le fichier.

config

Épinglez les informationsconfig.jsondans le fichier.

suiteFailed

La valeur est définie surfalseLorsque la machine d'état démarre. Si un groupe de test échoue dans unRunTask, cette valeur est alors définie surtruependant la durée restante de l'exécution de la machine d'état.

specificTestGroups

Si le lanceur de tests sélectionne des groupes de tests spécifiques à exécuter au lieu de toute la suite de tests, cette clé est créée et contient la liste des ID de groupes de tests spécifiques.

specificTestCases

Si le lanceur de tests sélectionne des cas de test spécifiques à exécuter au lieu de toute la suite de tests, cette clé est créée et contient la liste des ID de cas de test spécifiques.

hasExecutionErrors

Ne se ferme pas lorsque la machine d'état démarre. Si un état rencontre des erreurs d'exécution, cette variable est créée et définie surtruependant la durée restante de l'exécution de la machine d'état.

Vous pouvez interroger le contexte à l'aide de la notation JSONPath. La syntaxe des requêtes JSONPath dans les définitions d'état est{{$.query}}. Vous pouvez utiliser des requêtes JSONPath comme chaînes d'espace réservé dans certains états. IDT remplace les chaînes d'espace réservé par la valeur de la requête JSONPath évaluée à partir du contexte. Vous pouvez utiliser des espaces réservés pour les valeurs suivantes :

  • LeTestCasesvaleur dansRunTaskÉtats.

  • LeExpressionvaleurChoiceÉtat.

Lorsque vous accédez à des données depuis le contexte de la machine d'état, vérifiez que les conditions suivantes sont remplies :

  • Vos chemins JSON doivent commencer par$.

  • Chaque valeur doit être évaluée en chaîne, en nombre ou en booléen.

Pour plus d'informations sur l'utilisation de la notation JSONPath pour accéder aux données du contexte, consultezUtiliser le contexte IDT.

Erreurs d'exécution

Les erreurs d'exécution sont des erreurs dans la définition de la machine d'état rencontrées par la machine d'état lors de l'exécution d'un état. IDT enregistre les informations relatives à chaque erreur dans letest_manager.loget transmet le message de journal en continu dans la console.

Vous pouvez utiliser les méthodes suivantes pour gérer les erreurs d'exécution :

Capture

Pour utiliserCatch, ajoutez ce qui suit à votre définition d'état :

"Catch": [
    {    
        "ErrorEquals": [
            "<error-type>"
        ]
        "Next": "<state-name>" 
    }
]

Tous les champs qui contiennent des valeurs sont requis, comme indiqué ici :

Catch.ErrorEquals

Tableau des types d'erreurs à catch. Si une erreur d'exécution correspond à l'une des valeurs spécifiées, la machine d'état passe à l'état spécifié dansCatch.Next. Consultez chaque définition d'état pour plus d'informations sur le type d'erreur qu'elle produit.

Catch.Next

État suivant à passer si l'état actuel rencontre une erreur d'exécution correspondant à l'une des valeurs spécifiées dansCatch.ErrorEquals.

Les blocs de capture sont gérés de manière séquentielle jusqu'à ce qu'ils correspondent. Si les erreurs sans erreur correspondent à celles répertoriées dans les blocs Catch, les machines d'état continuent de s'exécuter. Étant donné que les erreurs d'exécution sont le résultat de définitions d'état incorrectes, nous vous recommandons de passer à l'état Échec lorsqu'un état rencontre une erreur d'exécution.

Erreur d'exécution

Lorsque certains états rencontrent des erreurs d'exécution, en plus d'émettre l'erreur, ils définissent également le paramètrehasExecutionErrorvaleur pourtruedans le contexte de la machine d'état. Vous pouvez utiliser cette valeur pour détecter quand une erreur se produit, puis utiliser unChoicepour faire passer la machine à états vers leFailÉtat.

Cette méthode possède les caractéristiques suivantes.

  • La machine d'état ne démarre avec aucune valeur attribuée àhasExecutionError, et cette valeur n'est pas disponible tant qu'un état particulier ne l'a pas définie. Cela signifie que vous devez définir explicitement laFallthroughOnErrorpourfalsepour laChoiceles états qui accèdent à cette valeur pour empêcher l'arrêt de la machine d'état si aucune erreur d'exécution ne se produit.

  • Une fois qu'il est réglé surtrue,hasExecutionErrorn'est jamais défini sur false ou supprimé du contexte. Cela signifie que cette valeur n'est utile que la première fois qu'elle est définie surtrue, et pour tous les États subséquents, il ne fournit pas de valeur significative.

  • LehasExecutionErrorest partagée avec toutes les machines d'état de branche dans leParallel, ce qui peut entraîner des résultats inattendus en fonction de l'ordre dans lequel il est accédé.

En raison de ces caractéristiques, nous ne recommandons pas d'utiliser cette méthode si vous pouvez utiliser un bloc Catch à la place.

Exemple de machines d'état

Cette section fournit quelques exemples de configurations de machines d'état.

Exemple de machine d'état : Exécutez un groupe de test unique

Cette machine d'état :

  • Exécute le groupe de test avec l'identifiantGroupA, qui doit être présente dans la suite d'ungroup.jsondans le fichier.

  • Vérifie les erreurs d'exécution et les transitions versFails'il y en a.

  • Génère un rapport et effectue des transitions versSucceeds'il n'y a pas d'erreurs, etFailautrement.

{
    "Comment": "Runs a single group and then generates a report.",
    "StartAt": "RunGroupA",
    "States": {
        "RunGroupA": {
            "Type": "RunTask",
            "Next": "Report",
            "TestGroup": "GroupA",
            "Catch": [
                {
                    "ErrorEquals": [
                        "RunTaskError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Report": {
            "Type": "Report",
            "Next": "Succeed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "ReportError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Succeed": {
            "Type": "Succeed"
        },
        "Fail": {
            "Type": "Fail"
        }
    }
}

Exemple de machine d'état : Exécuter des groupes de test sélectionnés par l'utilisateur

Cette machine d'état :

  • Vérifie si le coureur de test a sélectionné des groupes de test spécifiques. La machine d'état ne vérifie pas les cas de test spécifiques car les exécuteurs de tests ne peuvent pas sélectionner de cas de test sans avoir également sélectionné un groupe de test.

  • Si les groupes de test sont sélectionnés :

    • Exécute les cas de test au sein des groupes de test sélectionnés. Pour ce faire, la machine d'état ne spécifie explicitement aucun groupe de test ni aucun cas de test dans leRunTaskÉtat.

    • Génère un rapport après avoir exécuté tous les tests et les sorties.

  • Si les groupes de test ne sont pas sélectionnés :

    • Exécute des tests dans un groupe de testGroupA.

    • Génère des rapports et des sorties.

{
    "Comment": "Runs specific groups if the test runner chose to do that, otherwise runs GroupA.",
    "StartAt": "SpecificGroupsCheck",
    "States": {
        "SpecificGroupsCheck": {
            "Type": "Choice",
            "Default": "RunGroupA",
            "FallthroughOnError": true,
            "Choices": [
                {
                    "Expression": "{{$.specificTestGroups[0]}} != ''",
                    "Next": "RunSpecificGroups"
                }
            ]
        },
        "RunSpecificGroups": {
            "Type": "RunTask",
            "Next": "Report",
            "Catch": [
                {
                    "ErrorEquals": [
                        "RunTaskError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "RunGroupA": {
            "Type": "RunTask",
            "Next": "Report",
            "TestGroup": "GroupA",
            "Catch": [
                {
                    "ErrorEquals": [
                        "RunTaskError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Report": {
            "Type": "Report",
            "Next": "Succeed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "ReportError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Succeed": {
            "Type": "Succeed"
        },
        "Fail": {
            "Type": "Fail"
        }
    }
}

Exemple de machine d'état : Exécutez un groupe de test unique avec des fonctionnalités du produit

Cette machine d'état :

  • Exécutez le groupe de testGroupA.

  • Vérifie les erreurs d'exécution et les transitions versFails'il y en a.

  • Ajoute leFeatureThatDependsOnGroupAfonction deawsiotdevicetester_report.xmldans le fichier:

    • SiGroupApasse, la fonction est définie sursupported.

    • La fonctionnalité n'est pas marquée comme facultative dans le rapport.

  • Génère un rapport et effectue des transitions versSucceeds'il n'y a pas d'erreurs, etFailautrement

{
    "Comment": "Runs GroupA and adds product features based on GroupA",
    "StartAt": "RunGroupA",
    "States": {
        "RunGroupA": {
            "Type": "RunTask",
            "Next": "AddProductFeatures",
            "TestGroup": "GroupA",
            "ResultVar": "GroupA_passed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "RunTaskError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "AddProductFeatures": {
            "Type": "AddProductFeatures",
            "Next": "Report",
            "Features": [
                {
                    "Feature": "FeatureThatDependsOnGroupA",
                    "Groups": [
                        "GroupA"
                    ],
                    "IsRequired": true
                }
            ]
        },
        "Report": {
            "Type": "Report",
            "Next": "Succeed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "ReportError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Succeed": {
            "Type": "Succeed"
        },
        "Fail": {
            "Type": "Fail"
        }
    }
}

Exemple de machine d'état : Exécutez deux groupes de tests en parallel

Cette machine d'état :

  • Exécutez leGroupAetGroupBgroupes de test en parallel. LeResultVarvariables stockées dans le contexte par leRunTaskles états dans les machines d'état de branche sont disponibles pour leAddProductFeaturesÉtat.

  • Vérifie les erreurs d'exécution et les transitions versFails'il y en a. Cette machine d'état n'utilise pas deCatchbloc car cette méthode ne détecte pas les erreurs d'exécution dans les machines d'état de branche.

  • Ajoute des fonctionnalités auawsiotdevicetester_report.xmlfichier basé sur les groupes qui passent

    • SiGroupApasse, la fonction est définie sursupported.

    • La fonctionnalité n'est pas marquée comme facultative dans le rapport.

  • Génère un rapport et effectue des transitions versSucceeds'il n'y a pas d'erreurs, etFailautrement

Si deux appareils sont configurés dans le pool de périphériques, les deuxGroupAetGroupBpeut fonctionner en même temps. Toutefois, si l'un ou l'autreGroupAouGroupBcontient plusieurs tests, puis les deux appareils peuvent être alloués à ces tests. Si un seul appareil est configuré, les groupes de test seront exécutés de manière séquentielle.

{
    "Comment": "Runs GroupA and GroupB in parallel",
    "StartAt": "RunGroupAAndB",
    "States": {
        "RunGroupAAndB": {
            "Type": "Parallel",
            "Next": "CheckForErrors",
            "Branches": [
                {
                    "Comment": "Run GroupA state machine",
                    "StartAt": "RunGroupA",
                    "States": {
                        "RunGroupA": {
                            "Type": "RunTask",
                            "Next": "Succeed",
                            "TestGroup": "GroupA",
                            "ResultVar": "GroupA_passed",
                            "Catch": [
                                {
                                    "ErrorEquals": [
                                        "RunTaskError"
                                    ],
                                    "Next": "Fail"
                                }
                            ]
                        },
                        "Succeed": {
                            "Type": "Succeed"
                        },
                        "Fail": {
                            "Type": "Fail"
                        }
                    }
                },
                {
                    "Comment": "Run GroupB state machine",
                    "StartAt": "RunGroupB",
                    "States": {
                        "RunGroupA": {
                            "Type": "RunTask",
                            "Next": "Succeed",
                            "TestGroup": "GroupB",
                            "ResultVar": "GroupB_passed",
                            "Catch": [
                                {
                                    "ErrorEquals": [
                                        "RunTaskError"
                                    ],
                                    "Next": "Fail"
                                }
                            ]
                        },
                        "Succeed": {
                            "Type": "Succeed"
                        },
                        "Fail": {
                            "Type": "Fail"
                        }
                    }
                }
            ]
        },
        "CheckForErrors": {
            "Type": "Choice",
            "Default": "AddProductFeatures",
            "FallthroughOnError": true,
            "Choices": [
                {
                    "Expression": "{{$.hasExecutionErrors}} == true",
                    "Next": "Fail"
                }
            ]
        },
        "AddProductFeatures": {
            "Type": "AddProductFeatures",
            "Next": "Report",
            "Features": [
                {
                    "Feature": "FeatureThatDependsOnGroupA",
                    "Groups": [
                        "GroupA"
                    ],
                    "IsRequired": true
                },
                {
                    "Feature": "FeatureThatDependsOnGroupB",
                    "Groups": [
                        "GroupB"
                    ],
                    "IsRequired": true
                }
            ]
        },
        "Report": {
            "Type": "Report",
            "Next": "Succeed",
            "Catch": [
                {
                    "ErrorEquals": [
                        "ReportError"
                    ],
                    "Next": "Fail"
                }
            ]
        },
        "Succeed": {
            "Type": "Succeed"
        },
        "Fail": {
            "Type": "Fail"
        }
    }
}