View a markdown version of this page

Configuration de la machine d'état IDT - FreeRTOS
Format de machine à étatsÉtats et définitions d'états validesContexte de la machine à étatsErreurs d'exécutionExemples de machines à états

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.

Configuration de la machine d'état IDT

Important

À partir de la version 4.5.2 d'IDT, cette machine à états est obsolète. Nous vous recommandons vivement d'utiliser le nouvel orchestrateur de tests. Pour de plus amples informations, veuillez consulter Configuration de l'orchestrateur de tests 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 poursuit la transition entre ces états jusqu'à atteindre 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 à états pour vous. La machine à états par défaut exécute les fonctions suivantes :

  • Permet aux testeurs de sélectionner et d'exécuter des groupes de tests spécifiques, plutôt que l'ensemble de la suite de tests.

  • Si aucun groupe de test spécifique n'est sélectionné, exécute chaque groupe de test 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 l'IDT doit effectuer, par exemple exécuter un groupe de test ou produire un fichier de rapport.

  • Le passage à un état exécute l'action associée à l'état.

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

  • L'état final doit être l'un Succeed ou l'autreFail.

Format de machine à états

Vous pouvez utiliser le modèle suivant pour configurer votre propre <custom-test-suite-folder>/suite/state_machine.json 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 à états.

StartAt

Nom de l'état dans lequel IDT commence à exécuter la suite de tests. La valeur de StartAt doit être définie sur l'un des états répertoriés dans l'Statesobjet.

States

Objet qui associe des noms d'état définis par l'utilisateur à des états IDT valides. Chaque État. state-nameobjet contient la définition d'un état valide mappé austate-name.

L'Statesobjet doit inclure les Fail états Succeed et. Pour plus d'informations sur les états valides, consultezÉtats et définitions d'états valides.

États et définitions d'états valides

Cette section décrit les définitions d'état de tous les états valides qui peuvent être utilisés dans la machine à états IDT. Certains des états suivants prennent en charge les configurations au niveau du scénario de test. Cependant, nous vous recommandons de configurer les 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

L'RunTaskÉtat exécute des cas de test à partir 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 vers lequel effectuer la transition après avoir exécuté les actions dans l'état actuel.

TestGroup

Facultatif. L'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 testeur.

TestCases

Facultatif. Tableau d'identifiants de cas de test appartenant au groupe spécifié dansTestGroup. Sur la base des valeurs de TestGroup etTestCases, IDT détermine le comportement d'exécution du test comme suit :

  • Lorsque les deux TestGroup et TestCases sont spécifiés, IDT exécute les cas de test spécifiés à partir du groupe de tests.

  • Lorsque TestCases sont spécifiés mais ne TestGroup sont pas spécifiés, IDT exécute les cas de test spécifiés.

  • Lorsque cela TestGroup est spécifié, mais n'TestCasesest pas spécifié, IDT exécute tous les cas de test au sein du groupe de test spécifié.

  • Lorsque ni l'TestGroupun ni l'autre n'TestCasesest spécifié, IDT exécute tous les cas de test à partir du groupe de tests sélectionné par le testeur dans la CLI IDT. Pour permettre la sélection de groupes pour les testeurs, vous devez inclure à la fois RunTask des Choice états et des états dans votre statemachine.json fichier. Pour un exemple de la façon dont cela fonctionne, voir Exemple de machine à états : Exécuter des groupes de tests sélectionnés par l'utilisateur.

    Pour plus d'informations sur l'activation des commandes IDT CLI pour les testeurs, consultezActiver les commandes IDT CLI.

ResultVar

Le nom de la variable de contexte à définir avec les résultats 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 ResultVar selon true ou sur la false base des éléments suivants :

  • Si le nom de la variable est de la formetext_text_passed, la valeur est définie selon que tous les tests du premier groupe de tests ont réussi ou ont été ignorés.

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

Généralement, vous utiliserez RunTask state pour spécifier un ID de groupe de test sans spécifier d'ID de cas de test individuel, de sorte qu'IDT exécute tous les cas de test du groupe de test spécifié. Tous les cas de test exécutés par cet état s'exécutent en parallèle, dans un ordre aléatoire. Toutefois, si tous les scénarios de test nécessitent l'exécution d'un périphérique et qu'un seul appareil est disponible, les scénarios de test seront exécutés de manière séquentielle.

Gestion des erreurs

Si l'un des groupes de test ou des ID de cas de test spécifiés n'est pas valide, cet état génère une erreur d'RunTaskErrorexécution. Si l'état rencontre une erreur d'exécution, il définit également la hasExecutionError variable dans le contexte de la machine à états surtrue.

Choice

L'Choiceétat vous permet de définir dynamiquement l'état suivant vers lequel effectuer la transition en fonction de 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 vers lequel effectuer la transition si aucune des expressions définies dans ne Choices peut être évaluéetrue.

FallthroughOnError

Facultatif. Spécifie le comportement lorsque l'état rencontre une erreur lors de l'évaluation des expressions. Définissez cette option sur true si vous souhaitez ignorer une expression si l'évaluation entraîne une erreur. Si aucune expression ne correspond, la machine à états passe à l'Defaultétat. Si la FallthroughOnError valeur n'est pas spécifiée, sa valeur par défaut est. false

Choices

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

Choices.Expression

Chaîne d'expression qui donne une valeur booléenne. Si l'expression est évaluée àtrue, la machine à états passe à l'état défini dansChoices.Next. Les chaînes d'expression extraient les valeurs du contexte de la machine à états, puis effectuent des opérations sur celles-ci pour obtenir une valeur booléenne. Pour plus d'informations sur l'accès au contexte de la machine à états, consultezContexte de la machine à états.

Choices.Next

Le nom de l'état vers lequel effectuer la transition si l'expression définie dans est Choices.Expression évaluée àtrue.

Gestion des erreurs

L'Choiceétat peut nécessiter une gestion des erreurs dans les cas suivants :

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

  • 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 un Catch bloc pour gérer les erreurs dans cet état. Si vous souhaitez arrêter d'exécuter la machine d'état lorsqu'elle rencontre une erreur, vous devez FallthroughOnError définir surfalse. Cependant, nous vous recommandons de définir ettrue, FallthroughOnError selon votre cas d'utilisation, d'effectuer l'une des opérations suivantes :

  • Si une variable à laquelle vous accédez est censée ne pas exister dans certains cas, utilisez la valeur de Default et des Choices blocs supplémentaires pour spécifier l'état suivant.

  • Si une variable à laquelle vous accédez doit toujours exister, définissez son Default état surFail.

Parallèle

L'Parallelétat vous permet de définir et d'exécuter de nouvelles machines à états en parallèle les unes avec les 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 vers lequel effectuer la transition après avoir exécuté les actions dans l'état actuel.

Branches

Un tableau de définitions de machines à états à exécuter. Chaque définition de machine à états doit contenir ses propres Fail états StartAtSucceed, et. Les définitions de machines à états de ce tableau ne peuvent pas faire référence à des états en dehors de leur propre définition.

Note

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

L'Parallelétat passe à l'état suivant uniquement après avoir exécuté toutes les machines d'état de la branche. Chaque état nécessitant un périphérique attendra de s'exécuter jusqu'à ce que celui-ci soit disponible. Si plusieurs appareils sont disponibles, cet état exécute des scénarios de test provenant de plusieurs groupes en parallèle. S'il n'y a pas suffisamment d'appareils disponibles, les scénarios de test seront exécutés de manière séquentielle. Étant donné que les scénarios de test sont exécutés dans un ordre aléatoire lorsqu'ils sont exécutés en parallèle, différents appareils peuvent être utilisés pour exécuter des tests à partir du même groupe de tests.

Gestion des erreurs

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

Étant donné que les machines à état de branche ne transmettent pas d'erreurs d'exécution à la machine à état parent, vous ne pouvez pas utiliser de Catch bloc pour gérer les erreurs d'exécution dans les machines à état de branche. Utilisez plutôt la hasExecutionErrors valeur dans le contexte de la machine à états partagée. Pour un exemple de la façon dont cela fonctionne, voirExemple de machine à états : exécutez deux groupes de tests en parallèle.

AddProductFeatures

L'AddProductFeaturesétat vous permet d'ajouter des caractéristiques du produit au awsiotdevicetester_report.xml fichier généré par IDT.

Une caractéristique du produit est une information définie par l'utilisateur concernant des critères spécifiques auxquels un appareil peut répondre. Par exemple, la fonctionnalité MQTT du produit peut indiquer que l'appareil publie correctement les messages MQTT. Dans le rapport, les caractéristiques du produit sont définies sous supported la forme d'une valeur personnalisée ou d'une valeur personnalisée, en fonction de la réussite des tests spécifiés. not-supported

Note

L'AddProductFeaturesÉtat ne génère pas de rapports lui-même. Cet état doit passer à l'Reportétat pour 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 vers lequel effectuer la transition après avoir exécuté les actions dans l'état actuel.

Features

Un ensemble de caractéristiques du produit à afficher dans le awsiotdevicetester_report.xml fichier.

Feature

Le nom de la fonctionnalité

FeatureValue

Facultatif. La valeur personnalisée à utiliser dans le rapport à la place desupported. Si cette valeur n'est pas spécifiée, en fonction des résultats des tests, la valeur de la caractéristique est définie sur supported ounot-supported.

Si vous utilisez une valeur personnalisée pourFeatureValue, vous pouvez tester la même fonctionnalité avec des conditions différentes, et IDT concatène les valeurs des caractéristiques pour les conditions prises en charge. Par exemple, l'extrait suivant montre la MyFeature fonction avec deux valeurs 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 tests réussissent, la valeur de la caractéristique est définie surfirst-feature-supported, second-feature-supported.

Groups

Facultatif. Tableau d'identifiants de groupes de test. Tous les tests de chaque groupe de tests spécifié doivent réussir pour que la fonctionnalité soit prise en charge.

OneOfGroups

Facultatif. Tableau d'identifiants de groupes 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 d'identifiants de cas de test. Si vous spécifiez cette valeur, les conditions suivantes s'appliquent :

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

  • Groupsne doit contenir qu'un seul identifiant de groupe de test.

  • OneOfGroupsne doit pas être spécifié.

IsRequired

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

ExecutionMethods

Facultatif. Tableau de méthodes d'exécution correspondant à la protocol valeur spécifiée dans le device.json fichier. Si cette valeur est spécifiée, les testeurs doivent spécifier une protocol valeur correspondant à l'une des valeurs de ce tableau pour inclure la fonctionnalité dans le rapport. Si cette valeur n'est pas spécifiée, la fonctionnalité sera toujours incluse dans le rapport.

Pour utiliser l'AddProductFeaturesétat, vous devez définir la valeur de ResultVar in the RunTask state sur l'une des valeurs suivantes :

  • Si vous avez spécifié des identifiants de cas de test individuels, définissez ResultVar surgroup-id_test-id_passed.

  • Si vous n'avez pas spécifié d'ID de cas de test individuel, définissez ResultVar surgroup-id_passed.

L'AddProductFeaturesÉtat vérifie les résultats des tests de la manière suivante :

  • Si vous n'avez spécifié aucun ID de scénario de test, le résultat de chaque groupe de test est déterminé à partir de la valeur de la group-id_passed variable dans le contexte de la machine à états.

  • Si vous avez spécifié des identifiants de cas de test, le résultat de chacun des tests est déterminé à partir de la valeur de la group-id_test-id_passed variable dans le contexte de la machine à états.

Gestion des erreurs

Si un identifiant de groupe fourni dans cet état n'est pas un identifiant de groupe valide, cet état entraîne une erreur d'AddProductFeaturesErrorexécution. Si l'état rencontre une erreur d'exécution, il définit également la hasExecutionErrors variable dans le contexte de la machine à états surtrue.

Rapport

L'Reportétat génère les awsiotdevicetester_report.xml fichiers suite-name_Report.xml et. Cet état transmet également le rapport à la console.

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

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

Next

Nom de l'état vers lequel effectuer la transition après avoir exécuté les actions dans l'état actuel.

Vous devez toujours passer à l'Reportétat situé vers la fin du flux d'exécution du test afin que les utilisateurs puissent consulter 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 génère une erreur d'ReportErrorexécution.

LogMessage

L'LogMessageétat génère le test_manager.log fichier et transmet le message du journal à 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 vers lequel effectuer la transition après avoir exécuté les actions dans l'état actuel.

Level

Niveau d'erreur auquel le message de journal doit être créé. Si vous spécifiez un niveau qui n'est pas valide, cet état génère un message d'erreur et le supprime.

Message

Le message à enregistrer.

SelectGroup

L'SelectGroupétat met à jour le contexte de la machine à états pour indiquer quels groupes sont sélectionnés. Les valeurs définies par cet état sont utilisées par tous Choice les états suivants.

{
    "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 vers lequel effectuer la transition après avoir exécuté les actions dans l'état actuel.

TestGroups

Tableau de groupes de test qui seront marqués comme sélectionnés. Pour chaque ID de groupe de test de ce tableau, la group-id_selected variable est définie sur true dans le contexte. Assurez-vous de fournir des identifiants de groupe de test valides car IDT ne valide pas l'existence des groupes spécifiés.

Fail

L'Failétat indique 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 à états doit inclure cet état.

{
    "Type": "Fail"
}

Succeed

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

{
    "Type": "Succeed"
}

Contexte de la machine à états

Le contexte de la machine à états est un document JSON en lecture seule qui contient des données disponibles pour la machine à états lors de l'exécution. Le contexte de la machine à états est accessible uniquement depuis 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 testeurs dans le userdata.json fichier pour déterminer si l'exécution d'un test spécifique est requise.

Le contexte de la machine à états 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 le device.json fichier.

userData

Informations contenues dans le userdata.json dossier.

config

Épinglez les informations dans le config.json fichier.

suiteFailed

La valeur est définie au false démarrage de la machine à états. Si un groupe de test échoue dans un RunTask état, cette valeur est définie true pour la durée restante de l'exécution de la machine d'état.

specificTestGroups

Si le testeur sélectionne des groupes de tests spécifiques à exécuter au lieu de la suite de tests complète, cette clé est créée et contient la liste des identifiants de groupes de tests spécifiques.

specificTestCases

Si le lanceur de tests sélectionne des scénarios de test spécifiques à exécuter au lieu de la suite de tests complète, cette clé est créée et contient la liste des identifiants de cas de test spécifiques.

hasExecutionErrors

Ne se ferme pas au démarrage de la machine d'état. Si un état rencontre des erreurs d'exécution, cette variable est créée et définie true pour la durée restante de l'exécution de la machine à états.

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 :

  • La TestCases valeur en RunTask états.

  • ChoiceÉtat de Expression la valeur.

Lorsque vous accédez à des données depuis le contexte de la machine à états, assurez-vous que les conditions suivantes sont remplies :

  • Vos chemins JSON doivent commencer par $.

  • Chaque valeur doit être évaluée sous la forme d'une chaîne, d'un nombre ou d'un booléen.

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

Erreurs d'exécution

Les erreurs d'exécution sont des erreurs dans la définition de la machine à états que la machine à états rencontre lors de l'exécution d'un état. IDT enregistre les informations relatives à chaque erreur dans le test_manager.log fichier et transmet le message de journal à la console.

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

Attraper

Pour l'utiliserCatch, ajoutez ce qui suit à la définition de votre é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 à détecter. Si une erreur d'exécution correspond à l'une des valeurs spécifiées, la machine à états passe à l'état spécifié dansCatch.Next. Consultez la définition de chaque état pour obtenir des informations sur le type d'erreur qu'il génère.

Catch.Next

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

Les blocs Catch sont gérés de manière séquentielle jusqu'à ce que l'un d'eux corresponde. Si aucune erreur ne correspond à celles répertoriées dans les blocs Catch, les machines d'état continuent de s'exécuter. Les erreurs d'exécution étant 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.

a ExecutionError

Lorsque certains états rencontrent des erreurs d'exécution, en plus d'émettre l'erreur, ils définissent également la hasExecutionError valeur sur true dans le contexte de la machine à états. Vous pouvez utiliser cette valeur pour détecter lorsqu'une erreur se produit, puis utiliser un Choice état pour faire passer la machine à états à Fail cet état.

Cette méthode présente les caractéristiques suivantes.

  • La machine à états ne démarre avec aucune valeur attribuéehasExecutionError, et cette valeur n'est pas disponible tant qu'un état particulier ne la définit pas. Cela signifie que vous devez définir explicitement la valeur FallthroughOnError to false pour les Choice états qui accèdent à cette valeur afin d'empêcher la machine à états de s'arrêter si aucune erreur d'exécution ne se produit.

  • Une fois qu'il est défini surtrue, il n'hasExecutionErrorest jamais défini sur faux ni supprimé du contexte. Cela signifie que cette valeur n'est utile que la première fois qu'elle est définietrue, et pour tous les états suivants, elle ne fournit pas de valeur significative.

  • La hasExecutionError valeur est partagée avec toutes les machines d'état de branche de l'Parallelétat, ce qui peut entraîner des résultats inattendus en fonction de l'ordre dans lequel elle est consultée.

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

Exemples de machines à états

Cette section fournit quelques exemples de configurations de machine à états.

Exemple de machine à états : exécutez un seul groupe de test

Cette machine à états :

  • Exécute le groupe de test avec l'identifiantGroupA, qui doit être présent dans la suite dans un group.json fichier.

  • Vérifie les erreurs d'exécution et les transitions vers le Fail cas échéant.

  • Génère un rapport et passe à Succeed s'il n'y a pas d'erreur, ou dans le Fail cas contraire.

{
    "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 à états : exécuter des groupes de test sélectionnés par l'utilisateur

Cette machine à états :

  • Vérifie si le testeur a sélectionné des groupes de tests spécifiques. La machine à états ne vérifie pas les cas de test spécifiques car les testeurs ne peuvent pas sélectionner de cas de test sans sélectionner également un groupe de tests.

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

    • Exécute les scénarios de test au sein des groupes de tests sélectionnés. Pour ce faire, la machine à états ne spécifie pas explicitement de groupes de tests ou de cas de test dans l'RunTaskétat.

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

  • Si aucun groupe de test n'est sélectionné :

    • 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 à états : exécutez un seul groupe de test avec les fonctionnalités du produit

Cette machine à états :

  • Exécute le groupe de testGroupA.

  • Vérifie les erreurs d'exécution et les transitions vers le Fail cas échéant.

  • Ajoute la FeatureThatDependsOnGroupA fonctionnalité au awsiotdevicetester_report.xml fichier :

    • En GroupA cas de réussite, la fonction est réglée sursupported.

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

  • Génère un rapport et passe à Succeed s'il n'y a pas d'erreur, et dans le Fail cas contraire

{
    "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 à états : exécutez deux groupes de tests en parallèle

Cette machine à états :

  • Exécute les groupes GroupA et les GroupB tests en parallèle. Les ResultVar variables stockées dans le contexte par les RunTask états des machines à états de branche par sont disponibles pour l'AddProductFeaturesÉtat.

  • Vérifie les erreurs d'exécution et les transitions vers le Fail cas échéant. Cette machine à états n'utilise pas de Catch bloc car cette méthode ne détecte pas les erreurs d'exécution dans les machines à états de branche.

  • Ajoute des fonctionnalités au awsiotdevicetester_report.xml fichier en fonction des groupes qui réussissent

    • En GroupA cas de réussite, la fonction est réglée sursupported.

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

  • Génère un rapport et passe à Succeed s'il n'y a pas d'erreur, et dans le Fail cas contraire

Si deux appareils sont configurés dans le pool d'appareils, GroupA les deux GroupB peuvent fonctionner en même temps. Toutefois, si l'GroupAun ou l'autre GroupB contient plusieurs tests, les deux appareils peuvent être affectés à ces tests. Si un seul appareil est configuré, les groupes de test s'exécuteront 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"
        }
    }
}