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

Existe-t-il un meilleur moyen d’affirmer qu’une méthode génère une exception dans JUnit 5?

Actuellement, je dois utiliser une règle @ afin de vérifier que mon test génère une exception, mais cela ne fonctionne pas dans les cas où plusieurs méthodes sont susceptibles de générer des exceptions dans mon test.

    Vous pouvez utiliser assertThrows() , qui vous permet de tester plusieurs exceptions dans le même test. Avec le support de lambdas dans Java 8, cela va probablement devenir le moyen canonique de tester les exceptions dans JUnit.

    Selon les documents de JUnit :

     import static org.junit.jupiter.api.Assertions.assertThrows; ... @Test void exceptionTesting() { Executable closureContainingCodeToTest = () -> throw new IllegalArgumentException("a message"); assertThrows(IllegalArgumentException.class, closureContainingCodeToTest, "a message"); } 

    Dans Java 8 et JUnit 5 (Jupiter), nous pouvons affirmer des exceptions comme suit. Utiliser org.junit.jupiter.api.Assertions.assertThrows

    public static T assertThrows (classe expectedType, 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 échoue.

    Si vous ne souhaitez pas effectuer de vérifications supplémentaires sur l’instance d’exception, ignorez simplement la valeur renvoyée.

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

    Cette approche utilisera l’ Executable interface fonctionnelle dans org.junit.jupiter.api .

    Référer :

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

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

    Maintenant, Junit5 permet d’affirmer les exceptions

    Vous pouvez tester 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("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 un exemple de code d’exception

    ExpectCustomException.java

     public Ssortingng constructErrorMessage(Ssortingng... args) throws InvalidParameterCountException { if(args.length!=3) { throw new InvalidParameterCountException("Invalid parametercount: expected=3, passed="+args.length); }else { Ssortingng message = ""; for(Ssortingng 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 emptyList = new ArrayList<>(); Optional opt2 = emptyList.stream().findFirst(); assertThrows(NoSuchElementException.class, () -> opt2.get()); 

    L’appel de get() sur une option contenant un ArrayList vide lancera une NoSuchElementException . assertThrows dé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 élaboré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()); } 

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

     public static void assertThrows( public static  T expectThrows( 

    Voici un moyen facile.

     @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 attendue est lancée.