Estoy usando mockito en una prueba de junit. ¿Cómo hacer que ocurra una excepción y luego afirmar que tiene (pseudocódigo genérico)

Solución de estilo BDD (actualizada a Java 8)

Mockito por sí solo no es la mejor solución para manejar excepciones, use Mockito con Catch-Exception

Mockito + Catch-Exception + AssertJ

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

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

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

Código de muestra

• Mockito + Catch-Exception + Assertj muestra completa

Dependencias

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

Para responder a su segunda pregunta primero. Si está usando JUnit 4, puede anotar su prueba con

@Test(expected=MyException.class)

para afirmar que ha ocurrido una excepción. Y para "burlarse" de una excepción con mockito, use

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

Si también desea probar el mensaje de excepción, puede usar ExpectedException de JUnit con 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"));
}

Respuesta actualizada para 19/06/2015 (si está utilizando Java 8)

Solo usa afirmar

Usando afirj-core-3.0.0 + Java 8 Lambdas

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

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

Si usa JUnit 4 y Mockito 1.10.x Anote su método de prueba con:

@Test(expected = AnyException.class)

y para lanzar su excepción deseada use:

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

Haz que la excepción suceda así:

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

Verifique que haya sucedido ya sea afirmando que su prueba arrojará tal excepción:

@Test(expected = AnException.class)

O por verificación simulada normal:

verify(obj).someMethod();

La última opción es necesaria si su prueba está diseñada para probar que el código intermedio maneja la excepción (es decir, la excepción no se lanzará desde su método de prueba).

Use doThrow de Mockito y luego capture la excepción deseada para afirmar que se lanzó más tarde.

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

Usando mockito, puedes hacer que la excepción suceda.

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

Usando Junit5, puede afirmar una excepción, afirma si esa excepción se produce cuando se invoca el método de prueba .

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

Encuentre una muestra aquí: afirmar excepción junit

Sin relación con mockito, uno puede atrapar la excepción y afirmar sus propiedades. Para verificar que la excepción sucedió, afirme una condición falsa dentro del bloque try después de la declaración que arroja la excepción.

O si su excepción se produce desde el constructor de una clase:

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

}

Afirmar por mensaje de excepción:

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