JUnit 5: Wie wird eine Ausnahme ausgelöst?

Gibt es eine bessere Möglichkeit zu behaupten, dass eine Methode in JUnit 5 eine Ausnahme auslöst?

Derzeit muss ich eine @Rule verwenden, um zu überprüfen, ob mein Test eine Ausnahme auslöst. Dies funktioniert jedoch nicht in den Fällen, in denen ich erwarte, dass mehrere Methoden Ausnahmen in meinem Test auslösen.

Sie können verwenden assertThrows(), um mehrere Ausnahmen innerhalb desselben Tests zu testen. Mit der Unterstützung von Lambdas in Java 8 ist dies die kanonische Methode zum Testen auf Ausnahmen in JUnit.

Gemäß den JUnit-Dokumenten :

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

In Java 8 und JUnit 5 (Jupiter) können wir Ausnahmen wie folgt geltend machen. Verwenden vonorg.junit.jupiter.api.Assertions.assertThrows

public static <T erweitert Throwable> T assertThrows (Klasse <T> expectedType, ausführbare ausführbare Datei)

Gibt an, dass die Ausführung der angegebenen ausführbaren Datei eine Ausnahme des erwarteten Typs auslöst und die Ausnahme zurückgibt.

Wenn keine Ausnahme ausgelöst wird oder wenn eine Ausnahme eines anderen Typs ausgelöst wird, schlägt diese Methode fehl.

Wenn Sie keine zusätzlichen Überprüfungen für die Ausnahmeinstanz durchführen möchten, ignorieren Sie einfach den Rückgabewert.

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

Dieser Ansatz verwendet die Funktionsschnittstelle Executablein org.junit.jupiter.api.

Verweisen :

• 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. Ausführbar-

Sie haben es in JUnit 5 geändert (erwartet: InvalidArgumentException, tatsächliche: aufgerufene Methode) und der Code sieht folgendermaßen aus:

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

Jetzt bietet Junit5 eine Möglichkeit, die Ausnahmen geltend zu machen

Sie können sowohl allgemeine als auch benutzerdefinierte Ausnahmen testen

Ein allgemeines Ausnahmeszenario:

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

Ein Beispiel zum Testen von CustomException finden Sie hier: Beispiel für einen Ausnahmecode

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

Ich denke, das ist ein noch einfacheres Beispiel

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

Wenn Sie get()ein optionales Element mit einem Leerzeichen ArrayListaufrufen, wird a ausgelöst NoSuchElementException. assertThrowsdeklariert die erwartete Ausnahme und stellt einen Lambda-Lieferanten bereit (nimmt keine Argumente entgegen und gibt einen Wert zurück).

Vielen Dank an @prime für seine Antwort, die ich hoffentlich ausgearbeitet habe.

Sie können verwenden assertThrows(). Mein Beispiel stammt aus den Dokumenten 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());
}

Ein noch einfacherer Einzeiler. Für dieses Beispiel sind unter Verwendung von Java 8 und JUnit 5 keine Lambda-Ausdrücke oder geschweiften Klammern erforderlich

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

Eigentlich denke ich, dass es einen Fehler in der Dokumentation für dieses spezielle Beispiel gibt. Die beabsichtigte Methode ist expectedThrows

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

Hier ist ein einfacher Weg.

@Test
void exceptionTest() {

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

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

}

Dies ist nur erfolgreich, wenn die erwartete Ausnahme ausgelöst wird.