J'utilise mockito dans un test junit. Comment faire pour qu'une exception se produise et ensuite affirmer qu'elle a (pseudo-code générique)

Solution de style BDD (mise à jour vers Java 8)

Mockito seul n'est pas la meilleure solution pour gérer les exceptions, utilisez Mockito avec Catch-Exception

Mockito + Catch-Exception + AssertJ

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

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

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

Exemple de code

• Mockito + Catch-Exception + Assertj échantillon complet

Dépendances

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

Pour répondre d'abord à votre deuxième question. Si vous utilisez JUnit 4, vous pouvez annoter votre test avec

@Test(expected=MyException.class)

pour affirmer qu'une exception s'est produite. Et pour "simuler" une exception avec mockito, utilisez

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

Si vous souhaitez également tester le message d'exception, vous pouvez utiliser ExpectedException de JUnit avec Mockito:

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

Réponse mise à jour pour le 19/06/2015 (si vous utilisez java 8)

Utilisez simplement assertj

Utilisation d'assertj-core-3.0.0 + Java 8 Lambdas

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

Référence: http://blog.codeleak.pl/2015/04/junit-testing-exceptions-with-java-8.html

Si vous utilisez JUnit 4 et Mockito 1.10.x Annotez votre méthode de test avec:

@Test(expected = AnyException.class)

et pour lancer votre exception, utilisez:

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

Faites que l'exception se produise comme ceci:

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

Vérifiez que cela s'est produit soit en affirmant que votre test lèvera une telle exception:

@Test(expected = AnException.class)

Ou par une vérification simulée normale:

verify(obj).someMethod();

Cette dernière option est requise si votre test est conçu pour prouver que le code intermédiaire gère l'exception (c'est-à-dire que l'exception ne sera pas levée depuis votre méthode de test).

Utilisez doThrow de Mockito , puis attrapez l'exception souhaitée pour affirmer qu'elle a été levée plus tard.

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

En utilisant mockito, vous pouvez faire en sorte que l'exception se produise.

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

En utilisant Junit5, vous pouvez affirmer une exception, affirmer si cette exception est levée lors de l' appel de la méthode de test .

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

Trouvez un exemple ici: assert exception junit

Sans rapport avec mockito, on peut attraper l'exception et affirmer ses propriétés. Pour vérifier que l'exception s'est produite, déclarez une condition fausse dans le bloc try après l'instruction qui lève l'exception.

Ou si votre exception est levée depuis le constructeur d'une classe:

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

}

Message d'affirmation par exception:

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