Pré-requisitos Criação de um diretório de conjunto de testes Crie arquivos de configuração Obter IDT Client SDK Criação do executável do caso de teste Configuração das informações do dispositivo para o IDT Execução de conjunto de testes Solução de problemas

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 para AWS IoT Greengrass para desenvolver um pacote de testes em Python que contém um único caso de teste. Neste tutorial, você completará as seguintes etapas:

Criação de um diretório de conjunto de testes
Crie arquivos de configuração
Criação do executável do caso de teste
Execução de conjunto de testes

Pré-requisitos

Para concluir este tutorial, você precisará do seguinte:

Requisitos do computador host
- Versão mais recente do AWS IoT Device Tester
- Python 3.7 ou posterior
  
  Para verificar a versão do Python instalada em seu computador, execute o comando a seguir:
```
python3 --version
```
  No Windows, se o uso desse 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 para instalar o Python 3.7+. Para obter mais informações, consulte a Documentação do Python.
- urllib3
  
  Para verificar se urllib3 está instalado corretamente, execute o comando a seguir:
```
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.
  
  Recomendamos que você use um Raspberry Pi com o sistema operacional Raspberry Pi. Configure o SSH no seu Raspberry Pi para se conectar remotamente a ele.

Criação de um diretório de conjunto de testes

O IDT separa logicamente os casos de teste em grupos de teste dentro de cada conjunto de testes. Cada caso de teste deve estar dentro de um grupo de testes. 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 necessários:

Arquivos de configuração necessária

suite.json: Contém informações sobre o pacote de teste. Consulte Configurar suite.json.
group.json: Contém informações sobre um grupo de testes. Você deve criar um arquivo group.json para cada grupo de testes em seu conjunto de testes. Consulte Configuração de group.json.
test.json: Contém informações sobre um caso de testes. Você deve criar um arquivo test.json para cada caso de teste em seu conjunto de testes. Consulte Configuração de test.json.

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
}

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
}

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

Obter IDT Client SDK

Você usa o IDT Client SDK para permitir que o IDT interaja com o dispositivo em teste e relate os resultados do teste. Neste tutorial, você usará a versão Python do SDK.

Na pasta <device-tester-extract-location>/sdks/python/, copie a pasta idt_client para sua pasta MyTestSuite_1.0.0/suite/myTestGroup/myTestCase.

Para verificar se o SDK foi copiado, execute o comando a seguir.


cd MyTestSuite_1.0.0/suite/myTestGroup/myTestCase
python3 -c 'import idt_client'

Criação do 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 conjunto de testes pode conter vários executáveis de casos de teste. Para este tutorial, você criará somente um executável de caso de teste.

Criação de arquivo do conjunto de testes.

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()
```

Use as funções do SDK de cliente para adicionar a seguinte lógica de teste ao seu arquivo myTestCase.py:

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()

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()

Configuração das informações do dispositivo para o IDT

Configure as informações doseu dispositivo para o IDT executar o teste. Você deve atualizar o modelo device.json localizado na pasta <device-tester-extract-location>/configs com as seguintes informações.


[
  {
    "id": "pool",
    "sku": "N/A",
    "devices": [
      {
        "id": "<device-id>",
        "connectivity": {
          "protocol": "ssh",
          "ip": "<ip-address>",
          "port": "<port>",
          "auth": {
            "method": "pki | password",
            "credentials": {
              "user": "<user-name>",
              "privKeyPath": "/path/to/private/key",
              "password": "<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.

Execução de conjunto de testes

Depois de criar o conjunto de testes, verifique se ele funciona conforme o esperado. Para isso, conclua as etapas a seguir para executar o conjunto de testes em seu grupo de dispositivos existente.

Copie a pasta MyTestSuite_1.0.0 em <device-tester-extract-location>/tests.

Execute os seguintes comandos:


cd <device-tester-extract-location>/bin
./devicetester_[linux | mac | win_x86-64] run-suite --suite-id MyTestSuite

O IDT executa seu conjunto de testes e transmite os resultados para o console. Quando a execução do teste é concluída, você vê 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 erros, confira:

O IDT Client SDK está na pasta correta, conforme descrito nesta etapa.
Você atende a todos os pré-requisitos 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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Tutorial: compile e execute o pacote de amostra de teste de IDT

Crie arquivos de configuração do pacote de testes do IDT