JUnit 5: Làm thế nào để khẳng định một ngoại lệ được ném ra?

Có cách nào tốt hơn để khẳng định rằng một phương thức đưa ra một ngoại lệ trong JUnit 5 không?

Hiện tại, tôi phải sử dụng @Rule để xác minh rằng thử nghiệm của tôi có ngoại lệ, nhưng điều này không hiệu quả đối với các trường hợp tôi mong đợi nhiều phương pháp đưa ra ngoại lệ trong thử nghiệm của mình.

Bạn có thể sử dụng assertThrows(), cho phép bạn kiểm tra nhiều ngoại lệ trong cùng một bài kiểm tra. Với sự hỗ trợ cho lambdas trong Java 8, đây là cách chuẩn để kiểm tra các ngoại lệ trong JUnit.

Theo các tài liệu 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"));
}

Trong Java 8 và JUnit 5 (Sao Mộc), chúng ta có thể khẳng định các ngoại lệ như sau. Sử dụngorg.junit.jupiter.api.Assertions.assertThrows

công khai tĩnh <T extends throwable> T assertThrows (Class <T> kỳ vọng loại, thực thi thực thi)

Xác nhận rằng việc thực thi tệp thực thi được cung cấp sẽ ném ngoại lệ của Loại dự kiến ​​và trả về ngoại lệ.

Nếu không có ngoại lệ được ném, hoặc nếu một ngoại lệ của một loại khác được ném, phương pháp này sẽ thất bại.

Nếu bạn không muốn thực hiện kiểm tra bổ sung trong trường hợp ngoại lệ, chỉ cần bỏ qua giá trị trả về.

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

Cách tiếp cận đó sẽ sử dụng Giao diện chức năng Executabletrong org.junit.jupiter.api.

Tham khảo :

• http://junit.org/junit5/docs/civerse/user-guide/#wr-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.feft. Thực thi-

Họ đã thay đổi nó trong JUnit 5 (dự kiến: UnlimitedArgumentException, thực tế: phương thức được gọi) và mã trông giống như thế này:

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

Bây giờ Junit5 cung cấp một cách để khẳng định các ngoại lệ

Bạn có thể kiểm tra cả ngoại lệ chung và ngoại lệ tùy chỉnh

Một kịch bản ngoại lệ chung:

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

Bạn có thể tìm thấy một mẫu để kiểm tra CustomException tại đây: xác nhận mẫu mã ngoại lệ

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

Tôi nghĩ rằng đây là một ví dụ đơn giản hơn

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

Gọi get()vào một tùy chọn có chứa một trống ArrayListsẽ ném a NoSuchElementException. assertThrowstuyên bố ngoại lệ dự kiến ​​và cung cấp một nhà cung cấp lambda (không có đối số và trả về giá trị).

Cảm ơn @prime cho câu trả lời của anh ấy mà tôi hy vọng được xây dựng trên.

Bạn có thể sử dụng assertThrows(). Ví dụ của tôi được lấy từ các tài liệu http://junit.org/junit5/docs/civerse/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());
}

Một lót thậm chí đơn giản hơn. Không có biểu thức lambda hoặc dấu ngoặc nhọn cần thiết cho ví dụ này bằng cách sử dụng Java 8 và 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()
}

Trên thực tế tôi nghĩ rằng có một lỗi trong tài liệu cho ví dụ cụ thể này. Phương thức được dự định là kỳ vọng.

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

Đây là một cách dễ dàng.

@Test
void exceptionTest() {

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

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

}

Nó chỉ thành công khi Ngoại lệ bạn mong đợi được ném.