Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Flusso di lavoro di Device Advisor
In questo tutorial viene descritto come creare una suite di test personalizzata ed eseguire test sul dispositivo che si desidera testare nella console. Dopo aver completato i test, è possibile visualizzare i risultati del test e i registri dettagliati.
## Prerequisiti
Prima di iniziare questo tutorial, completa la procedura illustrata in [Configurazione](device-advisor-setting-up.md).
## Crea una definizione di suite di test
Innanzitutto, [installa un SDK](https://docs.aws.amazon.com/iot/latest/developerguide/iot-connect-service.html#iot-service-sdks). AWS
### `rootGroup` sintassi
Un gruppo root è una stringa JSON che specifica quali casi di test includere nella suite di test. Inoltre, consente di specificare le eventuali configurazioni necessarie per tali casi di test. Utilizza il gruppo root per strutturare e ordinare la suite di test in base alle tue esigenze. La gerarchia di una suite di test è:
```
test suite → test group(s) → test case(s)
```
Una suite di test deve avere almeno un gruppo di test e ogni gruppo di test deve avere almeno un test case. Device Advisor esegue i test nell'ordine in cui vengono definiti i gruppi di test e i test case.
Ogni gruppo radice segue questa struttura di base:
```
{
"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": ""
}
}]
}]
}
```
Nel gruppo root, definisci la suite di test con un `name`, `configuration` e i `tests` contenuti nel gruppo. Il gruppo `tests` contiene le definizioni di singoli test. Definisci ogni test con un `name`, `configuration` e un blocco `test` che definisce i casi di test per tale test. Infine, ogni caso di test è definito con un `id` e una `version`.
Per informazioni su come utilizzate i campi `"id"` e `"version"` per ogni caso di test (blocco `test`), consultare [Case test di Device Advisor](device-advisor-tests.md). Questa sezione contiene anche informazioni sulle impostazioni `configuration` disponibili.
Il blocco seguente è un esempio di configurazione del gruppo root. Queste configurazioni specificano i casi di test *MQTT Connect Happy Case* e *MQTT Connect Exponential Backoff Retries*, insieme alle descrizioni dei campi di configurazione.
```
{
"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
}
}]
}]
}
```
È necessario fornire la configurazione del gruppo radice quando si crea la definizione della suite di test. Salva il `suiteDefinitionId` restituito nell'oggetto di risposta. Puoi utilizzare questo ID per recuperare le informazioni sulla definizione della suite di test ed eseguire la suite di test.
Ecco un esempio di 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()
)
```
## Ottieni una definizione di suite di test
Dopo aver creato la definizione della suite di test, riceverai `suiteDefinitionId` nell'oggetto risposta dell'operazione API `CreateSuiteDefinition`.
Quando l'operazione restituisce il `suiteDefinitionId`, è possibile che vengano visualizzati nuovi campi `id` all'interno di ciascun gruppo e definizione del caso di test all'interno del gruppo root. Puoi usarli IDs per eseguire un sottoinsieme della definizione della tua suite di test.
Esempio di Java SDK:
```
response = iotDeviceAdvisorClient.GetSuiteDefinition(
GetSuiteDefinitionRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.build()
)
```
## Ottieni un endpoint di test
Utilizza l'operazione API `GetEndpoint` per ottenere l'endpoint di test utilizzato dal dispositivo. Seleziona l'endpoint più adatto al tuo test. Per eseguire contemporaneamente più suite di test, utilizza l'endpoint a livello di dispositivo fornendo un `thing ARN`, `certificate ARN` o `device role ARN`. Per eseguire una singola suite di test, non fornire argomenti all' GetEndpoint operazione di scelta dell'endpoint a livello di account.
Esempi di SDK:
```
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())
```
## Avvia una suite di test
Dopo che hai creato una definizione della suite di test e configurato il dispositivo di test per la connessione all'endpoint di test Device Advisor, esegui la suite di test con l'API `StartSuiteRun`.
Per i clienti MQTT, utilizza `certificateArn` o `thingArn` per eseguire la suite di test. Se entrambi sono configurati, il certificato viene utilizzato se appartiene all'oggetto.
Per MQTT over WebSocket customer, utilizzare `deviceRoleArn` per eseguire la suite di test. Se il ruolo specificato è diverso da quello descritto nella definizione della suite di test, il ruolo specificato sostituisce il ruolo definito.
Per `.parallelRun()`, utilizza `true` se l'endpoint a livello di dispositivo viene utilizzato per eseguire più suite di test in parallelo utilizzando un Account AWS.
Esempi di SDK:
```
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())
```
Salva la `suiteRunId` dalla risposta. Lo utilizzerai per recuperare i risultati dell'esecuzione di questa suite di test.
## Ottieni un'esecuzione della suite di test
Dopo aver avviato un'esecuzione di suite di test, è possibile verificarne lo stato di avanzamento e i risultati con l'API `GetSuiteRun`.
Esempi di SDK:
```
// Using the SDK, call the GetSuiteRun API.
response = iotDeviceAdvisorClient.GetSuiteRun(
GetSuiteRunRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunId("your-suite-run-id")
.build())
```
## Interrompi l'esecuzione di una suite di test
Per interrompere l'esecuzione di una suite di test ancora in corso, puoi chiamare l'operazione API `StopSuiteRun`. Dopo aver chiamato l'operazione API `StopSuiteRun`, il servizio avvia il processo di pulizia. Mentre il servizio esegue il processo di pulizia, lo stato di esecuzione della suite di test viene aggiornato a `Stopping`. Il processo di pulizia può richiedere alcuni minuti. Una volta completato il processo, lo stato di esecuzione della suite di test viene aggiornato a `Stopped`. Dopo che un'esecuzione di test si è completamente interrotta, puoi avviare un'altra esecuzione di suite di test. Puoi controllare periodicamente lo stato di esecuzione della suite utilizzando l'operazione API `GetSuiteRun`, come illustrato nella sezione precedente.
Esempi di SDK:
```
// Using the SDK, call the StopSuiteRun API.
response = iotDeviceAdvisorClient.StopSuiteRun(
StopSuiteRun.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunId("your-suite-run-id")
.build())
```
## Ottieni un rapporto di qualificazione per una suite di test di qualificazione riuscita
Se esegui una suite di test di qualifica completata correttamente, puoi recuperare un report di qualifica con l'operazione API `GetSuiteRunReport`. Utilizza questo report di qualifica per qualificare il dispositivo con il Programma di idoneità di AWS IoT Core . Per determinare se la suite di test è una suite di test di qualificazione, verifica se il parametro `intendedForQualification` è impostato su `true`. Dopo aver chiamato l'operazione API `GetSuiteRunReport`, puoi scaricare il report dall'URL restituito per un massimo di 90 secondi. Se trascorrono più di 90 secondi dalla precedente chiamata dell'operazione `GetSuiteRunReport`, chiama nuovamente l'operazione per recuperare un nuovo URL valido.
Esempi di SDK:
```
// Using the SDK, call the getSuiteRunReport API.
response = iotDeviceAdvisorClient.getSuiteRunReport(
GetSuiteRunReportRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunId("your-suite-run-id")
.build()
)
```