As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Tutorial: Execute end-to-end testes usando o Greengrass Testing Framework e o Greengrass Development Kit
AWS IoT Greengrass O Testing Framework (GTF) e o Greengrass Development Kit (GDK) oferecem aos desenvolvedores maneiras de executar testes. end-to-end Você pode concluir este tutorial para inicializar um projeto do GDK com um componente, inicializar um projeto do GDK com um módulo de end-to-end teste e criar um caso de teste personalizado. Depois de criar seu caso de teste personalizado, você poderá executar o teste.
Neste tutorial, você faz o seguinte:
1. Inicialize um projeto do GDK com um componente.
1. Inicialize um projeto GDK com um módulo de end-to-end teste.
1. Crie um caso de teste personalizado.
1. Adicione uma tag ao novo caso de teste.
1. Crie o JAR de teste.
1. Execute o teste do .
**Topics**
+ [Pré-requisitos](#run-e2e-tests-tutorial-prerequisites)
+ [Etapa 1: inicializar um projeto do GDK com um componente](#init-gdk-with-component)
+ [Etapa 2: inicializar um projeto do GDK com um end-to-end módulo de teste](#init-gdk-with-e2e-test)
+ [Etapa 3: definir um caso de teste personalizado](#run-e2e-tests-tutorial-instructions)
+ [Etapa 4: Adicionar uma tag ao novo caso de teste](#add-tag-to-test-case)
+ [Etapa 5: compilar o JAR de teste](#build-test-jar)
+ [Etapa 6: executar o teste](#run-test-gtf)
+ [Exemplo: criar um caso de teste personalizado](#build-test-case-example)
## Pré-requisitos
Para concluir este tutorial, você precisará do seguinte:
+ GDK versão 1.3.0 ou posterior
+ Java
+ Maven
+ Git
## Etapa 1: inicializar um projeto do GDK com um componente
+ Inicialize uma pasta vazia com um projeto do GDK. Faça download do componente `HelloWorld` implementado em Python executando o comando a seguir.
```
gdk component init -t HelloWorld -l python -n HelloWorld
```
Esse comando cria um diretório chamado `HelloWorld` no diretório atual.
## Etapa 2: inicializar um projeto do GDK com um end-to-end módulo de teste
+ O GDK permite que você baixe o modelo do módulo de teste que consiste em uma implementação de atributos e etapas. Execute o comando a seguir para abrir o diretório `HelloWorld` e inicializar o projeto GDK existente usando um módulo de teste.
```
cd HelloWorld
gdk test-e2e init
```
Esse comando cria um diretório chamado `gg-e2e-tests` no diretório `HelloWorld`. Esse diretório de teste é um projeto [Maven](https://maven.apache.org/) que depende do JAR independente de testes do Greengrass.
## Etapa 3: definir um caso de teste personalizado
Escrever um caso de teste personalizado consiste basicamente em duas etapas: criar um arquivo de recurso com um cenário de teste e implementar as definições das etapas. Para ver um exemplo de criação de um caso de teste personalizado, consulte [Exemplo: criar um caso de teste personalizado](#build-test-case-example). Use as etapas a seguir para criar seu caso de teste personalizado:
1. Criar um arquivo de recurso com um cenário de teste
Um recurso geralmente descreve uma funcionalidade específica do software que está sendo testado. No Cucumber, cada recurso é especificado como um arquivo de recurso individual com um título, uma descrição detalhada e um ou mais exemplos de casos específicos chamados cenários. Cada cenário consiste em um título, uma descrição detalhada e uma série de etapas que definem as interações e os resultados esperados. Os cenários são escritos em um formato estruturado usando as palavras-chave “determinado”, “quando” e “então”.
1. Implementar definições de etapas
Uma definição de etapa vincula a [etapa Gherkin](https://cucumber.io/docs/gherkin/reference/#steps) em linguagem simples ao código programático. Quando o Cucumber identifica uma etapa do Gherkin em um cenário, ele procura uma definição de etapa correspondente para ser executada.
## Etapa 4: Adicionar uma tag ao novo caso de teste
+ Você pode atribuir tags aos atributos e cenários para organizar o processo de teste. Você pode usar tags para categorizar os subconjuntos de cenários e também selecionar hooks condicionalmente para execução. Os atributos e os cenários podem ter várias tags separadas por um espaço.
Neste exemplo, usamos o componente `HelloWorld`.
No arquivo de recurso, adicione uma nova tag chamada `@HelloWorld` ao lado da tag `@Sample`.
```
@Sample @HelloWorld
Scenario: As a developer, I can create a component and deploy it on my device
....
```
## Etapa 5: compilar o JAR de teste
1. Crie o componente. Você deve criar o componente antes de criar o módulo de teste.
```
gdk component build
```
1. Crie o módulo de teste usando o comando a seguir. Esse comando criará o JAR de teste na pasta `greengrass-build`.
```
gdk test-e2e build
```
## Etapa 6: executar o teste
Quando você executa um caso de teste personalizado, o GTF automatiza o ciclo de vida do teste junto com o gerenciamento de recursos que foram criados durante o teste. Primeiro, ele provisiona um dispositivo em teste (DUT) como uma AWS IoT coisa e instala o software principal do Greengrass nele. Em seguida, ele criará um novo componente chamado `HelloWorld` usando a fórmula especificada nesse caminho. O componente do `HelloWorld` é então implantado no dispositivo principal por meio de uma implantação da coisa do Greengrass. Em seguida, é verificado se a implantação foi bem-sucedida. O status da implantação será alterado para `COMPLETED` dentro de 3 minutos se a implantação for bem-sucedida.
1. Vá para o arquivo `gdk-config.json` no diretório do projeto para direcionar os testes com a tag `HelloWorld`. Atualize a chave `test-e2e` usando o comando a seguir.
```
"test-e2e":{
"gtf_options" : {
"tags":"HelloWorld"
}
}
```
1. Antes de executar os testes, você deve fornecer AWS credenciais para o dispositivo host. O GTF usa essas credenciais para gerenciar os AWS recursos durante o processo de teste. Certifique-se de que o perfil fornecido tenha permissões para automatizar as operações necessárias incluídas no teste.
Execute os comandos a seguir para fornecer as AWS credenciais.
1.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
------
1. Execute o teste usando o seguinte comando.
```
gdk test-e2e run
```
Esse comando baixa a versão mais recente do núcleo do Greengrass na pasta `greengrass-build` e executa testes usando-a. Esse comando também visa somente os cenários com a tag `HelloWorld` e gera um relatório para eles. Você verá que os AWS recursos criados durante esse teste serão descartados no final do teste.
## Exemplo: criar um caso de teste personalizado
**Example**
O módulo de teste baixado no projeto GDK consiste em um recurso de amostra e um arquivo de implementação de etapas.
No exemplo a seguir, criamos um arquivo de atributo para testar o atributo de implantação do objeto do software Greengrass. Testamos parcialmente a funcionalidade desse atributo com um cenário que executa a implantação de um componente por meio da Nuvem AWS do Greengrass. Esta é uma série de etapas que nos ajudam a entender as interações e os resultados esperados deste caso de uso.
1.
**Criar um arquivo de atributos**
Navegue até a pasta `gg-e2e-tests/src/main/resources/greengrass/features` no diretório atual. É possível encontrar uma amostra `component.feature` que parece com o exemplo a seguir.
Nesse arquivo de recurso, você pode testar o recurso de implantação do software Greengrass. Você pode testar parcialmente a funcionalidade desse recurso com um cenário que executa uma implantação de um componente por meio da nuvem do Greengrass. O cenário é uma série de etapas que ajudam a entender as interações e os resultados esperados desse caso de uso.
```
Feature: Testing features of Greengrassv2 component
Background:
Given my device is registered as a Thing
And my device is running Greengrass
@Sample
Scenario: As a developer, I can create a component and deploy it on my device
When I create a Greengrass deployment with components
HelloWorld | /path/to/recipe/file
And I deploy the Greengrass deployment configuration
Then the Greengrass deployment is COMPLETED on the device after 180 seconds
And I call my custom step
```
O GTF contém as definições de etapas de todas as etapas a seguir, exceto a etapa chamada: `And I call my custom step`.
1.
**Implementar definições de etapas**
O JAR autônomo GTF contém as definições de todas as etapas, exceto uma: `And I call my custom step`. Você pode implementar essa etapa no módulo de teste.
Navegue até o código-fonte do arquivo de teste. É possível vincular sua etapa personalizada usando uma definição de etapa usando o comando a seguir.
```
@And("I call my custom step")
public void customStep() {
System.out.println("My custom step was called ");
}
```