Saya menggunakan mockito dalam tes junit. Bagaimana Anda membuat pengecualian terjadi dan kemudian menyatakan bahwa ia memiliki (kode pseudo generik)

Solusi Gaya BDD (Diperbarui ke Java 8)

Mockito sendiri bukan solusi terbaik untuk menangani pengecualian, gunakan Mockito dengan Catch-Exception

Mockito + Catch-Exception + AssertJ

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

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

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

Kode sampel

• Mockito + Catch-Exception + Assertj sampel lengkap

Ketergantungan

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

Untuk menjawab pertanyaan kedua Anda terlebih dahulu. Jika Anda menggunakan JUnit 4, Anda dapat membuat anotasi dengan tes Anda

@Test(expected=MyException.class)

untuk menegaskan bahwa pengecualian telah terjadi. Dan untuk "mengejek" pengecualian dengan mockito, gunakan

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

Jika Anda ingin menguji pesan pengecualian juga, Anda dapat menggunakan JUnit's ExpectedException dengan 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"));
}

Jawaban yang diperbarui untuk 06/19/2015 (jika Anda menggunakan java 8)

Cukup gunakan assertj

Menggunakan assertj-core-3.0.0 + Java 8 Lambdas

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

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

Jika Anda menggunakan JUnit 4, dan Mockito 1.10.x anotasi metode pengujian Anda dengan:

@Test(expected = AnyException.class)

dan untuk membuang penggunaan pengecualian yang Anda inginkan:

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

Buat pengecualian terjadi seperti ini:

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

Verifikasi itu telah terjadi baik dengan menyatakan bahwa tes Anda akan mengeluarkan pengecualian seperti itu:

@Test(expected = AnException.class)

Atau dengan verifikasi tiruan normal:

verify(obj).someMethod();

Opsi terakhir diperlukan jika pengujian Anda dirancang untuk membuktikan kode perantara menangani pengecualian (yaitu pengecualian tidak akan dilempar dari metode pengujian Anda).

Gunakan doTrow Mockito dan kemudian menangkap pengecualian yang diinginkan untuk menegaskan itu dibuang kemudian.

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

Menggunakan mockito, Anda dapat membuat pengecualian terjadi.

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

Menggunakan Junit5, Anda dapat menyatakan pengecualian, menegaskan apakah yang eksepsi dilemparkan ketika metode pengujian dipanggil.

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

Temukan sampel di sini: sebutkan pengecualian junit

Tidak terkait dengan mockito, orang dapat menangkap pengecualian dan menegaskan propertinya. Untuk memverifikasi bahwa pengecualian itu benar-benar terjadi, nyatakan kondisi yang salah dalam blok coba setelah pernyataan yang melempar pengecualian.

Atau jika pengecualian Anda dilempar dari konstruktor kelas:

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

}

Menegaskan dengan pesan pengecualian:

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