J'utilise mockito dans un test junit. Comment créer une exception et ensuite affirmer qu'elle existe (pseudo-code générique)
Mockito n'est pas la meilleure solution pour gérer les exceptions, utilisez Mockito avec Catch-Exception
given(otherServiceMock.bar()).willThrow(new MyException());
when(myService).foo();
then(caughtException()).isInstanceOf(MyException.class);
Pour répondre à votre deuxième question en premier. 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 "se moquer" d'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"));
}
Faites que l'exception se produise comme ceci:
when(obj.someMethod()).thenThrow(new AnException());
Vérifiez que cela est arrivé soit en affirmant que votre test lève une telle exception:
@Test(expected = AnException.class)
Ou par vérification fictive 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 par votre méthode de test).
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 souhaitée, utilisez:
Mockito.doThrow(new AnyException()).when(obj).callAnyMethod();
Réponse mise à jour pour le 19/06/2015 (si vous utilisez Java 8)
Il suffit d'utiliser assertj
Utilisation de 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
Utilisez Mockito's doThrow , puis saisissez l'exception souhaitée pour affirmer qu'elle a été émise 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);
}
Sans lien avec mockito, on peut attraper l'exception et en affirmer les propriétés. Pour vérifier que l'exception s'est bien produite, associez une condition fausse au bloc try après l'instruction qui lève l'exception.
Ou si votre exception est levée par 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);
}