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.
# Device-Advisor-Workflow
In diesem Tutorial wird erklärt, wie Sie eine benutzerdefinierte Testsuite erstellen und Tests für das Gerät ausführen, das Sie in der Konsole testen möchten. Nach Abschluss der Tests können Sie die Testergebnisse und detaillierte Protokolle anzeigen.
## Voraussetzungen
Bevor Sie mit diesem Tutorial beginnen, führen Sie die unter [Einrichtung](device-advisor-setting-up.md) beschriebenen Schritte aus.
## Erstellen einer Testsuite-Definition
[Installieren Sie zunächst ein AWS SDK](https://docs.aws.amazon.com/iot/latest/developerguide/iot-connect-service.html#iot-service-sdks).
### `rootGroup`-Syntax
Eine Root-Gruppe ist eine JSON-Zeichenfolge, die angibt, welche Testfälle in Ihre Testsuite aufgenommen werden sollen. Sie spezifiziert auch alle erforderlichen Konfigurationen für diese Testfälle. Verwenden Sie die Root-Gruppe, um Ihre Testsuite nach Ihren Bedürfnissen zu strukturieren und zu ordnen. Die Hierarchie einer Testsuite ist folgende:
```
test suite → test group(s) → test case(s)
```
Eine Testsuite muss mindestens eine Testgruppe haben und jede Testgruppe muss mindestens einen Testfall haben. Device Advisor führt Tests in der Reihenfolge aus, in der Sie die Testgruppen und Testfälle definieren.
Jede Root-Gruppe folgt dieser Grundstruktur:
```
{
"configuration": { // for all tests in the test suite
"": ""
}
"tests": [{
"name": ""
"configuration": { // for all sub-groups in this test group
"": ""
},
"tests": [{
"name": ""
"configuration": { // for all test cases in this test group
"": ""
},
"test": {
"id": ""
"version": ""
}
}]
}]
}
```
In der Root-Gruppe definieren Sie die Testsuite mit einem `name`, der `configuration` und den `tests`, die die Gruppe enthält. Die `tests`-Gruppe enthält die Definitionen der einzelnen Tests. Sie definieren jeden Test mit einem `name`, einer `configuration` und einem `test`-Block, der die Testfälle für diesen Test definiert. Schließlich wird jeder Testfall mit einer `id` und einer `version` definiert.
Hinweise zur Verwendung der Felder `"id"` und `"version"` und für jeden Testfall (`test`-Block) finden Sie unter [Device-Advisor-Testfälle](device-advisor-tests.md). Dieser Abschnitt enthält auch Informationen zu den verfügbaren `configuration`-Einstellungen.
Der folgende Block ist ein Beispiel für eine Root-Gruppenkonfiguration. Diese Konfiguration spezifiziert die Testfälle *MQTT Connect Happy Case* und *MQTT Connect Exponential Backoff Retries* zusammen mit Beschreibungen der Konfigurationsfelder.
```
{
"configuration": {}, // Suite-level configuration
"tests": [ // Group definitions should be provided here
{
"name": "My_MQTT_Connect_Group", // Group definition name
"configuration": {} // Group definition-level configuration,
"tests": [ // Test case definitions should be provided here
{
"name": "My_MQTT_Connect_Happy_Case", // Test case definition name
"configuration": {
"EXECUTION_TIMEOUT": 300 // Test case definition-level configuration, in seconds
},
"test": {
"id": "MQTT_Connect", // test case id
"version": "0.0.0" // test case version
}
},
{
"name": "My_MQTT_Connect_Jitter_Backoff_Retries", // Test case definition name
"configuration": {
"EXECUTION_TIMEOUT": 600 // Test case definition-level configuration, in seconds
},
"test": {
"id": "MQTT_Connect_Jitter_Backoff_Retries", // test case id
"version": "0.0.0" // test case version
}
}]
}]
}
```
Sie müssen die Root-Gruppenkonfiguration angeben, wenn Sie Ihre Testsuite-Definition erstellen. Speichern Sie die `suiteDefinitionId`, die im Antwortobjekt zurückgegeben wird. Sie können diese ID verwenden, um Ihre Testsuite-Definitionsinformationen abzurufen und Ihre Testsuite auszuführen.
Hier ist ein Beispiel für ein Java-SDK:
```
response = iotDeviceAdvisorClient.createSuiteDefinition(
CreateSuiteDefinitionRequest.builder()
.suiteDefinitionConfiguration(SuiteDefinitionConfiguration.builder()
.suiteDefinitionName("your-suite-definition-name")
.devices(
DeviceUnderTest.builder()
.thingArn("your-test-device-thing-arn")
.certificateArn("your-test-device-certificate-arn")
.deviceRoleArn("your-device-role-arn") //if using SigV4 for MQTT over WebSocket
.build()
)
.rootGroup("your-root-group-configuration")
.devicePermissionRoleArn("your-device-permission-role-arn")
.protocol("MqttV3_1_1 || MqttV5 || MqttV3_1_1_OverWebSocket || MqttV5_OverWebSocket")
.build()
)
.build()
)
```
## Abrufen einer Testsuite-Definition
Nachdem Sie Ihre Testsuite-Definition erstellt haben, erhalten Sie die `suiteDefinitionId` im Antwortobjekt der `CreateSuiteDefinition`-API-Operation.
Wenn der Vorgang die `suiteDefinitionId` zurückgibt, sehen Sie möglicherweise neue `id`-Felder in jeder Gruppe und eine Testfalldefinition innerhalb der Root-Gruppe. Sie können diese verwenden IDs , um eine Teilmenge Ihrer Testsuite-Definition auszuführen.
Java-SDK-Beispiel:
```
response = iotDeviceAdvisorClient.GetSuiteDefinition(
GetSuiteDefinitionRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.build()
)
```
## Abrufen eines Testendpunkts
Verwenden Sie die `GetEndpoint`-API-Operation, um den von Ihrem Gerät verwendeten Testendpunkt abzurufen. Wählen Sie den Endpunkt aus, der am besten zu Ihrem Test passt. Um mehrere Testsuiten gleichzeitig auszuführen, verwenden Sie den Endpunkt auf Geräteebene, indem Sie einen `thing ARN`, `certificate ARN` oder `device role ARN` angeben. Um eine einzelne Testsuite auszuführen, geben Sie keine Argumente für den GetEndpoint Vorgang zur Auswahl des Endpunkts auf Kontoebene an.
SDK-Beispiel:
```
response = iotDeviceAdvisorClient.getEndpoint(GetEndpointRequest.builder()
.certificateArn("your-test-device-certificate-arn")
.thingArn("your-test-device-thing-arn")
.deviceRoleArn("your-device-role-arn") //if using SigV4 for MQTT over WebSocket
.build())
```
## Ausführen einer Testsuite
Nachdem Sie eine Testsuite-Definition erstellt und Ihr Testgerät so konfiguriert haben, dass es eine Verbindung zu Ihrem Device-Advisor-Testendpunkt herstellt, führen Sie Ihre Testsuite mit der `StartSuiteRun`-API aus.
Für MQTT-Kunden verwenden Sie entweder `certificateArn` oder `thingArn`, um die Testsuite auszuführen. Wenn beide konfiguriert sind, wird das Zertifikat verwendet, wenn es zum Ding gehört.
Verwenden Sie für MQTT statt WebSocket Kunde, `deviceRoleArn` um die Testsuite auszuführen. Wenn sich die angegebene Rolle von der in der Testsuite-Definition angegebenen Rolle unterscheidet, hat die angegebene Rolle Vorrang vor der definierten Rolle.
Verwenden Sie für `.parallelRun()` `true`, wenn Sie einen Endpunkt auf Geräteebene verwenden, um mehrere Testsuiten parallel mit einem AWS-Konto auszuführen.
SDK-Beispiel:
```
response = iotDeviceAdvisorClient.startSuiteRun(StartSuiteRunRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunConfiguration(SuiteRunConfiguration.builder()
.primaryDevice(DeviceUnderTest.builder()
.certificateArn("your-test-device-certificate-arn")
.thingArn("your-test-device-thing-arn")
.deviceRoleArn("your-device-role-arn") //if using SigV4 for MQTT over WebSocket
.build())
.parallelRun(true | false)
.build())
.build())
```
Speichern Sie die `suiteRunId` aus der Antwort. Sie werden diese verwenden, um die Ergebnisse dieser Testsuite-Ausführung abzurufen.
## Abrufen einer Testsuite-Ausführung
Nachdem Sie eine Testsuite ausgeführt haben, können Sie ihren Fortschritt und ihre Ergebnisse mit der `GetSuiteRun`-API überprüfen.
SDK-Beispiel:
```
// Using the SDK, call the GetSuiteRun API.
response = iotDeviceAdvisorClient.GetSuiteRun(
GetSuiteRunRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunId("your-suite-run-id")
.build())
```
## Beenden einer Testsuite-Ausführung
Um eine Testsuite-Ausführung, die noch läuft, zu beenden, können Sie die `StopSuiteRun`-API-Operation aufrufen. Nachdem Sie die `StopSuiteRun`-Operation aufgerufen haben, startet der Service den Bereinigungsvorgang. Während der Service den Bereinigungsvorgang ausführt, führt die Testsuite Statusaktualisierungen bis `Stopping` durch. Der Bereinigungsvorgang kann mehrere Minuten in Anspruch nehmen. Sobald der Vorgang abgeschlossen ist, führt die Testsuite Statusaktualisierungen bis `Stopped` durch. Nachdem ein Testlauf vollständig beendet wurde, starten Sie eine weitere Testsuite-Ausführung. Sie können den Status der Ausführung der Suite regelmäßig mithilfe der `GetSuiteRun`-API-Operation überprüfen, wie im vorherigen Abschnitt gezeigt.
SDK-Beispiel:
```
// Using the SDK, call the StopSuiteRun API.
response = iotDeviceAdvisorClient.StopSuiteRun(
StopSuiteRun.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunId("your-suite-run-id")
.build())
```
## Abrufen eines Qualifizierungsberichts für eine erfolgreiche Ausführung der Qualifizierungstestsuite
Wenn Sie eine Qualifizierungstestsuite ausführen, die erfolgreich abgeschlossen wurde, können Sie mit der `GetSuiteRunReport`-API-Operation einen Qualifizierungsbericht abrufen. Sie verwenden diesen Qualifizierungsbericht, um Ihr Gerät für das AWS IoT Core -Qualifizierungsprogramm zu qualifizieren. Um festzustellen, ob es sich bei Ihrer Testsuite um eine Qualifizierungstestsuite handelt, überprüfen Sie, ob der `intendedForQualification`-Parameter auf `true` eingestellt ist. Nachdem Sie die `GetSuiteRunReport`-API-Operation aufgerufen haben, können Sie den Bericht bis zu 90 Sekunden lang von der zurückgegebenen URL herunterladen. Wenn seit dem letzten Aufruf der `GetSuiteRunReport`-Operation mehr als 90 Sekunden vergangen sind, rufen Sie die Operation erneut auf, um eine neue, gültige URL abzurufen.
SDK-Beispiel:
```
// Using the SDK, call the getSuiteRunReport API.
response = iotDeviceAdvisorClient.getSuiteRunReport(
GetSuiteRunReportRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunId("your-suite-run-id")
.build()
)
```