Aviso de fim do suporte: em 7 de outubro de 2026, AWS o suporte para o. AWS IoT Greengrass Version 1 Depois de 7 de outubro de 2026, você não poderá mais acessar os AWS IoT Greengrass V1 recursos. Para obter mais informações, visite [Migrar de AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).

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`](gg-core.md#config-json). 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-config-custom.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 AWS credenciais usadas pelo teste para se conectar à AWS nuvem. 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-config-custom.md#userdata-config-custom).

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

Você pode consultar o contexto usando a JSONPath notação dos seus arquivos JSON e do seu executável de texto com e. `GetContextValue` `GetContextString` APIs A sintaxe JSONPath das cadeias de caracteres 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 `statemachine.json`, é usado `{{$.query}}`.
+ Nos comandos da API, é usado `query` ou `{{$.query}}`, dependendo do comando. Para obter mais informações, consulte a documentação em linha no SDKs. 

A tabela a seguir descreve os operadores em uma JSONPath expressão típica:


| Operador  | Descrição  | 
| --- |--- |
| \$1 | O elemento raiz. Como o valor de contexto de nível superior do IDT é um objeto, normalmente você usará \$1. para iniciar suas consultas. | 
| .childName | Acessa o elemento filho com o nome childName de um objeto. Se aplicado a uma matriz, produz uma nova matriz com esse operador aplicado a cada elemento. O nome do elemento diferencia maiúsculas e minúsculas. Por exemplo, a consulta para acessar o valor awsRegion no objeto config é \$1.config.awsRegion. | 
| [start:end] | Filtra elementos de uma matriz, recuperando itens que começam no índice start e vão até o índice end, ambos inclusive. | 
| [index1, index2, ... , indexN] | Filtra elementos de uma matriz, recuperando itens somente dos índices especificados. | 
| [?(expr)] | Filtra elementos de uma matriz usando a expressão expr. Esta expressão que deve ser avaliada para um valor booleano. | 

Para criar expressões de filtro, use os seguintes elementos:

```
<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 valor JSONPath ou em sua expressão for um valor de matriz, booleano ou objeto, esse será o único operador binário compatível que você poderá usar.
  + `>=` (Maior ou igual a)
  + `>` (Maior que)
  + `=~` (Correspondência de expressão regular). Para usar esse operador em uma expressão de filtro, o valor JSONPath ou 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 [RE2sintaxe](https://github.com/google/re2/wiki/Syntax).

Você pode usar JSONPath consultas no formato \$1\$1*query*\$1\$1 como cadeias de caracteres de espaço reservado `environmentVariables` nos campos `args` e nos `test.json` arquivos e nos `environmentVariables` campos 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 JSONPath espaços reservados para recuperar cadeias de caracteres únicas para definir como variáveis de ambiente.