JUnit 5: Bagaimana cara menyatakan pengecualian dilemparkan?

Apakah ada cara yang lebih baik untuk menyatakan bahwa metode melempar pengecualian di JUnit 5?

Saat ini, saya harus menggunakan aturan @ untuk memverifikasi bahwa tes saya melempar pengecualian, tetapi ini tidak berfungsi untuk kasus-kasus di mana saya mengharapkan beberapa metode untuk melemparkan pengecualian dalam pengujian saya.

Anda dapat menggunakan assertThrows(), yang memungkinkan Anda menguji beberapa pengecualian dalam pengujian yang sama. Dengan dukungan untuk lambdas di Jawa 8, ini adalah cara kanonik untuk menguji pengecualian di JUnit.

Per dokumen JUnit :

import static org.junit.jupiter.api.Assertions.assertThrows;

@Test
void exceptionTesting() {
    MyException thrown = assertThrows(
           MyException.class,
           () -> myObject.doThing(),
           "Expected doThing() to throw, but it didn't"
    );

    assertTrue(thrown.getMessage().contains("Stuff"));
}

Di Java 8 dan JUnit 5 (Jupiter) kita dapat menyatakan pengecualian sebagai berikut. Menggunakanorg.junit.jupiter.api.Assertions.assertThrows

public static <T extends Throwable> T assertThrows (Kelas <T> expectedType, Executable executable)

Menyatakan bahwa eksekusi yang dapat dieksekusi yang disediakan memberikan pengecualian dari tipe yang diharapkan dan mengembalikan pengecualian.

Jika tidak ada pengecualian yang dilemparkan, atau jika pengecualian dari tipe yang berbeda dilemparkan, metode ini akan gagal.

Jika Anda tidak ingin melakukan pemeriksaan tambahan pada contoh pengecualian, abaikan saja nilai pengembaliannya.

@Test
public void itShouldThrowNullPointerExceptionWhenBlahBlah() {
    assertThrows(NullPointerException.class,
            ()->{
            //do whatever you want to do here
            //ex : objectName.thisMethodShoulThrowNullPointerExceptionForNullParameter(null);
            });
}

Pendekatan itu akan menggunakan Interface Fungsional Executabledi org.junit.jupiter.api.

Merujuk:

• http://junit.org/junit5/docs/current/user-guide/#writing-tests-assertions
• http://junit.org/junit5/docs/5.0.0-M2/api/org/junit/jupiter/api/Executable.html
• http://junit.org/junit5/docs/5.0.0-M4/api/org/junit/jupiter/api/Assertions.html#assertThrows-java.lang.Class-org.junit.jupiter.api.function. Dapat dieksekusi-

Mereka telah mengubahnya di JUnit 5 (diharapkan: InvalidArgumentException, aktual: metode yang dipanggil) dan kode terlihat seperti ini:

@Test
public void wrongInput() {
    Throwable exception = assertThrows(InvalidArgumentException.class,
            ()->{objectName.yourMethod("WRONG");} );
}

Sekarang Junit5 menyediakan cara untuk menegaskan pengecualian

Anda dapat menguji pengecualian umum dan pengecualian khusus

Skenario pengecualian umum:

ExpectGeneralException.java

public void validateParameters(Integer param ) {
    if (param == null) {
        throw new NullPointerException("Null parameters are not allowed");
    }
}

ExpectGeneralExceptionTest.java

@Test
@DisplayName("Test assert NullPointerException")
void testGeneralException(TestInfo testInfo) {
    final ExpectGeneralException generalEx = new ExpectGeneralException();

     NullPointerException exception = assertThrows(NullPointerException.class, () -> {
            generalEx.validateParameters(null);
        });
    assertEquals("Null parameters are not allowed", exception.getMessage());
}

Anda dapat menemukan sampel untuk menguji CustomException di sini: menegaskan contoh kode pengecualian

ExpectCustomException.java

public String constructErrorMessage(String... args) throws InvalidParameterCountException {
    if(args.length!=3) {
        throw new InvalidParameterCountException("Invalid parametercount: expected=3, passed="+args.length);
    }else {
        String message = "";
        for(String arg: args) {
            message += arg;
        }
        return message;
    }
}

ExpectCustomExceptionTest.java

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

Saya pikir ini adalah contoh yang lebih sederhana

List<String> emptyList = new ArrayList<>();
Optional<String> opt2 = emptyList.stream().findFirst();
assertThrows(NoSuchElementException.class, () -> opt2.get());

Memanggil get()opsional yang berisi kosong ArrayListakan melempar a NoSuchElementException. assertThrowsmendeklarasikan pengecualian yang diharapkan dan memberikan pemasok lambda (tidak mengambil argumen dan mengembalikan nilai).

Terima kasih kepada @prime atas jawabannya yang mudah-mudahan saya uraikan.

Anda bisa menggunakannya assertThrows(). Contoh saya diambil dari dokumen http://junit.org/junit5/docs/current/user-guide/

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

....

@Test
void exceptionTesting() {
    Throwable exception = assertThrows(IllegalArgumentException.class, () -> {
        throw new IllegalArgumentException("a message");
    });
    assertEquals("a message", exception.getMessage());
}

Satu liner yang bahkan lebih sederhana. Tidak diperlukan ekspresi lambda atau kurung kurawal untuk contoh ini menggunakan Java 8 dan JUnit 5

import static org.junit.jupiter.api.Assertions.assertThrows;

@Test
void exceptionTesting() {

    assertThrows(MyException.class, myStackObject::doStackAction, "custom message if assertion fails..."); 

// note, no parenthesis on doStackAction ex ::pop NOT ::pop()
}

Sebenarnya saya pikir ada kesalahan dalam dokumentasi untuk contoh khusus ini. Metode yang dimaksudkan adalah expectThrows

public static void assertThrows(
public static <T extends Throwable> T expectThrows(

Ini cara yang mudah.

@Test
void exceptionTest() {

   try{
        model.someMethod("invalidInput");
        fail("Exception Expected!");
   }
   catch(SpecificException e){

        assertTrue(true);
   }
   catch(Exception e){
        fail("wrong exception thrown");
   }

}

Itu hanya berhasil ketika Pengecualian yang Anda harapkan dilemparkan.