Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso del contexto de IDT
<a name="idt-context"></a>

Cuando IDT ejecuta un conjunto de pruebas, el conjunto de pruebas puede acceder a un conjunto de datos que se pueden utilizar para determinar cómo se ejecuta cada prueba. Estos datos se denominan contexto de IDT. Por ejemplo, la configuración de los datos de usuario proporcionada por los ejecutores de pruebas en un archivo `userdata.json` se pone a disposición de los conjuntos de pruebas en el contexto de IDT. 

El contexto de IDT puede considerarse un documento JSON de solo lectura. Los conjuntos de pruebas pueden recuperar datos del contexto y escribirlos en él mediante tipos de datos JSON estándar, como objetos, matrices, números, etc.

## Esquema de contexto
<a name="idt-context-schema"></a>

El contexto de IDT utiliza el siguiente 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`  
Información del [archivo `config.json`](set-custom-idt-config.md#config-json-custom). El campo `config` también contiene el siguiente campo adicional:    
`config.timeoutMultiplier`  
El multiplicador para cualquier valor de tiempo de espera utilizado por el conjunto de pruebas. El ejecutor de pruebas especifica este valor desde la CLI de IDT. El valor predeterminado es `1`.

`device`  
Información sobre el dispositivo seleccionado para la prueba. Esta información equivale al elemento de matriz `devices` del [archivo `device.json`](set-custom-idt-config.md#device-config-custom) del dispositivo seleccionado.

`devicePool`  
Información sobre el grupo de dispositivos seleccionado para la ejecución de la prueba. Esta información equivale al elemento de matriz del grupo de dispositivos en el nivel superior definido en el archivo `device.json` para el grupo de dispositivos seleccionado.

`resource`  
Información sobre los dispositivos de recursos del archivo `resource.json`.    
`resource.devices`  
Esta información equivale a la matriz `devices` definida en el archivo `resource.json`. Cada elemento `devices` incluye el siguiente campo adicional:    
`resource.device.name`  
El nombre del dispositivo de recursos. Este valor se establece en el valor `requiredResource.name` en el archivo `test.json`.

`testData.awsCredentials`  
Las credenciales de AWS que se utilizan en la prueba para conectarse a la nube de AWS. Esta información se obtiene del archivo `config.json`.

`testData.logFilePath`  
La ruta al archivo de registro en el que el caso de prueba escribe los mensajes de registro. El conjunto de pruebas crea este archivo si no existe. 

`userData`  
Información proporcionada por el ejecutor de la prueba en el [archivo `userdata.json`](set-custom-idt-config.md#userdata-config-custom).

## Acceda a los datos en el contexto
<a name="accessing-context-data"></a>

Puede consultar el contexto mediante la notación JSONPath de sus archivos JSON y de su ejecutable de texto con las API `GetContextValue` y`GetContextString`. La sintaxis de las cadenas JSONPath para acceder al contexto IDT varía de la siguiente manera:
+ En `suite.json` y `test.json`, se usa `{{query}}` Es decir, no utilice el elemento raíz `$.` para iniciar la expresión.
+ En `test_orchestrator.yaml`, se usa `{{query}}`.

  Si usa la máquina de estados obsoleta, entonces en `state_machine.json`, usa `{{$.query}}`.
+ En los comandos de la API, se utiliza `query` o `{{$.query}}`, según el comando. Para obtener más información, consulte la documentación en línea en los SDK. 

En la siguiente tabla se describen los operadores de una expresión JSONPath típica:


| Operator  | Description  | 
| --- |--- |
| \$1 | The root element. Because the top-level context value for IDT is an object, you will typically use \$1. to start your queries. | 
| .childName | Accesses the child element with name childName from an object. If applied to an array, yields a new array with this operator applied to each element. The element name is case sensitive. For example, the query to access the awsRegion value in the config object is \$1.config.awsRegion. | 
| [start:end] | Filters elements from an array, retrieving items beginning from the iniciar index and going up to the finales index, both inclusive. | 
| [index1, index2, ... , indexN] | Filters elements from an array, retrieving items from only the specified indices. | 
| [?(expr)] | Filters elements from an array using the expr expression. This expression must evaluate to a boolean value. | 

Para crear expresiones de filtro, utilice la siguiente sintaxis:

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

En esta sintaxis: 
+ `jsonpath` es un JSONPath que utiliza la sintaxis JSON estándar. 
+ `value` es cualquier valor personalizado que utilice la sintaxis JSON estándar.
+ `operator` es uno de los siguientes operadores:
  + `<` (Menor que)
  + `<=` (Menor o igual que)
  + `==` (Igual que)

    Si el JSONPath o el valor de la expresión es un valor de matriz, booleano o de objeto, este es el único operador binario compatible que puede utilizar.
  + `>=` (Mayor o igual que)
  + `>` (Mayor que)
  + `=~` (Coincidencia de expresión regular). Para usar este operador en una expresión de filtro, el JSONPath o el valor del lado izquierdo de la expresión debe evaluarse como una cadena y el lado derecho debe ser un valor de patrón que siga la sintaxis [RE2](https://github.com/google/re2/wiki/Syntax).

Puede utilizar consultas JSONPath con el formato \$1\$1*query*\$1\$1 como cadenas de marcador de posición dentro de los campos `args` y `environmentVariables` en los archivos `test.json` y dentro de los campos `environmentVariables` en los archivos `suite.json`. IDT realiza una búsqueda contextual y rellena los campos con el valor evaluado de la consulta. Por ejemplo, en el archivo `suite.json`, puede utilizar cadenas de marcadores de posición para especificar los valores de las variables de entorno que cambian con cada caso de prueba e IDT rellenará las variables de entorno con el valor correcto para cada caso de prueba. Sin embargo, cuando se utilizan cadenas de marcadores de posición en los archivos `test.json` y `suite.json`, las consultas tienen en cuenta las siguientes consideraciones:
+ Debe escribir en minúsculas cada vez que aparezca la clave `devicePool` en la consulta. Es decir, utilizar `devicepool` en su lugar.
+ Para las matrices, solo puede usar matrices de cadenas. Además, las matrices utilizan un formato `item1, item2,...,itemN` no estándar. Si la matriz contiene solo un elemento, se serializa como `item`, lo que la hace que no se pueda distinguir de un campo de cadena. 
+ No puede utilizar marcadores de posición para recuperar objetos del contexto.

Debido a estas consideraciones, le recomendamos que, siempre que sea posible, utilice la API para acceder al contexto en su lógica de prueba en lugar de cadenas de marcadores de posición en los archivos `test.json` y `suite.json`. Sin embargo, en algunos casos puede ser más conveniente utilizar marcadores de posición de JSONPath para recuperar cadenas individuales y configurarlas como variables de entorno.