Introduction aux tests paramétrés

Objectifs du chapitre :

• Comprendre le concept des tests paramétrés.
• Apprendre à utiliser l'annotation @RunWith(Parameterized.class) en JUnit 4 pour créer des tests paramétrés.
• Apprendre à créer des tests paramétrés avec l'annotation @Parameters.
• Découvrir comment les tests paramétrés peuvent améliorer la couverture et l'efficacité des tests.

9.1 Qu'est-ce qu'un test paramétré ?

Les tests paramétrés permettent d'exécuter la même méthode de test plusieurs fois avec différentes données d'entrée. Cela est particulièrement utile lorsque vous avez une logique qui doit être testée avec plusieurs ensembles de données. Les tests paramétrés améliorent la couverture des tests et réduisent la duplication du code de test.

9.2 Utilisation de @RunWith(Parameterized.class) en JUnit 4

En JUnit 4, les tests paramétrés sont réalisés à l'aide de l'annotation @RunWith(Parameterized.class). Cette annotation indique à JUnit de gérer la classe de test comme un test paramétré.

Étapes pour créer des tests paramétrés en JUnit 4 :

1. Ajouter la dépendance JUnit dans le fichier pom.xml (si ce n'est pas déjà fait) :

   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.13.2</version>
       <scope>test</scope>
   </dependency>
   

2. Annoter la classe de test avec @RunWith(Parameterized.class) :

   import org.junit.runner.RunWith;
   import org.junit.runners.Parameterized;
   
   @RunWith(Parameterized.class)
   public class MyParamTest {
       // Class contents
   }
   

3. Définir les paramètres du test avec @Parameters :

   • Créez une méthode statique annotée avec @Parameters qui renvoie une collection d'objets (les paramètres de test).

4. Définir les variables d'instance pour les paramètres :

   • Déclarez des variables d'instance pour stocker les paramètres.

5. Créer un constructeur pour initialiser les variables d'instance :

   • Ce constructeur prendra les paramètres comme arguments.

6. Écrire les méthodes de test :

   • Utilisez les variables d'instance dans vos méthodes de test.

Exemple complet :

Classe à tester (Calculator.java) :

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

Classe de test paramétré (CalculatorTest.java) :

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.util.Arrays;
import java.util.Collection;

import static org.junit.Assert.assertEquals;

@RunWith(Parameterized.class)
public class CalculatorTest {

    private int a;
    private int b;
    private int expected;

    public CalculatorTest(int a, int b, int expected) {
        this.a = a;
        this.b = b;
        this.expected = expected;
    }

    @Parameterized.Parameters
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][] {
            { 1, 1, 2 },
            { 2, 3, 5 },
            { 3, 5, 8 },
            { 4, 4, 8 }
        });
    }

    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        assertEquals(expected, calculator.add(a, b));
    }
}

Dans cet exemple, le test testAdd est exécuté quatre fois avec des ensembles de paramètres différents, vérifiant que la méthode add du Calculator fonctionne correctement pour chaque ensemble de données.

9.3 Tests paramétrés en JUnit 5

En JUnit 5, les tests paramétrés sont réalisés avec l'annotation @ParameterizedTest et différentes sources de paramètres comme @ValueSource, @CsvSource, @MethodSource, etc.

Exemple complet en JUnit 5 :

Classe à tester (Calculator.java) :

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

Classe de test paramétré (CalculatorTest.java) :

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorTest {

    @ParameterizedTest
    @CsvSource({
        "1, 1, 2",
        "2, 3, 5",
        "3, 5, 8",
        "4, 4, 8"
    })
    void testAdd(int a, int b, int expected) {
        Calculator calculator = new Calculator();
        assertEquals(expected, calculator.add(a, b));
    }
}

Dans cet exemple, le test testAdd est exécuté avec des ensembles de paramètres fournis par @CsvSource, vérifiant que la méthode add fonctionne correctement pour chaque ensemble de données.

9.4 Avantages des tests paramétrés

1. Réduction de la duplication du code de test :

   • Les tests paramétrés permettent d'éviter d'écrire des méthodes de test similaires pour différentes valeurs de paramètres.

2. Amélioration de la couverture des tests :

   • En testant avec plusieurs ensembles de données, les tests paramétrés aident à s'assurer que le code fonctionne correctement dans une variété de situations.

3. Facilité de maintenance :

   • Les modifications aux cas de test peuvent être gérées en un seul endroit (la méthode fournissant les paramètres), facilitant la mise à jour des tests.

Résumé du chapitre :

• Les tests paramétrés permettent d'exécuter la même méthode de test avec différentes données d'entrée, améliorant ainsi la couverture des tests.
• En JUnit 4, utilisez @RunWith(Parameterized.class) et @Parameters pour créer des tests paramétrés.
• En JUnit 5, utilisez @ParameterizedTest et diverses sources de paramètres comme @CsvSource pour réaliser des tests paramétrés.
• Les tests paramétrés réduisent la duplication du code de test, améliorent la couverture des tests et facilitent la maintenance.