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á.
# Tutorial: desenvolva um pacote de testes de IDT simples
Um conjunto de testes combina o seguinte:
+ Executáveis de teste que contêm a lógica de teste
+ Arquivos de configuração que descrevem o pacote de teste
Este tutorial mostra como usar o IDT AWS IoT Greengrass para desenvolver uma suíte de testes em Python que contém um único caso de teste. Neste tutorial, você concluirá as seguintes etapas:
1. [Crie um diretório de pacotes de teste](#test-suite-dir)
1. [Crie arquivos de configuração](#test-suite-json)
1. [Crie o executável do caso de teste](#test-suite-exe)
1. [Execute o pacote de teste](#run-test-suite)
## Pré-requisitos
Para concluir este tutorial, você precisará do seguinte:
+
**Requisitos do computador host**
+ Versão mais recente do AWS IoT Device Tester
+ [Python](https://www.python.org/downloads/) 3.7 ou posterior
Para verificar a versão do Python instalada em seu computador, execute o seguinte comando:
```
python3 --version
```
No Windows, se o uso deste comando retornar um erro, use `python --version`. Se o número da versão retornada for 3.7 ou superior, execute o seguinte comando em um terminal do Powershell para definir `python3` como um alias para seu comando `python`.
```
Set-Alias -Name "python3" -Value "python"
```
Se nenhuma informação sobre versão for retornada ou se o número da versão for menor do que 3.7, siga as instruções em [Fazer download do Python](https://wiki.python.org/moin/BeginnersGuide/Download) para instalar o Python 3.7\$1. Para obter mais informações, consulte a [Documentação do Python](https://docs.python.org).
+ [urllib3](https://urllib3.readthedocs.io/en/latest/)
Para verificar se `urllib3` está instalado corretamente, execute o seguinte comando:
```
python3 -c 'import urllib3'
```
Se o `urllib3` não estiver instalado, execute o comando a seguir para instalá-lo:
```
python3 -m pip install urllib3
```
+
**Requisitos do dispositivo**
+ Um dispositivo com sistema operacional Linux e uma conexão de rede com a mesma rede do seu computador host.
É recomendado o uso de um [Raspberry Pi](https://www.raspberrypi.org/) com o sistema operacional Raspberry Pi. Certifique-se de configurar o [SSH](https://www.raspberrypi.org/documentation/remote-access/ssh/) no seu Raspberry Pi para se conectar remotamente a ele.
## Crie um diretório de pacotes de teste
O IDT separa logicamente os casos de teste em grupos de teste dentro de cada pacote de teste. Cada caso de teste deve estar dentro de um grupo de teste. Para este tutorial, crie uma pasta chamada `MyTestSuite_1.0.0` e crie a seguinte árvore de diretórios nesta pasta:
```
MyTestSuite_1.0.0
└── suite
└── myTestGroup
└── myTestCase
```
## Crie arquivos de configuração
Seu pacote de teste deve conter os seguintes [arquivos de configuração](idt-json-config.md) necessários:Arquivos de configuração necessária
`suite.json`
Contém informações sobre o pacote de teste. Consulte [Configurar suite.json](idt-json-config.md#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](idt-json-config.md#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](idt-json-config.md#test-json).
1. Na pasta `MyTestSuite_1.0.0/suite`, crie um arquivo `suite.json` com a seguinte estrutura:
```
{
"id": "MyTestSuite_1.0.0",
"title": "My Test Suite",
"details": "This is my test suite.",
"userDataRequired": false
}
```
1. Na pasta `MyTestSuite_1.0.0/myTestGroup`, crie um arquivo `group.json` com a seguinte estrutura:
```
{
"id": "MyTestGroup",
"title": "My Test Group",
"details": "This is my test group.",
"optional": false
}
```
1. Na pasta `MyTestSuite_1.0.0/myTestGroup/myTestCase`, crie um arquivo `test.json` com a seguinte estrutura:
```
{
"id": "MyTestCase",
"title": "My Test Case",
"details": "This is my test case.",
"execution": {
"timeout": 300000,
"linux": {
"cmd": "python3",
"args": [
"myTestCase.py"
]
},
"mac": {
"cmd": "python3",
"args": [
"myTestCase.py"
]
},
"win": {
"cmd": "python3",
"args": [
"myTestCase.py"
]
}
}
}
```
Agora, a árvore de diretórios da pasta `MyTestSuite_1.0.0` deve ser semelhante à seguinte:
```
MyTestSuite_1.0.0
└── suite
├── suite.json
└── myTestGroup
├── group.json
└── myTestCase
└── test.json
```
## Obtenha o SDK do cliente do IDT
Use o [SDK de cliente do IDT](create-test-executables.md#idt-client-sdk) para permitir que o IDT interaja com o dispositivo testado e relate os resultados do teste. Neste tutorial, use a versão em Python do SDK.
Na pasta `/sdks/python/`, copie a pasta `idt_client` para sua pasta `MyTestSuite_1.0.0/suite/myTestGroup/myTestCase`.
Para verificar se o SDK foi copiado com êxito, execute o comando a seguir.
```
cd MyTestSuite_1.0.0/suite/myTestGroup/myTestCase
python3 -c 'import idt_client'
```
## Crie o executável do caso de teste
Os executáveis do caso de teste contêm a lógica de teste que você deseja executar. Um pacote de teste pode conter vários executáveis de casos de teste. Para este tutorial, crie somente um executável de caso de teste.
1. Crie o arquivo do pacote de teste.
Na pasta `MyTestSuite_1.0.0/suite/myTestGroup/myTestCase`, crie um arquivo `myTestCase.py` com o seguinte conteúdo:
```
from idt_client import *
def main():
# Use the client SDK to communicate with IDT
client = Client()
if __name__ == "__main__":
main()
```
1. Use as funções do SDK de cliente para adicionar a seguinte lógica de teste ao seu arquivo `myTestCase.py`:
1. Execute um comando SSH no dispositivo em teste.
```
from idt_client import *
def main():
# Use the client SDK to communicate with IDT
client = Client()
# Create an execute on device request
exec_req = ExecuteOnDeviceRequest(ExecuteOnDeviceCommand("echo 'hello world'"))
# Run the command
exec_resp = client.execute_on_device(exec_req)
# Print the standard output
print(exec_resp.stdout)
if __name__ == "__main__":
main()
```
1. Envie o resultado do teste para o IDT.
```
from idt_client import *
def main():
# Use the client SDK to communicate with IDT
client = Client()
# Create an execute on device request
exec_req = ExecuteOnDeviceRequest(ExecuteOnDeviceCommand("echo 'hello world'"))
# Run the command
exec_resp = client.execute_on_device(exec_req)
# Print the standard output
print(exec_resp.stdout)
# Create a send result request
sr_req = SendResultRequest(TestResult(passed=True))
# Send the result
client.send_result(sr_req)
if __name__ == "__main__":
main()
```
## Configurar as informações do dispositivo para o IDT
Configure as informações do seu dispositivo para o IDT executar o teste. É preciso atualizar o modelo `device.json` localizado na pasta `/configs` com as informações a seguir.
```
[
{
"id": "pool",
"sku": "N/A",
"devices": [
{
"id": "",
"connectivity": {
"protocol": "ssh",
"ip": "",
"port": "",
"auth": {
"method": "pki | password",
"credentials": {
"user": "",
"privKeyPath": "/path/to/private/key",
"password": ""
}
}
}
}
]
}
]
```
No objeto `devices`, forneça as seguintes informações:
`id`
Um identificador exclusivo, definido pelo usuário, para o seu dispositivo.
`connectivity.ip`
O endereço IP do seu dispositivo.
`connectivity.port`
Opcional. O número da porta que deve ser usado nas conexões SSH ao seu dispositivo.
`connectivity.auth`
Informações de autenticação da conexão.
Essa propriedade será aplicada somente se `connectivity.protocol` estiver definido como `ssh`.
`connectivity.auth.method`
O método de autenticação usado para acessar um dispositivo pelo protocolo de conectividade indicado.
Os valores compatíveis são:
+ `pki`
+ `password`
`connectivity.auth.credentials`
As credenciais usadas para autenticação.
`connectivity.auth.credentials.user`
O nome de usuário usado para fazer login no seu dispositivo.
`connectivity.auth.credentials.privKeyPath`
O caminho completo para a chave privada usada para fazer login no dispositivo.
Esse valor se aplica somente se `connectivity.auth.method` estiver definido como `pki`.
`devices.connectivity.auth.credentials.password`
A senha usada para fazer login no dispositivo.
Esse valor se aplica somente se `connectivity.auth.method` estiver definido como `password`.
**nota**
Especifique `privKeyPath` somente se `method` estiver definido como `pki`.
Especifique `password` somente se `method` estiver definido como `password`.
## Execute o pacote de teste
Depois de criar o pacote de teste, verifique se ele funciona conforme o esperado. Conclua as etapas a seguir para executar o pacote de teste em seu grupo de dispositivos existente.
1. Copie sua pasta `MyTestSuite_1.0.0` em `/tests`.
1. Execute os seguintes comandos :
```
cd /bin
./devicetester_[linux | mac | win_x86-64] run-suite --suite-id MyTestSuite
```
O IDT executa seu pacote de teste e transmite os resultados para o console. Quando a execução do teste é concluída, são vistas as seguintes informações:
```
time="2020-10-19T09:24:47-07:00" level=info msg=Using pool: pool
time="2020-10-19T09:24:47-07:00" level=info msg=Using test suite "MyTestSuite_1.0.0" for execution
time="2020-10-19T09:24:47-07:00" level=info msg=b'hello world\n' suiteId=MyTestSuite groupId=myTestGroup testCaseId=myTestCase deviceId=my-device executionId=9a52f362-1227-11eb-86c9-8c8590419f30
time="2020-10-19T09:24:47-07:00" level=info msg=All tests finished. executionId=9a52f362-1227-11eb-86c9-8c8590419f30
time="2020-10-19T09:24:48-07:00" level=info msg=
========== Test Summary ==========
Execution Time: 1s
Tests Completed: 1
Tests Passed: 1
Tests Failed: 0
Tests Skipped: 0
----------------------------------
Test Groups:
myTestGroup: PASSED
----------------------------------
Path to IoT Device Tester Report: /path/to/devicetester/results/9a52f362-1227-11eb-86c9-8c8590419f30/awsiotdevicetester_report.xml
Path to Test Execution Logs: /path/to/devicetester/results/9a52f362-1227-11eb-86c9-8c8590419f30/logs
Path to Aggregated JUnit Report: /path/to/devicetester/results/9a52f362-1227-11eb-86c9-8c8590419f30/MyTestSuite_Report.xml
```
## Solução de problemas
Use as informações a seguir para ajudar a resolver os problemas ao concluir o tutorial.
**Caso de teste não é executado**
Se o teste não for executado, o IDT transmitirá os logs de erro para o console e isso pode ajudar a solucionar o problema de execução do teste. Antes de verificar os logs de erro, verifique o seguinte:
+ O SDK de cliente do IDT está na pasta correta, conforme descrito [nesta etapa](#add-idt-sdk).
+ Você atende a todos os [pré-requisitos](#prereqs-tutorial-custom) deste tutorial.
**Não é possível se conectar ao dispositivo em teste**
Verifique o seguinte:
+ Seu arquivo `device.json` contém o endereço IP, a porta e as informações de autenticação corretos.
+ Você pode se conectar ao seu dispositivo via SSH a partir do seu computador host.