JUnit 5 : Comment vérifier qu'une exception est levée ?

Question

Existe-t-il un meilleur moyen d'affirmer qu'une méthode lance une exception dans JUnit 5?

Actuellement, je dois utiliser une @Rule pour vérifier que mon test lance une exception, mais cela ne fonctionne pas pour les cas où je m'attends à ce que plusieurs méthodes lancent des exceptions dans mon test.

Answer 1

Vous pouvez utiliser assertThrows(), qui vous permet de tester plusieurs exceptions dans le même test. Avec le support des lambda en Java 8, c'est la manière canonique de tester les exceptions dans JUnit.

Selon la documentation de JUnit:

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

@Test
void exceptionTesting() {
    MyException thrown = assertThrows(
           MyException.class,
           () -> myObject.doThing(),
           "Expected doThing() to throw, but it didn't"
    );

    assertTrue(thrown.getMessage().contentEquals("Stuff"));
}

Answer 2

En Java 8 et JUnit 5 (Jupiter), nous pouvons faire des assertions pour les exceptions comme suit. Utilisation de org.junit.jupiter.api.Assertions.assertThrows

public static < T extends Throwable > T assertThrows(Class< T > expectedType, Executable executable)

Asserte que l'exécution de l'exécutable fourni lance une exception du expectedType et retourne l'exception.

Si aucune exception n'est lancée, ou si une exception d'un type différent est levée, cette méthode échouera.

Si vous ne souhaitez pas effectuer de vérifications supplémentaires sur l'instance de l'exception, ignorez simplement la valeur de retour.

@Test
public void itShouldThrowNullPointerExceptionWhenBlahBlah() {
    assertThrows(NullPointerException.class,
            ()->{
            //faites ce que vous voulez faire ici
            //ex : objectName.thisMethodShoulThrowNullPointerExceptionForNullParameter(null);
            });
}

Cette approche utilisera l'Interface Fonctionnelle Executable dans org.junit.jupiter.api.

Référence :

• http://junit.org/junit5/docs/current/user-guide/#writing-tests-assertions
• http://junit.org/junit5/docs/5.0.0-M2/api/org/junit/jupiter/api/Executable.html
• http://junit.org/junit5/docs/5.0.0-M4/api/org/junit/jupiter/api/Assertions.html#assertThrows-java.lang.Class-org.junit.jupiter.api.function.Executable-

Answer 3

Ils l'ont changé dans JUnit 5 (attendu : InvalidArgumentException, réel : méthode invoquée) et le code ressemble à ceci :

@Test
public void mauvaiseEntrée() {
    Throwable exception = assertThrows(InvalidArgumentException.class,
            ()->{objectName.yourMethod("WRONG");} );
}

Answer 4

Maintenant, Junit5 fournit une façon de vérifier les exceptions

Vous pouvez tester à la fois les exceptions générales et les exceptions personnalisées

Un scénario d'exception générale:

ExpectGeneralException.java

public void validateParameters(Integer param ) {
    if (param == null) {
        throw new NullPointerException("Les paramètres nuls ne sont pas autorisés");
    }
}

ExpectGeneralExceptionTest.java

@Test
@DisplayName("Test d'assertion NullPointerException")
void testGeneralException(TestInfo testInfo) {
    final ExpectGeneralException generalEx = new ExpectGeneralException();

     NullPointerException exception = assertThrows(NullPointerException.class, () -> {
            generalEx.validateParameters(null);
        });
    assertEquals("Les paramètres nuls ne sont pas autorisés", exception.getMessage());
}

Vous pouvez trouver un exemple pour tester CustomException ici : exemple de code d'exception

ExpectCustomException.java

public String constructErrorMessage(String... args) throws InvalidParameterCountException {
    if(args.length!=3) {
        throw new InvalidParameterCountException("Compteur de paramètres invalide : attendu=3, passé="+args.length);
    }else {
        String message = "";
        for(String arg: args) {
            message += arg;
        }
        return message;
    }
}

ExpectCustomExceptionTest.java

@Test
@DisplayName("Test d'assertion d'exception")
void testCustomException(TestInfo testInfo) {
    final ExpectCustomException expectEx = new ExpectCustomException();

     InvalidParameterCountException exception = assertThrows(InvalidParameterCountException.class, () -> {
            expectEx.constructErrorMessage("exemple ","erreur");
        });
    assertEquals("Compteur de paramètres invalide : attendu=3, passé=2", exception.getMessage());
}

Answer 5

Je pense que c'est un exemple encore plus simple

List emptyList = new ArrayList<>();
Optional opt2 = emptyList.stream().findFirst();
assertThrows(NoSuchElementException.class, () -> opt2.get());

Appeler get() sur un facultatif contenant une ArrayList vide lancera une NoSuchElementException. assertThrows déclare l'exception attendue et fournit un fournisseur lambda (ne prend pas d'arguments et renvoie une valeur).

Merci à @prime pour sa réponse sur laquelle j'ai espérons-le, élaboré.