Sto usando mockito in un test di junit. Come si fa a far accadere un'eccezione e quindi affermarla (pseudo-codice generico)

Soluzione BDD Style (aggiornata a Java 8)

Mockito da solo non è la soluzione migliore per gestire le eccezioni, usa Mockito con Catch-Exception

Mockito + Catch-Exception + AssertJ

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

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

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

Codice di esempio

• Mockito + Catch-Exception + Assertj campione completo

dipendenze

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

Per rispondere prima alla tua seconda domanda. Se si utilizza JUnit 4, è possibile annotare il test con

@Test(expected=MyException.class)

per affermare che si è verificata un'eccezione. E per "deridere" un'eccezione con mockito, usa

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

Se si desidera testare anche il messaggio di eccezione, è possibile utilizzare ExpectedException di 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"));
}

Risposta aggiornata per 19/06/2015 (se stai usando Java 8)

Usa assertj

Utilizzo di assertj-core-3.0.0 + Java 8 Lambdas

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

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

Se stai usando JUnit 4 e Mockito 1.10.x Annota il tuo metodo di test con:

@Test(expected = AnyException.class)

e per generare l'eccezione desiderata usare:

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

Fai in modo che l'eccezione accada in questo modo:

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

Verifica che sia successo affermando che il tuo test genererà tale eccezione:

@Test(expected = AnException.class)

O dalla normale verifica fittizia:

verify(obj).someMethod();

Quest'ultima opzione è necessaria se il test è progettato per dimostrare che il codice intermedio gestisce l'eccezione (ovvero l'eccezione non verrà generata dal metodo di test).

Usa il doThrow di Mockito e poi cattura l'eccezione desiderata per affermare che è stata lanciata in seguito.

@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, puoi far accadere l'eccezione.

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

Usando Junit5, puoi affermare un'eccezione, affermare se tale eccezione viene generata quando viene invocato il metodo di 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());
}

Trova un esempio qui: asserisci eccezione junit

Non correlato al mockito, si può catturare l'eccezione e affermarne le proprietà. Per verificare che si sia verificata l'eccezione, asserire una condizione falsa all'interno del blocco try dopo l'istruzione che genera l'eccezione.

O se la tua eccezione viene generata dal costruttore di una 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);  

}

Asserire tramite messaggio di eccezione:

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