As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Use o contexto do IDT
<a name="idt-context"></a>

Quando o IDT executa um pacote de teste, o pacote de teste pode acessar um conjunto de dados que podem ser usados para determinar como cada teste é executado. Estes dados são chamados de contexto do IDT. Por exemplo, a configuração de dados do usuário fornecida pelos executores de teste em um arquivo `userdata.json` é disponibilizada para pacotes de teste no contexto do IDT. 

O contexto do IDT pode ser considerado um documento JSON somente para leitura. Os pacotes de teste podem recuperar e gravar dados no contexto usando tipos de dados JSON padrão, como objetos, matrizes, números e assim por diante.

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

O contexto do IDT usa o formato a seguir:

```
{
    "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`  
Informações do [arquivo `config.json`](set-custom-idt-config.md#config-json-custom). O campo `config` também contém o seguinte campo adicional:    
`config.timeoutMultiplier`  
O multiplicador de um valor de tempo limite usado pelo conjunto de testes. Este valor é especificado pelo executor de teste da CLI do IDT. O valor padrão é `1`.

`device`  
Informações sobre o dispositivo selecionado para a execução do teste. Estas informações são equivalentes à matriz `devices` definida no [arquivo `device.json`](set-custom-idt-config.md#device-config-custom) do dispositivo selecionado.

`devicePool`  
Informações sobre o grupo de dispositivos selecionado para a execução do teste. Estas informações são equivalentes ao elemento de matriz do grupo de dispositivos de nível superior definido no arquivo `device.json` do grupo de dispositivos selecionado.

`resource`  
As informações sobre dispositivos de recursos do arquivo `resource.json`.    
`resource.devices`  
Estas informações são equivalentes à matriz `devices` definida no arquivo `resource.json`. Cada elemento `devices` inclui o seguinte campo adicional:    
`resource.device.name`  
O nome do dispositivo de recurso. Este valor é definido como o valor `requiredResource.name` no arquivo `test.json`.

`testData.awsCredentials`  
As credenciais da AWS usadas pelo teste para se conectar à nuvem da AWS. Estas informações são obtidas do arquivo `config.json`.

`testData.logFilePath`  
O caminho para o arquivo de log no qual o caso de teste grava mensagens de log. O pacote de teste criará este arquivo se ele não existir. 

`userData`  
As informações fornecidas pelo executor de teste no [arquivo `userdata.json`](set-custom-idt-config.md#userdata-config-custom).

## Acessar dados no contexto
<a name="accessing-context-data"></a>

É possível consultar o contexto usando a notação JSONPath dos arquivos JSON e do executável de texto com as APIs `GetContextValue` e `GetContextString`. A sintaxe das cadeias de caracteres JSONPath para acessar o contexto do IDT varia da seguinte forma:
+ Em `suite.json` e `test.json`, é usado `{{query}}`. Ou seja, não use o elemento raiz `$.` para iniciar sua expressão.
+ Em `test_orchestrator.yaml`, é usado `{{query}}`.

  Se você usa a máquina de estado obsoleta, então em`state_machine.json`, você usa. `{{$.query}}`
+ Nos comandos da API, é usado `query` ou `{{$.query}}`, dependendo do comando. Para obter mais informações, consulte a documentação em linha dos SDKs. 

A tabela a seguir descreve os operadores em uma expressão 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 rápido index and going up to the end 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 criar expressões de filtro, use a sintaxe a seguir:

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

Nesta sintaxe: 
+ `jsonpath` é um JSONPath que usa a sintaxe JSON padrão. 
+ `value` é qualquer valor personalizado que usa a sintaxe JSON padrão.
+ `operator` é um dos seguintes operadores:
  + `<` (Menor que)
  + `<=` (Menor ou igual a)
  + `==` (Igual a)

    Se o JSONPath ou o valor em sua expressão for um valor de matriz, booleano ou objeto, este será o único operador binário compatível que será possível usar.
  + `>=` (Maior ou igual a)
  + `>` (Maior que)
  + `=~` (Correspondência de expressão regular). Para usar este operador em uma expressão de filtro, o JSONPath ou valor no lado esquerdo da expressão deve ser avaliado como uma string e o lado direito deve ser um valor padrão que siga a sintaxe [RE2](https://github.com/google/re2/wiki/Syntax).

É possível usar consultas JSONPath no formato \$1\$1*query*\$1\$1 como strings de reserva de espaço nos campos `args` e `environmentVariables` nos arquivos `test.json` e nos campos `environmentVariables` nos arquivos `suite.json`. O IDT realiza uma pesquisa de contexto e preenche os campos com o valor avaliado da consulta. Por exemplo, no arquivo `suite.json`, é possível usar strings de espaço reservado para especificar valores de variáveis de ambiente que mudam com cada caso de teste e o IDT preencherá as variáveis de ambiente com o valor correto para cada caso de teste. No entanto, ao usar strings de caracteres de espaço reservado em arquivos `test.json` e `suite.json`, as seguintes considerações se aplicam às suas consultas:
+ Cada ocorrência da chave `devicePool` em sua consulta deve estar em letras minúsculas. Ou seja, em vez disso, use `devicepool`.
+ Para as matrizes, somente matrizes de strings podem ser usadas. Além disso, as matrizes usam um formato `item1, item2,...,itemN` não padrão. Se a matriz contiver somente um elemento, ela será serializada como `item`, tornando-a indistinguível de um campo de strings. 
+ Não é possível usar espaços reservados para recuperar objetos do contexto.

Por conta dessas considerações, é recomendado, sempre que possível, usar a API para acessar o contexto em sua lógica de teste em vez de strings de espaço reservado em arquivos `test.json` e `suite.json`. No entanto, em alguns casos, pode ser mais conveniente usar espaços reservados JSONPath para recuperar strings únicas para definir como variáveis de ambiente.