Optimiser vos tests avec Cucumber

Écrit par Faiez T.

Introduction :

Qu’est-ce que Cucumber ?

Cucumber est un outil puissant utilisé pour automatiser les tests logiciels, qui repose sur la méthodologie du Behavior Driven Development (BDD). Il permet de décrire le comportement attendu d’une application sous forme de scénarios simples et compréhensibles par tous, facilitant ainsi la collaboration entre les différentes équipes.

Qu’est-ce que BDD ?

Le Behavior Driven Development (BDD) est une approche de développement logiciel qui se concentre sur la description du comportement attendu d’une application à travers des scénarios clairs et accessibles. Ces scénarios peuvent être compris par toutes les parties prenantes, qu’il s’agisse de développeurs, de testeurs, d’analystes métiers ou d’utilisateurs finaux, facilitant ainsi la communication et la collaboration tout au long du processus de développement.

Pourquoi utiliser Cucumber ?

1. Langage naturel avec Gherkin

L’un des points forts de Cucumber est qu’il utilise un langage naturel appelé Gherkin pour définir les tests. Gherkin est une syntaxe simple qui permet d’écrire des scénarios en anglais ou dans d’autres langues, en suivant une structure intuitive.

• Exemple d’un scénario Gherkin :

Feature: Connexion utilisateur  
 Scenario: Connexion réussie avec des identifiants valides  
   Given un utilisateur avec un identifiant valide "faiez.tmar"  
   When il tente de se connecter avec son mot de passe  
   Then il est redirigé vers la page d'accueil

2. Tests lisibles et compréhensibles

Les scénarios écrits avec Cucumber sont compréhensibles par toutes les parties prenantes du projet, qu’elles soient techniques ou non. Cela permet :

• Une collaboration accrue entre les développeurs, les testeurs et les responsables métier.
• Une meilleure compréhension des fonctionnalités attendues de l’application.

3. Automatisation des Tests

Une fois les scénarios définis, Cucumber permet de les automatiser, ce qui améliore la qualité du logiciel en garantissant :

• Une exécution rapide et fiable des tests.
• La détection rapide des régressions lors des phases de développement.

Les concepts clés de Cucumber

1. Feature

Une Feature est un fichier .feature qui décrit une fonctionnalité spécifique de l’application. Ce fichier regroupe plusieurs scénarios liés à cette fonctionnalité.

• Exemple :

Feature: Gestion des utilisateurs
Afin de pouvoir accéder à l'application
En tant qu'utilisateur enregistré
Je veux pouvoir me connecter avec mes identifiants

2. Scénario

Un Scenario décrit une situation ou un cas d’utilisation spécifique, en détaillant le comportement attendu de l’application dans ce cas.

• Exemple :

Scenario: Connexion avec des identifiants valides
Given un utilisateur avec l'identifiant "faiez.tmar"
When il saisit son mot de passe correct
Then il est redirigé vers la page d'accueil

3. Steps

Les Steps ou étapes définissent les actions à réaliser et les résultats attendus dans le scénario. Elles se décomposent en trois catégories principales :

• Given : Décrit le contexte initial.
• When : Décrit l’action ou l’événement déclencheur.
• Then : Définit le résultat attendu.

Syntaxe des Steps :

Given un utilisateur est sur la page de connexion  
When il saisit ses identifiants corrects  
Then il est redirigé vers la page d'accueil

4. Step Definitions

Les Step Definitions sont des méthodes implémentées en Java (ou dans un autre langage compatible) qui définissent le comportement à exécuter pour chaque étape du scénario.

• Exemple en Java :

@Given("un utilisateur est sur la page de connexion")
public void userOnLoginPage() {
// Code pour naviguer vers la page de connexion
}
@When("il saisit ses identifiants corrects")
public void provideCorrectCredentials() {
// Code pour saisir les identifiants
}
@Then("il est redirigé vers la page d'accueil")
public void redirectedToHomePage() {
// Code pour vérifier la redirection
}

Exemple d’Implémentation de Cucumber avec Spring Boot

1. Configuration du Projet

Pour intégrer Cucumber dans un projet Spring Boot, vous devez ajouter les dépendances nécessaires dans le fichier pom.xml :

<dependencies>
    <!-- Dépendance Cucumber -->
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-java</artifactId>
        <version>7.0.0</version>
    </dependency>
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-spring</artifactId>
        <version>7.0.0</version>
    </dependency>
    <!-- Dépendance Spring Boot Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Créez une classe CucumberTest.java :

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;
@RunWith(Cucumber.class)
@CucumberOptions(features = "classpath:features", plugin = {"pretty"})
public class CucumberTest {
}

2. Exemple de scénario Gherkin :

Dans un fichier article.feature, nous allons définir des scénarios en Gherkin pour tester la gestion des articles. Chaque scénario correspond à une action CRUD sur un article.

Feature: Gestion des articles
  Afin de gérer les informations de mes articles
  En tant qu'administrateur
  Je veux pouvoir créer, lire, mettre à jour et supprimer des articles.
Scenario: Création d'un nouvel article
  Given un article avec le titre "Cucumber et Spring Boot"
  When l'article est créé
  Then l'article doit être enregistré dans la base de données
Scenario: Lecture d'un article
  Given un article avec le titre "Cucumber et Spring Boot"
  When je consulte l'article
  Then le titre de l'article doit être "Cucumber et Spring Boot"
Scenario: Mise à jour d'un article
  Given un article avec le titre "Cucumber et Spring Boot"
  When je mets à jour l'article avec le titre "Cucumber avancé"
  Then le titre de l'article doit être "Cucumber avancé"
Scenario: Suppression d'un article
  Given un article avec le titre "Cucumber et Spring Boot"
  When je supprime l'article
  Then l'article ne doit plus exister dans la base de données

3. Implémentation des steps en Java

Dans la classe ArticleStepDefinitions.java, nous allons implémenter les étapes des scénarios.

import io.cucumber.java.en.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.ResponseEntity;
import org.springframework.test.web.client.TestRestTemplate;
import static org.junit.Assert.*;
@SpringBootTest
public class ArticleStepDefinitions {
    @Autowired
    private ArticleRepository articleRepository;
    private Article article;
    @Given("un article avec le titre {string}")
    public void givenAnArticleWithTitle(String titre) {
        article = new Article();
        article.setTitre(titre);
    }
    @When("l'article est créé")
    public void whenArticleIsCreated() {
        articleRepository.save(article); 
    }
    @Then("l'article doit être enregistré dans la base de données")
    public void thenArticleShouldBeSavedInDatabase() {
        Article savedArticle = articleRepository.findByTitre(article.getTitre());
        assertNotNull(savedArticle); 
        assertEquals(article.getTitre(), savedArticle.getTitre()); 
    }
    @When("je consulte l'article")
    public void whenGetArticle() {
        article = articleRepository.findByTitre(article.getTitre());
    }
    @Then("le titre de l'article doit être {string}")
    public void thenTitleOfArticleShouldBe(String titre) {
        assertEquals(titre, article.getTitre()); 
    }
    @When("je mets à jour l'article avec le titre {string}")
    public void whenIUpdateTheArticleWithTitle(String nouveauTitre) {
        article.setTitre(nouveauTitre);
        articleRepository.save(article); 
    }
    @Then("le titre de l'article doit être {string}")
    public void thenTitleOfArticleShouldBeUpdated(String titre) {
        article = articleRepository.findByTitre(titre);
        assertNotNull(article); 
        assertEquals(titre, article.getTitre()); 
    }
    @When("je supprime l'article")
    public void whenIDeleteTheArticle() {
        articleRepository.delete(article); 
    }
    @Then("l'article ne doit plus exister dans la base de données")
    public void thenArticleShouldNotExistInDatabase() {
        Article deletedArticle = articleRepository.findByTitre(article.getTitre());
        assertNull(deletedArticle); 
    }
}

4. Exécution des Tests

Vous pouvez maintenant exécuter vos tests avec Maven en utilisant la commande suivante :

mvn test

Les tests Cucumber vont s’exécuter, et vous pourrez vérifier les résultats pour vous assurer que les opérations CRUD sur les articles fonctionnent correctement.

Conclusion

En conclusion, Cucumber, en tant que framework basé sur la méthodologie BDD, facilite l’automatisation des tests et améliore la collaboration entre les équipes grâce à son utilisation de scénarios écrits dans un langage naturel. Son approche permet une compréhension claire des comportements attendus de l’application, tant pour les techniciens que pour les non-techniciens.

Grâce à l’intégration avec des outils comme Spring Boot, Cucumber permet d’implémenter et d’exécuter efficacement des tests automatisés, garantissant ainsi une meilleure qualité logicielle et une détection rapide des régressions.