Prérequis Étape 1 : Initialisation d'un projet GDK avec un composant Étape 2 : Initialisation d'un projet GDK avec un module de test end-to-end Étape 3 : créer un cas de test personnalisé Étape 4 : ajouter un tag au nouveau scénario de test Étape 5 : créer le fichier JAR de test Étape 6 : Exécuter le test Exemple : création d'un scénario de test personnalisé

Tutoriel : Exécuter end-to-end des tests à l'aide du framework de test Greengrass et du kit de développement Greengrass

AWS IoT GreengrassLe Testing Framework (GTF) et le Greengrass Development Kit (GDK) offrent aux développeurs des moyens d'exécuter des tests. end-to-end Vous pouvez suivre ce didacticiel pour initialiser un projet GDK avec un composant, initialiser un projet GDK avec un module de end-to-end test et créer un cas de test personnalisé. Après avoir créé votre scénario de test personnalisé, vous pouvez exécuter le test.

Dans ce didacticiel, vous effectuez les opérations suivantes :

Initialisez un projet GDK avec un composant.
Initialisez un projet GDK avec un module de end-to-end test.
Créez un cas de test personnalisé.
Ajoutez une étiquette au nouveau scénario de test.
Créez le fichier JAR de test.
Exécutez le test .

Rubriques

Prérequis
Étape 1 : Initialisation d'un projet GDK avec un composant
Étape 2 : Initialisation d'un projet GDK avec un module de test end-to-end
Étape 3 : créer un cas de test personnalisé
Étape 4 : ajouter un tag au nouveau scénario de test
Étape 5 : créer le fichier JAR de test
Étape 6 : Exécuter le test
Exemple : création d'un scénario de test personnalisé

Prérequis

Pour suivre ce didacticiel, vous aurez besoin des éléments suivants :

GDK version 1.3.0 ou ultérieure
Java
Maven
Git

Étape 1 : Initialisation d'un projet GDK avec un composant

Initialisez un dossier vide avec un projet GDK. Téléchargez le HelloWorld composant implémenté en Python en exécutant la commande suivante.
```
gdk component init -t HelloWorld -l python -n HelloWorld
```
Cette commande crée un nouveau répertoire nommé HelloWorld dans le répertoire en cours.

Étape 2 : Initialisation d'un projet GDK avec un module de test end-to-end

GDK vous permet de télécharger le modèle du module de test composé d'une fonctionnalité et d'une implémentation par étapes. Exécutez la commande suivante pour ouvrir le HelloWorld répertoire et initialiser le projet GDK existant à l'aide d'un module de test.
```
cd HelloWorld
gdk test-e2e init
```
Cette commande crée un nouveau répertoire nommé gg-e2e-tests dans le HelloWorld répertoire. Ce répertoire de test est un projet Maven qui dépend du JAR autonome de test Greengrass.

Étape 3 : créer un cas de test personnalisé

La rédaction d'un scénario de test personnalisé comprend généralement deux étapes : créer un fichier de fonctionnalités avec un scénario de test et implémenter les définitions d'étapes. Pour un exemple de création d'un scénario de test personnalisé, voirExemple : création d'un scénario de test personnalisé. Suivez les étapes suivantes pour créer votre scénario de test personnalisé :

Création d'un fichier de fonctionnalités avec un scénario de test

Une fonctionnalité décrit généralement une fonctionnalité spécifique du logiciel testé. Dans Cucumber, chaque fonctionnalité est spécifiée sous la forme d'un fichier de fonctionnalités individuel avec un titre, une description détaillée et un ou plusieurs exemples de cas spécifiques appelés scénarios. Chaque scénario comprend un titre, une description détaillée et une série d'étapes qui définissent les interactions et les résultats attendus. Les scénarios sont rédigés dans un format structuré à l'aide des mots clés « donné », « quand » et « alors ».
Mettre en œuvre les définitions des étapes

Une définition d'étape lie l'étape Gherkin en langage clair au code programmatique. Lorsque Cucumber identifie une étape Gherkin dans un scénario, il recherche une définition d'étape correspondante à exécuter.

Étape 4 : ajouter un tag au nouveau scénario de test

Vous pouvez attribuer des balises aux fonctionnalités et aux scénarios afin d'organiser le processus de test. Vous pouvez utiliser des balises pour classer les sous-ensembles de scénarios et également sélectionner les hooks à exécuter de manière conditionnelle. Les fonctionnalités et les scénarios peuvent comporter plusieurs balises séparées par un espace.

Dans cet exemple, nous utilisons le HelloWorld composant.

Dans le fichier de fonctionnalités, ajoutez une nouvelle balise nommée @HelloWorld à côté de la @Sample balise.
```
@Sample @HelloWorld
Scenario: As a developer, I can create a component and deploy it on my device
....
```

Étape 5 : créer le fichier JAR de test

Construisez le composant. Vous devez créer le composant avant de créer le module de test.
```
gdk component build
```
Créez le module de test à l'aide de la commande suivante. Cette commande créera le fichier JAR de test dans le greengrass-build dossier.
```
gdk test-e2e build
```

Étape 6 : Exécuter le test

Lorsque vous exécutez un scénario de test personnalisé, le GTF automatise le cycle de vie du test ainsi que la gestion des ressources créées pendant le test. Il approvisionne d'abord un appareil en cours de test (DUT) en tant qu'AWS IoTobjet et y installe le logiciel de base Greengrass. Il créera ensuite un nouveau composant nommé HelloWorld en utilisant la recette spécifiée dans ce chemin. Le HelloWorld composant est ensuite déployé sur le périphérique principal par le biais d'un déploiement d'objets Greengrass. Il sera ensuite vérifié si le déploiement est réussi. L'état du déploiement passera à 3 COMPLETED minutes si le déploiement est réussi.

Accédez au gdk-config.json fichier dans le répertoire du projet pour cibler les tests avec la HelloWorld balise. Mettez à jour la test-e2e clé à l'aide de la commande suivante.
```
  "test-e2e":{
    "gtf_options" : { 
         "tags":"HelloWorld"
     }
  }
```
Avant d'exécuter les tests, vous devez fournir des AWS informations d'identification au périphérique hôte. GTF utilise ces informations d'identification pour gérer les AWS ressources pendant le processus de test. Assurez-vous que le rôle que vous fournissez dispose des autorisations nécessaires pour automatiser les opérations nécessaires incluses dans le test.

Exécutez les commandes suivantes pour fournir les AWS informations d'identification.
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"
Exécutez le test à l'aide de la commande suivante.
```
gdk test-e2e run
```
Cette commande télécharge la dernière version du noyau Greengrass dans le greengrass-build dossier et exécute des tests en l'utilisant. Cette commande cible également uniquement les scénarios dotés de la HelloWorld balise et génère un rapport pour ces scénarios. Vous verrez que les AWS ressources créées lors de ce test sont supprimées à la fin du test.

Exemple : création d'un scénario de test personnalisé

Le module de test téléchargé dans le projet GDK se compose d'un exemple de fonctionnalité et d'un fichier d'implémentation des étapes.

Dans l'exemple suivant, nous créons un fichier de fonctionnalités pour tester la fonctionnalité de déploiement d'objets du logiciel Greengrass. Nous testons partiellement la fonctionnalité de cette fonctionnalité avec un scénario qui effectue le déploiement d'un composant via GreengrassAWS Cloud. Il s'agit d'une série d'étapes qui nous aident à comprendre les interactions et les résultats attendus de ce cas d'utilisation.

Création d'un fichier de fonctionnalités

Accédez au gg-e2e-tests/src/main/resources/greengrass/features dossier dans le répertoire actuel. Vous pouvez trouver l'exemple component.feature qui ressemble à l'exemple suivant.

Dans ce fichier de fonctionnalités, vous pouvez tester la fonctionnalité de déploiement d'objets du logiciel Greengrass. Vous pouvez tester partiellement la fonctionnalité de cette fonctionnalité avec un scénario qui effectue le déploiement d'un composant via le cloud Greengrass. Le scénario est une série d'étapes qui aident à comprendre les interactions et les résultats attendus de ce cas d'utilisation.
```
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
```
GTF contient les définitions des étapes de toutes les étapes suivantes, à l'exception de l'étape nommée :And I call my custom step.
Mettre en œuvre les définitions des étapes

Le fichier JAR autonome GTF contient les définitions d'étapes de toutes les étapes à l'exception d'une étape :. And I call my custom step Vous pouvez implémenter cette étape dans le module de test.

Accédez au code source du fichier de test. Vous pouvez lier votre étape personnalisée à l'aide d'une définition d'étape à l'aide de la commande suivante.
```
@And("I call my custom step")
public void customStep() {
    System.out.println("My custom step was called ");
}
```

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Options de configuration GTF

Tutoriel : Utiliser un test de confiance issu de la suite de tests de confiance