Bagaimana cara menegaskan pesan pengecualian saya dengan anotasi Tes JUnit?

Saya telah menulis beberapa tes JUnit dengan @Testanotasi. Jika metode pengujian saya melempar pengecualian yang diperiksa dan jika saya ingin menegaskan pesan bersama dengan pengecualian, apakah ada cara untuk melakukannya dengan @Testanotasi JUnit ? AFAIK, JUnit 4.7 tidak menyediakan fitur ini tetapi apakah ada versi di masa depan yang menyediakannya? Saya tahu di .NET Anda dapat menegaskan pesan dan kelas pengecualian. Mencari fitur serupa di dunia Java.

Ini yang aku inginkan:

@Test (expected = RuntimeException.class, message = "Employee ID is null")
public void shouldThrowRuntimeExceptionWhenEmployeeIDisNull() {}

Anda dapat menggunakan @Ruleanotasi dengan ExpectedException, seperti ini:

@Rule
public ExpectedException expectedEx = ExpectedException.none();

@Test
public void shouldThrowRuntimeExceptionWhenEmployeeIDisNull() throws Exception {
    expectedEx.expect(RuntimeException.class);
    expectedEx.expectMessage("Employee ID is null");

    // do something that should throw the exception...
    System.out.println("=======Starting Exception process=======");
    throw new NullPointerException("Employee ID is null");
}

Perhatikan bahwa contoh dalam ExpectedExceptiondokumen tersebut (saat ini) salah - tidak ada konstruktor publik, jadi Anda harus menggunakannya ExpectedException.none().

Saya suka @Rulejawabannya. Namun, jika karena alasan tertentu Anda tidak ingin menggunakan aturan. Ada opsi ketiga.

@Test (expected = RuntimeException.class)
public void myTestMethod()
{
   try
   {
      //Run exception throwing operation here
   }
   catch(RuntimeException re)
   {
      String message = "Employee ID is null";
      assertEquals(message, re.getMessage());
      throw re;
    }
    fail("Employee Id Null exception did not throw!");
  }

Apakah Anda harus menggunakan @Test(expected=SomeException.class)? Ketika kita harus menegaskan pesan pengecualian yang sebenarnya, inilah yang kita lakukan.

@Test
public void myTestMethod()
{
  try
  {
    final Integer employeeId = null;
    new Employee(employeeId);
    fail("Should have thrown SomeException but did not!");
  }
  catch( final SomeException e )
  {
    final String msg = "Employee ID is null";
    assertEquals(msg, e.getMessage());
  }
}

Di JUnit 4.13 Anda dapat melakukan:

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;

...

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

  assertEquals("a message", exception.getMessage());
}

Ini juga berfungsi di JUnit 5 tetapi dengan impor berbeda:

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

...

Sebenarnya, penggunaan terbaik adalah dengan coba / tangkap. Mengapa? Karena Anda dapat mengontrol tempat di mana Anda mengharapkan pengecualian.

Pertimbangkan contoh ini:

@Test (expected = RuntimeException.class)
public void someTest() {
   // test preparation
   // actual test
}

Bagaimana jika suatu hari kode dimodifikasi dan persiapan ujian akan melempar RuntimeException? Dalam hal ini tes yang sebenarnya bahkan tidak diuji dan bahkan jika itu tidak membuang pengecualian tes akan berlalu.

Itulah mengapa jauh lebih baik menggunakan try / catch daripada mengandalkan anotasi.

Raystorm punya jawaban yang bagus. Saya juga bukan penggemar berat Aturan. Saya melakukan sesuatu yang serupa, kecuali bahwa saya membuat kelas utilitas berikut untuk membantu keterbacaan dan kegunaan, yang merupakan salah satu plus besar anotasi di tempat pertama.

Tambahkan kelas utilitas ini:

import org.junit.Assert;

public abstract class ExpectedRuntimeExceptionAsserter {

    private String expectedExceptionMessage;

    public ExpectedRuntimeExceptionAsserter(String expectedExceptionMessage) {
        this.expectedExceptionMessage = expectedExceptionMessage;
    }

    public final void run(){
        try{
            expectException();
            Assert.fail(String.format("Expected a RuntimeException '%s'", expectedExceptionMessage));
        } catch (RuntimeException e){
            Assert.assertEquals("RuntimeException caught, but unexpected message", expectedExceptionMessage, e.getMessage());
        }
    }

    protected abstract void expectException();

}

Kemudian untuk pengujian unit saya, yang saya butuhkan adalah kode ini:

@Test
public void verifyAnonymousUserCantAccessPrivilegedResourceTest(){
    new ExpectedRuntimeExceptionAsserter("anonymous user can't access privileged resource"){
        @Override
        protected void expectException() {
            throw new RuntimeException("anonymous user can't access privileged resource");
        }
    }.run(); //passes test; expected exception is caught, and this @Test returns normally as "Passed"
}

Jika menggunakan @Rule, set pengecualian diterapkan ke semua metode pengujian di kelas Tes.

Saya tidak pernah menyukai cara menyatakan pengecualian dengan Junit. Jika saya menggunakan "yang diharapkan" dalam anotasi, tampaknya dari sudut pandang saya, kami melanggar pola "diberikan, kapan, lalu" karena "maka" ditempatkan di bagian atas definisi pengujian.

Juga, jika kita menggunakan "Aturan", kita harus berurusan dengan kode boilerplate begitu banyak. Jadi, jika Anda dapat menginstal pustaka baru untuk tes Anda, saya sarankan untuk melihat AssertJ (pustaka yang sekarang dilengkapi dengan SpringBoot)

Kemudian tes yang tidak melanggar prinsip "diberikan / kapan / kemudian", dan itu dilakukan dengan menggunakan AssertJ untuk memverifikasi:

1 - Pengecualian adalah yang kami harapkan. 2 - Ini juga pesan yang diharapkan

Akan terlihat seperti ini:

 @Test
void should_throwIllegalUse_when_idNotGiven() {

    //when
    final Throwable raisedException = catchThrowable(() -> getUserDAO.byId(null));

    //then
    assertThat(raisedException).isInstanceOf(IllegalArgumentException.class)
            .hasMessageContaining("Id to fetch is mandatory");
}

Saya suka jawaban user64141 tetapi menemukan bahwa itu bisa lebih digeneralisasi. Inilah pendapat saya:

public abstract class ExpectedThrowableAsserter implements Runnable {

    private final Class<? extends Throwable> throwableClass;
    private final String expectedExceptionMessage;

    protected ExpectedThrowableAsserter(Class<? extends Throwable> throwableClass, String expectedExceptionMessage) {
        this.throwableClass = throwableClass;
        this.expectedExceptionMessage = expectedExceptionMessage;
    }

    public final void run() {
        try {
            expectException();
        } catch (Throwable e) {
            assertTrue(String.format("Caught unexpected %s", e.getClass().getSimpleName()), throwableClass.isInstance(e));
            assertEquals(String.format("%s caught, but unexpected message", throwableClass.getSimpleName()), expectedExceptionMessage, e.getMessage());
            return;
        }
        fail(String.format("Expected %s, but no exception was thrown.", throwableClass.getSimpleName()));
    }

    protected abstract void expectException();

}

Perhatikan bahwa meninggalkan pernyataan "gagal" dalam blok uji coba menyebabkan pengecualian pernyataan terkait ditangkap; menggunakan return dalam pernyataan catch mencegah hal ini.

Impor perpustakaan catch-exception , dan gunakan itu. Ini jauh lebih bersih daripada ExpectedExceptionaturan atau try-catch.

Contoh dari dokumen mereka:

import static com.googlecode.catchexception.CatchException.*;
import static com.googlecode.catchexception.apis.CatchExceptionHamcrestMatchers.*;

// given: an empty list
List myList = new ArrayList();

// when: we try to get the first element of the list
catchException(myList).get(1);

// then: we expect an IndexOutOfBoundsException with message "Index: 1, Size: 0"
assertThat(caughtException(),
  allOf(
    instanceOf(IndexOutOfBoundsException.class),
    hasMessage("Index: 1, Size: 0"),
    hasNoCause()
  )
);

@Test (expectedExceptions = ValidationException.class, expectedExceptionsMessageRegExp = "This is not allowed")
public void testInvalidValidation() throws Exception{
     //test code
}