Écrire un test unitaire pour une classe de service simple

1. Anatomie d'un Test Unitaire

Pour écrire un test, il nous faut deux choses : une pièce de code à tester et une classe de test pour la vérifier.

La Classe sous Test (Class Under Test)

En jargon de test, on appelle la classe que l'on souhaite vérifier la "Classe sous Test" (ou Class Under Test, CUT). Pour nos exemples, nous allons utiliser un service très simple et classique : une calculatrice.

Voici le code de notre service Calculator, que nous placerons dans src/main/java/com/example/Calculator.java.

package com.example;

public class Calculator {

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

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }
}

La Classe de Test

Une classe de test est une classe Java standard qui contient des méthodes dédiées à la vérification d'une autre classe. Voici les conventions et la structure à suivre :

En résumé, pour notre classe Calculator, nous créerons une classe CalculatorTest dans le dossier src/test/java/com/example/. Cette séparation garantit que notre code de test reste en dehors de l'application finale.

2. Le Modèle "Arrange, Act, Assert"

Une bonne méthode de test est structurée et facile à lire. Pour cela, on suit presque toujours un modèle en trois étapes connu sous le nom de Arrange, Act, Assert (Préparer, Agir, Vérifier). En anglais, on parle aussi souvent de Given, When, Then.

1. Arrange (Given / Étant donné) : On prépare tout ce qui est nécessaire pour le test. On instancie la classe à tester et on définit les données d'entrée.
2. Act (When / Quand) : On exécute l'action, c'est-à-dire la méthode que l'on veut tester.
3. Assert (Then / Alors) : On vérifie que le résultat obtenu est bien celui que l'on attendait. C'est le cœur du test.

3. Écrire et Exécuter Votre Premier Test

Maintenant que nous avons la théorie, mettons-la en pratique. Nous allons créer la classe de test pour notre Calculator et écrire un test pour la méthode add.

La vidéo suivante vous montrera comment créer la classe Calculator, générer sa classe de test dans IntelliJ, et écrire la première méthode de test en utilisant une assertion.

Comme vous l'avez vu, le processus est assez direct. Voici le code complet pour notre premier test de la méthode add :

// Dans src/test/java/com/example/CalculatorTest.java

package com.example;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class CalculatorTest {

    @Test
    void shouldAddTwoPositiveNumbers() {
        // 1. Arrange (Préparer)
        Calculator calculator = new Calculator();
        int a = 5;
        int b = 3;
        int expectedResult = 8;

        // 2. Act (Agir)
        int actualResult = calculator.add(a, b);

        // 3. Assert (Vérifier)
        assertEquals(expectedResult, actualResult, "5 + 3 devrait être égal à 8");
    }
}

Analysons ce code :

• import org.junit.jupiter.api.Test; : Importe l'annotation qui déclare une méthode de test.
• import static org.junit.jupiter.api.Assertions.assertEquals; : L'import statique nous permet d'appeler assertEquals directement, sans préfixer avec Assertions.. C'est une convention très courante qui allège le code.
• @Test : Indique à JUnit que la méthode shouldAddTwoPositiveNumbers est un cas de test à exécuter.
• assertEquals(expected, actual, message) : C'est la méthode d'assertion.
  • Le premier paramètre est la valeur attendue.
  • Le second paramètre est la valeur réellement obtenue par notre code.
  • Le troisième paramètre (optionnel) est un message qui s'affichera si le test échoue, ce qui est très utile pour le débogage.

Bonne pratique : Respectez toujours l'ordre (expected, actual) dans assertEquals. Si le test échoue, les messages d'erreur de JUnit seront beaucoup plus clairs, vous indiquant "Expected: 8, but was: 7" plutôt que l'inverse, qui serait déroutant.

4. Exercice Pratique : Tester une Classe Person

Il est temps de mettre les mains dans le cambouis ! L'exercice suivant vous demande de créer une classe simple et d'écrire les tests pour valider son comportement.

La vidéo de Graven propose un excellent cas pratique avec une correction détaillée.

Votre mission :

1. Créez une nouvelle classe Person dans src/main/java/com/example/ avec les attributs privés suivants :
   • String firstName
   • String lastName
   • int age
2. Créez un constructeur qui initialise ces trois attributs.
3. Générez les getters pour chaque attribut.
4. Créez la classe de test correspondante PersonTest.
5. Dans PersonTest, écrivez une méthode de test unique qui vérifie que, après avoir créé un objet Person, les getters retournent bien les valeurs qui ont été passées au constructeur.

Mettez cette leçon en pause et essayez de le faire par vous-même. C'est le meilleur moyen d'apprendre !

Correction :

Une fois que vous avez essayé, vous pouvez regarder la correction dans la vidéo.

Conclusion

Félicitations ! Vous venez d'écrire votre première classe de test fonctionnelle en Java. Vous avez appris à structurer vos tests de manière claire et à utiliser l'assertion la plus fondamentale pour valider le comportement de votre code. C'est la compétence de base sur laquelle repose toute la discipline des tests automatisés.

Les points clés à retenir :

• Une classe de test se nomme NomDeLaClasseTest et se place dans src/test/java.
• Chaque méthode de test est marquée par l'annotation @Test.
• On structure une méthode de test en suivant le modèle Arrange, Act, Assert.
• assertEquals(expected, actual) est l'outil principal pour vérifier qu'une méthode retourne le bon résultat.
• Des noms de méthodes de test descriptifs (ex: should...) rendent les rapports de test plus lisibles.

Maintenant que vous maîtrisez la création d'une classe de test simple, nous allons, dans la prochaine leçon, enrichir votre boîte à outils. Nous explorerons d'autres types d'assertions comme assertTrue, assertNotNull ou assertNotEquals, ce qui vous permettra de valider des aspects plus variés du comportement de votre code.