Introduction aux tests unitaires en Java avec JUnit

Les tests unitaires servent à vérifier automatiquement que votre code fonctionne comme prévu, sans avoir à tout tester à la main.
Ils sont très utiles pour éviter les erreurs et gagner du temps quand on modifie un programme.

---

1Qu’est-ce qu’un test unitaire ?

Un test unitaire vérifie qu’une petite partie du code (souvent une méthode) donne le résultat attendu.

Exemple :

Vérifier que la méthode addition(2, 3) retourne bien 5.

Quand un test échoue (❌), cela veut dire que le code ne fonctionne pas comme prévu.
Quand il réussit (✅), tout est bon !

---

Les fichiers de test doivent être dans :

src/test/java/

---

Exemple simple de code à tester

// 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 multiply(int a, int b) {
        return a * b;
    }

    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division par zéro interdite !");
        }
        return a / b;
    }
}

---

Premier test unitaire

// src/test/java/com/example/CalculatorTest.java
package com.example;

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

class CalculatorTest {

    @Test
    void testAddition() {
        Calculator calc = new Calculator();
        int result = calc.add(2, 3);
        assertEquals(5, result);
    }

    @Test
    void testMultiplication() {
        Calculator calc = new Calculator();
        assertEquals(12, calc.multiply(3, 4));
    }

    @Test
    void testDivision() {
        Calculator calc = new Calculator();
        assertEquals(2, calc.divide(6, 3));
    }

    @Test
    void testDivisionParZero() {
        Calculator calc = new Calculator();
        assertThrows(IllegalArgumentException.class, () -> calc.divide(10, 0));
    }
}

---

Autres exemples de tests

Tester des chaînes de caractères

package com.example;

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

class StringTest {

    @Test
    void testUpperCase() {
        String texte = "java";
        assertEquals("JAVA", texte.toUpperCase());
    }

    @Test
    void testTrim() {
        String texte = "   bonjour   ";
        assertEquals("bonjour", texte.trim());
    }

    @Test
    void testConcatenation() {
        String a = "Hello";
        String b = "World";
        assertEquals("HelloWorld", a + b);
    }

    @Test
    void testContains() {
        String message = "JUnit est simple";
        assertTrue(message.contains("simple"));
    }
}

---

Tester une classe avec conditions

// src/main/java/com/example/Student.java
package com.example;

public class Student {
    private String name;
    private double average;

    public Student(String name, double average) {
        this.name = name;
        this.average = average;
    }

    public boolean isPassed() {
        return average >= 60.0;
    }

    public String getMention() {
        if (average >= 90) return "Excellent";
        if (average >= 75) return "Très bien";
        if (average >= 60) return "Passable";
        return "Échec";
    }
}

// src/test/java/com/example/StudentTest.java
package com.example;

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

class StudentTest {

    @Test
    void testStudentPassed() {
        Student s = new Student("Alice", 82.5);
        assertTrue(s.isPassed());
    }

    @Test
    void testStudentFailed() {
        Student s = new Student("Bob", 45.0);
        assertFalse(s.isPassed());
    }

    @Test
    void testMention() {
        Student s1 = new Student("Alice", 95);
        Student s2 = new Student("Bob", 70);
        Student s3 = new Student("Charlie", 50);

        assertEquals("Excellent", s1.getMention());
        assertEquals("Passable", s2.getMention());
        assertEquals("Échec", s3.getMention());
    }
}

---

Les principaux types de tests

Type de test	Objectif	Exemple concret
Test unitaire	Tester une seule méthode	Calculator.add(2,3) retourne 5
Test d’intégration	Vérifier que plusieurs classes fonctionnent ensemble	StudentService utilise StudentRepository correctement
Test fonctionnel	Vérifier une fonctionnalité complète	“Créer un étudiant et vérifier qu’il apparaît dans la liste”
Test de régression	Vérifier qu’une modification n’a rien cassé	Rejouer les anciens tests après un changement
Test de performance	Vérifier que le code est rapide	Vérifier que triRapide() s’exécute en moins de 10 ms
Test de bout en bout (E2E)	Tester l’application entière	Simuler un vrai utilisateur

---

Les assertions les plus utiles

Méthode	Rôle	Exemple
assertEquals(a, b)	Vérifie que les deux valeurs sont égales	assertEquals(5, calc.add(2,3))
assertNotEquals(a, b)	Vérifie que les deux valeurs sont différentes	assertNotEquals(0, calc.divide(6,3))
assertTrue(condition)	Vérifie que la condition est vraie	assertTrue(user.isLoggedIn())
assertFalse(condition)	Vérifie que la condition est fausse	assertFalse(list.isEmpty())
assertNull(obj)	Vérifie que l’objet est null	assertNull(person.getAddress())
assertNotNull(obj)	Vérifie que l’objet n’est pas null	assertNotNull(new User())
assertThrows(Exception.class, code)	Vérifie qu’une exception est lancée	assertThrows(IllegalArgumentException.class, () -> divide(10, 0))

---

8Exécution des tests

Dans IntelliJ IDEA

1. Clic droit sur la classe de test
2. Sélectionnez Run 'CalculatorTest'

En ligne de commande

mvn test

Résultat : - ✅ Tests réussis → code correct
- ❌ Échec → corrigez la méthode en cause

---

Bonnes pratiques

✅ Un test doit être indépendant des autres
✅ Donnez un nom clair au test (testAdditionSimple)
✅ Testez les cas normaux et les cas d’erreur
✅ N’utilisez pas System.out.println() — utilisez des assertions
✅ Exécutez vos tests souvent pendant le développement