Test en Java : frameworks et outils (JUnit, TestNG, Mockito)

Test en Java : aperçu des frameworks et outils

Un test de qualité est une partie essentielle du développement en Java. Les frameworks modernes permettent d'automatiser la vérification du code, de détecter les erreurs à un stade précoce et d'assurer la stabilité de l'application. Dans cet article, nous examinerons les outils clés pour les tests unitaires, le mocking et les tests d'intégration en Java, et nous fournirons des exemples pratiques de leur utilisation.

1. JUnit 5 — le standard des tests unitaires

JUnit 5 (Jupiter) est le framework le plus populaire pour les tests modulaires en Java. Il fournit des annotations pour définir des méthodes de test, gérer le cycle de vie et la paramétrisation.

Annotations principales de JUnit 5 :

• @Test — désigne une méthode de test
• @BeforeEach / @AfterEach — exécutées avant/après chaque test
• @BeforeAll / @AfterAll — exécutées une fois pour toute la classe
• @ParameterizedTest — pour les tests avec différentes données d'entrée

Exemple d'un test simple :

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

public class CalculatorTest {

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

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

2. TestNG — une alternative avec des fonctionnalités avancées

TestNG (Test Next Generation) est un autre framework puissant, inspiré de JUnit, mais offrant des fonctionnalités supplémentaires : regroupement de tests, tests dépendants, exécution parallèle et configurations flexibles via XML.

Caractéristiques distinctives de TestNG :

• @Test(groups = {"smoke"}) — regroupement de tests
• @DataProvider — transmission de données aux tests
• @Test(dependsOnMethods = {"methodA"}) — dépendances entre tests

Exemple avec DataProvider :

import org.testng.annotations.DataProvider;import org.testng.annotations.Test;import static org.testng.Assert.assertEquals;

public class DataDrivenTest {

    @DataProvider(name = "testData")    public Object[][] createData() {        return new Object[][] {            { 1, 2, 3 },            { 5, -3, 2 },            { 0, 0, 0 }        };    }

    @Test(dataProvider = "testData")    public void testAdd(int a, int b, int expected) {        Calculator calc = new Calculator();        assertEquals(calc.add(a, b), expected);    }}

3. Mockito — création de bouchons (mocks)

Mockito est une bibliothèque pour créer des objets mock en Java. Elle permet d'isoler le composant testé de ses dépendances (base de données, services externes) et de vérifier les interactions entre les objets.

Fonctionnalités principales de Mockito :

• mock() — création d'un objet mock
• when().thenReturn() — définition du comportement
• verify() — vérification des appels de méthodes
• @Mock et @InjectMocks — injection automatique des mocks

Exemple d'utilisation de Mockito :

import static org.mockito.Mockito.*;import org.junit.jupiter.api.Test;

public class UserServiceTest {

    @Test    void testGetUser() {        // Création d'un mock pour le repository        UserRepository mockRepo = mock(UserRepository.class);        when(mockRepo.findById(1L)).thenReturn(new User("Alice"));

        UserService service = new UserService(mockRepo);        User user = service.getUser(1L);

        assertEquals("Alice", user.getName());        verify(mock