Aller au contenu principal

Chapitre 2: Tests Unitaires avec JUnit 5

Introduction​

JUnit 5 est le framework de test standard pour Java. C'est la base de tous vos tests Spring Boot. Ce chapitre vous apprend à l'utiliser efficacement.

🎯 Objectifs du Chapitre​

À la fin de ce chapitre, vous saurez:

  1. ✅ Utiliser les annotations JUnit 5
  2. ✅ Écrire des assertions claires
  3. ✅ Tester les exceptions
  4. ✅ Créer des tests paramétrés
  5. ✅ Gérer le cycle de vie des tests

1. Structure d'un Test​

Anatomie de Base​

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

class CalculatorTest {

    @Test  // ← Indique une méthode de test
    void shouldAddTwoNumbers() {
        // Arrange (Préparer)
        Calculator calc = new Calculator();
        
        // Act (Exécuter)
        int result = calc.add(2, 3);
        
        // Assert (Vérifier)
        assertEquals(5, result);
    }
}

Conventions​

class ProductServiceTest {  // ← Nom: ClasseTestée + Test
    
    @Test
    void shouldReturnProductById() {  // ← Méthode descriptive
        // ...
    }
    
    @Test
    void shouldThrowExceptionWhenProductNotFound() {
        // ...
    }
}

2. Annotations Principales​

@Test​

import org.junit.jupiter.api.Test;

@Test
void simpleTest() {
    assertTrue(1 + 1 == 2);
}

@DisplayName​

@Test
@DisplayName("Devrait calculer le prix TTC avec TVA 20%")
void shouldCalculatePriceWithVAT() {
    double result = priceService.calculateWithVAT(100.0, 0.20);
    assertEquals(120.0, result);
}

@Disabled​

@Test
@Disabled("En attente de fix du bug #123")
void brokenTest() {
    // Ce test sera ignoré
}

@BeforeEach et @AfterEach​

class ProductServiceTest {
    
    private ProductService productService;
    
    @BeforeEach
    void setUp() {
        // Exécuté AVANT chaque test
        productService = new ProductService();
    }
    
    @AfterEach
    void tearDown() {
        // Exécuté APRÈS chaque test (nettoyage)
        productService = null;
    }
    
    @Test
    void test1() { /* productService est frais */ }
    
    @Test
    void test2() { /* productService est frais */ }
}

@BeforeAll et @AfterAll​

class DatabaseTest {
    
    @BeforeAll
    static void setUpAll() {
        // Exécuté UNE FOIS avant tous les tests
        // Doit être static!
        System.out.println("Initialisation globale...");
    }
    
    @AfterAll
    static void tearDownAll() {
        // Exécuté UNE FOIS après tous les tests
        System.out.println("Nettoyage global...");
    }
}

Ordre d'Exécution​

@BeforeAll (1 fois)
│
├── @BeforeEach
│   └── @Test test1()
│   └── @AfterEach
│
├── @BeforeEach
│   └── @Test test2()
│   └── @AfterEach
│
└── @AfterAll (1 fois)

3. Assertions​

Assertions de Base​

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

@Test
void demonstrateAssertions() {
    // Égalité
    assertEquals(5, calculator.add(2, 3));
    assertEquals("Hello", greeting.getMessage());
    assertEquals(3.14, Math.PI, 0.01);  // Avec delta pour double
    
    // Booléens
    assertTrue(user.isActive());
    assertFalse(list.isEmpty());
    
    // Null
    assertNull(optionalValue.orElse(null));
    assertNotNull(service.findById(1L));
    
    // Références
    assertSame(expected, actual);      // Même objet
    assertNotSame(obj1, obj2);         // Objets différents
}

Assertions sur Collections​

@Test
void testCollections() {
    List<String> fruits = List.of("Apple", "Banana", "Cherry");
    
    // Taille
    assertEquals(3, fruits.size());
    
    // Contenu
    assertTrue(fruits.contains("Apple"));
    assertFalse(fruits.contains("Grape"));
    
    // Avec AssertJ (plus lisible)
    assertThat(fruits)
        .hasSize(3)
        .contains("Apple", "Banana")
        .doesNotContain("Grape")
        .startsWith("Apple")
        .endsWith("Cherry");
}

Messages Personnalisés​

@Test
void testWithMessage() {
    int age = user.getAge();
    
    assertTrue(age >= 18, "L'utilisateur doit être majeur");
    assertEquals(25, age, () -> "L'âge attendu était 25 mais était " + age);
}

assertAll (Assertions Groupées)​

@Test
void testUserProperties() {
    User user = new User("John", "john@email.com", 25);
    
    // Toutes les assertions sont exécutées, même si une échoue
    assertAll("User properties",
        () -> assertEquals("John", user.getName()),
        () -> assertEquals("john@email.com", user.getEmail()),
        () -> assertEquals(25, user.getAge()),
        () -> assertTrue(user.isActive())
    );
}

4. Tester les Exceptions​

assertThrows​

@Test
void shouldThrowExceptionWhenDividingByZero() {
    Calculator calc = new Calculator();
    
    // Vérifie que l'exception est lancée
    assertThrows(ArithmeticException.class, () -> {
        calc.divide(10, 0);
    });
}

@Test
void shouldThrowExceptionWithMessage() {
    // Capturer l'exception pour vérifier le message
    IllegalArgumentException exception = assertThrows(
        IllegalArgumentException.class,
        () -> userService.createUser(null)
    );
    
    assertEquals("Username cannot be null", exception.getMessage());
}

assertDoesNotThrow​

@Test
void shouldNotThrowException() {
    assertDoesNotThrow(() -> {
        userService.createUser("validUser");
    });
}

5. Tests Paramétrés​

@ParameterizedTest avec @ValueSource​

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

@ParameterizedTest
@ValueSource(strings = {"John", "Jane", "Bob"})
void shouldAcceptValidNames(String name) {
    assertTrue(validator.isValidName(name));
}

@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 4, 5})
void shouldBePositive(int number) {
    assertTrue(number > 0);
}

@CsvSource​

@ParameterizedTest
@CsvSource({
    "1, 1, 2",
    "2, 3, 5",
    "10, 20, 30",
    "-1, 1, 0"
})
void shouldAddNumbers(int a, int b, int expected) {
    assertEquals(expected, calculator.add(a, b));
}

@ParameterizedTest
@CsvSource({
    "john@email.com, true",
    "invalid-email, false",
    "test@domain.org, true",
    "'', false"
})
void shouldValidateEmail(String email, boolean expected) {
    assertEquals(expected, validator.isValidEmail(email));
}

@MethodSource​

@ParameterizedTest
@MethodSource("provideUsers")
void shouldValidateUser(User user, boolean expectedValid) {
    assertEquals(expectedValid, validator.isValid(user));
}

static Stream<Arguments> provideUsers() {
    return Stream.of(
        Arguments.of(new User("John", 25), true),
        Arguments.of(new User("", 25), false),
        Arguments.of(new User("Jane", -1), false),
        Arguments.of(new User("Bob", 18), true)
    );
}

@EnumSource​

@ParameterizedTest
@EnumSource(Status.class)
void shouldHandleAllStatuses(Status status) {
    assertDoesNotThrow(() -> processor.process(status));
}

@ParameterizedTest
@EnumSource(value = Status.class, names = {"ACTIVE", "PENDING"})
void shouldHandleActiveStatuses(Status status) {
    assertTrue(status == Status.ACTIVE || status == Status.PENDING);
}

6. Tests Conditionnels​

@EnabledOnOs / @DisabledOnOs​

@Test
@EnabledOnOs(OS.WINDOWS)
void windowsOnlyTest() {
    // Ne s'exécute que sur Windows
}

@Test
@DisabledOnOs(OS.MAC)
void notOnMacTest() {
    // Ne s'exécute pas sur Mac
}

@EnabledIfEnvironmentVariable​

@Test
@EnabledIfEnvironmentVariable(named = "ENV", matches = "dev")
void onlyInDevEnvironment() {
    // S'exécute seulement si ENV=dev
}

@EnabledIf​

@Test
@EnabledIf("customCondition")
void conditionalTest() {
    // ...
}

boolean customCondition() {
    return LocalTime.now().getHour() < 12;  // Matin seulement
}

7. Tests Imbriqués​

@Nested​

class UserServiceTest {

    @Nested
    @DisplayName("When creating a user")
    class CreateUser {
        
        @Test
        @DisplayName("should succeed with valid data")
        void shouldSucceedWithValidData() {
            User user = userService.create("John", "john@email.com");
            assertNotNull(user.getId());
        }
        
        @Test
        @DisplayName("should fail with empty name")
        void shouldFailWithEmptyName() {
            assertThrows(ValidationException.class, 
                () -> userService.create("", "john@email.com"));
        }
    }
    
    @Nested
    @DisplayName("When deleting a user")
    class DeleteUser {
        
        @Test
        @DisplayName("should remove from database")
        void shouldRemoveFromDatabase() {
            userService.delete(1L);
            assertFalse(userService.exists(1L));
        }
    }
}

Affichage dans l'IDE​

UserServiceTest
├── When creating a user
│   ├── ✓ should succeed with valid data
│   └── ✓ should fail with empty name
└── When deleting a user
    └── ✓ should remove from database

8. Timeouts​

@Timeout​

@Test
@Timeout(5)  // Échoue si plus de 5 secondes
void shouldCompleteQuickly() {
    // ...
}

@Test
@Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
void shouldCompleteVeryQuickly() {
    // ...
}

assertTimeout​

@Test
void shouldCompleteInTime() {
    assertTimeout(Duration.ofSeconds(2), () -> {
        // Code qui doit s'exécuter en moins de 2s
        Thread.sleep(1000);
    });
}

9. AssertJ (Recommandé)​

AssertJ offre une syntaxe plus fluide et lisible:

import static org.assertj.core.api.Assertions.*;

@Test
void demonstrateAssertJ() {
    // Chaînes
    assertThat("Hello World")
        .startsWith("Hello")
        .endsWith("World")
        .contains("lo Wo")
        .hasSize(11);
    
    // Nombres
    assertThat(42)
        .isPositive()
        .isGreaterThan(40)
        .isBetween(40, 50);
    
    // Collections
    assertThat(List.of("a", "b", "c"))
        .hasSize(3)
        .contains("a", "b")
        .doesNotContain("d")
        .containsExactly("a", "b", "c");
    
    // Objets
    assertThat(user)
        .isNotNull()
        .hasFieldOrPropertyWithValue("name", "John")
        .extracting(User::getEmail)
        .isEqualTo("john@email.com");
    
    // Exceptions
    assertThatThrownBy(() -> service.riskyMethod())
        .isInstanceOf(RuntimeException.class)
        .hasMessageContaining("error");
}

10. Résumé​

Annotations Clés​

AnnotationDescription
@TestMarque une méthode de test
@BeforeEachAvant chaque test
@AfterEachAprès chaque test
@BeforeAllAvant tous les tests (static)
@AfterAllAprès tous les tests (static)
@DisplayNameNom lisible pour le test
@DisabledDésactive le test
@ParameterizedTestTest avec plusieurs valeurs
@NestedGroupe de tests imbriqué

Assertions Essentielles​

assertEquals(expected, actual);
assertTrue(condition);
assertFalse(condition);
assertNull(value);
assertNotNull(value);
assertThrows(Exception.class, () -> ...);
assertAll("group", () -> ..., () -> ...);

Pattern de Test​

@Test
void should_ExpectedBehavior_When_Condition() {
    // Arrange
    // ...
    
    // Act
    // ...
    
    // Assert
    // ...
}

🎯 Prochaine Étape​

JUnit 5 permet d'écrire des tests, mais comment tester une classe qui dépend d'autres classes? C'est là qu'intervient Mockito.

➡️ Chapitre 3: Mocking avec Mockito

⬅️ Retour au Module 9