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 den IDT-Statuscomputer

Ein State-Computer ist ein Konstrukt, das den Ausführungsablauf der Testsuite steuert. Es bestimmt den Startstatus einer Testsuite, verwaltet Zustandsübergänge basierend auf benutzerdefinierten Regeln und wechselt weiter durch diese Zustände, bis sie den Endzustand erreicht.

Wenn Ihre Testsuite keinen benutzerdefinierten Zustandscomputer enthält, generiert IDT einen Zustandscomputer für Sie. Der Standardstatus-Computer führt die folgenden Funktionen aus:

Der Zustandsautomat für eine IDT-Testsuite muss die folgenden Kriterien erfüllen:

Format des Zustandsautomaten

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

{
  "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 Status und Statusdefinitionen

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

RunTask

DieRunTaskstate führt Testfälle von 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 Regel wird verwendetRunTaskstatus, um eine Testgruppen-ID anzugeben, ohne einzelne Testfall-IDs anzugeben, damit IDT alle Testfälle in der angegebenen Testgruppe ausführt. Alle Testfälle, die von diesem Status ausgeführt werden, laufen parallel in einer zufälligen Reihenfolge. Wenn jedoch für alle Testfälle ein Gerät ausgeführt werden muss und nur ein einziges Gerät verfügbar ist, werden die Testfälle stattdessen nacheinander ausgeführt.

Fehlerbehandlung

Wenn eine der angegebenen Testgruppen oder Testfall-IDs nicht gültig ist, gibt dieser Status dieRunTaskErrorFehler bei der-Ausführung. Wenn der Status auf einen Ausführungsfehler stößt, wird auch diehasExecutionErrorVariable im Zustandsmaschine-Kontext zutrueaus.

Choice

DieChoicestate ermöglicht es Ihnen, den nächsten Status dynamisch festzulegen, auf den Sie basierend auf benutzerdefinierten Bedingungen wechseln möchten.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Fehlerbehandlung

DieChoicestate kann in folgenden Fällen eine Fehlerbehandlung erfordern:

Sie können keinCatchblockieren, um Fehler in diesem Zustand zu behandeln. Wenn Sie die Ausführung des Statusrechners beenden möchten, wenn ein Fehler auftritt, müssen SieFallthroughOnErrorzufalseaus. Wir empfehlen jedoch, dass Sie festlegenFallthroughOnErrorzutrue, und abhängig von Ihrem Anwendungsfall führen Sie eine der folgenden Maßnahmen durch:

Parallel

DieParallelstate ermöglicht es Ihnen, neue Zustandsmaschinen parallel zueinander zu definieren und auszuführen.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

DieParallelstate wechselt erst in den nächsten Status, nachdem alle Zweigzustandsmaschinen ausgeführt wurden. Jeder Status, der ein Gerät benötigt, wartet auf die 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 Testfälle nacheinander ausgeführt. Da Testfälle in einer zufälligen Reihenfolge ausgeführt werden, wenn sie parallel ausgeführt werden, können verschiedene Geräte verwendet werden, um Tests aus derselben Testgruppe auszuführen.

Fehlerbehandlung

Stellen Sie sicher, dass sowohl der Zweigzustandsmaschine als auch der übergeordnete Zustandsmaschine in dieFailstatus, um Ausführungsfehler zu behandeln.

Da Zweigzustandsmaschinen keine Ausführungsfehler an den übergeordneten Zustandscomputer übermitteln, können Sie keineCatchblockieren, um Ausführungsfehler in Zweigzustandsmaschinen zu behandeln. Verwenden Sie stattdessen denhasExecutionErrorsWert im Kontext des freigegebenen Zustands-Rechners. Ein Beispiel dafür, wie dies funktioniert, finden Sie unterBeispiel für einen Zustandsautomaten: Führen Sie zwei Testgruppen parallel ausaus.

addProductFeatures

DieAddProductFeaturesstate ermöglicht es Ihnen, Produktfunktionen zumawsiotdevicetester_report.xmlvon IDT generierte Datei.

Ein Produktmerkmal sind benutzerdefinierte Informationen zu bestimmten Kriterien, die ein Gerät möglicherweise erfüllen kann. Zum Beispiel, dasMQTTDie Produktfunktion kann angeben, dass das Gerät MQTT-Nachrichten ordnungsgemäß veröffentlicht. Im Bericht werden Produkteigenschaften als festgelegtsupported,not-supportedoder ein benutzerdefinierter Wert, basierend darauf, ob bestimmte 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:

So verwenden Sie denAddProductFeaturesstate, müssen Sie den Wert vonResultVarimRunTaskGeben Sie einen der folgenden Werte an:

DieAddProductFeaturesStatusprüfungen für Testergebnisse in der folgenden Weise:

Fehlerbehandlung

Wenn eine in diesem Status angegebene Gruppen-ID keine gültige Gruppen-ID ist, führt dieser Status zuAddProductFeaturesErrorFehler bei der-Ausführung. Wenn der Status auf einen Ausführungsfehler stößt, wird auch diehasExecutionErrorsVariable im Zustandsmaschine-Kontext zutrueaus.

Bericht

DieReportDer Zustand generiert densuite-name_Report.xmlundawsiotdevicetester_report.xmlDateien. Dieser Status streamt den Bericht auch an die Konsole.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Du solltest immer auf dieReportgegen Ende des Testausführungsflusses angeben, damit Testläufer Testergebnisse anzeigen können. In der Regel ist der nächste Status nach diesem StatusSucceedaus.

Fehlerbehandlung

Wenn dieser Status Probleme beim Erstellen der Berichte aufweist, gibt er dieReportErrorFehler bei der-Ausführung.

LogMessage

DieLogMessageDer Zustand generiert dentest_manager.log-Datei und streamt die Protokollnachricht in die Konsole.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

SelectGroup

DieSelectGroupstatus aktualisiert den Zustandsmaschinenkontext, um anzugeben, welche Gruppen ausgewählt sind. Die von diesem Status festgelegten Werte werden von allen nachfolgenden verwendetChoice-Staaten.

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Fehler

DieFailstatus gibt an, dass der Zustandsmaschine nicht korrekt ausgeführt wurde. Dies ist ein Endstatus für den Statuscomputer, und jede Statusmaschinendefinition muss diesen Status enthalten.

{
    "Type": "Fail"
}

Succeed

DieSucceedstatus gibt an, dass der Zustandsmaschine korrekt ausgeführt wurde. Dies ist ein Endstatus für den Statuscomputer, und jede Statusmaschinendefinition muss diesen Status enthalten.

{
    "Type": "Succeed"
}

Kontext des Zustandsautomaten

Der Zustandsmaschinenkontext ist ein schreibgeschütztes JSON-Dokument, das Daten enthält, die dem Statuscomputer während der Ausführung zur Verfügung stehen. Der Zustandsmaschinenkontext ist nur vom Zustandsmaschine aus zugänglich und enthält Informationen, die den Testfluss bestimmen. Beispielsweise können Sie Informationen verwenden, die von Testläufern konfiguriert wurden, imuserdata.json-Datei, um festzustellen, ob ein bestimmter Test ausgeführt werden muss.

Der Kontext des Zustandsautomaten 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 mit JsonPath-Notation abfragen. Die Syntax für JsonPath-Abfragen in Statusdefinitionen lautet{{$.query}}aus. Sie können JsonPath-Abfragen als Platzhalterzeichenfolgen in einigen Zuständen verwenden. IDT ersetzt die Platzhalterzeichenfolgen durch den Wert der ausgewerteten JsonPath-Abfrage aus dem Kontext. Sie können Platzhalter für folgende Werte verwenden:

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

Weitere Informationen zur Verwendung von JSONPath-Notation für den Zugriff auf Daten aus dem Kontext finden Sie unterVerwenden Sie den IDT-Kontextaus.

Ausführungsfehler

Ausführungsfehler sind Fehler in der Statusmaschinendefinition, auf die der Statuscomputer beim Ausführen eines Status stößt. IDT protokolliert Informationen zu jedem Fehler imtest_manager.log-Datei und streamt die Protokollnachricht in die Konsole.

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

Fangen

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

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

Nachfolgend sind alle Pflichtfelder beschrieben:

Catch-Blöcke werden nacheinander gehandhabt, bis einer übereinstimmt. Wenn die Keine Fehler mit den in den Catch-Blöcken aufgeführten übereinstimmen, werden die Zustandsmaschinen weiterhin ausgeführt. Da Ausführungsfehler auf falsche Zustandsdefinitionen zurückzuführen sind, empfehlen wir Ihnen, in den Status „Fail“ zu wechseln, wenn ein Status auf einen Ausführungsfehler stößt.

hasExecutionError

Wenn einige Zustände auf Ausführungsfehler stoßen, legen sie zusätzlich zur Fehlerausgabe auch diehasExecutionErrorWert zutrueim Zustandsautomatenkontext. Sie können diesen Wert verwenden, um zu erkennen, wann ein Fehler auftritt, und dann eineChoicestatus, um die Zustandsmaschine auf denFailStatus.

Diese Methode hat folgende Merkmale:

Aufgrund dieser Eigenschaften empfehlen wir, diese Methode nicht zu verwenden, wenn Sie stattdessen einen Catch-Block verwenden können.

Beispiel für einen Zustandsautomaten

In diesem Abschnitt finden Sie einige Beispielkonfigurationen für Zustandsautomaten.

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

Dieser Zustandsautomat:

{
    "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 einen Zustandsautomaten: Ausführen von vom Benutzer ausgewählten Testgruppen

Dieser Zustandsautomat:

{
    "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 einen Zustandsautomaten: Führen Sie eine einzelne Testgruppe mit Produktfunktionen aus

Dieser Zustandsautomat:

{
    "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 einen Zustandsautomaten: Führen Sie zwei Testgruppen parallel aus

Dieser Zustandsautomat:

Wenn zwei Geräte im Gerätepool konfiguriert sind, sind beideGroupAundGroupBkann gleichzeitig ausgeführt werden. Wenn jedoch entwederGroupAoderGroupBhat mehrere Tests, dann können beide Geräte diesen Tests zugeordnet werden. Wenn nur ein Gerät konfiguriert ist, werden die Testgruppen nacheinander 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"
        }
    }
}