JUnit 5: ¿Cómo afirmar que se lanza una excepción?

¿Existe una mejor manera de afirmar que un método genera una excepción en JUnit 5?

Actualmente, tengo que usar una @Rule para verificar que mi prueba arroja una excepción, pero esto no funciona para los casos en los que espero que varios métodos arrojen excepciones en mi prueba.

Puede utilizar assertThrows(), que le permite probar varias excepciones dentro de la misma prueba. Con soporte para lambdas en Java 8, esta es la forma canónica de probar excepciones en JUnit.

Según los documentos 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().contains("Stuff"));
}

En Java 8 y JUnit 5 (Jupiter) podemos afirmar excepciones de la siguiente manera. Utilizandoorg.junit.jupiter.api.Assertions.assertThrows

public static <T extiende Throwable> T assertThrows (Class <T> esperabaTipo, ejecutable ejecutable)

Afirma que la ejecución del ejecutable suministrado genera una excepción del tipo esperado y devuelve la excepción.

Si no se lanza ninguna excepción, o si se lanza una excepción de un tipo diferente, este método fallará.

Si no desea realizar comprobaciones adicionales en la instancia de excepción, simplemente ignore el valor de retorno.

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

Ese enfoque utilizará la interfaz funcional Executableen org.junit.jupiter.api.

Refiera:

• 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. Ejecutable-

Lo cambiaron en JUnit 5 (esperado: InvalidArgumentException, actual: método invocado) y el código se ve así:

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

Ahora Junit5 proporciona una forma de afirmar las excepciones

Puede probar tanto las excepciones generales como las personalizadas

Un escenario de excepción general:

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

Puede encontrar una muestra para probar CustomException aquí: ejemplo de código de aserción de excepción

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

Puede utilizar assertThrows(). Mi ejemplo está tomado de los 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());
}

Creo que este es un ejemplo aún más simple.

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

Llamar get()a un opcional que contiene un vacío ArrayListarrojará un NoSuchElementException. assertThrowsdeclara la excepción esperada y proporciona un proveedor lambda (no toma argumentos y devuelve un valor).

Gracias a @prime por su respuesta, que espero que desarrolle.

Un trazador de líneas aún más simple. No se requieren expresiones lambda ni llaves para este ejemplo usando Java 8 y 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()
}

De hecho, creo que hay un error en la documentación de este ejemplo en particular. El método que se pretende es esperar

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