Làm cách nào để xác nhận thông báo ngoại lệ của tôi với chú thích Kiểm tra JUnit?

Tôi đã viết một vài bài kiểm tra JUnit với @Testchú thích. Nếu phương thức kiểm tra của tôi đưa ra một ngoại lệ được kiểm tra và nếu tôi muốn xác nhận thông báo cùng với ngoại lệ đó, có cách nào để làm như vậy với @Testchú thích JUnit không? AFAIK, JUnit 4.7 không cung cấp tính năng này nhưng có phiên bản nào trong tương lai cung cấp tính năng này không? Tôi biết trong .NET bạn có thể xác nhận thông báo và lớp ngoại lệ. Tìm kiếm tính năng tương tự trong thế giới Java.

Đây là những gì tôi muốn:

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

Bạn có thể sử dụng @Rulechú thích với ExpectedException, như thế này:

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

Lưu ý rằng ví dụ trong ExpectedExceptiontài liệu là (hiện tại) sai - không có nhà xây dựng công cộng, vì vậy bạn phải sử dụng ExpectedException.none().

Tôi thích @Rulecâu trả lời. Tuy nhiên, nếu vì lý do nào đó bạn không muốn sử dụng quy tắc. Có một lựa chọn thứ ba.

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

Bạn có phải sử dụng @Test(expected=SomeException.class)? Khi chúng ta phải xác nhận thông điệp thực sự của ngoại lệ, đây là những gì chúng ta làm.

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

Trong JUnit 4.13 bạn có thể làm:

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

Điều này cũng hoạt động trong JUnit 5 nhưng với các lần nhập khác nhau:

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

...

Trên thực tế, cách sử dụng tốt nhất là với thử / bắt. Tại sao? Bởi vì bạn có thể kiểm soát nơi bạn mong đợi ngoại lệ.

Xem xét ví dụ này:

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

Điều gì sẽ xảy ra nếu một ngày mã được sửa đổi và chuẩn bị kiểm tra sẽ ném RuntimeException? Trong trường hợp đó, kiểm tra thực tế thậm chí không được kiểm tra và ngay cả khi nó không đưa ra bất kỳ ngoại lệ nào, kiểm tra sẽ vượt qua.

Đó là lý do tại sao sử dụng thử / bắt tốt hơn là dựa vào chú thích.

Raystorm đã có một câu trả lời tốt. Tôi cũng không phải là một fan hâm mộ lớn của Nội quy. Tôi làm một cái gì đó tương tự, ngoại trừ việc tôi tạo lớp tiện ích sau để giúp dễ đọc và dễ sử dụng, đây là một trong những điểm cộng lớn của chú thích ở vị trí đầu tiên.

Thêm lớp tiện ích này:

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

}

Sau đó, để kiểm tra đơn vị của tôi, tất cả những gì tôi cần là mã này:

@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"
}

Nếu sử dụng @Rule, tập ngoại lệ được áp dụng cho tất cả các phương thức kiểm tra trong lớp Kiểm tra.

Tôi không bao giờ thích cách khẳng định ngoại lệ với Junit. Nếu tôi sử dụng "mong đợi" trong chú thích, có vẻ như theo quan điểm của tôi, chúng tôi đang vi phạm mẫu "được đưa ra, khi nào, sau đó" bởi vì "sau đó" được đặt ở đầu định nghĩa kiểm tra.

Ngoài ra, nếu chúng tôi sử dụng "@Rule", chúng tôi phải xử lý rất nhiều mã soạn sẵn. Vì vậy, nếu bạn có thể cài đặt các thư viện mới cho các thử nghiệm của mình, tôi khuyên bạn nên xem AssertJ (thư viện đó hiện có kèm theo SpringBoot)

Sau đó, một bài kiểm tra không vi phạm các nguyên tắc "đã cho / khi / sau đó" và được thực hiện bằng cách sử dụng AssertJ để xác minh:

1 - Ngoại lệ là những gì chúng ta mong đợi. 2 - Nó cũng có một thông điệp dự kiến

Sẽ như thế này:

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

Tôi thích câu trả lời của user64141 nhưng thấy rằng nó có thể khái quát hơn. Đây là của tôi:

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

}

Lưu ý rằng việc để lại câu lệnh "fail" trong khối thử khiến ngoại lệ xác nhận liên quan bị bắt; sử dụng return trong câu lệnh bắt ngăn chặn điều này.

Nhập thư viện ngoại lệ bắt và sử dụng thư viện đó. Nó sạch hơn nhiều so với ExpectedExceptionquy tắc hoặc a try-catch.

Ví dụ hình thành tài liệu của họ:

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
}