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

Existe-t-il une meilleure façon d'affirmer qu'une méthode lève une exception dans JUnit 5?

Actuellement, je dois utiliser une @Rule afin de vérifier que mon test lève une exception, mais cela ne fonctionne pas dans les cas où je m'attends à ce que plusieurs méthodes lèvent des exceptions dans mon test.

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

Selon les documents 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().contains("Stuff"));
}

En Java 8 et JUnit 5 (Jupiter), nous pouvons affirmer les exceptions comme suit. En utilisantorg.junit.jupiter.api.Assertions.assertThrows

public statique <T étend Throwable> T assertThrows (Class <T> attenduType, exécutable exécutable)

Affirme que l'exécution de l'exécutable fourni lève une exception du type attendu et renvoie l'exception.

Si aucune exception n'est levé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 d'exception, ignorez simplement la valeur de retour.

@Test
public void itShouldThrowNullPointerExceptionWhenBlahBlah() {
    assertThrows(NullPointerException.class,
            ()->{
            //do whatever you want to do here
            //ex : objectName.thisMethodShoulThrowNullPointerExceptionForNullParameter(null);
            });
}

Cette approche utilisera l'interface fonctionnelle Executabledans org.junit.jupiter.api.

Référer :

• 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. Exécutable-

Ils l'ont changé dans JUnit 5 (attendu: InvalidArgumentException, actual: méthode invoquée) et le code ressemble à celui-ci:

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

Maintenant Junit5 fournit un moyen d'affirmer les exceptions

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

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

ExpectGeneralException.java

public void validateParameters(Integer param ) {
    if (param == null) {
        throw new NullPointerException("Null parameters are not allowed");
    }
}

ExpectGeneralExceptionTest.java

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

     NullPointerException exception = assertThrows(NullPointerException.class, () -> {
            generalEx.validateParameters(null);
        });
    assertEquals("Null parameters are not allowed", exception.getMessage());
}

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

ExpectCustomException.java

public String constructErrorMessage(String... args) throws InvalidParameterCountException {
    if(args.length!=3) {
        throw new InvalidParameterCountException("Invalid parametercount: expected=3, passed="+args.length);
    }else {
        String message = "";
        for(String arg: args) {
            message += arg;
        }
        return message;
    }
}

ExpectCustomExceptionTest.java

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

     InvalidParameterCountException exception = assertThrows(InvalidParameterCountException.class, () -> {
            expectEx.constructErrorMessage("sample ","error");
        });
    assertEquals("Invalid parametercount: expected=3, passed=2", exception.getMessage());
}

Je pense que c'est un exemple encore plus simple

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

Faire appel get()à une option contenant un vide ArrayListlancera un NoSuchElementException. assertThrowsdéclare l'exception attendue et fournit un fournisseur lambda (ne prend aucun argument et renvoie une valeur).

Merci à @prime pour sa réponse que j'espère avoir développée.

Vous pouvez utiliser assertThrows(). Mon exemple est tiré de la documentation http://junit.org/junit5/docs/current/user-guide/

import org.junit.jupiter.api.Test;

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

....

@Test
void exceptionTesting() {
    Throwable exception = assertThrows(IllegalArgumentException.class, () -> {
        throw new IllegalArgumentException("a message");
    });
    assertEquals("a message", exception.getMessage());
}

Une doublure encore plus simple. Aucune expression lambda ou accolade n'est requise pour cet exemple utilisant Java 8 et JUnit 5

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

@Test
void exceptionTesting() {

    assertThrows(MyException.class, myStackObject::doStackAction, "custom message if assertion fails..."); 

// note, no parenthesis on doStackAction ex ::pop NOT ::pop()
}

En fait, je pense qu'il y a une erreur dans la documentation de cet exemple particulier. La méthode prévue est expectThrows

public static void assertThrows(
public static <T extends Throwable> T expectThrows(

Voici un moyen simple.

@Test
void exceptionTest() {

   try{
        model.someMethod("invalidInput");
        fail("Exception Expected!");
   }
   catch(SpecificException e){

        assertTrue(true);
   }
   catch(Exception e){
        fail("wrong exception thrown");
   }

}

Il ne réussit que lorsque l'exception que vous attendez est levée.