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à.

# Usa il contesto IDT
<a name="idt-context"></a>

Quando IDT esegue una suite di test, la suite di test può accedere a un set di dati che possono essere utilizzati per determinare la modalità di esecuzione di ciascun test. Questi dati sono chiamati contesto IDT. Ad esempio, la configurazione dei dati utente fornita dai test runner in un `userdata.json` file viene resa disponibile alle suite di test nel contesto IDT. 

Il contesto IDT può essere considerato un documento JSON di sola lettura. Le suite di test possono recuperare dati e scrivere dati nel contesto utilizzando tipi di dati JSON standard come oggetti, matrici, numeri e così via.

## Schema contestuale
<a name="idt-context-schema"></a>

Il contesto IDT utilizza il seguente formato:

```
{
    "config": {
        <config-json-content>
        "timeoutMultiplier": timeout-multiplier
    },
    "device": {
        <device-json-device-element>
    },
    "devicePool": {
        <device-json-pool-element>
    },
    "resource": {
        "devices": [
            {
                <resource-json-device-element>
                "name": "<resource-name>"
            }
        ]
    },
    "testData": {
        "awsCredentials": {
            "awsAccessKeyId": "<access-key-id>",
            "awsSecretAccessKey": "<secret-access-key>",
            "awsSessionToken": "<session-token>"
        },
        "logFilePath": "/path/to/log/file"
    },
    "userData": {
        <userdata-json-content>
    }
}
```

`config`  
Informazioni dal [`config.json`file](set-custom-idt-config.md#config-json-custom). Il `config` campo contiene anche il seguente campo aggiuntivo:    
`config.timeoutMultiplier`  
Il moltiplicatore per l'eventuale valore di timeout utilizzato dalla suite di test. Questo valore è specificato dal test runner dalla CLI IDT. Il valore predefinito è `1`.

`device`  
Informazioni sul dispositivo selezionato per l'esecuzione del test. Queste informazioni sono equivalenti all'elemento dell'`devices`array nel [`device.json`file](set-custom-idt-config.md#device-config-custom) per il dispositivo selezionato.

`devicePool`  
Informazioni sul pool di dispositivi selezionato per l'esecuzione del test. Queste informazioni sono equivalenti all'elemento dell'array del pool di dispositivi di primo livello definito nel `device.json` file per il pool di dispositivi selezionato.

`resource`  
Informazioni sui dispositivi di risorse contenute nel `resource.json` file.    
`resource.devices`  
Queste informazioni sono equivalenti all'`devices`array definito nel `resource.json` file. Ogni `devices` elemento include il seguente campo aggiuntivo:    
`resource.device.name`  
Il nome del dispositivo di risorse. Questo valore è impostato sul `requiredResource.name` valore del `test.json` file.

`testData.awsCredentials`  
Le AWS credenziali utilizzate dal test per connettersi al AWS cloud. Queste informazioni sono ottenute dal `config.json` file.

`testData.logFilePath`  
Il percorso del file di registro in cui il test case scrive i messaggi di registro. La suite di test crea questo file se non esiste. 

`userData`  
Informazioni fornite dal test runner nel [`userdata.json`file](set-custom-idt-config.md#userdata-config-custom).

## Accedere ai dati nel contesto
<a name="accessing-context-data"></a>

Puoi interrogare il contesto utilizzando la JSONPath notazione dei tuoi file JSON e del tuo file eseguibile di testo con and. `GetContextValue` `GetContextString` APIs La sintassi con cui le JSONPath stringhe accedono al contesto IDT varia come segue:
+ In `suite.json` e`test.json`, si usa. `{{query}}` Cioè, non usate l'elemento root `$.` per iniziare l'espressione.
+ In`test_orchestrator.yaml`, si usa`{{query}}`.

  Se usi la macchina a stati deprecata, allora in`state_machine.json`, usi. `{{$.query}}`
+ Nei comandi API, si utilizza `query` o`{{$.query}}`, a seconda del comando. Per ulteriori informazioni, consultate la documentazione in linea in. SDKs 

La tabella seguente descrive gli operatori di un' JSONPathespressione tipica:


| Operatore  | Descrizione  | 
| --- |--- |
| \$1 | Lelemento radice. Poiché il valore di contesto di primo livello per IDT è un oggetto, viene in genere utilizzato \$1. per avviare le query. | 
| .childName | Accede all'elemento secondario con il nome childName di un oggetto. Se applicato a un array, restituisce un nuovo array con questo operatore applicato a ciascun elemento. Il nome dell'elemento distingue tra maiuscole e minuscole. Ad esempio, la query per accedere al awsRegion valore nell'configoggetto è\$1.config.awsRegion. | 
| [start:end] | Filtra gli elementi da una matrice, recuperando gli elementi che iniziano dall'startindice e risalgono all'endindice, entrambi inclusi. | 
| [index1, index2, ... , indexN] | Filtra gli elementi da un array, recuperando gli elementi solo dagli indici specificati. | 
| [?(expr)] | Filtra gli elementi di un array utilizzando l'espressione. expr Questa espressione deve restituire un valore booleano. | 

Per creare espressioni di filtro, utilizzate la seguente sintassi:

```
<jsonpath> | <value> operator <jsonpath> | <value> 
```

In questa sintassi: 
+ `jsonpath`è un programma JSONPath che utilizza la sintassi JSON standard. 
+ `value`è qualsiasi valore personalizzato che utilizza la sintassi JSON standard.
+ `operator`è uno dei seguenti operatori:
  + `<`(Meno di)
  + `<=`(Minore o uguale a)
  + `==`(Uguale a)

    Se il valore JSONPath o nell'espressione è un array, un valore booleano o un valore di oggetto, questo è l'unico operatore binario supportato che è possibile utilizzare.
  + `>=`(Maggiore o uguale a)
  + `>`(Maggiore di)
  + `=~`(Corrispondenza delle espressioni regolari). Per utilizzare questo operatore in un'espressione di filtro, il valore JSONPath o sul lato sinistro dell'espressione deve restituire una stringa e il lato destro deve essere un valore di modello che segue la [RE2sintassi](https://github.com/google/re2/wiki/Syntax).

È possibile utilizzare JSONPath le interrogazioni nel formato \$1\$1*query*\$1\$1 come stringhe segnaposto all'interno dei `environmentVariables` campi `args` e nei campi `test.json` dei file. `environmentVariables` `suite.json` IDT esegue una ricerca contestuale e popola i campi con il valore valutato della query. Ad esempio, nel `suite.json` file, è possibile utilizzare stringhe segnaposto per specificare i valori delle variabili di ambiente che cambiano con ogni test case e IDT popolerà le variabili di ambiente con il valore corretto per ogni test case. Tuttavia, quando utilizzate stringhe segnaposto nei `suite.json` file `test.json` e, alle vostre query valgono le seguenti considerazioni:
+ È necessario che ogni occorrenza della `devicePool` chiave nella query sia scritta interamente in lettere minuscole. Cioè, usa `devicepool` invece.
+ Per gli array, è possibile utilizzare solo matrici di stringhe. Inoltre, gli array utilizzano un formato non standard. `item1, item2,...,itemN` Se l'array contiene solo un elemento, viene serializzato come`item`, rendendolo indistinguibile da un campo di stringhe. 
+ Non è possibile utilizzare segnaposti per recuperare oggetti dal contesto.

Alla luce di queste considerazioni, consigliamo, quando possibile, di utilizzare l'API per accedere al contesto nella logica di test anziché le stringhe segnaposto nei file e nei file. `test.json` `suite.json` Tuttavia, in alcuni casi potrebbe essere più comodo utilizzare i JSONPath segnaposto per recuperare singole stringhe da impostare come variabili di ambiente.