JUnit 5: Como afirmar que uma exceção é lançada?

Existe uma maneira melhor de afirmar que um método lança uma exceção no JUnit 5?

Atualmente, tenho que usar uma @Rule para verificar se meu teste lança uma exceção, mas isso não funciona nos casos em que espero que vários métodos lançem exceções no meu teste.

Você pode usar assertThrows(), o que permite testar várias exceções no mesmo teste. Com suporte para lambdas no Java 8, esta é a maneira canônica de testar exceções no JUnit.

De acordo com os documentos da 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"));
}

No Java 8 e JUnit 5 (Jupiter), podemos afirmar exceções da seguinte maneira. Usandoorg.junit.jupiter.api.Assertions.assertThrows

estático público <T estende Throwable> T assertThrows (classe <T >pectedType, executável executável)

Indica que a execução do executável fornecido lança uma exceção do allowedType e retorna a exceção.

Se nenhuma exceção for lançada, ou se uma exceção de um tipo diferente for lançada, esse método falhará.

Se você não deseja executar verificações adicionais na instância de exceção, simplesmente ignore o valor de retorno.

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

Essa abordagem usará a interface funcional Executableno org.junit.jupiter.api.

Referir :

• 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. Executável-

Eles foram alterados no JUnit 5 (esperado: InvalidArgumentException, atual: método invocado) e o código se parece com este:

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

Agora o Junit5 fornece uma maneira de afirmar as exceções

Você pode testar exceções gerais e exceções personalizadas

Um cenário de exceção geral:

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());
}

Você pode encontrar uma amostra para testar a CustomException aqui: afirmar amostra de código de exceção

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());
}

Eu acho que este é um exemplo ainda mais simples

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

Chamar get()um opcional contendo um vazio ArrayListlançará a NoSuchElementException. assertThrowsdeclara a exceção esperada e fornece um fornecedor lambda (não aceita argumentos e retorna um valor).

Agradeço ao @prime por sua resposta na qual espero elaborar.

Você pode usar assertThrows(). Meu exemplo é retirado dos documentos 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());
}

Um forro ainda mais simples. Nenhuma expressão lambda ou chaveta necessária para este exemplo usando Java 8 e 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()
}

Na verdade, acho que há um erro na documentação deste exemplo em particular. O método pretendido é expectThrows

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

Aqui está uma maneira fácil.

@Test
void exceptionTest() {

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

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

}

Só é bem-sucedido quando a exceção que você espera é lançada.