Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Konfigurieren Sie die IDT-Zustandsmaschine

Eine Zustandsmaschine ist ein Konstrukt, das den Ausführungsablauf der Testsuite steuert. Sie bestimmt den Startstatus einer Testsuite, verwaltet Zustandsübergänge auf der Grundlage benutzerdefinierter Regeln und durchläuft diese Zustände so lange, bis der Endzustand erreicht ist.

Wenn Ihre Testsuite keine benutzerdefinierte Zustandsmaschine enthält, generiert IDT eine Zustandsmaschine für Sie. Die Standard-Zustandsmaschine erfüllt die folgenden Funktionen:

Die Zustandsmaschine für eine IDT-Testsuite muss die folgenden Kriterien erfüllen:

Format der Zustandsmaschine

Sie können die folgende Vorlage verwenden, um Ihre eigene <custom-test-suite-folder>/suite/state_machine.json Datei zu konfigurieren:

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Gültige Bundesstaaten und Bundesstaatendefinitionen

In diesem Abschnitt werden die Zustandsdefinitionen aller gültigen Zustände beschrieben, die in der IDT-Zustandsmaschine verwendet werden können. Einige der folgenden Zustände unterstützen Konfigurationen auf Testfallebene. Wir empfehlen jedoch, Zustandsübergangsregeln auf Testgruppenebene statt auf Testfallebene zu konfigurieren, sofern dies nicht unbedingt erforderlich ist.

RunTask

Der RunTask Staat führt Testfälle aus einer in der Testsuite definierten Testgruppe aus.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

In der Regel verwenden Sie RunTask state, um eine Testgruppen-ID anzugeben, ohne einzelne Testfall-IDs anzugeben, sodass IDT alle Testfälle in der angegebenen Testgruppe ausführt. Alle Testfälle, die in diesem Status ausgeführt werden, werden parallel in zufälliger Reihenfolge ausgeführt. Wenn jedoch für alle Testfälle ein Gerät zum Ausführen erforderlich ist und nur ein einziges Gerät verfügbar ist, werden die Testfälle stattdessen sequentiell ausgeführt.

Fehlerbehandlung

Wenn eine der angegebenen Testgruppen oder Testfall-IDs nicht gültig ist, gibt dieser Status den RunTaskError Ausführungsfehler aus. Wenn der Status auf einen Ausführungsfehler stößt, setzt er auch die hasExecutionError Variable im Zustandsmaschinenkontext auftrue.

Choice

Mit dem Choice Status können Sie anhand benutzerdefinierter Bedingungen dynamisch den nächsten Status festlegen, zu dem der Übergang erfolgen soll.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Fehlerbehandlung

Der Choice Status kann in den folgenden Fällen eine Fehlerbehandlung erfordern:

Sie können einen Catch Block nicht verwenden, um Fehler in diesem Zustand zu behandeln. Wenn Sie die Ausführung der Zustandsmaschine beenden möchten, wenn sie auf einen Fehler stößt, müssen Sie FallthroughOnError auf setzenfalse. Wir empfehlen jedoch, dass Sie FallthroughOnError diese true Option wählen und je nach Anwendungsfall eine der folgenden Aktionen ausführen:

Parallel

Mit dem Parallel Status können Sie neue Zustandsautomaten definieren und parallel zueinander ausführen.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Der Parallel Status wechselt erst in den nächsten Zustand, nachdem alle Branch State Machines ausgeführt wurden. Jeder Status, für den ein Gerät erforderlich ist, wartet mit der Ausführung, bis das Gerät verfügbar ist. Wenn mehrere Geräte verfügbar sind, führt dieser Status Testfälle aus mehreren Gruppen parallel aus. Wenn nicht genügend Geräte verfügbar sind, werden die Testfälle sequentiell ausgeführt. Da Testfälle in zufälliger Reihenfolge ausgeführt werden, wenn sie parallel ausgeführt werden, können verschiedene Geräte verwendet werden, um Tests derselben Testgruppe auszuführen.

Fehlerbehandlung

Stellen Sie sicher, dass sowohl der Branch State Machine als auch der Parent State Machine in den Fail Zustand übergehen, in dem Ausführungsfehler behandelt werden können.

Da Branch State Machines keine Ausführungsfehler an den übergeordneten State Machine übertragen, können Sie keinen Catch Block verwenden, um Ausführungsfehler in Branch State Machines zu behandeln. Verwenden Sie stattdessen den hasExecutionErrors Wert im Shared State Machine-Kontext. Ein Beispiel dafür, wie das funktioniert, finden Sie unterBeispiel für eine Zustandsmaschine: Führen Sie zwei Testgruppen parallel aus.

AddProductFeatures

Mit dem AddProductFeatures Status können Sie der von IDT generierten awsiotdevicetester_report.xml Datei Produktfunktionen hinzufügen.

Eine Produktfunktion besteht aus benutzerdefinierten Informationen zu bestimmten Kriterien, die ein Gerät möglicherweise erfüllt. Die MQTT Produktfunktion kann beispielsweise angeben, dass das Gerät MQTT-Nachrichten ordnungsgemäß veröffentlicht. Im Bericht werden Produktmerkmale als oder als benutzerdefinierter Wert festgelegt supportednot-supported, je nachdem, ob die angegebenen Tests bestanden wurden.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Um den AddProductFeatures Status zu verwenden, müssen Sie den Wert von ResultVar in the RunTask state auf einen der folgenden Werte setzen:

Der AddProductFeatures Staat prüft auf folgende Weise, ob Testergebnisse vorliegen:

Fehlerbehandlung

Wenn eine in diesem Status angegebene Gruppen-ID keine gültige Gruppen-ID ist, führt dieser Status zu einem AddProductFeaturesError Ausführungsfehler. Wenn der Status auf einen Ausführungsfehler stößt, wird auch die hasExecutionErrors Variable im Zustandsmaschinenkontext auf gesetzttrue.

Bericht

Der Report Status generiert die suite-name_Report.xml awsiotdevicetester_report.xml Und-Dateien. Dieser Status streamt den Bericht auch an die Konsole.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Sie sollten immer gegen Ende der Testausführung in den Report Status wechseln, damit die Testläufer die Testergebnisse sehen können. In der Regel ist der nächste Status nach diesem StatusSucceed.

Fehlerbehandlung

Wenn bei diesem Status Probleme beim Generieren der Berichte auftreten, wird der ReportError Ausführungsfehler ausgegeben.

LogMessage

Der LogMessage Status generiert die test_manager.log Datei und streamt die Protokollnachricht an die Konsole.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

SelectGroup

Der SelectGroup Status aktualisiert den Zustandsmaschinen-Kontext, um anzuzeigen, welche Gruppen ausgewählt sind. Die von diesem Status festgelegten Werte werden von allen nachfolgenden Choice Zuständen verwendet.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Fehler

Der Fail Status gibt an, dass die Zustandsmaschine nicht korrekt ausgeführt wurde. Dies ist ein Endzustand für die Zustandsmaschine, und jede Zustandsmaschinendefinition muss diesen Zustand enthalten.

{
    "Type": "Fail"
}

Succeed

Der Succeed Status gibt an, dass die Zustandsmaschine korrekt ausgeführt wurde. Dies ist ein Endzustand für die Zustandsmaschine, und jede Zustandsmaschinendefinition muss diesen Zustand enthalten.

{
    "Type": "Succeed"
}

Kontext der Zustandsmaschine

Der Zustandsmaschinenkontext ist ein schreibgeschütztes JSON-Dokument, das Daten enthält, die der Zustandsmaschine während der Ausführung zur Verfügung stehen. Auf den Zustandsmaschinen-Kontext kann nur von der Zustandsmaschine aus zugegriffen werden. Er enthält Informationen, die den Testablauf bestimmen. Sie können beispielsweise Informationen verwenden, die von Testläufern in der userdata.json Datei konfiguriert wurden, um zu ermitteln, ob ein bestimmter Test ausgeführt werden muss.

Der State-Machine-Kontext verwendet das folgende Format:

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

Sie können den Kontext mithilfe der JSONPath-Notation abfragen. Die Syntax für JSONPath-Abfragen in Zustandsdefinitionen lautet. {{$.query}} In einigen Bundesstaaten können Sie JSONPath-Abfragen als Platzhalterzeichenfolgen verwenden. IDT ersetzt die Platzhalterzeichenfolgen durch den Wert der ausgewerteten JSONPath-Abfrage aus dem Kontext. Sie können Platzhalter für die folgenden Werte verwenden:

Wenn Sie auf Daten aus dem Zustandsmaschinenkontext zugreifen, stellen Sie sicher, dass die folgenden Bedingungen erfüllt sind:

Weitere Hinweise zur Verwendung der JSONPath-Notation für den Zugriff auf Daten aus dem Kontext finden Sie unter. Verwenden Sie den IDT-Kontext

Ausführungsfehler

Ausführungsfehler sind Fehler in der Zustandsmaschinen-Definition, auf die die Zustandsmaschine bei der Ausführung eines Zustands stößt. IDT protokolliert Informationen zu jedem Fehler in der test_manager.log Datei und streamt die Protokollnachricht an die Konsole.

Sie können die folgenden Methoden verwenden, um Ausführungsfehler zu behandeln:

Fangen

Um es zu verwendenCatch, fügen Sie Ihrer Zustandsdefinition Folgendes hinzu:

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Catch-Blöcke werden sequentiell verarbeitet, bis einer der Blöcke entspricht. Wenn die Fehler „Keine“ mit den in den Catch-Blöcken aufgeführten übereinstimmen, werden die State-Maschinen weiter ausgeführt. Da Ausführungsfehler auf falsche Zustandsdefinitionen zurückzuführen sind, empfehlen wir, in den Status Fail überzugehen, wenn in einem Zustand ein Ausführungsfehler auftritt.

hat ExecutionError

Treten bei einigen Staaten Ausführungsfehler auf, geben sie nicht nur den Fehler aus, sondern setzen den hasExecutionError Wert auch true im Kontext der Zustandsmaschine auf. Sie können diesen Wert verwenden, um zu erkennen, wann ein Fehler auftritt, und dann einen Choice Status verwenden, um die Zustandsmaschine in den Fail Status zu überführen.

Diese Methode weist die folgenden Merkmale auf.

Aufgrund dieser Eigenschaften wird die Verwendung dieser Methode nicht empfohlen, wenn Sie stattdessen einen Catch-Block verwenden können.

Beispiel für Zustandsautomaten

Dieser Abschnitt enthält einige Beispiele für State-Machine-Konfigurationen.

Beispiel für eine Zustandsmaschine: Führen Sie eine einzelne Testgruppe aus

Diese Zustandsmaschine:

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

Beispiel für eine Zustandsmaschine: Führen Sie vom Benutzer ausgewählte Testgruppen aus

Diese Zustandsmaschine:

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

Beispiel für eine Zustandsmaschine: Führen Sie eine einzelne Testgruppe mit Produktfunktionen aus

Diese Zustandsmaschine:

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

Beispiel für eine Zustandsmaschine: Führen Sie zwei Testgruppen parallel aus

Diese Zustandsmaschine:

Wenn zwei Geräte im Gerätepool konfiguriert sind, GroupB können beide GroupA gleichzeitig ausgeführt werden. Wenn jedoch einer GroupA oder mehrere Tests GroupB enthält, können beide Geräte diesen Tests zugewiesen werden. Wenn nur ein Gerät konfiguriert ist, werden die Testgruppen sequentiell ausgeführt.

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