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á.
# Device Advisor
O [Device Advisor](https://aws.amazon.com/iot-core/features/) é um recurso de teste totalmente gerenciado baseado em nuvem para validar dispositivos de IoT durante o desenvolvimento do software do dispositivo. O Device Advisor fornece testes pré-criados que você pode usar para validar dispositivos de IoT para conectividade confiável e segura antes de implantá-los na produção. AWS IoT Core Os testes pré-criados do Device Advisor ajudam você a validar o software do dispositivo em relação às práticas recomendadas de uso de [TLS](https://docs.aws.amazon.com//iot/latest/developerguide/protocols.html), [MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/protocols.html), [Sombra do dispositivo](https://docs.aws.amazon.com//iot/latest/developerguide/iot-device-shadows.html) e [Tarefas de IoT](https://docs.aws.amazon.com//iot/latest/developerguide/iot-jobs.html). Você também pode baixar relatórios de qualificação assinados para enviar à Rede de Parceiros da AWS para qualificar o dispositivo para o [Catálogo de dispositivos de parceiros da AWS](https://devices.amazonaws.com/) sem a necessidade de enviar o dispositivo e esperar que ele seja testado.
**nota**
O Device Advisor é compatível com as regiões us-east-1, us-west-2, ap-northeast-1 e eu-west-1.
O Device Advisor oferece suporte a dispositivos e clientes que usam os protocolos MQTT e MQTT over WebSocket Secure (WSS) para publicar e assinar mensagens. Todos os protocolos suportam IPv4 IPv6 e.
O Device Advisor é compatível com certificados de servidor RSA.
Qualquer dispositivo que tenha sido criado para se conectar AWS IoT Core pode aproveitar as vantagens do Device Advisor. Você pode acessar o Device Advisor pelo [AWS IoT console](https://us-east-1.console.aws.amazon.com/iot/home?region=us-east-1#/deviceadvisor/intro) ou usando o AWS CLI ou SDK. Quando estiver pronto para testar seu dispositivo, registre-o AWS IoT Core e configure o software do dispositivo com o endpoint Device Advisor. Em seguida, escolha os testes pré-criados, configure-os, execute-os no dispositivo e obtenha os resultados do teste junto com logs detalhados ou um relatório de qualificação.
O Device Advisor é um endpoint de teste na AWS nuvem. Você pode testar os dispositivos configurando-os para se conectarem ao endpoint de teste fornecido pelo Device Advisor. Depois que um dispositivo é configurado para se conectar ao endpoint de teste, você pode visitar o console do Device Advisor ou usar o AWS SDK para escolher os testes que deseja executar em seus dispositivos. Em seguida, o Device Advisor gerencia todo o ciclo de vida de um teste, incluindo o provisionamento de recursos, o agendamento do processo de teste, o gerenciamento da máquina de estado, o registro do comportamento do dispositivo, o registro em logs dos resultados e o fornecimento dos resultados finais na forma de um relatório de teste.
**Protocolos TLS**
O protocolo Transport Layer Security (TLS) é usado para criptografar dados confidenciais em redes não seguras, como a Internet. O protocolo TLS é o sucessor do protocolo Secure Sockets Layer (SSL).
O Device Advisor é compatível com os seguintes protocolos TLS:
+ TLS 1.3 (recomendado)
+ TLS 1.2
**Protocolos, mapeamentos de porta e autenticação**
O protocolo de comunicação do dispositivo é usado por um dispositivo ou cliente para se conectar ao agente de mensagens usando um endpoint do dispositivo. A tabela a seguir lista os protocolos com os quais os endpoints do Device Advisor são compatíveis e os métodos e portas de autenticação usados.
**Protocolos, autenticação e mapeamentos de porta**
| Protocolo | Operações compatíveis | Autenticação | Porta | Nome do protocolo ALPN |
| --- | --- | --- | --- | --- |
| Acabou o MQTT WebSocket | Publicar/assinar | Signature versão 4 | 443 | N/D |
| MQTT | Publicar/assinar | Certificado do cliente X.509 | 8883 | `x-amzn-mqtt-ca` |
| MQTT | Publicar/assinar | Certificado do cliente X.509 | 443 | N/D |
**Topics**
+ [Configurar](device-advisor-setting-up.md)
+ [Conceitos básicos do Device Advisor no console](da-console-guide.md)
+ [Fluxo de trabalho do Device Advisor](device-advisor-workflow.md)
+ [Fluxo de trabalho detalhado do console do Device Advisor](device-advisor-console-tutorial.md)
+ [Fluxo de trabalho do console de testes de longa duração](device-advisor-long-duration-console-tutorial.md)
+ [Endpoints da VPC do Device Advisor (AWS PrivateLink)](device-advisor-vpc-endpoint.md)
+ [Casos de teste do Device Advisor](device-advisor-tests.md)
# Configurar
Antes de usar o Device Advisor pela primeira vez, execute as seguintes tarefas:
## Criar um objeto do IoT
Primeiro, crie um objeto do IoT e anexe um certificado a ela. Para ver um tutorial sobre como criar objetos, consulte [Criar um objeto](https://docs.aws.amazon.com/iot/latest/developerguide/create-iot-resources.html#create-aws-thing).
## Criar um perfil do IAM a ser usado como perfil de dispositivo
**nota**
Você pode criar rapidamente o perfil do dispositivo com o console do Device Advisor. Para saber como configurar o perfil do dispositivo com o console do Device Advisor, consulte [Conceitos básicos do Device Advisor no console](https://docs.aws.amazon.com/iot/latest/developerguide/da-console-guide.html).
1. Acesse o [AWS Identity and Access Management console](https://console.aws.amazon.com/iam/home?region=us-west-2#/home) e faça login no que Conta da AWS você usa para testar o Device Advisor.
1. No painel de navegação à esquerda, escolha **Políticas**.
1. Escolha **Criar política**.
1. Em **Criar política**, faça o seguinte:
1. Para **Serviço**, escolha **IoT**.
1. Em **Ações**, faça uma das seguintes:
+ (Recomendado) Selecione ações com base na política anexada ao objeto ou certificado de IoT que você criou na seção anterior.
+ Pesquise as seguintes ações na caixa **Filtrar ação** e selecione-as:
+ `Connect`
+ `Publish`
+ `Subscribe`
+ `Receive`
+ `RetainPublish`
1. Em **Recursos**, restrinja o cliente, o tópico e os recursos do tópico. A restrição desses recursos é uma prática recomendada de segurança. Para restringir recursos, faça o seguinte:
1. Escolha **Especificar ARN do recurso do cliente para a ação Conectar**.
1. Escolha **Adicionar ARN** e, em seguida, faça o seguinte:
**nota**
O *clientId* é o ID do cliente MQTT que o dispositivo usa para interagir com o Device Advisor.
+ Especifique a **Região**, o **accountId** e o **clientID** no editor visual do ARN.
+ Insira manualmente os nomes de recursos da Amazon (ARNs) dos tópicos de IoT com os quais você deseja executar seus casos de teste.
1. Escolha **Adicionar**.
1. Escolha **Especificar ARN do recurso de tópico para a ação Receber e mais uma**.
1. Escolha **Adicionar ARN** e, em seguida, faça o seguinte:
**nota**
O *nome do tópico* é o tópico do MQTT no qual o dispositivo publica mensagens.
+ Especifique a **Região**, o **accountID** e o **Nome do tópico** no editor visual do ARN.
+ Insira manualmente os tópicos ARNs de IoT com os quais você deseja executar seus casos de teste.
1. Escolha **Adicionar**.
1. Escolha **Especificar ARN do recurso topicFilter para a ação Assinar**.
1. Escolha **Adicionar ARN** e, em seguida, faça o seguinte:
**nota**
O *nome do tópico* é o tópico do MQTT que o dispositivo assina.
+ Especifique a **Região**, o **accountID** e o **Nome do tópico** no editor visual do ARN.
+ Insira manualmente os tópicos ARNs de IoT com os quais você deseja executar seus casos de teste.
1. Escolha **Adicionar**.
1. Escolha **Próximo: tags**.
1. Escolha **Próximo: revisar**.
1. Em **Revisar política**, insira um **Nome** para a política.
1. Selecione **Criar política**.
1. No painel de navegação à esquerda, escolha **Perfis**.
1. Selecione **Criar perfil**.
1. Em **Tipo de entidade confiável**, escolha **Política de confiança personalizada**.
1. Insira a política de confiança a seguir no campo **Política de confiança personalizada**. Para proteger do problema de confused deputy, adicione as chaves de contexto de condição global `[aws:SourceArn](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)` e `[aws:SourceAccount](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)` à política.
**Importante**
`aws:SourceArn` deve estar em conformidade com `format: arn:aws:iotdeviceadvisor:region:account-id:*.`. Certifique-se de que a `region` corresponda à Região da AWS IoT e `account-id` corresponda ao ID da conta do cliente. Para obter mais informações, consulte [Prevenção de confused deputy entre serviços](https://docs.aws.amazon.com/iot/latest/developerguide/security-best-practices.html#cross-service-confused-deputy-prevention-DA).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAwsIoTCoreDeviceAdvisor",
"Effect": "Allow",
"Principal": {
"Service": "iotdeviceadvisor.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:iotdeviceadvisor:*:123456789012:suitedefinition/*"
}
}
}
]
}
```
1. Escolha **Próximo**.
1. Selecione a política que você criou na Etapa 4.
1. Abra a seção **Definir limite de permissões** e escolha **Usar um limite de permissões para controlar o número máximo de permissões de perfis**.
1. Escolha **Próximo**.
1. Insira um **Nome de perfil** e uma **Descrição de perfil**.
1. Selecione **Criar perfil**.
## Crie uma política gerenciada personalizada para que um usuário do IAM use o Device Advisor
1. Navegue até o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Se solicitado, insira suas credenciais da AWS para fazer login.
1. No painel de navegação à esquerda, escolha **Políticas**.
1. Escolha **Criar política** e escolha a guia **JSON**.
1. Adicione as permissões necessárias para usar o Device Advisor. O documento de política pode ser encontrado no tópico [Práticas recomendadas de segurança](https://docs.aws.amazon.com/iot/latest/developerguide/security-best-practices.html#device-advisor-perms).
1. Escolha **Review Policy** (Revisar política).
1. Preencha os campos **Nome** e **Descrição**.
1. Escolha **Criar política**.
## Criar um usuário do IAM para usar o Device Advisor
**nota**
Recomendamos que você crie um usuário do IAM para usar ao executar testes do Device Advisor. Executar testes do Device Advisor por um usuário administrador pode representar riscos de segurança e não é recomendado.
1. Navegue até o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)Se solicitado, insira suas AWS credenciais para fazer login.
1. No painel de navegação à esquerda, escolha **Usuários**.
1. Escolha **Add User** (Adicionar usuário).
1. Digite um **Nome de usuário**.
1. Os usuários precisam de acesso programático se quiserem interagir com pessoas AWS fora do Console de gerenciamento da AWS. A forma de conceder acesso programático depende do tipo de usuário que está acessando AWS.
Para conceder acesso programático aos usuários, selecione uma das seguintes opções:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/device-advisor-setting-up.html)
1. Escolha **Próximo: Permissões**.
1. Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis:
+ Usuários e grupos em Centro de Identidade do AWS IAM:
Crie um conjunto de permissões. Siga as instruções em [Criação de um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
+ Usuários gerenciados no IAM com provedor de identidades:
Crie um perfil para a federação de identidades. Siga as instruções em [Criando um perfil para um provedor de identidades de terceiros (federação)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) no *Guia do Usuário do IAM*.
+ Usuários do IAM:
+ Crie um perfil que seu usuário possa assumir. Siga as instruções em [Criação de um perfil para um usuário do IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) no *Guia do usuário do IAM*.
+ (Não recomendado) Vincule uma política diretamente a um usuário ou adicione um usuário a um grupo de usuários. Siga as instruções em [Adição de permissões a um usuário (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) no *Guia do usuário do IAM*.
1. Na caixa de pesquisa, digite o nome da política gerenciada pelo cliente que você criou. Em seguida, marque a caixa de seleção **Nome da política**.
1. Escolha **Próximo: tags**.
1. Escolha **Próximo: revisar**.
1. Escolha **Criar usuário**.
1. Escolha **Fechar**.
O Device Advisor exige acesso aos seus AWS recursos (itens, certificados e endpoints) em seu nome. O usuário do IAM deve ter as permissões necessárias para: O Device Advisor também publicará registros na Amazon CloudWatch se você anexar a política de permissões necessária ao seu usuário do IAM.
## Configurar o dispositivo
O Device Advisor usa a extensão TLS Server Name Indication (SNI) para aplicar configurações de TLS. Os dispositivos devem usar essa extensão quando se conectam e transmitem um nome de servidor idêntico ao endpoint de teste do Device Advisor.
O Device Advisor permite a conexão TLS quando um teste está no estado `Running`. Ele nega a conexão TLS antes e depois de cada execução de teste. Por isso, recomenda-se usar o mecanismo de nova tentativa de conexão do dispositivo para uma experiência de teste totalmente automatizada com o Device Advisor. Você pode executar conjuntos de teste que incluem mais de um caso de teste, como TLS Connect, MQTT Connect e MQTT Publish. Se você executar vários casos de teste, recomendamos que o dispositivo tente se conectar ao nosso endpoint de teste a cada cinco segundos. Em seguida, você pode automatizar a execução de vários casos de teste em sequência.
**nota**
Para preparar o software do dispositivo para testes, recomendamos que você use um SDK que possa se conectar ao AWS IoT Core. Em seguida, você deve atualizar o SDK com o endpoint de teste do Device Advisor fornecido para sua Conta da AWS.
O Device Advisor é compatível com dois tipos de endpoints: endpoints em nível de conta e em nível de dispositivo. Escolha o endpoint que seja mais adequado ao caso de uso. Para executar simultaneamente vários conjuntos de testes para dispositivos diferentes, use um endpoint no nível do dispositivo.
Execute o seguinte comando para obter o endpoint no nível do dispositivo:
Para clientes do MQTT que usam certificados de cliente X.509:
```
aws iotdeviceadvisor get-endpoint --thing-arn your-thing-arn
```
or
```
aws iotdeviceadvisor get-endpoint --certificate-arn your-certificate-arn
```
Para WebSocket clientes com mais de MQTT que usam o Signature versão 4:
```
aws iotdeviceadvisor get-endpoint --device-role-arn your-device-role-arn --authentication-method SignatureVersion4
```
Para executar um conjunto de testes por vez, escolha um endpoint no nível da conta. Execute o seguinte comando para obter o endpoint no nível da conta:
```
aws iotdeviceadvisor get-endpoint
```
# Conceitos básicos do Device Advisor no console
Este tutorial ajuda você a começar AWS IoT Core Device Advisor a usar o console. O Device Advisor oferece recursos como testes obrigatórios e relatórios de qualificação assinados. Você pode usar esses testes e relatórios para qualificar e listar dispositivos no [Catálogo de dispositivos do parceiro da AWS](https://devices.amazonaws.com/), conforme detalhado no [programa de qualificação do AWS IoT Core](https://aws.amazon.com/partners/dqp/).
Para obter mais informações sobre o uso do Device Advisor, consulte [Fluxo de trabalho do Device Advisor](device-advisor-workflow.md) e [Fluxo de trabalho detalhado do console do Device Advisor](device-advisor-console-tutorial.md).
Para concluir este tutorial, siga as etapas descritas em [Configurar](device-advisor-setting-up.md).
**nota**
O Device Advisor é compatível com o seguinte Regiões da AWS:
Leste dos EUA (N. da Virgínia)
Oeste dos EUA (Oregon)
Ásia-Pacífico (Tóquio)
Europa (Irlanda)
**Introdução**
1. No painel de navegação do [console AWS IoT](https://console.aws.amazon.com//iot), em **Teste**, escolha **Device Advisor**. Em seguida, escolha o botão **Iniciar passo a passo** no console.
![\[O Device Advisor é um recurso de teste totalmente gerenciado para dispositivos de IoT para validar a interação segura AWS IoT Core, identificar problemas de software e obter resultados de testes.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-gs.png)
1. A página **Conceitos básicos do Device Advisor** fornece uma visão geral das etapas necessárias para criar um conjunto de testes e executar testes no dispositivo. Você também pode encontrar o endpoint de teste do Device Advisor para sua conta aqui. Você deve configurar o firmware ou o software no dispositivo usado para o teste para se conectar a esse endpoint de teste.
Para concluir as etapas neste tutorial, primeiro é preciso [criar um objeto e um certificado](https://docs.aws.amazon.com/iot/latest/developerguide/device-advisor-setting-up.html#da-create-thing-certificate). Depois de revisar as informações em **Como funciona**, escolha **Próximo**.
![\[Etapas para testar a conectividade dos dispositivos de IoT: selecione o protocolo, crie um conjunto de testes, defina as configurações do dispositivo.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-gs1.png)
1. Na **Etapa 1: selecionar um protocolo**, selecione um protocolo nas opções listadas. Em seguida, escolha **Próximo**.
![\[Interface do Device Advisor mostrando opções para selecionar um protocolo de comunicação (MQTT 3.1.1, MQTT 3.1.1 over, MQTT 5 WebSocket, MQTT 5 over) WebSocket para testar um dispositivo de IoT.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-protocol.png)
1. Na **Etapa 2**, você cria e configura um conjunto de testes personalizado. Um conjunto de testes personalizado deve ter pelo menos um grupo de teste, e cada grupo de teste deve ter pelo menos um caso de teste. Adicionamos o caso de teste do **MQTT Connect** para você começar.
Escolha **Propriedades do conjunto de testes**.
![\[A tela “Criar pacote de testes” no Device Advisors, na qual os usuários podem criar e configurar grupos e casos de teste para testar dispositivos de IoT com o protocolo MQTT.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-test-suite-create.png)
Forneça as propriedades do conjunto de testes ao criar o conjunto de testes. Você pode configurar as seguintes propriedades em nível de conjunto:
+ **Nome do conjunto de testes**: insira um nome para o conjunto de testes.
+ **Tempo limite** (opcional): o tempo limite (em segundos) para cada caso de teste no conjunto de testes atual. Se você não especificar um valor, o valor padrão será usado.
+ **Tags** (opcional): adicione tags ao conjunto de testes.
Quando terminar, escolha **Atualizar propriedades**.
![\[Formulário para atualizar as propriedades de um pacote de testes, incluindo nome, tempo limite e capacidade de adicionar tags. Contém um botão “Atualizar propriedades”.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-test-suite-properties.png)
1. (Opcional) Para atualizar a configuração do grupo do conjunto de testes, escolha o botão **Editar** ao lado do nome do grupo de teste.
+ **Nome**: insira um nome para o grupo de conjunto de teste.
+ **Tempo limite** (opcional): o tempo limite (em segundos) para cada caso de teste no conjunto de testes atual. Se você não especificar um valor, o valor padrão será usado.
Ao terminar, escolha **Concluído** para continuar.
![\[Um grupo de teste chamado “Grupo de teste 1" é exibido com opções para configurar o tempo limite e adicionar grupos de teste.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-test-suite-config.png)
1. (Opcional) Para atualizar a configuração de um caso de teste, escolha o botão **Editar** ao lado do nome do caso de teste.
+ **Nome**: insira um nome para o grupo de conjunto de teste.
+ **Tempo limite** (opcional): o tempo limite (em segundos) para o caso de teste selecionado. Se você não especificar um valor, o valor padrão será usado.
Ao terminar, escolha **Concluído** para continuar.
![\[A interface “Criar pacote de testes” que mostra opções para configurar um pacote de testes, grupos de teste e casos de teste individuais para testar dispositivos de IoT.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-test-case-config.png)
1. (Opcional) Para adicionar mais grupos de teste ao conjunto de testes, escolha **Adicionar grupo de teste** e siga as instruções na Etapa 5.
1. (Opcional) Para adicionar mais casos de teste, arraste os casos de teste na seção **Casos de teste** para qualquer um dos grupos de teste.
![\[A interface “Criar pacote de testes” em que os usuários podem configurar grupos de teste e casos de teste para teste de protocolo MQTT para dispositivos IoT.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-drag.png)
1. Você pode alterar a ordem dos grupos de teste e casos de teste. Para fazer alterações, arraste os casos de teste listados para cima ou para baixo na lista. O Device Advisor executa testes na ordem em que você os listou.
Depois de configurar o conjunto de testes, escolha **Próximo**.
1. Na **Etapa 3**, selecione um AWS IoT item ou certificado para testar usando o Device Advisor. Se você não tiver nenhum objeto ou certificado existente, consulte [Configuração](https://docs.aws.amazon.com/iot/latest/developerguide/device-advisor-setting-up.html).
![\[As opções de configuração que incluem selecionar um protocolo, criar um pacote de testes, definir as configurações do dispositivo e revisar as execuções e os resultados dos testes.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-device-settings.png)
1. Você pode configurar uma função de dispositivo que o Device Advisor usa para realizar ações do AWS IoT MQTT em nome do seu dispositivo de teste. Somente para o caso de teste do **MQTT Connect**, a ação **Conectar** é selecionada automaticamente. Isso ocorre porque o perfil do dispositivo exige essa permissão para executar o conjunto de testes. Para outros casos de teste, as ações correspondentes são selecionadas.
Forneça os valores dos recursos para cada uma das ações selecionadas. Por exemplo, para a ação **Conectar**, forneça o ID do cliente que o dispositivo usa para se conectar ao endpoint do Device Advisor. Você pode fornecer vários valores com valores separados por vírgula e valores de prefixo com um caractere curinga (\$1). Por exemplo, para fornecer permissão para publicar em qualquer tópico que comece com `MyTopic`, insira **MyTopic\$1** como valor do recurso.
![\[A interface do Device Advisor, na qual você pode selecionar uma função de dispositivo e definir permissões para conectar, publicar, assinar e gerenciar tópicos e clientes do MQTT. IDs\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-device-role.png)
Para usar um perfil de dispositivo criado anteriormente em [Configuração](https://docs.aws.amazon.com/iot/latest/developerguide/device-advisor-setting-up.html), escolha **Selecionar um perfil existente**. Em seguida, escolha o perfil do dispositivo em **Selecionar perfil**.
![\[Uma interface de formulário web para selecionar uma função de dispositivo, com opções para criar uma nova função ou selecionar uma função existente chamada "DeviceAdvisorServiceRole”.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-select-device-role.png)
Configure o perfil do dispositivo com uma das duas opções fornecidas e escolha **Próximo**.
1. Na seção **Endpoint de teste**, selecione o endpoint que melhor se adapta ao caso de uso. Para executar várias suítes de testes simultaneamente com as mesmas Conta da AWS, selecione Endpoint no **nível do dispositivo**. Para executar um conjunto de testes por vez, selecione **Endpoint em nível de conta**.
![\[Opções para selecionar o endpoint no nível da conta ou no nível do dispositivo para teste, com uma URL de endpoint fornecida e o botão Avançar.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-endpoint.png)
1. A **Etapa 4** mostra uma visão geral do dispositivo de teste selecionado, do endpoint de teste, do conjunto de testes e do perfil do dispositivo de teste configurados. Selecione o botão **Editar** para qualquer seção que você deseja editar. Depois de confirmar a configuração de teste, escolha **Executar** para criar o conjunto de testes e executá-los.
**nota**
Para obter melhores resultados, você pode conectar o dispositivo de teste selecionado ao endpoint de teste do Device Advisor antes de iniciar a execução do conjunto de testes. Recomendamos que você tenha um mecanismo criado para que o dispositivo tente se conectar ao nosso endpoint de teste a cada cinco segundos por até um a dois minutos.
![\[Um console de configuração de dispositivos que mostra detalhes da função do dispositivo, endpoint de teste e opções para cancelar, voltar ou executar.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-device-review.png)
![\[Um console de configuração de dispositivos que mostra detalhes da função do dispositivo, endpoint de teste e opções para cancelar, voltar ou executar.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-device-review-contd.png)
1. No painel de navegação, em **Teste**, escolha **Device Advisor** e, em seguida, escolha **Execuções e resultados de testes**. Selecione uma execução do conjunto de testes para ver os detalhes e os logs da execução.
![\[A interface do conjunto de testes que indica que um teste MQTT 3.1.1 está em andamento para o dispositivo "”MyThing.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-console-runs-results.png)
1. Para acessar os CloudWatch registros da Amazon para a suíte, execute:
+ Escolha **Registro da suíte de testes** para ver os CloudWatch registros da execução da suíte de testes.
+ Escolha **Registro do caso de teste** para qualquer caso de teste para visualizar os registros específicos do caso CloudWatch de teste.
1. Com base nos resultados do teste, [solucione os problemas](https://docs.aws.amazon.com/iot/latest/developerguide/iot_troubleshooting.html#device-advisor-troubleshooting) do dispositivo até que todos os testes sejam aprovados.
# Fluxo de trabalho do Device Advisor
Este tutorial explica como criar um conjunto de testes personalizado e executar testes no dispositivo que você deseja testar no console. Depois que os testes forem concluídos, você poderá visualizar os resultados do teste e os logs detalhados.
## Pré-requisitos
Antes de iniciar este tutorial, conclua as etapas descritas em [Configurar](device-advisor-setting-up.md).
## Criar uma definição de conjunto de teste
Primeiro, [instale um AWS SDK.](https://docs.aws.amazon.com/iot/latest/developerguide/iot-connect-service.html#iot-service-sdks)
### Sintaxe de `rootGroup`
Um grupo raiz é uma string JSON que especifica quais casos de teste incluir no conjunto de testes. Ele também especifica todas as configurações necessárias para esses casos de teste. Use o grupo raiz para estruturar e ordenar o conjunto de testes com base em suas necessidades. A hierarquia de um conjunto de testes é:
```
test suite → test group(s) → test case(s)
```
Um conjunto de testes deve ter pelo menos um grupo de teste, e cada grupo de teste deve ter pelo menos um caso de teste. O Device Advisor executa testes na ordem em que você define os grupos de teste e os casos de teste.
Cada grupo raiz segue essa estrutura básica:
```
{
"configuration": { // for all tests in the test suite
"": ""
}
"tests": [{
"name": ""
"configuration": { // for all sub-groups in this test group
"": ""
},
"tests": [{
"name": ""
"configuration": { // for all test cases in this test group
"": ""
},
"test": {
"id": ""
"version": ""
}
}]
}]
}
```
No grupo raiz, você define o conjunto de testes com um `name`, um `configuration` e os `tests` que o grupo contém. O grupo `tests` contém as definições de testes individuais. Você define cada teste com um `name`, um `configuration` e um bloco `test` que define os casos de teste desse teste. Finalmente, cada caso de teste é definido com um `id` e um `version`.
Para obter informações sobre como usar os campos `"id"` e `"version"` para cada caso de teste (bloco `test`), consulte [Casos de teste do Device Advisor](device-advisor-tests.md). Essa seção também contém informações sobre as configurações `configuration` disponíveis.
O bloco a seguir é um exemplo de configuração de grupo raiz. Essas configurações especificam os casos de teste *MQTT Connect Happy Case* e *MQTT Connect Exponential Backoff Retries*, junto com as descrições dos campos de configuração.
```
{
"configuration": {}, // Suite-level configuration
"tests": [ // Group definitions should be provided here
{
"name": "My_MQTT_Connect_Group", // Group definition name
"configuration": {} // Group definition-level configuration,
"tests": [ // Test case definitions should be provided here
{
"name": "My_MQTT_Connect_Happy_Case", // Test case definition name
"configuration": {
"EXECUTION_TIMEOUT": 300 // Test case definition-level configuration, in seconds
},
"test": {
"id": "MQTT_Connect", // test case id
"version": "0.0.0" // test case version
}
},
{
"name": "My_MQTT_Connect_Jitter_Backoff_Retries", // Test case definition name
"configuration": {
"EXECUTION_TIMEOUT": 600 // Test case definition-level configuration, in seconds
},
"test": {
"id": "MQTT_Connect_Jitter_Backoff_Retries", // test case id
"version": "0.0.0" // test case version
}
}]
}]
}
```
Você deve fornecer a configuração do grupo raiz ao criar a definição de conjunto de testes. Salve o `suiteDefinitionId` que é retornado no objeto da resposta. Você pode usar esse ID para recuperar as informações de definição do conjunto de testes e executar o conjunto de testes.
Aqui está um exemplo do Java SDK:
```
response = iotDeviceAdvisorClient.createSuiteDefinition(
CreateSuiteDefinitionRequest.builder()
.suiteDefinitionConfiguration(SuiteDefinitionConfiguration.builder()
.suiteDefinitionName("your-suite-definition-name")
.devices(
DeviceUnderTest.builder()
.thingArn("your-test-device-thing-arn")
.certificateArn("your-test-device-certificate-arn")
.deviceRoleArn("your-device-role-arn") //if using SigV4 for MQTT over WebSocket
.build()
)
.rootGroup("your-root-group-configuration")
.devicePermissionRoleArn("your-device-permission-role-arn")
.protocol("MqttV3_1_1 || MqttV5 || MqttV3_1_1_OverWebSocket || MqttV5_OverWebSocket")
.build()
)
.build()
)
```
## Obtenha uma definição de conjunto de teste
Depois de criar a definição de conjunto de testes, você recebe o `suiteDefinitionId` no objeto de resposta da operação da API `CreateSuiteDefinition`.
Quando a operação retorna o `suiteDefinitionId`, você pode ver novos campos `id` em cada grupo e a definição do caso de teste dentro do grupo raiz. Você pode usá-los IDs para executar um subconjunto da definição do seu conjunto de testes.
Exemplo de Java SDK:
```
response = iotDeviceAdvisorClient.GetSuiteDefinition(
GetSuiteDefinitionRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.build()
)
```
## Obtenha um endpoint de teste
Use a operação da API `GetEndpoint` para obter o endpoint de teste usado pelo dispositivo. Selecione o endpoint que melhor se adapta ao teste. Para executar vários conjuntos de testes simultaneamente, use o endpoint em nível de dispositivo fornecendo um `thing ARN`, um `certificate ARN` ou um `device role ARN`. Para executar uma única suíte de testes, não forneça argumentos à GetEndpoint operação para escolher o endpoint no nível da conta.
Exemplo do SDK:
```
response = iotDeviceAdvisorClient.getEndpoint(GetEndpointRequest.builder()
.certificateArn("your-test-device-certificate-arn")
.thingArn("your-test-device-thing-arn")
.deviceRoleArn("your-device-role-arn") //if using SigV4 for MQTT over WebSocket
.build())
```
## Inicie a execução de um conjunto de testes
Depois de criar uma definição de conjunto de testes e configurar o dispositivo de teste para se conectar ao endpoint de teste do Device Advisor, execute o conjunto de testes com a API `StartSuiteRun`.
Para clientes do MQTT, use um `certificateArn` ou um `thingArn` para executar o conjunto de testes. Se ambos estiverem configurados, o certificado será usado se pertencer ao objeto.
Para MQTT em vez WebSocket do cliente, use `deviceRoleArn` para executar a suíte de testes. Se o perfil especificado for diferente do perfil especificado na definição do conjunto de testes, o perfil especificado substituirá o perfil definido.
Para `.parallelRun()`, use `true` se você usar um endpoint em nível de dispositivo para executar vários conjuntos de testes em paralelo usando uma Conta da AWS.
Exemplo do SDK:
```
response = iotDeviceAdvisorClient.startSuiteRun(StartSuiteRunRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunConfiguration(SuiteRunConfiguration.builder()
.primaryDevice(DeviceUnderTest.builder()
.certificateArn("your-test-device-certificate-arn")
.thingArn("your-test-device-thing-arn")
.deviceRoleArn("your-device-role-arn") //if using SigV4 for MQTT over WebSocket
.build())
.parallelRun(true | false)
.build())
.build())
```
Salve o `suiteRunId` da resposta. Você usará isso para recuperar os resultados da execução desse conjunto de testes.
## Obtenha a execução de um conjunto de testes
Depois de iniciar a execução de um conjunto de testes, você pode verificar o progresso e os resultados com a API `GetSuiteRun`.
Exemplo do SDK:
```
// Using the SDK, call the GetSuiteRun API.
response = iotDeviceAdvisorClient.GetSuiteRun(
GetSuiteRunRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunId("your-suite-run-id")
.build())
```
## Interromper a execução de um conjunto de testes
Para interromper a execução de um conjunto de testes que ainda está em andamento, você pode chamar a operação da API `StopSuiteRun`. Depois de chamar a operação `StopSuiteRun`, o serviço inicia o processo de limpeza. Enquanto o serviço executa o processo de limpeza, o conjunto de testes executa atualizações de status para `Stopping`. O processo pode demorar vários minutos. Quando o processo estiver concluído, o conjunto de testes executará atualizações de status para `Stopped`. Depois que a execução de um teste for completamente interrompida, você poderá iniciar outra execução do conjunto de testes. Você pode verificar periodicamente o status de execução do conjunto usando a operação da API `GetSuiteRun`, conforme mostrado na seção anterior.
Exemplo do SDK:
```
// Using the SDK, call the StopSuiteRun API.
response = iotDeviceAdvisorClient.StopSuiteRun(
StopSuiteRun.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunId("your-suite-run-id")
.build())
```
## Obtenha um relatório de qualificação para uma execução bem-sucedida do conjunto de testes de qualificação
Se você executar um conjunto de testes de qualificação concluído com êxito, poderá recuperar um relatório de qualificação com a operação da API `GetSuiteRunReport`. Você usa esse relatório de qualificação para qualificar o dispositivo com o programa de qualificação AWS IoT Core . Para determinar se o conjunto de testes é um conjunto de testes de qualificação, verifique se o parâmetro `intendedForQualification` está definido como `true`. Depois de chamar a operação da API `GetSuiteRunReport`, você pode baixar o relatório do URL retornado por até 90 segundos. Se passarem mais de 90 segundos desde a última vez em que você chamou a operação `GetSuiteRunReport`, chame a operação novamente para recuperar um novo URL válido.
Exemplo do SDK:
```
// Using the SDK, call the getSuiteRunReport API.
response = iotDeviceAdvisorClient.getSuiteRunReport(
GetSuiteRunReportRequest.builder()
.suiteDefinitionId("your-suite-definition-id")
.suiteRunId("your-suite-run-id")
.build()
)
```
# Fluxo de trabalho detalhado do console do Device Advisor
Neste tutorial, você criará um conjunto de testes personalizado e executará testes no dispositivo que você deseja testar no console. Depois que os testes forem concluídos, você poderá visualizar os resultados do teste e os logs detalhados.
**Topics**
+ [Pré-requisitos](#da-detailed-prereqs)
+ [Criar uma definição de conjunto de teste](#device-advisor-console-create-suite)
+ [Inicie a execução de um conjunto de testes](#device-advisor-console-run-test-suite)
+ [Interromper a execução de um conjunto de testes (opcional)](#device-advisor-stop-test-run)
+ [Exibir detalhes e logs da execução do conjunto de testes](#device-advisor-console-view-logs)
+ [Baixe um relatório AWS IoT de qualificação](#device-advisor-console-qualification-report)
## Pré-requisitos
Para concluir as etapas neste tutorial, você precisa [criar um objeto e um certificado](https://docs.aws.amazon.com/iot/latest/developerguide/device-advisor-setting-up.html#da-create-thing-certificate).
## Criar uma definição de conjunto de teste
Crie um pacote de testes para que você possa executá-lo em seus dispositivos e realizar a verificação.
1. No [console AWS IoT](https://console.aws.amazon.com//iot), no painel de navegação, expanda **Teste**, **Device Advisor** e escolha **Conjuntos de testes**.
![\[A interface do Device Advisor com opções para criar pacotes de teste para dispositivos qualificados, execução de testes de longa duração e pacotes de testes personalizados.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-testsuite.png)
Escolha **Criar conjunto de testes**.
1. Selecione `Use the AWS Qualification test suite` ou `Create a new test suite`.
Para protocolo, escolha **MQTT 3.1.1** ou **MQTT 5**.
![\[“Criar suíte de testes” com opções para escolher o tipo de suíte de teste (AWS IoT Core qualificação, longa duração ou personalizada) e o protocolo (MQTT 3.1.1 ou MQTT 5).\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-create-test-suite.png)
Selecione `Use the AWS Qualification test suite` para se qualificar e listar seu dispositivo no Catálogo de dispositivos AWS parceiros. Ao escolher essa opção, os casos de teste necessários para a qualificação do dispositivo para o programa de qualificação AWS IoT Core são pré-selecionados. Grupos de teste e casos de teste não podem ser adicionados nem removidos. Você ainda precisará configurar as propriedades do conjunto de testes.
Selecione `Create a new test suite` para criar e configurar um conjunto de testes personalizado. Recomendamos começar com essa opção para testes iniciais e solução de problemas. Um conjunto de testes personalizado deve ter pelo menos um grupo de teste, e cada grupo de teste deve ter pelo menos um caso de teste. Para fins deste tutorial, selecionaremos essa opção e escolheremos **Próximo**.
![\[Página de configuração do pacote de testes que mostra as etapas para criar um pacote de testes com grupos de teste e casos para testar dispositivos de IoT.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-configure-test-suite.png)
1. Escolha **Propriedades do conjunto de testes**. Você deve criar as propriedades do conjunto de testes ao criar o conjunto de testes.
![\[A interface “Configurar pacote de testes” que mostra opções para criar grupos de teste e adicionar casos de teste para testar a funcionalidade do dispositivo de IoT.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-test-suite-properties.png)
Em **Propriedades do conjunto de testes**, preencha o seguinte:
+ **Nome do conjunto de teste**: você pode criar o conjunto com um nome personalizado.
+ **Tempo limite** (opcional): o tempo limite em segundos para cada caso de teste no conjunto de testes atual. Se você não especificar um valor, o valor padrão será usado.
+ **Tags** (opcional): adicione tags ao conjunto de testes.
![\[Janela intitulada “Propriedades do pacote de testes” mostrando campos para especificar um nome de pacote de testes, tempo limite e tags personalizadas para um pacote de demonstração do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-test-suite-properties-1.png)
Quando terminar, escolha **Atualizar propriedades**.
1. Para modificar a configuração em nível de grupo, em `Test group 1`, escolha **Editar**. Em seguida, insira um **Nome** para dar ao grupo um nome personalizado.
Opcionalmente, você também pode inserir um valor de **Tempo limite** em segundos no grupo de teste selecionado. Se você não especificar um valor, o valor padrão será usado.
![\[A interface “Configurar pacote de testes” para criar grupos e casos de teste para validar a funcionalidade do dispositivo de IoT.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-edit-test-group.png)
Escolha **Concluído**.
1. Arraste um dos casos de teste disponíveis de **Casos de teste** para o grupo de teste.
![\[A interface de configuração para criar um pacote de testes no Device Advisor, com opções para adicionar grupos de teste e casos de teste para testar dispositivos de IoT.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-configure-test-suite-step5.png)
1. Para modificar a configuração do nível do caso de teste para o caso de teste que você adicionou ao grupo de teste, escolha **Editar**. Em seguida, insira um **Nome** para dar ao grupo um nome personalizado.
Opcionalmente, você também pode inserir um valor de **Tempo limite** em segundos no grupo de teste selecionado. Se você não especificar um valor, o valor padrão será usado.
![\[Interface de configuração do pacote de testes com opções para configurar grupos de teste, casos de teste, configurações de tempo limite e pontos de partida para a execução do pacote de testes.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-edit-test-case.png)
Selecione **Concluído**.
**nota**
Para adicionar mais grupos de teste ao conjunto de testes, escolha **Adicionar grupo de teste**. Siga as etapas anteriores para criar e configurar mais grupos de teste ou adicionar mais casos de teste a um ou mais grupos de teste. Grupos de teste e casos de teste podem ser reordenados escolhendo e arrastando um caso de teste até a posição desejada. O Device Advisor executa testes na ordem em que você define os grupos de teste e os casos de teste.
1. Escolha **Próximo**.
1. Na **Etapa 3**, configure uma função de dispositivo que o Device Advisor usará para realizar ações do AWS IoT MQTT em nome do seu dispositivo de teste.
Se você selecionou o caso de teste do **MQTT Connect** somente na **Etapa 2**, a ação **Conectar** será verificada automaticamente, pois essa permissão é necessária no perfil do dispositivo para executar esse conjunto de testes. Se você selecionou outros casos de teste, as ações necessárias correspondentes serão verificadas. Certifique-se de que os valores dos recursos para cada uma das ações sejam fornecidos. Por exemplo, para a ação **Conectar**, forneça o ID do cliente com o qual o dispositivo se conectará ao endpoint do Device Advisor. Você pode fornecer vários valores usando vírgulas para separar os valores e também pode fornecer valores de prefixo usando um caractere curinga (\$1). Por exemplo, para fornecer permissão para publicar em qualquer tópico que comece com `MyTopic`, você pode fornecer “`MyTopic*`” como o valor do recurso.
![\[A etapa “Selecionar uma função de dispositivo” no Device Advisor para criar um pacote de testes, com opções para criar ou selecionar uma função e campos para especificar o nome da função, as permissões e os detalhes do recurso.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-connect-role.png)
Se você já criou um perfil do dispositivo anteriormente e gostaria de usar esse perfil, selecione **Selecionar um perfil existente** e escolha o perfil do dispositivo em **Selecionar perfil**.
![\[A página para selecionar uma função de dispositivo para testes do Device Advisor, com opções para criar ou selecionar uma função.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-existing-role.png)
Configure o perfil do dispositivo usando uma das duas opções fornecidas e escolha **Próximo**.
1. Na **Etapa 4**, verifique se a configuração fornecida em cada uma das etapas está correta. Para editar a configuração fornecida para uma etapa específica, escolha **Editar** para a etapa correspondente.
Depois de verificar a configuração, escolha **Criar conjunto de testes**.
O conjunto de testes deve ser criado e você será redirecionado para a página **Conjuntos de testes**, onde poderá ver todos os conjuntos que foram criados.
Se a criação do conjunto de testes falhar, verifique se o conjunto de testes, os grupos de teste, os casos de teste e o perfil do dispositivo foram configurados conforme as instruções anteriores.
## Inicie a execução de um conjunto de testes
1. No [console AWS IoT](https://console.aws.amazon.com//iot), no painel de navegação, expanda **Teste**, **Device Advisor** e escolha **Conjuntos de testes**.
1. Escolha o conjunto de testes do qual você gostaria de ver os detalhes do conjunto de testes.
![\[O console que mostra um único pacote de testes chamado “Pacote de demonstração do Device Advisor” criado em 11 de maio de 2021.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-test-suites.png)
A página de detalhes do conjunto de testes exibe todas as informações relacionadas ao conjunto de testes.
1. Escolha **Ações** e, em seguida, **Executar conjunto de testes**.
![\[A página do pacote de demonstração com o botão “Executar pacote de testes” e um log de atividades vazio mostrando nenhuma execução anterior do pacote de testes.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-run-test-suites.png)
1. Em **Executar configuração**, você precisará selecionar AWS IoT algo ou certificado para testar usando o Device Advisor. Se você não tiver nenhum item ou certificado existente, primeiro [crie AWS IoT Core recursos](device-advisor-setting-up.md).
Na seção **Endpoint de teste**, selecione o endpoint que melhor se adapta ao caso. Se você planeja executar várias suítes de teste simultaneamente usando a mesma AWS conta no futuro, selecione Endpoint em nível **de dispositivo**. Caso contrário, se planeja apenas executar um conjunto de testes por vez, selecione **Endpoint em nível de conta**.
Configure o dispositivo de teste com o endpoint de teste do Device Advisor selecionado.
Depois de selecionar um objeto ou um certificado e escolher um endpoint do Device Advisor, escolha **Executar teste**.
![\[A configuração para executar uma suíte de testes AWS IoT Core, permitindo que você selecione dispositivos de teste (itens ou certificados), escolha um endpoint de teste (no nível da conta ou do dispositivo) e, opcionalmente, adicione tags.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-choose-thing-certificate.png)
1. Escolha **Ir para os resultados** no banner superior para ver os detalhes da execução do teste.
![\[Detalhes de um pacote de testes personalizado intitulado “Pacote de demonstração do Device Advisor” em andamento com o status “Pendente”.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-test-run-results.png)
## Interromper a execução de um conjunto de testes (opcional)
1. No [console AWS IoT](https://console.aws.amazon.com//iot), no painel de navegação, expanda **Teste**, **Device Advisor** e escolha **Execuções e resultados de testes**.
1. Escolha o conjunto de testes em andamento que você deseja interromper.
![\[Os resultados das execuções de teste no console do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-test-suite-to-stop.PNG)
1. Escolha **Ações** e, em seguida, **Interromper conjunto de testes**.
![\[Os resultados das execuções de teste no console do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-stop-test-suite.PNG)
1. O processo de limpeza levará alguns minutos para ser concluído. Enquanto o processo de limpeza for executado, o status da execução do teste será `STOPPING`. Aguarde a conclusão do processo de limpeza e que o status do conjunto de testes mude para o status `STOPPED` antes de iniciar a execução de um novo conjunto.
![\[Os resultados parados das execuções de teste no console do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-stopped-test-suite.PNG)
## Exibir detalhes e logs da execução do conjunto de testes
1. No [console AWS IoT](https://console.aws.amazon.com//iot), no painel de navegação, expanda **Teste**, **Device Advisor** e escolha **Execuções e resultados de testes**.
Esta página será exibida:
+ Número de objetos de IoT
+ Número de certificados de IoT
+ Número de conjuntos de teste atualmente em execução
+ Todas as execuções do conjunto de testes que foram criadas
1. Escolha o conjunto de testes do qual você gostaria de ver os detalhes e logs da execução.
![\[Uma seção de Execuções e resultados de testes que exibe detalhes de um pacote de testes chamado “Pacote de demonstração do Device Advisor” que está em andamento.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-test-suite-run.png)
A página de resumo da execução exibe o status da execução atual do conjunto de testes. Essa página é atualizada automaticamente a cada 10 segundos. Recomendamos que você tenha um mecanismo criado para que o dispositivo tente se conectar ao nosso endpoint de teste a cada cinco segundos por um a dois minutos. Em seguida, você pode executar vários casos de teste em sequência de maneira automatizada.
![\[O log do caso de teste que mostra um teste bem-sucedido do MQTT Connect sem nenhuma mensagem do sistema exibida.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-run-summary.png)
1. Para acessar os CloudWatch registros da execução da suíte de testes, escolha **Registro da suíte de testes**.
Para acessar CloudWatch os registros de qualquer caso de teste, escolha **Registro de casos de teste**.
1. Com base nos resultados do teste, [solucione os problemas](https://docs.aws.amazon.com/iot/latest/developerguide/iot_troubleshooting.html#device-advisor-troubleshooting) do dispositivo até que todos os testes sejam aprovados.
## Baixe um relatório AWS IoT de qualificação
Se você escolheu a opção **Usar a suíte de testes de AWS IoT qualificação** ao criar uma suíte de testes e conseguiu executar uma suíte de testes de qualificação, poderá baixar um relatório de qualificação escolhendo **Baixar relatório de qualificação** na página de resumo da execução do teste.
![\[Resultados do teste do Programa de Qualificação que mostram testes aprovados para MQTT, TLS e outros componentes.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/da-qualification-report.png)
# Fluxo de trabalho do console de testes de longa duração
Este tutorial ajuda você a começar com os testes de Longa duração no Device Advisor usando o console. Para concluir o tutorial, siga as etapas em [Configurar](device-advisor-setting-up.md).
1. No [console AWS IoT](https://console.aws.amazon.com/iot), no painel de navegação, expanda **Teste**, **Device Advisor** e escolha **Conjuntos de testes**. Na página, selecione **Criar conjunto de testes de longa duração**.
![\[A seção Criar pacote de testes de longa duração do console do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/create-ld-ts.png)
1. Na página **Criar conjunto de testes**, selecione **Conjunto testes de longa duração** e escolha **Próximo**.
Para protocolo, escolha **MQTT 3.1.1** ou **MQTT 5**.
![\[A etapa Criar pacote de testes do console do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/choose-ld-ts.png)
1. Faça o seguinte na página **Configurar conjunto de teste**:
1. Atualize o campo **Nome do conjunto de testes**.
1. Atualize o campo **Nome do grupo de testes**.
1. Escolha as **Operações do dispositivo** que o dispositivo pode realizar. Isso selecionará os testes a serem executados.
1. Selecione a opção **Configurações**.
![\[A etapa Criar pacote de testes do console do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/configure-ld-ts.png)
1. (Opcional) Insira o tempo máximo que o Device Advisor deve aguardar até que os testes básicos sejam concluídos. Selecione **Salvar**.
![\[A caixa “Tempo limite opcional” para “Testes básicos” do console do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/timeout-ld-ts.png)
1. Faça o seguinte nas seções **Testes avançados** e **Configurações adicionais**.
1. Selecione ou desmarque os **Testes avançados** que você deseja executar como parte desse teste.
1. **Edite** as configurações dos testes quando aplicável.
1. Configure o **Tempo de execução adicional** na seção **Configurações adicionais**.
1. Escolha **Próximo** para fazer a próxima etapa.
![\[A interface do Device Advisor que permite configurar e executar testes em dispositivos de IoT.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/additional-ld-ts.png)
1. Nesta etapa, **Crie um novo perfil** ou **Selecione um perfil existente**. Para mais detalhes, consulte [Criar um perfil do IAM a ser usado como perfil de dispositivo](device-advisor-setting-up.md#da-iam-role).
![\[A etapa de função de dispositivo em que é possível criar ou selecionar um perfil para o dispositivo que está sendo testado. A função concede permissões para que o Device Advisor execute ações MQTT como Connect, Publish e Subscribe em nome do dispositivo de teste.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/devicerole-ld-ts.png)
1. Revise todas as configurações criadas até essa etapa e selecione **Criar conjunto de testes**.
![\[A página “Revisão”, na qual você pode revisar todos os detalhes da configuração do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/finalconfigure1-ld-ts.png)
![\[A página de configuração na qual você pode ver todos os detalhes do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/finalconfigure2-ld-ts.png)
1. O conjunto de testes criado está na seção **Conjuntos de testes**. Selecione o conjunto para visualizar detalhes.
![\[Um novo pacote de testes chamado “Demonstração de longa duração” foi criado com sucesso no Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/finalts-ld-ts.png)
1. Para executar o conjunto de testes criado, selecione **Ações** e depois **Executar conjunto de testes**.
![\[O menu suspenso Ações do novo conjunto de testes chamado “Demonstração de longa duração” na interface do Device Advisor.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/runts-ld-ts.png)
1. Escolha as opções de configuração na página **Executar configuração**.
1. Selecione as **Objetos** ou o **Certificado** para executar o teste.
1. Selecione o **Endpoint em nível de conta** ou o **Endpoint em nível de dispositivo**.
1. Escolha **Executar teste** para executar o teste.
![\[A página Executar configuração na interface do Device Advisor. A página mostra Selecionar dispositivos de teste, Objetos, Endpoint de teste e Tags.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/runconfiguration-ld-ts.png)
1. Para visualizar os resultados da execução do conjunto de testes, selecione **Execuções e resultados de teste** no painel de navegação esquerdo. Escolha o conjunto de testes que foi executado para ver os detalhes dos resultados.
![\[O caso de teste “Demonstração de longa duração” na página de execuções e resultados do teste.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/results-ld-ts.png)
1. A etapa anterior abre a página de resumo do teste. Todos os detalhes da execução do teste são exibidos nessa página. Quando o console solicitar o início da conexão do dispositivo, conecte-o ao endpoint fornecido. O progresso dos testes é visto nessa página.
![\[A página de resumo do teste “Demonstração de longa duração” que você criou.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/summary-ld-ts.png)
1. O teste de Longa duração fornece um **Resumo do log de teste** adicional no painel lateral, que exibe todos os eventos importantes que ocorrem entre o dispositivo e o agente quase em tempo real. Para ver logs mais detalhados, clique em **Log do caso de teste**.
![\[A seção de resumo do log de teste na página do teste “Demonstração de longa duração”.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/log-ld-ts.png)
# Endpoints da VPC do Device Advisor (AWS PrivateLink)
Você pode estabelecer uma conexão privada entre sua VPC e o endpoint de AWS IoT Core Device Advisor teste (plano de dados) criando uma interface *VPC* endpoint. Você pode usar esse endpoint para validar AWS IoT dispositivos para conectividade confiável e segura AWS IoT Core antes de implantá-los na produção. Os testes pré-criados do Device Advisor ajudam você a validar o software do dispositivo em relação às práticas recomendadas de uso de [TLS](https://docs.aws.amazon.com/iot/latest/developerguide/protocols.html), [MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/protocols.html), [Sombra do dispositivo](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) e [Tarefas do AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-jobs.html).
[AWS PrivateLink](https://aws.amazon.com/privatelink)alimenta os endpoints da interface usados com seus dispositivos de IoT. Esse serviço ajuda você a acessar o endpoint de teste do AWS IoT Core Device Advisor sem um gateway da Internet, um dispositivo NAT, uma conexão VPN ou uma conexão do Direct Connect . As instâncias em sua VPC que enviam pacotes TCP e MQTT não precisam de endereços IP públicos para se comunicar com os endpoints de teste. AWS IoT Core Device Advisor Tráfego entre sua VPC e o AWS IoT Core Device Advisor que não sai. Nuvem AWS Qualquer comunicação TLS e MQTT entre dispositivos de IoT e casos de teste do Device Advisor permanece dentro dos recursos da sua Conta da AWS.
Cada endpoint de interface é representado por uma ou mais [interfaces de rede elástica](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) nas sub-redes.
Para saber mais sobre como usar os endpoints da VPC da interface, consulte [Endpoints da VPC da interface (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) no *Guia do usuário da Amazon VPC*.
## Considerações sobre AWS IoT Core Device Advisor VPC endpoints
Antes de configurar [propriedades e limitações de endpoint da interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#vpce-interface-limitations) no *Guia do usuário da Amazon VPC* antes de configurar os endpoints da VPC da interface. Considere o seguinte antes de continuar:
+ AWS IoT Core Device Advisor atualmente oferece suporte para fazer chamadas para o endpoint de teste do Device Advisor (plano de dados) a partir de sua VPC. Um agente de mensagens usa comunicações de plano de dados para enviar e receber dados. Ele faz isso com a ajuda dos pacotes TLS e MQTT. VPC endpoints para AWS IoT Core Device Advisor conectar seu AWS IoT dispositivo aos endpoints de teste do Device Advisor. [As ações da API do ambiente de gerenciamento](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotdeviceadvisor/index.html) não são usadas por esse endpoint da VPC. Para criar ou executar uma suíte de testes ou outro plano de controle APIs, use o console, um AWS SDK ou uma interface de linha de AWS comando na Internet pública.
+ Os seguintes Regiões da AWS oferecem suporte a endpoints VPC para: AWS IoT Core Device Advisor
+ Leste dos EUA (N. da Virgínia)
+ Oeste dos EUA (Oregon)
+ Ásia-Pacífico (Tóquio)
+ Europa (Irlanda)
+ O Device Advisor oferece suporte ao MQTT com certificados de cliente X.509 e certificados de servidor RSA.
+ As [políticas de endpoint da VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) não são compatíveis no momento.
+ Consulte os [pré-requisitos](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#prerequisites-interface-endpoints) de endpoint da VPC para obter instruções sobre como [criar recursos](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) que conectem os endpoints da VPC. Você deve criar uma VPC e sub-redes privadas para usar VPC endpoints. AWS IoT Core Device Advisor
+ Há cotas em seus AWS PrivateLink recursos. Para obter mais informações, consulte as [AWS PrivateLink cotas](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-limits-endpoints.html).
+ Os VPC endpoints oferecem suporte somente ao tráfego. IPv4
## Crie uma interface VPC endpoint para AWS IoT Core Device Advisor
Para começar a usar endpoints da VPC, [crie um endpoint da VPC da interface](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html). Em seguida, selecione AWS IoT Core Device Advisor como AWS service (Serviço da AWS) o. Se você estiver usando o AWS CLI, ligue [describe-vpc-endpoint-services](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-vpc-endpoint-services.html)para confirmar que AWS IoT Core Device Advisor está presente em uma zona de disponibilidade em seu Região da AWS. Confirme se o grupo de segurança conectado ao endpoint permite a [comunicação do protocolo TCP](https://docs.aws.amazon.com/iot/latest/developerguide/protocols.html) para tráfego MQTT e TLS. Por exemplo, na região Leste dos EUA (Norte da Virgínia), use o seguinte comando:
```
aws ec2 describe-vpc-endpoint-services --service-name com.amazonaws.us-east-1.deviceadvisor.iot
```
Você pode criar um VPC endpoint AWS IoT Core usando o seguinte nome de serviço:
+ com.amazonaws.*region*.deviceadvisor.iot
Por padrão, o DNS privado está ativado para o endpoint. Isso garante que o uso do endpoint de teste padrão permaneça nas sub-redes privadas. Para obter seu endpoint em nível de conta ou dispositivo, use o console AWS CLI ou um AWS SDK. Por exemplo, se você executa [get-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotdeviceadvisor/get-endpoint.html) em uma sub-rede pública ou na Internet pública, você pode obter o endpoint e usá-lo para se conectar ao Device Advisor. Para mais informações, consulte [Acessar um serviço por um endpoint de interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#access-service-though-endpoint) no *Guia do usuário da Amazon VPC*.
Para conectar clientes MQTT às interfaces de endpoint da VPC, AWS PrivateLink o serviço cria registros DNS em uma zona hospedada privada anexada à sua VPC. Esses registros DNS direcionam as solicitações do dispositivo AWS IoT para o endpoint da VPC.
## Controle do acesso a AWS IoT Core Device Advisor mais de VPC endpoints
[Você pode restringir o acesso ao dispositivo AWS IoT Core Device Advisor e permitir o acesso somente por meio de VPC endpoints usando as chaves de contexto de condição da VPC.](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) AWS IoT Core é compatível com as seguintes chaves de contexto relacionadas à VPC:
+ [SourceVpc](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcevpc)
+ [SourceVpce](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcevpce)
+ [VPCSourcelp](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-vpcsourceip)
**nota**
AWS IoT Core Device Advisor não oferece suporte às [políticas de VPC endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html#vpc-endpoint-policies) no momento.
A política a seguir concede permissão para se conectar AWS IoT Core Device Advisor usando um ID de cliente que corresponda ao nome da coisa. Ele também publica em qualquer tópico prefixado pelo nome do objeto. A política depende da conexão do dispositivo a um endpoint da VPC com um ID específico do endpoint da VPC. Essa política nega tentativas de conexão com o endpoint de teste do AWS IoT Core Device Advisor público.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:client/${iot:Connection.Thing.ThingName}"
],
"Condition": {
"StringEquals": {
"aws:SourceVpce": "vpce-1a2b3c4d"
}
}
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/${iot:Connection.Thing.ThingName}/*"
]
}
]
}
```
# Casos de teste do Device Advisor
O Device Advisor fornece testes pré-criados em seis categorias.
+ [TLS](device-advisor-tests-tls.md)
+ [MQTT](device-advisor-tests-mqtt.md)
+ [Shadow](device-advisor-tests-shadow.md)
+ [Execução de trabalho](device-advisor-tests-job-execution.md)
+ [Políticas e permissões](device-advisor-tests-permissions-policies.md)
+ [Testes de longa duração](device-advisor-tests-long-duration.md)
## Casos de teste do Device Advisor para se qualificar para o Programa de Qualificação de AWS Dispositivos.
O dispositivo deve passar nos testes a seguir para se qualificar conforme o [Programa de Qualificação de Dispositivos da AWS](https://aws.amazon.com/partners/programs/dqp/).
**nota**
Esta é uma lista revisada dos testes de qualificação.
+ [TLS Connect](device-advisor-tests-tls.md#TLS_Connect) ("TLS Connect")
+ [Certificado de servidor de nome de assunto incorreto do TLS](device-advisor-tests-tls.md#TLS_Incorrect_Subject_Name)(“Nome comum do assunto incorreto [CN]/Nome alternativo do assunto [SAN]”)
+ [TLS Unsecure Server Cert](device-advisor-tests-tls.md#TLS_Unsecure_Server_Cert) ("Not Signed By Recognized CA")
+ [Suporte de dispositivo TLS para pacotes de AWS IoT criptografia (“Suporte de dispositivo TLS AWS IoT para conjuntos](device-advisor-tests-tls.md#TLS_DeviceSupport_For_IOT) de criptografia recomendados”)
+ [TLS Receive Maximum Size Fragments](device-advisor-tests-tls.md#TLS_MaximumSize)("TLS Receive Maximum Size Fragments")
+ [TLS Expired Server Cert](device-advisor-tests-tls.md#TLS_Expired_Server_Cert)("Expired server certificate")
+ [TLS Large Size Server Cert](device-advisor-tests-tls.md#TLS_LargeServerCert)("TLS large Size Server Certificate")
+ [MQTT Connect](device-advisor-tests-mqtt.md#MQTT_Connect) (“Dispositivo envie CONNECT para AWS IoT Core (Happy case)”)
+ [MQTT Subscribe](device-advisor-tests-mqtt.md#MQTT_Subscribe) ("Can Subscribe (Happy Case)")
+ [MQTT Publish](device-advisor-tests-mqtt.md#MQTT_Publish) ("QoS0 (Happy Case)")
+ [MQTT Connect Jitter Retries](device-advisor-tests-mqtt.md#MQTT_ConnectJitterBackoff) (“Device connect retries with jitter backoff - No CONNACK response”)
# TLS
Use esses testes para determinar se o protocolo de segurança da camada de transporte (TLS) entre seus dispositivos AWS IoT é seguro.
**nota**
O Device Advisor agora é compatível com o TLS 1.3.
## Happy Path
**TLS Connect**
Valida se o dispositivo em teste pode concluir o handshake TLS para. AWS IoT Esse teste não valida a implementação do MQTT do dispositivo cliente.
**Example Definição do caso de teste da API:**
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Para obter melhores resultados, recomendamos um valor de tempo limite de dois minutos.
```
"tests":[
{
"name":"my_tls_connect_test",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", //in seconds
},
"test":{
"id":"TLS_Connect",
"version":"0.0.0"
}
}
]
```
**Example Saídas do caso de teste:**
+ **Aprovação** — O dispositivo em teste concluiu o handshake TLS com. AWS IoT
+ **Passe com avisos** — O dispositivo em teste concluiu o handshake TLS com AWS IoT, mas houve mensagens de aviso de TLS do dispositivo ou. AWS IoT
+ **Falha** — O dispositivo em teste falhou ao concluir o handshake TLS AWS IoT devido a um erro de handshake.
**O TLS recebe fragmentos de tamanho máximo**
Esse caso de teste valida que o dispositivo pode receber e processar fragmentos de tamanho máximo do TLS. O dispositivo de teste deve assinar um tópico pré-configurado com QoS 1 para receber uma grande carga. É possível personalizar a carga com a configuração `${payload}`.
**Example Definição do caso de teste da API:**
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Para obter melhores resultados, recomendamos um valor de tempo limite de dois minutos.
```
"tests":[
{
"name":"TLS Receive Maximum Size Fragments",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", //in seconds
"PAYLOAD_FORMAT":"{"message":"${payload}"}", // A string with a placeholder ${payload}, or leave it empty to receive a plain string.
"TRIGGER_TOPIC": "test_1" // A topic to which a device will subscribe, and to which a test case will publish a large payload.
},
"test":{
"id":"TLS_Receive_Maximum_Size_Fragments",
"version":"0.0.0"
}
}
]
```
## Pacotes de criptografia
**Suporte a dispositivos TLS para pacotes de AWS IoT criptografia recomendados**
Valida se os conjuntos de cifras na mensagem Hello do Cliente TLS do dispositivo em teste contêm os [conjuntos de cifras do AWS IoT](transport-security.md) recomendados. Fornece mais informações sobre os conjuntos de cifras compatíveis com o dispositivo.
**Example Definição do caso de teste da API:**
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_tls_support_aws_iot_cipher_suites_test",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
},
"test":{
"id":"TLS_Support_AWS_IoT_Cipher_Suites",
"version":"0.0.0"
}
}
]
```
**Example Saídas do caso de teste:**
+ **Aprovado** — O dispositivo em conjuntos de cifras de teste contém pelo menos um dos conjuntos de AWS IoT cifras recomendados e não contém nenhum conjunto de cifras não suportado.
+ **Passe com avisos** — Os conjuntos de cifras do dispositivo contêm pelo menos um conjunto de cifras da AWS IoT , mas:
1. Ele não contém nenhum dos conjuntos de cifras recomendados
1. Ele contém pacotes de criptografia que não são suportados pelo. AWS IoT
Sugerimos que você verifique se todos os conjuntos de cifras não compatíveis são seguros.
+ **Falha** — O dispositivo em conjuntos de criptografia de teste não contém nenhum dos conjuntos de criptografia AWS IoT compatíveis.
## Certificado de servidor de tamanho maior
**Certificado de servidor de tamanho maior do TLS**
Valida se o dispositivo pode concluir o handshake TLS com AWS IoT quando recebe e processa um certificado de servidor de tamanho maior. O tamanho do certificado do servidor (em bytes) usado por esse teste é maior do que o usado atualmente no caso de teste do **TLS Connect** e do IoT Core em 20. Durante esse caso de teste AWS IoT , testa o espaço do buffer do seu dispositivo para TLS. Se o espaço do buffer for grande o suficiente, o handshake TLS será concluído sem erros. Esse teste não valida a implementação do MQTT do dispositivo. O caso de teste ocorre após a conclusão do processo de handshake do TLS.
**Example Definição do caso de teste da API:**
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Para obter melhores resultados, recomendamos um valor de tempo limite de dois minutos. Se esse caso de teste falhar, mas o caso de teste do **TLS Connect** for aprovado, recomendamos que você aumente o limite de espaço de buffer do dispositivo para TLS. Aumentar os limites de espaço de buffer garante que o dispositivo possa processar um certificado de servidor de tamanho maior caso o tamanho aumente.
```
"tests":[
{
"name":"my_tls_large_size_server_cert_test",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
},
"test":{
"id":"TLS_Large_Size_Server_Cert",
"version":"0.0.0"
}
}
]
```
**Example Saídas do caso de teste:**
+ **Aprovação** — O dispositivo em teste concluiu o handshake TLS com AWS IoT.
+ **Passe com avisos** — O dispositivo em teste concluiu o handshake TLS com AWS IoT, mas há mensagens de aviso de TLS do dispositivo ou. AWS IoT
+ **Falha — O dispositivo em teste falhou ao concluir o handshake TLS AWS IoT devido a um erro durante o processo de handshake.**
## Certificado de servidor TLS desprotegido
**Não assinado por uma CA reconhecida**
Valida que o dispositivo em teste fecha a conexão se for apresentado um certificado de servidor sem uma assinatura válida da CA ATS. Um dispositivo só deve se conectar a um endpoint que apresente um certificado válido.
**Example Definição do caso de teste da API:**
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_tls_unsecure_server_cert_test",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", //in seconds
},
"test":{
"id":"TLS_Unsecure_Server_Cert",
"version":"0.0.0"
}
}
]
```
**Example Saídas do caso de teste:**
+ **Passe** — O dispositivo em teste fechou a conexão.
+ **Falha** — O dispositivo em teste concluiu o handshake TLS com. AWS IoT
**Certificado de servidor de nome de assunto incorreto do TLS/Nome comum do assunto incorreto (CN)/Nome alternativo do assunto (SAN)**
Valida se o dispositivo em teste fecha a conexão se for apresentado um certificado de servidor para um nome de domínio diferente do solicitado.
**Example Definição do caso de teste da API:**
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_tls_incorrect_subject_name_cert_test",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
},
"test":{
"id":"TLS_Incorrect_Subject_Name_Server_Cert",
"version":"0.0.0"
}
}
]
```
**Example Saídas do caso de teste:**
+ **Passe** — O dispositivo em teste fechou a conexão.
+ **Falha** — O dispositivo em teste concluiu o handshake TLS com. AWS IoT
## Certificado de servidor TLS expirado
**Certificado de servidor expirado**
Valida que o dispositivo em teste fecha a conexão se for apresentado um certificado de servidor expirado.
**Example Definição do caso de teste da API:**
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_tls_expired_cert_test",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", //in seconds
},
"test":{
"id":"TLS_Expired_Server_Cert",
"version":"0.0.0"
}
}
]
```
**Example Saídas do caso de teste:**
+ **Aprovação** — O dispositivo em teste se recusa a concluir o handshake TLS com. AWS IoT O dispositivo envia uma mensagem de alerta do TLS antes de fechar a conexão.
+ **Passe com avisos** — O dispositivo em teste se recusa a concluir o handshake TLS com AWS IoT. No entanto, ele não envia uma mensagem de alerta do TLS antes de fechar a conexão.
+ **Falha** — O dispositivo em teste conclui o handshake TLS com. AWS IoT
# MQTT
## CONECTAR, DESCONECTAR e RECONECTAR
**“Dispositivo envie CONNECT para AWS IoT Core (Happy case)”**
Valida se o dispositivo em teste envia uma solicitação CONNECT.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_mqtt_connect_test",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
},
"test":{
"id":"MQTT_Connect",
"version":"0.0.0"
}
}
]
```
**“O dispositivo pode retornar o PUBACK a um tópico arbitrário para QoS1”**
Esse caso de teste verificará se o dispositivo (cliente) pode retornar uma mensagem PUBACK se tiver recebido uma mensagem de publicação do agente após assinar um tópico com QoS1.
O conteúdo e o tamanho da carga são configuráveis para esse caso de teste. Se o tamanho da carga estiver configurado, o Device Advisor substituirá o valor do conteúdo da carga e enviará uma carga predefinida para o dispositivo com o tamanho desejado. O tamanho da carga é um valor entre 0 e 128 e não pode exceder 128 KB. O AWS IoT Core rejeita solicitações de publicação e conexão maiores que 128 KB, conforme visto na página de [limites e cotas do protocolo e do agente de mensagens do AWS IoT Core](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits).
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos. `PAYLOAD_SIZE` pode ser configurado para um valor entre 0 e 128 kilobytes. A definição de um tamanho de carga substitui o conteúdo da carga, pois o Device Advisor enviará uma carga predefinida com o tamanho determinado de volta ao dispositivo.
```
"tests":[
{
"name":"my_mqtt_client_puback_qos1",
"configuration": {
// optional:"TRIGGER_TOPIC": "myTopic",
"EXECUTION_TIMEOUT":"300", // in seconds
"PAYLOAD_FOR_PUBLISH_VALIDATION":"custom payload",
"PAYLOAD_SIZE":"100" // in kilobytes
},
"test": {
"id": "MQTT_Client_Puback_QoS1",
"version": "0.0.0"
}
}
]
```
**“Tentativas de conexão do dispositivo com recuo de variação de sinal - Sem resposta de CONNACK”**
Valida se o dispositivo em teste usa o recuo de variação de sinal adequado ao se reconectar com o agente por pelo menos cinco vezes. O agente registra a data e hora do dispositivo sob a solicitação CONNECT do teste, realiza a validação do pacote, faz uma pausa sem enviar um CONNACK para o dispositivo em teste e espera que o dispositivo em teste reenvie a solicitação. A sexta tentativa de conexão tem permissão para passar, e o CONNACK tem permissão para fluir de volta para o dispositivo em teste.
O processo anterior é executado novamente. No total, esse caso de teste exige que o dispositivo se conecte pelo menos 12 vezes no total. Os registros de data e hora coletados são usados para validar se o recuo de variação de sinal é usado pelo dispositivo em teste. Se o dispositivo em teste tiver um atraso de recuo estritamente exponencial, esse caso de teste será aprovado com avisos.
Recomendamos a implementação do mecanismo [Recuo exponencial e variação de sinal](https://aws.amazon.com/blogs//architecture/exponential-backoff-and-jitter/) no dispositivo em teste para passar neste caso de teste.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 4 minutos.
```
"tests":[
{
"name":"my_mqtt_jitter_backoff_retries_test",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
},
"test":{
"id":"MQTT_Connect_Jitter_Backoff_Retries",
"version":"0.0.0"
}
}
]
```
**“Tentativas de conexão do dispositivo com recuo exponencial - Sem resposta de CONNACK”**
Valida se o dispositivo em teste usa o recuo exponencial adequado ao se reconectar com o agente por pelo menos cinco vezes. O agente registra a data e a hora do dispositivo sob a solicitação CONNECT do teste, realiza a validação do pacote, faz uma pausa sem enviar um CONNACK para o dispositivo cliente e espera que o dispositivo em teste reenvie a solicitação. Os registros de data e hora coletados são usados para validar se um recuo exponencial é usado pelo dispositivo em teste.
Recomendamos a implementação do mecanismo [Recuo exponencial e variação de sinal](https://aws.amazon.com/blogs//architecture/exponential-backoff-and-jitter/) no dispositivo em teste para passar neste caso de teste.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 4 minutos.
```
"tests":[
{
"name":"my_mqtt_exponential_backoff_retries_test",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"600", // in seconds
},
"test":{
"id":"MQTT_Connect_Exponential_Backoff_Retries",
"version":"0.0.0"
}
}
]
```
**“Reconexão do dispositivo com recuo de variação de sinal - Após a desconexão do servidor”**
Valida se um dispositivo em teste usa a variação de sinal e o recuo necessários ao se reconectar após ser desconectado do servidor. O Device Advisor desconecta o dispositivo do servidor por pelo menos cinco vezes e observa o comportamento do dispositivo na reconexão do MQTT. O Device Advisor registra a data e a hora da solicitação CONNECT para o dispositivo em teste, realiza a validação do pacote, faz uma pausa sem enviar um CONNACK para o dispositivo cliente e espera que o dispositivo em teste reenvie a solicitação. Os registros de data e hora coletados são usados para validar se o dispositivo em teste usa variação de sinal e recuo ao se reconectar. Se o dispositivo em teste tiver um recuo estritamente exponencial ou não implementar um mecanismo de recuo exponencial de variação de sinal adequado, esse caso de teste será aprovado com avisos. Se o dispositivo em teste tiver implementado um mecanismo de recuo linear ou um mecanismo de recuo constante, o teste falhará.
Para passar nesse caso de teste, recomendamos a implementação do mecanismo [Recuo exponencial e variação de sinal](https://aws.amazon.com/blogs//architecture/exponential-backoff-and-jitter/) no dispositivo em teste.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 4 minutos.
O número de tentativas de reconexão a serem validadas para recuo pode ser alterado especificando `RECONNECTION_ATTEMPTS`. O número deve estar entre 5 e 10. O valor padrão é 5.
```
"tests":[
{
"name":"my_mqtt_reconnect_backoff_retries_on_server_disconnect",
"configuration":{
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
"RECONNECTION_ATTEMPTS": 5
},
"test":{
"id":"MQTT_Reconnect_Backoff_Retries_On_Server_Disconnect",
"version":"0.0.0"
}
}
]
```
**“Reconexão do dispositivo com recuo de variação de sinal - Em conexão instável”**
Valida se um dispositivo em teste usa a variação de sinal e o recuo necessários ao se reconectar em uma conexão instável. O Device Advisor desconecta o dispositivo do servidor após cinco conexões bem-sucedidas e observa o comportamento do dispositivo na reconexão do MQTT. O Device Advisor registra a data e a hora da solicitação CONNECT para o dispositivo em teste, realiza a validação do pacote, envia de volta um CONNACK, desconecta-se, registra a data e a hora da desconexão e espera que o dispositivo em teste reenvie a solicitação. Os registros de data e hora coletados são usados para validar se o dispositivo em teste usa variação de sinal e recuo ao se reconectar após conexões bem-sucedidas, mas instáveis. Se o dispositivo em teste tiver um recuo estritamente exponencial ou não implementar um mecanismo de recuo exponencial de variação de sinal adequado, esse caso de teste será aprovado com avisos. Se o dispositivo em teste tiver implementado um mecanismo de recuo linear ou um mecanismo de recuo constante, o teste falhará.
Para passar nesse caso de teste, recomendamos a implementação do mecanismo [Recuo exponencial e variação de sinal](https://aws.amazon.com/blogs//architecture/exponential-backoff-and-jitter/) no dispositivo em teste.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 4 minutos.
O número de tentativas de reconexão a serem validadas para recuo pode ser alterado especificando `RECONNECTION_ATTEMPTS`. O número deve estar entre 5 e 10. O valor padrão é 5.
```
"tests":[
{
"name":"my_mqtt_reconnect_backoff_retries_on_unstable_connection",
"configuration":{
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
"RECONNECTION_ATTEMPTS": 5
},
"test":{
"id":"MQTT_Reconnect_Backoff_Retries_On_Unstable_Connection",
"version":"0.0.0"
}
}
]
```
## Publicar
**“QoS0 (Happy Case)”**
Valida se o dispositivo em teste publica uma mensagem com QoS0 ou QoS1. Você também pode validar o tópico da mensagem e da carga especificando o valor do tópico e a carga nas configurações de teste.
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_mqtt_publish_test",
"configuration":{
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
"TOPIC_FOR_PUBLISH_VALIDATION": "my_TOPIC_FOR_PUBLISH_VALIDATION",
"PAYLOAD_FOR_PUBLISH_VALIDATION": "my_PAYLOAD_FOR_PUBLISH_VALIDATION",
},
"test":{
"id":"MQTT_Publish",
"version":"0.0.0"
}
}
]
```
**“Tentativa de publicação de QoS1 - Sem PUBACK”**
Valida que o dispositivo em teste republica uma mensagem enviada com QoS1, se o agente não enviar PUBACK. Você também pode validar o tópico da mensagem especificando esse tópico nas configurações de teste. O dispositivo cliente não deve se desconectar antes de republicar a mensagem. Esse teste também valida se a mensagem republicada tem o mesmo identificador de pacote que a original. Durante a execução do teste, se o dispositivo perder a conexão e se reconectar, o caso de teste será reiniciado sem falhas, e o dispositivo deverá executar as etapas do caso de teste novamente.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. É recomendado por pelo menos 4 minutos.
```
"tests":[
{
"name":"my_mqtt_publish_retry_test",
"configuration":{
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
"TOPIC_FOR_PUBLISH_VALIDATION": "my_TOPIC_FOR_PUBLISH_VALIDATION",
"PAYLOAD_FOR_PUBLISH_VALIDATION": "my_PAYLOAD_FOR_PUBLISH_VALIDATION",
},
"test":{
"id":"MQTT_Publish_Retry_No_Puback",
"version":"0.0.0"
}
}
]
```
**“Publicar mensagens retidas”**
Valida se o dispositivo em teste publica uma mensagem com `retainFlag` definida como true. Você também pode validar o tópico e a carga da mensagem definindo o valor do tópico e a carga nas configurações de teste. Se o `retainFlag` enviado dentro do pacote PUBLICAR não estiver definido como true, o caso de teste falhará.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos. Para executar esse caso de teste, adicione a ação `iot:RetainPublish` no [perfil do dispositivo](https://docs.aws.amazon.com/iot/latest/developerguide/device-advisor-setting-up.html#da-iam-role).
```
"tests":[
{
"name":"my_mqtt_publish_retained_messages_test",
"configuration":{
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
"TOPIC_FOR_PUBLISH_RETAINED_VALIDATION": "my_TOPIC_FOR_PUBLISH_RETAINED_VALIDATION",
"PAYLOAD_FOR_PUBLISH_RETAINED_VALIDATION": "my_PAYLOAD_FOR_PUBLISH_RETAINED_VALIDATION",
},
"test":{
"id":"MQTT_Publish_Retained_Messages",
"version":"0.0.0"
}
}
]
```
**“Publicar com propriedade do usuário”**
Valida se o dispositivo em teste publica uma mensagem com a propriedade de usuário correta. Você pode validar a propriedade do usuário definindo o par nome-valor nas configurações de teste. Se a propriedade do usuário não for fornecida ou não corresponder, o caso de teste falhará.
*Definição do caso de teste da API:*
Esse é o MQTT5 único caso de teste.
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_mqtt_user_property_test",
"test":{
"USER_PROPERTIES": [
{"name": "name1", "value":"value1"},
{"name": "name2", "value":"value2"}
],
"EXECUTION_TIMEOUT":"300", // in seconds
},
"test":{
"id":"MQTT_Publish_User_Property",
"version":"0.0.0"
}
}
]
```
## Assinar
**“Pode assinar (Happy Case)”**
Valida se o dispositivo em teste assina os tópicos do MQTT. Você também pode validar o tópico que o dispositivo em teste assina especificando esse tópico nas configurações de teste.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_mqtt_subscribe_test",
"configuration":{
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
"TOPIC_LIST_FOR_SUBSCRIPTION_VALIDATION":["my_TOPIC_FOR_PUBLISH_VALIDATION_a","my_TOPIC_FOR_PUBLISH_VALIDATION_b"]
},
"test":{
"id":"MQTT_Subscribe",
"version":"0.0.0"
}
}
]
```
**“Nova tentativa de assinar - Sem SUBACK”**
Valida se o dispositivo em teste tenta novamente uma assinatura com falha dos tópicos do MQTT. O servidor, então, espera e não envia um SUBACK. Se o dispositivo cliente não repetir a assinatura, o teste falhará. O dispositivo cliente deve tentar novamente a assinatura com falha com o mesmo ID de pacote. Você também pode validar o tópico que o dispositivo em teste assina especificando esse tópico nas configurações de teste. Durante a execução do teste, se o dispositivo perder a conexão e se reconectar, o caso de teste será reiniciado sem falhas, e o dispositivo deverá executar as etapas do caso de teste novamente.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 4 minutos.
```
"tests":[
{
"name":"my_mqtt_subscribe_retry_test",
"configuration":{
"EXECUTION_TIMEOUT":"300", // in seconds
// optional:
"TOPIC_LIST_FOR_SUBSCRIPTION_VALIDATION":["myTOPIC_FOR_PUBLISH_VALIDATION_a","my_TOPIC_FOR_PUBLISH_VALIDATION_b"]
},
"test":{
"id":"MQTT_Subscribe_Retry_No_Suback",
"version":"0.0.0"
}
}
]
```
## Keep-alive
**“Matt No Ack PingResp”**
Este caso de teste valida se o dispositivo em teste se desconecta quando não recebe uma resposta de ping. Como parte desse caso de teste, o Device Advisor bloqueia respostas enviadas AWS IoT Core para solicitações de publicação, assinatura e ping. Também valida se o dispositivo em teste desconecta a conexão do MQTT.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um tempo limite maior que 1,5 vezes o valor `keepAliveTime`.
O máximo `keepAliveTime` não deve ser maior que 230 segundos para este teste.
```
"tests":[
{
"name":"Mqtt No Ack PingResp",
"configuration":
//optional:
"EXECUTION_TIMEOUT":"306", // in seconds
},
"test":{
"id":"MQTT_No_Ack_PingResp",
"version":"0.0.0"
}
}
]
```
## Sessão persistente
**“Sessão persistente (Happy Case)”**
Este caso de teste valida o comportamento do dispositivo quando desconectado de uma sessão persistente. O caso de teste verifica se o dispositivo pode se reconectar, retomar as assinaturas dos tópicos acionadores sem assinar de novo explicitamente, receber as mensagens armazenadas nos tópicos e funcionar conforme o esperado durante uma sessão persistente. Quando esse caso de teste é aprovado, ele indica que o dispositivo cliente é capaz de manter uma sessão persistente com o AWS IoT Core broker da maneira esperada. Para obter mais informações sobre sessões AWS IoT persistentes, consulte [Usando sessões persistentes do MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt.html#mqtt-persistent-sessions).
Nesse caso de teste, espera-se que o dispositivo cliente faça CONNECT com o AWS IoT Core com o sinalizador de sessão limpa definido como false e, em seguida, assine um tópico acionador. Após uma assinatura bem-sucedida, o dispositivo será desconectado pelo AWS IoT Core Device Advisor. Enquanto o dispositivo estiver em um estado desconectado, uma carga de mensagem de QoS 1 será armazenada nesse tópico. O Device Advisor permitirá então que o dispositivo cliente se reconecte ao endpoint de teste. Nesse ponto, como há uma sessão persistente, espera-se que o dispositivo cliente retome assinaturas de tópicos sem enviar nenhum pacote SUBSCRIBE adicional e receba a mensagem de QoS 1 do agente. Após a reconexão, se o dispositivo cliente se inscrever novamente em seu tópico acionador enviando um pacote SUBSCRIBE adicional, and/or se o cliente não receber a mensagem armazenada do tópico acionador, o caso de teste falhará.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de pelo menos 4 minutos. Na primeira conexão, o dispositivo cliente precisa assinar explicitamente um `TRIGGER_TOPIC` que não estava assinado antes. Para passar no caso de teste, o dispositivo cliente deve assinar com sucesso o `TRIGGER_TOPIC` com um QoS 1. Depois de se reconectar, espera-se que o dispositivo cliente entenda que há uma sessão persistente ativa; portanto, ele deve aceitar a mensagem armazenada enviada pelo tópico acionador e retornar PUBACK para essa mensagem específica.
```
"tests":[
{
"name":"my_mqtt_persistent_session_happy_case",
"configuration":{
//required:
"TRIGGER_TOPIC": "myTrigger/topic",
// optional:
// if Payload not provided, a string will be stored in the trigger topic to be sent back to the client device
"PAYLOAD": "The message which should be received from AWS IoT Broker after re-connecting to a persistent session from the specified trigger topic.",
"EXECUTION_TIMEOUT":"300" // in seconds
},
"test":{
"id":"MQTT_Persistent_Session_Happy_Case",
"version":"0.0.0"
}
}
]
```
**“Sessão persistente - Expiração da sessão”**
Este caso de teste ajuda a validar o comportamento do dispositivo quando um dispositivo desconectado se reconecta a uma sessão persistente expirada. Depois que a sessão expirar, esperamos que o dispositivo assine novamente os tópicos assinados anteriormente, enviando explicitamente um novo pacote SUBSCRIBE.
Durante a primeira conexão, esperamos que o dispositivo de teste SE CONECTE ao agente de AWS IoT, pois seu `CleanSession` sinalizador está definido como falso para iniciar uma sessão persistente. O dispositivo deve então assinar um tópico acionador. Em seguida, o dispositivo é desconectado pelo AWS IoT Core Device Advisor, após uma assinatura bem-sucedida e o início de uma sessão persistente. Após a desconexão, o AWS IoT Core Device Advisor permite que o dispositivo de teste se reconecte ao endpoint de teste. Nesse ponto, quando o dispositivo de teste envia outro pacote CONNECT, o AWS IoT Core Device Advisor envia de volta um pacote CONNACK que indica que a sessão persistente expirou. O dispositivo de teste precisa interpretar esse pacote corretamente e espera-se que ele assine novamente o mesmo tópico acionador quando a sessão persistente for encerrada. Se o dispositivo de teste não assinar novamente o tópico acionador, o caso de teste falhará. Para que o teste seja aprovado, o dispositivo precisa entender que a sessão persistente acabou e enviar de volta um novo pacote SUBSCRIBE para o mesmo tópico acionador na segunda conexão.
Se esse caso de teste for aprovado em um dispositivo de teste, isso indicará que o dispositivo é capaz de lidar com a reconexão após a expiração da sessão persistente de uma forma esperada.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de pelo menos 4 minutos. O dispositivo de teste precisa assinar explicitamente um `TRIGGER_TOPIC`, o qual não assinava antes. Para passar no caso de teste, o dispositivo de teste deve enviar um pacote CONNECT com o sinalizador `CleanSession` definido como false e assinar com êxito um tópico acionador com um QoS 1. Depois de uma conexão bem-sucedida, AWS IoT Core o Device Advisor desconecta o dispositivo. Após a desconexão, o AWS IoT Core Device Advisor permite que o dispositivo se reconecte, e espera-se que o dispositivo se inscreva novamente, `TRIGGER_TOPIC` pois o AWS IoT Core Device Advisor teria encerrado a sessão persistente.
```
"tests":[
{
"name":"my_expired_persistent_session_test",
"configuration":{
//required:
"TRIGGER_TOPIC": "myTrigger/topic",
// optional:
"EXECUTION_TIMEOUT":"300" // in seconds
},
"test":{
"id":"MQTT_Expired_Persistent_Session",
"version":"0.0.0"
}
}
]
```
# Shadow
Use esses testes para verificar se seus dispositivos em teste usam o serviço AWS IoT Device Shadow corretamente. Consulte [AWS IoT Serviço Device Shadow](iot-device-shadows.md) para obter mais informações. Se esses casos de teste estiverem configurados no conjunto de testes, será necessário fornecer um objeto ao iniciar a execução do conjunto.
**O MQTT over** não WebSocket é suportado no momento.
## Publicar
***“O dispositivo publica o estado após a conexão (Happy Case)”***
Valida se um dispositivo pode publicar seu estado depois de se conectar ao AWS IoT Core
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_shadow_publish_reported_state",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
"SHADOW_NAME": "SHADOW_NAME",
"REPORTED_STATE": {
"STATE_ATTRIBUTE": "STATE_VALUE"
}
},
"test":{
"id":"Shadow_Publish_Reported_State",
"version":"0.0.0"
}
}
]
```
Os `REPORTED_STATE` podem ser fornecidos para validação adicional do estado exato da sombra do dispositivo, após a conexão. Por padrão, esse caso de teste valida o estado de publicação do dispositivo.
Se `SHADOW_NAME` não for fornecido, o caso de teste procurará mensagens publicadas em prefixos de tópicos do tipo de sombra Sem nome (clássico) por padrão. Forneça um nome de sombra se o dispositivo usar o tipo de sombra nomeado. Consulte [Como usar sombras em dispositivos](https://docs.aws.amazon.com/iot/latest/developerguide/device-shadow-comms-device.html) para obter mais informações.
## Atualizar
***“O dispositivo atualiza o estado reportado para o estado desejado (Happy Case)”***
Valida se o dispositivo lê todas as mensagens de atualização recebidas e sincroniza o estado do dispositivo para corresponder às propriedades de estado desejadas. O dispositivo deve publicar o último estado relatado após a sincronização. Se o dispositivo já tiver uma sombra existente antes de executar o teste, certifique-se de que o estado desejado configurado para o caso de teste e o estado relatado existente ainda não correspondam. Você pode identificar as mensagens de atualização do Shadow enviadas pelo Device Advisor examinando o **ClientToken**campo no documento Shadow como ele será`DeviceAdvisorShadowTestCaseSetup`.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 2 minutos.
```
"tests":[
{
"name":"my_shadow_update_reported_state",
"configuration": {
"DESIRED_STATE": {
"STATE_ATTRIBUTE": "STATE_VALUE"
},
// optional:
"EXECUTION_TIMEOUT":"300", // in seconds
"SHADOW_NAME": "SHADOW_NAME"
},
"test":{
"id":"Shadow_Update_Reported_State",
"version":"0.0.0"
}
}
]
```
O `DESIRED_STATE` deve ter pelo menos um atributo e um valor associado.
Se `SHADOW_NAME` não for fornecido, o caso de teste procurará mensagens publicadas em prefixos de tópicos do tipo de sombra Sem nome (clássico) por padrão. Forneça um nome de sombra se o dispositivo usar o tipo de sombra nomeado. Consulte [Como usar sombras em dispositivos](https://docs.aws.amazon.com/iot/latest/developerguide/device-shadow-comms-device.html) para obter mais informações.
# Execução de trabalho
**“O dispositivo pode concluir a execução de um trabalho”**
Esse caso de teste ajuda você a validar se seu dispositivo é capaz de receber atualizações usando o AWS IoT Jobs e publicar o status de atualizações bem-sucedidas. Para obter mais informações sobre AWS IoT trabalhos, consulte [Trabalhos](https://docs.aws.amazon.com//iot/latest/developerguide/iot-jobs.html).
Para executar esse caso de teste com êxito, há dois tópicos da AWS reservados que você precisa conceder ao [Perfil de dispositivo](https://docs.aws.amazon.com/iot/latest/developerguide/device-advisor-setting-up.html#da-iam-role). Para assinar mensagens relacionadas a atividades de trabalhos, use os tópicos **notify** e **notify-next**. O perfil de dispositivo deve conceder a ação PUBLICAR para os seguintes tópicos:
+ \$1aws/things/**thingName**/jobs/**jobId**/get
+ \$1aws/things/**thingName**/jobs/**jobId**/update
É recomendável conceder ações de SUBSCRIBE e RECEIVE para os seguintes tópicos:
+ **\$1aws/things/ ThingName/**jobs/get/accepted
+ \$1aws/things/**thingName**/jobs/**jobId**/get/rejected
+ \$1aws/things/**thingName**/jobs/**jobId**/update/accepted
+ \$1aws/things/**thingName**/jobs/**jobId**/update/rejected
É recomendável conceder ações de SUBSCRIBE para o seguinte tópico:
+ \$1aws/things/**thingName**/jobs/notify-next
Para obter mais informações sobre esses tópicos reservados, consulte tópicos reservados para [Trabalhos de AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/reserved-topics.html#reserved-topics-job).
**O MQTT over** não WebSocket é suportado no momento.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de cinco minutos. Recomendamos um valor de tempo limite de 3 minutos. Dependendo do documento do AWS IoT Job ou da fonte fornecida, ajuste o valor do tempo limite (por exemplo, se um trabalho levar muito tempo para ser executado, defina um valor de tempo limite maior para o caso de teste). Para executar o teste, é necessário um documento de AWS IoT trabalho válido ou uma ID de trabalho já existente. Um documento AWS IoT Job pode ser fornecido como um documento JSON ou um link S3. Se um documento de trabalho for fornecido, fornecer um ID de trabalho é opcional. Se um ID de trabalho for fornecido, o Device Advisor usará esse ID ao criar o AWS IoT Job em seu nome. Se o documento do trabalho não for fornecido, você poderá fornecer um ID existente que esteja na mesma região em que você está executando o caso de teste. Nesse caso, o Device Advisor usará esse AWS IoT Job ao executar o caso de teste.
```
"tests": [
{
"name":"my_job_execution",
"configuration": {
// optional:
// Test case will create a job task by using either JOB_DOCUMENT or JOB_DOCUMENT_SOURCE.
// If you manage the job task on your own, leave it empty and provide the JOB_JOBID (self-managed job task).
// JOB_DOCUMENT is a JSON formatted string
"JOB_DOCUMENT": "{
\"operation\":\"reboot\",
\"files\" : {
\"fileName\" : \"install.py\",
\"url\" : \"${aws:iot:s3-presigned-url:https://s3.amazonaws.com/bucket-name/key}\"
}
}",
// JOB_DOCUMENT_SOURCE is an S3 link to the job document. It will be used only if JOB_DOCUMENT is not provided.
"JOB_DOCUMENT_SOURCE": "https://s3.amazonaws.com/bucket-name/key",
// JOB_JOBID is mandatory, only if neither document nor document source is provided. (Test case needs to know the self-managed job task id).
"JOB_JOBID": "String",
// JOB_PRESIGN_ROLE_ARN is used for the presign Url, which will replace the placeholder in the JOB_DOCUMENT field
"JOB_PRESIGN_ROLE_ARN": "String",
// Presigned Url expiration time. It must be between 60 and 3600 seconds, with the default value being 3600.
"JOB_PRESIGN_EXPIRES_IN_SEC": "Long"
"EXECUTION_TIMEOUT": "300", // in seconds
},
"test": {
"id": "Job_Execution",
"version": "0.0.0"
}
}
]
```
Para obter mais informações sobre como criar e usar documentos de trabalho, consulte o [documento de trabalho](https://docs.aws.amazon.com//iot/latest/developerguide/iot-jobs.html).
# Políticas e permissões
Você pode usar os testes a seguir para determinar se as políticas anexadas aos certificados dos dispositivos seguem as melhores práticas padrão.
**O MQTT over** não WebSocket é suportado no momento.
**“As políticas anexadas ao certificado do dispositivo não contêm curingas”**
Valida se as políticas de permissão associadas a um dispositivo seguem as melhores práticas e não concedem ao dispositivo mais permissões do que o necessário.
*Definição do caso de teste da API:*
`EXECUTION_TIMEOUT` tem um valor padrão de 1 minuto. Recomendamos definir um tempo limite de pelo menos 30 segundos.
```
"tests":[
{
"name":"my_security_device_policies",
"configuration": {
// optional:
"EXECUTION_TIMEOUT":"60" // in seconds
},
"test": {
"id": "Security_Device_Policies",
"version": "0.0.0"
}
}
]
```
# Testes de longa duração
Os testes de longa duração são um novo conjunto de testes que monitora o comportamento de um dispositivo quando ele opera por longos períodos de tempo. Em comparação com a execução de testes individuais que se concentram em comportamentos específicos de um dispositivo, o teste de longa duração examina o comportamento do dispositivo em uma variedade de cenários do mundo real ao longo da vida útil do dispositivo. O Device Advisor organiza os testes na ordem mais eficiente possível. O teste gera resultados e logs, incluindo um log de resumo com métricas úteis sobre o desempenho do dispositivo durante o teste.
## Caso de teste de longa duração do MQTT
No caso de teste de longa duração do MQTT, o comportamento do dispositivo é observado inicialmente em cenários felizes, como MQTT Connect, Subscribe, Publish e Reconnect. Em seguida, o dispositivo é observado em vários cenários de falha complexos, como MQTT Reconnect Backoff, Long Server Disconnect e Intermittent Connectivity.
## Fluxo de execução de casos de teste de longa duração do MQTT
Há três fases na execução de um caso de teste de longa duração do MQTT:
![\[A “Execução de teste de longa duração do MQTT” que mostra a execução do teste básico, a execução dos testes avançados e o tempo de execução adicional.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/mqtt-execution-flow.png)
### Execução de testes básicos
Nesta fase, o caso de teste executa testes simples em paralelo. O teste valida se o dispositivo tem as operações selecionadas na configuração.
O conjunto de testes básicos pode incluir o seguinte, com base nas operações selecionadas:
#### CONECTAR
Esse cenário valida se o dispositivo é capaz de fazer uma conexão bem-sucedida com o agente.
![\[O fluxo de conexão básico que inclui um dispositivo enviar uma mensagem CONNECT e o Broker responde com uma mensagem CONNACK com um código de retorno bem-sucedido.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/basic-connect.png)
#### PUBLICAR
Este cenário valida se o dispositivo publica com êxito no agente.
##### QoS 0
Este caso de teste valida se o dispositivo envia com êxito uma mensagem `PUBLISH` ao agente durante uma publicação com QoS 0. O teste não espera que a mensagem `PUBACK` seja recebida pelo dispositivo.
![\[O fluxo PUBLISH QoS 0 que inclui um dispositivo enviando uma mensagem PUBLISH com nível de QoS 0.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/Qos0.png)
##### QoS 1
Neste caso de teste, espera-se que o dispositivo envie duas mensagens `PUBLISH` ao agente com QoS 1. Após a primeira mensagem `PUBLISH`, o agente espera por até 15 segundos antes de responder. O dispositivo deve repetir a mensagem `PUBLISH` original com o mesmo identificador de pacote dentro da janela de 15 segundos. Se isso acontecer, o agente responde com uma mensagem `PUBACK`, e o teste é validado. Se o dispositivo não tentar novamente a `PUBLISH`, a `PUBACK` original será enviada ao dispositivo, e o teste será marcado como **Aprovado com avisos**, junto com uma mensagem do sistema. Durante a execução do teste, se o dispositivo perder a conexão e se reconectar, o caso de teste será reiniciado sem falhas, e o dispositivo deverá executar as etapas do cenário de teste novamente.
![\[O fluxo PUBLISH QoS 1 que inclui um dispositivo enviando uma mensagem PUBLISH com nível de QoS 1 e várias interações com o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/Qos1.png)
#### ASSINAR
Este cenário valida se o dispositivo assina com êxito o agente.
##### QoS 0
Este caso de teste valida se o dispositivo envia com êxito uma mensagem `SUBSCRIBE` ao agente durante uma assinatura com QoS 0. O teste não espera que o dispositivo receba uma mensagem SUBACK.
![\[O fluxo SUBSCRIBE QoS 0 que inclui um dispositivo enviando uma mensagem SUBSCRIBE com nível de QoS 0 e um agente respondendo com uma mensagem SUBACK e o código Success Maximum QoS 0.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/subscribe-Qos0.png)
##### QoS 1
Neste caso de teste, espera-se que o dispositivo envie duas mensagens `SUBSCRIBE` ao agente com QoS 1. Após a primeira mensagem `SUBSCRIBE`, o agente espera por até 15 segundos antes de responder. O dispositivo deve repetir a mensagem `SUBSCRIBE` original com o mesmo identificador de pacote dentro da janela de 15 segundos. Se isso acontecer, o agente responde com uma mensagem `SUBACK`, e o teste é validado. Se o dispositivo não tentar novamente a `SUBSCRIBE`, a `SUBACK` original será enviada ao dispositivo, e o teste será marcado como **Aprovado com avisos**, junto com uma mensagem do sistema. Durante a execução do teste, se o dispositivo perder a conexão e se reconectar, o caso de teste será reiniciado sem falhas, e o dispositivo deverá executar as etapas do cenário de teste novamente.
![\[O fluxo SUBSCRIBE QoS 1 que inclui um dispositivo enviando uma mensagem SUBSCRIBE com nível de QoS 1 e várias interações com o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/subscribe-Qos1.png)
#### RECONECTAR
Este cenário valida se o dispositivo se reconecta com êxito ao agente após o dispositivo ser desconectado de uma conexão bem-sucedida. O Device Advisor não desconectará o dispositivo se ele estiver conectado mais de uma vez anteriormente durante o conjunto de testes. Em vez disso, ele marcará o teste como **Aprovado**.
![\[O fluxo RECONNECT entre o DUT e o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/reconnect.png)
### Execução de testes avançados
Nesta fase, o caso de teste executa testes mais complexos em série para validar se o dispositivo segue as melhores práticas. Esses testes avançados estão disponíveis para seleção e podem ser excluídos se não forem necessários. Cada teste avançado tem o próprio valor de tempo limite com base no que o cenário exige.
#### RETURN PUBACK ON QoS 1 SUBSCRIPTION
**nota**
Selecione este cenário somente se o dispositivo for capaz de realizar assinaturas de QoS 1.
Esse cenário valida se, depois que o dispositivo assina um tópico e recebe uma mensagem `PUBLISH` do agente, ele retorna uma mensagem `PUBACK`.
![\[O fluxo RETURN PUBACK ON QoS 1 SUBSCTIPTION entre DUT e o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/return-puback.png)
#### RECEIVE LARGE PAYLOAD
**nota**
Selecione este cenário somente se o dispositivo for capaz de realizar assinaturas de QoS 1.
Esse cenário valida se o dispositivo responde com uma mensagem `PUBACK` após receber uma mensagem `PUBLISH` do agente para um tópico de QoS 1 com uma grande carga. O formato da carga esperada pode ser configurado usando a opção `LONG_PAYLOAD_FORMAT`.
![\[O fluxo RECEIVE LARGE PAYLOAD entre o DUT e o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/large-payload.png)
#### SESSÃO PERSISTENTE
**nota**
Selecione este cenário somente se o dispositivo for capaz de realizar assinaturas de QoS 1 e puder manter uma sessão persistente.
Esse cenário valida o comportamento do dispositivo na manutenção de sessões persistentes. O teste é validado quando as seguintes condições são atendidas:
+ O dispositivo se conecta ao agente com uma assinatura ativa de QoS 1 e sessões persistentes ativadas.
+ O dispositivo se desconecta com sucesso do agente durante a sessão.
+ O dispositivo se reconecta ao agente e retoma as assinaturas dos tópicos acionadores sem assinar de novo esses tópicos explicitamente.
+ O dispositivo recebe com sucesso as mensagens armazenadas pelo agente para os tópicos assinados e funciona conforme o esperado.
Para obter mais informações sobre sessões AWS IoT persistentes, consulte [Usando sessões persistentes do MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/mqtt.html#mqtt-persistent-sessions).
![\[O fluxo PERSISTENT SESSION entre o DUT e o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/persistent-session.png)
#### KEEP ALIVE
Este cenário valida se o dispositivo se desconecta com sucesso depois de não receber uma resposta de ping do agente. A conexão deve ter um cronômetro de keep-alive válido configurado. Como parte desse teste, o agente bloqueia todas as respostas enviadas para mensagens `PUBLISH`, `SUBSCRIBE` e `PINGREQ`. Também valida se o dispositivo em teste desconecta a conexão do MQTT.
![\[O fluxo KEEP ALIVE entre o DUT e o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/keep-alive.png)
#### CONECTIVIDADE INTERMITENTE
Este cenário valida se o dispositivo pode se conectar novamente ao agente depois que ele desconecta o dispositivo em intervalos aleatórios por um período de tempo aleatório.
![\[O fluxo INTERMITTENT CONNECTIVITY entre o DUT e o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/intermittent.png)
#### RECONNECT BACKOFF
Este cenário valida se o dispositivo tem um mecanismo de recuo implementado quando o agente se desconecta dele várias vezes. O Device Advisor relata o tipo de recuo como exponencial, variação de sinal, linear ou constante. O número de tentativas de recuo é configurável usando a opção `BACKOFF_CONNECTION_ATTEMPTS`. O valor padrão é 5. O valor é configurável entre 5 e 10.
Para passar nesse teste, recomendamos a implementação do mecanismo [Recuo exponencial e variação de sinal](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/) no dispositivo em teste.
![\[O fluxo RECONNECT BACKOFF entre o DUT e o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/reconnect-backoff.png)
#### DESCONEXÃO LONGA DO SERVIDOR
Este cenário valida se o dispositivo pode se reconectar com êxito após o agente desconectar o dispositivo por um longo período de tempo (até 120 minutos). A hora da desconexão do servidor pode ser configurada usando a opção `LONG_SERVER_DISCONNECT_TIME`. O valor padrão são 120 minutos. Esse valor é configurável de 30 a 120 minutos.
![\[O fluxo LONG SERVER DISCONNECT entre o DUT e o agente.\]](http://docs.aws.amazon.com/pt_br/iot/latest/developerguide/images/longserver-disconnect.png)
### Tempo de execução adicional
O tempo de execução adicional é o tempo que o teste espera após concluir todos os testes acima e antes de encerrar o caso de teste. Os clientes usam esse período adicional para monitorar e registrar todas as comunicações entre o dispositivo e o agente. O tempo de execução adicional pode ser configurado usando a opção `ADDITIONAL_EXECUTION_TIME`. Por padrão, essa opção é definida como 0 minutos e pode ser de 0 a 120 minutos.
## Opções de configuração de teste de longa duração do MQTT
Todas as opções de configuração fornecidas para o teste de longa duração do MQTT são opcionais. As seguintes opções estão disponíveis:
**OPERATIONS**
A lista de operações que o dispositivo executa, como `CONNECT`, `PUBLISH` e `SUBSCRIBE`. O caso de teste executa cenários com base nas operações especificadas. As operações que não são especificadas são consideradas válidas.
```
{
"OPERATIONS": ["PUBLISH", "SUBSCRIBE"]
//by default the test assumes device can CONNECT
}
```
**SCENARIOS**
Com base nas operações selecionadas, o caso de teste executa cenários para validar o comportamento do dispositivo. Há dois tipos de cenários:
+ Os **Cenários básicos** são testes simples que validam se o dispositivo pode realizar as operações selecionadas acima como parte da configuração. Eles são pré-selecionados com base nas operações especificadas na configuração. Mais nenhuma entrada é necessária na configuração.
+ **Cenários avançados** são cenários mais complexos que são executados em relação ao dispositivo para validar se ele segue as práticas recomendadas quando se depara com as condições do mundo real. Eles são opcionais e podem ser passados como uma matriz de cenários para a entrada de configuração do conjunto de testes.
```
{
"SCENARIOS": [ // list of advanced scenarios
"PUBACK_QOS_1",
"RECEIVE_LARGE_PAYLOAD",
"PERSISTENT_SESSION",
"KEEP_ALIVE",
"INTERMITTENT_CONNECTIVITY",
"RECONNECT_BACK_OFF",
"LONG_SERVER_DISCONNECT"
]
}
```
**BASIC\$1TESTS\$1EXECUTION\$1TIME\$1OUT:**
O tempo máximo que o caso de teste aguardará até que todos os testes básicos sejam concluídos. O valor padrão são 60 minutos. Esse valor é configurável de 30 a 120 minutos.
**LONG\$1SERVER\$1DISCONNECT\$1TIME:**
O tempo necessário para que o caso de teste se desconecte e reconecte o dispositivo durante o teste de Desconexão longa do servidor. O valor padrão são 60 minutos. Esse valor é configurável de 30 a 120 minutos.
**ADDITIONAL\$1EXECUTION\$1TIME:**
A configuração dessa opção fornece uma janela de tempo após a conclusão de todos os testes, para monitorar eventos entre o dispositivo e o agente. O valor padrão é 0 minutos. Esse valor é configurável de 0 a 120 minutos.
**BACKOFF\$1CONNECTION\$1ATTEMPTS:**
Essa opção configura o número de vezes que o dispositivo é desconectado pelo caso de teste. Isso é usado pelo teste Recuo de reconexão. O valor padrão é 5 tentativas. Esse valor é configurável de 5 a 10.
**LONG\$1PAYLOAD\$1FORMAT:**
O formato da carga da mensagem que o dispositivo espera quando o caso de teste é publicado em um tópico de QoS 1 assinado pelo dispositivo.
**Definição do caso de teste da API:**
```
{
"tests":[
{
"name":"my_mqtt_long_duration_test",
"configuration": {
// optional
"OPERATIONS": ["PUBLISH", "SUBSCRIBE"],
"SCENARIOS": [
"LONG_SERVER_DISCONNECT",
"RECONNECT_BACK_OFF",
"KEEP_ALIVE",
"RECEIVE_LARGE_PAYLOAD",
"INTERMITTENT_CONNECTIVITY",
"PERSISTENT_SESSION",
],
"BASIC_TESTS_EXECUTION_TIMEOUT": 60, // in minutes (60 minutes by default)
"LONG_SERVER_DISCONNECT_TIME": 60, // in minutes (120 minutes by default)
"ADDITIONAL_EXECUTION_TIME": 60, // in minutes (0 minutes by default)
"BACKOFF_CONNECTION_ATTEMPTS": "5",
"LONG_PAYLOAD_FORMAT":"{"message":"${payload}"}"
},
"test":{
"id":"MQTT_Long_Duration",
"version":"0.0.0"
}
}
]
}
```
## Log de resumo do caso de teste de longa duração do MQTT
O caso de teste de longa duração do MQTT é executado por mais tempo do que os casos de teste normais. É fornecido um log de resumo separado, que lista eventos importantes, como conexões de dispositivos, publicação e assinatura durante a execução. Os detalhes incluem o que foi testado, o que não foi testado e o que falhou. No final do log, o teste inclui um resumo de todos os eventos que aconteceram durante a execução do caso de teste. Isso inclui:
+ *O temporizador Keep Alive está configurado no dispositivo.*
+ *Sinalizador de sessão persistente configurado no dispositivo.*
+ *O número de conexões do dispositivo durante a execução do teste.*
+ *O tipo de recuo de reconexão do dispositivo, se validado para o teste de recuo de reconexão.*
+ *Os tópicos nos quais o dispositivo publicou durante a execução do caso de teste.*
+ *Os tópicos que o dispositivo assinou durante a execução do caso de teste.*