Test des exceptions

Objectifs du chapitre :

• Apprendre à tester les exceptions dans les tests unitaires.
• Utiliser l'annotation @Test(expected = Exception.class) pour vérifier qu'une exception est lancée.
• Effectuer des assertions sur les messages d'erreur pour valider les détails des exceptions.

8.1 Introduction au test des exceptions

Les exceptions sont des événements anormaux qui peuvent se produire pendant l'exécution d'un programme. Il est crucial de tester que votre code gère correctement ces situations en lançant les exceptions appropriées. Tester les exceptions dans les tests unitaires permet de s'assurer que votre code se comporte comme prévu en cas d'erreurs.

8.2 Utilisation de l'annotation @Test(expected = Exception.class)

En JUnit 4, vous pouvez utiliser l'annotation @Test avec le paramètre expected pour vérifier qu'une méthode lance une exception spécifique.

Exemple :

Classe à tester (Calculator.java) :

public class Calculator {
    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division by zero is not allowed.");
        }
        return a / b;
    }
}

Classe de test (CalculatorTest.java) :

import org.junit.Test;

public class CalculatorTest {

    @Test(expected = IllegalArgumentException.class)
    public void testDivideByZero() {
        Calculator calculator = new Calculator();
        calculator.divide(1, 0);
    }
}

Dans cet exemple, le test réussira si la méthode divide lance une IllegalArgumentException lorsque le diviseur est zéro.

8.3 Utilisation de assertThrows en JUnit 5

JUnit 5 introduit une manière plus flexible de tester les exceptions en utilisant la méthode assertThrows. Cette méthode permet de capturer l'exception et de vérifier ses détails, comme le message d'erreur.

Exemple :

Classe à tester (Calculator.java) :

public class Calculator {
    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division by zero is not allowed.");
        }
        return a / b;
    }
}

Classe de test (CalculatorTest.java) :

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

public class CalculatorTest {

    @Test
    void testDivideByZero() {
        Calculator calculator = new Calculator();
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
            calculator.divide(1, 0);
        });
        assertEquals("Division by zero is not allowed.", exception.getMessage());
    }
}

Dans cet exemple, assertThrows vérifie qu'une IllegalArgumentException est lancée et capture l'exception pour permettre des assertions supplémentaires, comme vérifier le message d'erreur.

8.4 Assertions sur les messages d'erreur

Lors de la capture d'une exception avec assertThrows, vous pouvez vérifier que le message d'erreur est correct, ce qui est souvent essentiel pour valider que l'exception est lancée pour les bonnes raisons.

Exemple détaillé :

Classe à tester (User.java) :

public class User {
    private String username;

    public void setUsername(String username) {
        if (username == null || username.isEmpty()) {
            throw new IllegalArgumentException("Username cannot be null or empty.");
        }
        this.username = username;
    }
}

Classe de test (UserTest.java) :

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

public class UserTest {

    @Test
    void testSetUsernameWithNull() {
        User user = new User();
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
            user.setUsername(null);
        });
        assertEquals("Username cannot be null or empty.", exception.getMessage());
    }

    @Test
    void testSetUsernameWithEmptyString() {
        User user = new User();
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
            user.setUsername("");
        });
        assertEquals("Username cannot be null or empty.", exception.getMessage());
    }
}

Dans ces exemples, les tests vérifient non seulement que l'exception correcte est lancée, mais aussi que le message d'erreur est conforme aux attentes, garantissant ainsi que les validations dans la méthode setUsername sont correctement implémentées.

Résumé du chapitre :

• Tester les exceptions est crucial pour s'assurer que le code gère correctement les situations anormales.
• En JUnit 4, l'annotation @Test(expected = Exception.class) permet de vérifier qu'une méthode lance une exception spécifique.
• JUnit 5 offre une méthode plus flexible avec assertThrows, permettant de capturer et de vérifier les détails de l'exception, y compris le message d'erreur.
• Les assertions sur les messages d'erreur garantissent que les exceptions sont lancées pour les bonnes raisons.