

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

# Criação de arquivos de configuração do conjunto de testes do IDT
<a name="idt-json-config"></a>

Esta seção descreve os formatos nos quais você cria arquivos de configuração incluídos ao escrever um pacote de teste personalizado.

**Arquivos de configuração necessária**

**`suite.json`**  
Contém informações sobre o pacote de teste. Consulte [Configurar suite.json](#suite-json).

**`group.json`**  
Contém informações sobre um grupo de teste. É preciso criar um arquivo `group.json` para cada grupo de teste em seu pacote de teste. Consulte [Configurar group.json](#group-json).

**`test.json`**  
Contém informações sobre um caso de teste. É preciso criar um arquivo `test.json` para cada caso de teste em seu pacote de teste. Consulte [Configurar test.json](#test-json).

**Arquivos de configuração opcional**

**`test_orchestrator.yaml` ou `state_machine.json`**  
Define como os testes são executados quando o IDT executa o conjunto de testes. SSe [Configurar test\$1orchestrator.yaml](#test-orchestrator-config).  
Desde o IDT v4.5.2, você usa o arquivo `test_orchestrator.yaml` para definir o fluxo de trabalho de testes. Nas versões anteriores do IDT, você usa o arquivo `state_machine.json`. Para obter informações sobre a máquina de estado, consulte [Configurar a máquina de estado do IDT](idt-state-machine.md).

**`userdata_schema.json`**  
Define o esquema do [arquivo `userdata.json`](set-config-custom.md#userdata-config-custom) que os executores de teste podem incluir na definição de configuração. O arquivo `userdata.json` é usado em qualquer informação de configuração adicional necessária para executar o teste, mas que não esteja presente no arquivo `device.json`. Consulte [Configurar userdata\$1schema.json](#userdata-schema-json).

Os arquivos de configuração JSON são colocados no seu `<custom-test-suite-folder>`, conforme mostrado aqui.

```
<custom-test-suite-folder>
└── suite
    ├── suite.json
    ├── test_orchestrator.yaml
    ├── userdata_schema.json
    ├── <test-group-folder>
        ├── group.json
        ├── <test-case-folder>
            └── test.json
```

## Configurar suite.json
<a name="suite-json"></a>

O arquivo `suite.json` define as variáveis de ambiente e determina se os dados do usuário são necessários para executar o pacote de teste. Use o modelo a seguir para configurar seu arquivo `<custom-test-suite-folder>/suite/suite.json`: 

```
{
    "id": "<suite-name>_<suite-version>",
    "title": "<suite-title>",
    "details": "<suite-details>",
    "userDataRequired": true | false,
    "environmentVariables": [
        {
            "key": "<name>",
            "value": "<value>",
        },
        ...
        {
            "key": "<name>",
            "value": "<value>",
        }
    ]
}
```

Todos os campos que contêm valores são necessários, conforme descrito aqui:

**`id`**  
Um ID exclusivo, definido pelo usuário, para o pacote de teste. O valor de `id` deve corresponder ao nome da pasta do pacote de teste na qual o arquivo `suite.json` está localizado. O nome e a versão do pacote devem atender aos seguintes requisitos:   
+ `<suite-name>` não pode conter sublinhados.
+ `<suite-version>` é indicado como `x.x.x`, em que `x` é um número.
O ID é mostrado nos relatórios de teste gerados pelo IDT.

**`title`**  
Um nome definido pelo usuário para o produto ou recurso que está sendo testado por esse pacote de teste. O nome é exibido na CLI do IDT para os executores de teste.

**`details`**  
Uma descrição breve da finalidade do pacote de teste.

**`userDataRequired`**  
Define se os executores de teste precisam incluir informações personalizadas em um arquivo `userdata.json`. Se definir esse valor como `true`, também deverá incluir o [arquivo `userdata_schema.json`](#userdata-schema-json) na pasta do pacote de teste.

**`environmentVariables`**  
Opcional. Uma matriz de variáveis de ambiente para configurar para esse pacote de teste.    
**`environmentVariables.key`**  
O nome da variável de ambiente.  
**`environmentVariables.value`**  
O valor da variável de ambiente.

## Configurar group.json
<a name="group-json"></a>

O arquivo `group.json` define se o grupo de teste é necessário ou opcional. Use o modelo a seguir para configurar seu arquivo `<custom-test-suite-folder>/suite/<test-group>/group.json`: 

```
{
    "id": "<group-id>",
    "title": "<group-title>",
    "details": "<group-details>",
    "optional": true | false,
}
```

Todos os campos que contêm valores são necessários, conforme descrito aqui:

**`id`**  
Um ID exclusivo, definido pelo usuário, para o grupo de teste. O valor de `id` deve corresponder ao nome da pasta do grupo de teste na qual o arquivo `group.json` está localizado e não deve ter sublinhados (`_`). O ID é usado nos relatórios de teste gerados pelo IDT.

**`title`**  
Um nome descritivo para o grupo de teste. O nome é exibido na CLI do IDT para os executores de teste.

**`details`**  
Uma descrição breve da finalidade do grupo de teste.

**`optional`**  
Opcional. Defina como `true` para exibir este grupo de teste como um grupo opcional depois que o IDT terminar de executar os testes necessários. O valor padrão é `false`.

## Configurar test.json
<a name="test-json"></a>

O arquivo `test.json` determina os executáveis do caso de teste e as variáveis de ambiente que são usadas por um caso de teste. Para obter mais informações sobre como criar executáveis de casos de teste, consulte [Crie um executável de caso de teste do IDT](test-executables.md).

Use o modelo a seguir para configurar seu arquivo `<custom-test-suite-folder>/suite/<test-group>/<test-case>/test.json`: 

```
{
    "id": "<test-id>",
    "title": "<test-title>",
    "details": "<test-details>",
    "requireDUT": true | false,
    "requiredResources": [
        {
            "name": "<resource-name>",
            "features": [
                {
                    "name": "<feature-name>",
                    "version": "<feature-version>",
                    "jobSlots": <job-slots>
                }
            ]
        }
    ],
    "execution": {
        "timeout": <timeout>,
        "mac": {
            "cmd": "/path/to/executable",
            "args": [
                "<argument>"
            ],
        },
        "linux": {
            "cmd": "/path/to/executable",
            "args": [
                "<argument>"
            ],
        },
        "win": {
            "cmd": "/path/to/executable",
            "args": [
                "<argument>"
            ]
        }
    },
    "environmentVariables": [
        {
            "key": "<name>",
            "value": "<value>",
        }
    ]
}
```

Todos os campos que contêm valores são necessários, conforme descrito aqui:

**`id`**  
Um ID exclusivo, definido pelo usuário, para o caso de teste. O valor de `id` deve corresponder ao nome da pasta do caso de teste na qual o arquivo `test.json` está localizado e não deve ter sublinhados (`_`). O ID é usado nos relatórios de teste gerados pelo IDT.

**`title`**  
Um nome descritivo para o caso de teste. O nome é exibido na CLI do IDT para os executores de teste.

**`details`**  
Uma descrição breve da finalidade do caso de teste.

**`requireDUT`**  
Opcional. Defina como `true` se um dispositivo for necessário para executar este teste. Caso contrário, defina como `false`. O valor padrão é `true`. Os executores de teste configurarão os dispositivos que usarão para executar o teste nos arquivos `device.json`.

**`requiredResources`**  
Opcional. Uma matriz que fornece informações sobre os dispositivos de recursos necessários para executar esse teste.     
**`requiredResources.name`**  
O nome exclusivo a ser dado ao dispositivo de recurso quando este teste está sendo executado.  
**`requiredResources.features`**  
Uma matriz de recursos de dispositivos de recursos definidos pelo usuário.     
**`requiredResources.features.name`**  
O nome do recurso. O recurso do dispositivo para o qual você deseja usar este dispositivo. Este nome é comparado ao nome do recurso fornecido pelo executor de teste no arquivo `resource.json`.  
**`requiredResources.features.version`**  
Opcional. A versão do recurso. Este valor é comparado à versão do recurso fornecida pelo executor de teste no arquivo `resource.json`. Se uma versão não for fornecida, o recurso não será verificado. Se um número de versão não for obrigatório para o recurso, deixe este campo em branco.  
**`requiredResources.features.jobSlots`**  
Opcional. O número de testes simultâneos que podem ser compatíveis com este recurso. O valor padrão é `1`. Se você quiser que o IDT use dispositivos distintos para recursos individuais, recomendamos que você defina esse valor como `1`.

**`execution.timeout`**  
A quantidade de tempo (em milissegundos) que o IDT aguardará a conclusão da execução do teste. Para obter mais informações sobre este valor, consulte [Crie um executável de caso de teste do IDT](test-executables.md).

**`execution.os`**  
Os executáveis do caso de teste a serem executados com base no sistema operacional do computador host que executa o IDT. Os valores compatíveis são `linux`, `mac` e `win`.     
**`execution.os.cmd`**  
O caminho para o executável do caso de teste que deseja executar para o sistema operacional especificado. Este local deve estar no caminho do sistema.  
**`execution.os.args`**  
Opcional. Os argumentos a serem fornecidos para executar o executável do caso de teste.

**`environmentVariables`**  
Opcional. Uma matriz de variáveis de ambiente definidas para este caso de teste.     
**`environmentVariables.key`**  
O nome da variável de ambiente.  
**`environmentVariables.value`**  
O valor da variável de ambiente.
Se especificar a mesma variável de ambiente no arquivo `test.json` e no arquivo `suite.json`, o valor no arquivo `test.json` terá precedência. 

## Configurar test\$1orchestrator.yaml
<a name="test-orchestrator-config"></a>

Um orquestrador de teste é uma estrutura que controla o fluxo de execução do pacote de teste. Ele determina o estado inicial de um pacote de teste, gerencia as transições de estado com base nas regras definidas pelo usuário e continua a transição por esses estados até atingir o estado final. 

Se seu pacote de teste não incluir um orquestrador de testes definido pelo usuário, o IDT gerará um orquestrador de testes para você.

O orquestrador de teste padrão executa as seguintes funções:
+ Fornece aos executores de teste a capacidade de selecionar e executar grupos de testes específicos, em vez de todo o pacote de teste.
+ Se grupos de teste específicos não forem selecionados, executará cada grupo de teste no pacote de teste em uma ordem aleatória. 
+ Gera relatórios e imprime um resumo do console que mostra os resultados do teste para cada grupo de teste e caso de teste.

Para obter mais informações sobre como o orquestrador de testes do IDT funciona, consulte [Configure o orquestrador de testes do IDT](idt-test-orchestrator.md).

## Configurar userdata\$1schema.json
<a name="userdata-schema-json"></a>

O arquivo `userdata_schema.json` determina o esquema no qual os executores de teste fornecem dados do usuário. Os dados do usuário são necessários se seu pacote de teste exigir informações que não estejam presentes no arquivo `device.json`. Por exemplo, seus testes podem precisar de credenciais de rede Wi-Fi, portas abertas específicas ou certificados que um usuário deve fornecer. Estas informações podem ser fornecidas ao IDT como um parâmetro de entrada chamado `userdata`, cujo valor é um arquivo `userdata.json`, que os usuários criam em suas pastas `<device-tester-extract-location>/config`. O formato do arquivo `userdata.json` é baseado no arquivo `userdata_schema.json` incluído no pacote de teste.

Para indicar que os executores de teste devem fornecer um arquivo `userdata.json`:

1. No arquivo `suite.json`, defina `userDataRequired` como `true`.

1. No seu `<custom-test-suite-folder>`, crie um arquivo `userdata_schema.json`.

1. Edite o arquivo `userdata_schema.json` para criar um [esquema JSON válido do IETF Draft v4](https://json-schema.org/specification-links#draft-4).

Quando o IDT executa seu pacote de teste, ele lê automaticamente o esquema e o usa para validar o arquivo `userdata.json` fornecido pelo executor do teste. Se válido, o conteúdo do arquivo `userdata.json` estará disponível no [contexto do IDT](idt-context.md) e no [contexto do orquestrador de testes](idt-test-orchestrator.md#idt-test-orchestrator-context).