JUnit 5: Wie wird eine Ausnahme ausgelöst?

Gibt es einen besseren Weg zu behaupten, dass eine Methode eine exception wirft in JUnit 5?

Derzeit, ich habe mit einer @ - Regel, um zu überprüfen, ob meine test wirft eine exception, aber das funktioniert nicht für die Fälle, in denen ich erwarte, dass mehrere Methoden zum auslösen von Ausnahmen in meinem test.

InformationsquelleAutor der Frage steventrouble | 2016-10-26

Können Sie assertThrows()die können Sie testen, mehrere Ausnahmen im gleichen test. Mit Unterstützung für Lambda-Ausdrücke in Java 8, das ist wahrscheinlich werde der übliche Weg, um test für Ausnahmen in JUnit.

Pro die JUnit-docs:

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

...

@Test
void exceptionTesting() {
    Executable closureContainingCodeToTest = () -> throw new IllegalArgumentException("a message");

    assertThrows(IllegalArgumentException.class, closureContainingCodeToTest, "a message");
}

InformationsquelleAutor der Antwort steventrouble

31

In Java 8 und JUnit-5 (Jupiter) können wir behaupten Ausnahmen wie folgt.
Mit org.junit.jupiter.api.Assertions.assertThrows

public static < T extends Throwable - > T assertThrows(Klasse< T > expectedType,
Ausführbare Datei bei ausführbaren)

Behauptet, dass die Ausführung der gelieferten ausführbaren wirft eine Ausnahme von der expectedType und gibt die Ausnahme.

Wenn keine Ausnahme geworfen wird, oder wenn eine Ausnahme von einer anderen Art ausgelöst wird, wird diese Methode scheitern wird.

Wenn Sie nicht wollen, um weitere Prüfungen durchführen, die auf die exception-Instanz, ignorieren Sie einfach die return-Wert.
```
@Test
public void itShouldThrowNullPointerExceptionWhenBlahBlah() {
    assertThrows(NullPointerException.class,
            ()->{
            //do whatever you want to do here
            //ex : objectName.thisMethodShoulThrowNullPointerExceptionForNullParameter(null);
            });
}
```
Diesem Ansatz werden die Funktionalen Schnittstelle Executable im org.junit.jupiter.api.

Finden :
InformationsquelleAutor der Antwort prime

Haben Sie es geändert in JUnit-5 (erwartet: InvalidArgumentException, aktuell: aufgerufene Methode) und der code sieht wie folgt aus:

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

InformationsquelleAutor der Antwort jstar

Nun Junit5 bietet eine Möglichkeit zur Geltendmachung der Ausnahmen

Können Sie testen, sowohl auf Allgemeine Ausnahmen und individuelle Ausnahmen

Eine Allgemeine Ausnahme Szenario:

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

Finden Sie eine Probe, um zu testen CustomException hier : assert-exception code Beispiel

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

InformationsquelleAutor der Antwort Anupama Boorlagadda

5

Ich denke, das ist ein noch einfacheres Beispiel
```
List<String> emptyList = new ArrayList<>();
Optional<String> opt2 = emptyList.stream().findFirst();
assertThrows(NoSuchElementException.class, () -> opt2.get());
```
Aufrufen get() auf eine optional mit einem leeren ArrayList werfen wird NoSuchElementException. assertThrows erklärt die erwartete Ausnahme und bietet ein lambda-Lieferant (nimmt keine Argumente und gibt einen Wert zurück).

Dank @prime für seine Antwort, die ich hoffentlich erarbeitet.

InformationsquelleAutor der Antwort JesseBoyd

Können Sie assertThrows(). Mein Beispiel stammt aus der Dokumentation 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());
}

InformationsquelleAutor der Antwort Will Humphreys

1

Eigentlich denke ich, es ist ein Fehler in der Dokumentation für dieses Beispiel. Die Methode, die vorgesehen ist, expectThrows
```
public static void assertThrows(
public static <T extends Throwable> T expectThrows(
```
InformationsquelleAutor der Antwort Peter Isberg

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

}

Es gelingt nur, wenn der Ausnahme, die Sie erwarten, ist geworfen.

InformationsquelleAutor der Antwort kiwicomb123

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.