Ich benutze Mockito in einem Junit-Test. Wie kann man eine Ausnahme auslösen und dann behaupten, dass sie vorliegt (generischer Pseudocode)?

BDD Style Solution (auf Java 8 aktualisiert)

Mockito allein ist nicht die beste Lösung für die Behandlung von Ausnahmen. Verwenden Sie Mockito mit Catch-Exception

Mockito + Catch-Exception + AssertJ

given(otherServiceMock.bar()).willThrow(new MyException());

when(() -> myService.foo());

then(caughtException()).isInstanceOf(MyException.class);

Beispielcode

• Mockito + Catch-Exception + Assertj vollständige Probe

Abhängigkeiten

• eu.codearte.catch-Ausnahme: catch-Ausnahme: 2.0
• org.assertj: assertj-core: 3.12.2

Um Ihre zweite Frage zuerst zu beantworten. Wenn Sie JUnit 4 verwenden, können Sie Ihren Test mit Anmerkungen versehen

@Test(expected=MyException.class)

zu behaupten, dass eine Ausnahme aufgetreten ist. Und um eine Ausnahme mit Mockito zu "verspotten", verwenden Sie

when(myMock.doSomething()).thenThrow(new MyException());

Wenn Sie auch die Ausnahmemeldung testen möchten, können Sie die ExpectedException von JUnit mit Mockito verwenden:

@Rule
public ExpectedException expectedException = ExpectedException.none();

@Test
public void testExceptionMessage() throws Exception {
    expectedException.expect(AnyException.class);
    expectedException.expectMessage("The expected message");

    given(foo.bar()).willThrow(new AnyException("The expected message"));
}

Aktualisierte Antwort für den 19.06.2015 (wenn Sie Java 8 verwenden)

Verwenden Sie einfach assertj

Verwenden von assertj-core-3.0.0 + Java 8 Lambdas

@Test
public void shouldThrowIllegalArgumentExceptionWhenPassingBadArg() {
assertThatThrownBy(() -> myService.sumTingWong("badArg"))
                                  .isInstanceOf(IllegalArgumentException.class);
}

Referenz: http://blog.codeleak.pl/2015/04/junit-testing-exceptions-with-java-8.html

Wenn Sie JUnit 4 und Mockito 1.10.x verwenden, kommentieren Sie Ihre Testmethode mit:

@Test(expected = AnyException.class)

und um Ihre gewünschte Ausnahme zu werfen, verwenden Sie:

Mockito.doThrow(new AnyException()).when(obj).callAnyMethod();

Machen Sie die Ausnahme so:

when(obj.someMethod()).thenThrow(new AnException());

Stellen Sie sicher, dass dies geschehen ist, indem Sie behaupten, dass Ihr Test eine solche Ausnahme auslöst:

@Test(expected = AnException.class)

Oder durch normale Scheinüberprüfung:

verify(obj).someMethod();

Die letztere Option ist erforderlich, wenn Ihr Test beweisen soll, dass Zwischencode die Ausnahme behandelt (dh die Ausnahme wird von Ihrer Testmethode nicht ausgelöst).

Verwenden Sie Mockitos doThrow und fangen Sie dann die gewünschte Ausnahme ab, um zu bestätigen, dass sie später ausgelöst wurde.

@Test
public void fooShouldThrowMyException() {
    // given
    val myClass = new MyClass();
    val arg = mock(MyArgument.class);
    doThrow(MyException.class).when(arg).argMethod(any());
    Exception exception = null;

    // when
    try {
        myClass.foo(arg);
    } catch (MyException t) {
        exception = t;
    }

    // then
    assertNotNull(exception);
}

Mit mockito können Sie die Ausnahme auslösen.

when(testingClassObj.testSomeMethod).thenThrow(new CustomException());

Junit5 verwenden, können Sie Ausnahme geltend machen, behauptet , ob die Ausnahme ausgelöst wird , wenn Verfahren Prüfung aufgerufen wird.

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

Hier finden Sie ein Beispiel: Assert Exception Junit

Unabhängig von Mockito kann man die Ausnahme abfangen und ihre Eigenschaften geltend machen. Um zu überprüfen, ob die Ausnahme aufgetreten ist, setzen Sie nach der Anweisung, die die Ausnahme auslöst, eine falsche Bedingung im try-Block.

Oder wenn Ihre Ausnahme vom Konstruktor einer Klasse ausgelöst wird:

@Rule
public ExpectedException exception = ExpectedException.none();

@Test
public void myTest() {    

    exception.expect(MyException.class);
    CustomClass myClass= mock(CustomClass.class);
    doThrow(new MyException("constructor failed")).when(myClass);  

}

Durch Ausnahmemeldung bestätigen:

    try {
        MyAgent.getNameByNode("d");
    } catch (Exception e) {
        Assert.assertEquals("Failed to fetch data.", e.getMessage());
    }