如何测试代码不会抛出异常？

我最终是这样做的。

@Test
fun `Should not throw`() {
    whenever(authService.isAdmin()).thenReturn(true)

    assertDoesNotThrow {
        service.throwIfNotAllowed("client")
    }
}

这可能不是最佳方式，但它确保在被测试的代码块中不会抛出异常。

import org.assertj.core.api.Assertions;
import org.junit.Test;

public class AssertionExample {

    @Test
    public void testNoException(){
        assertNoException();
    }    

    private void assertException(){
        Assertions.assertThatThrownBy(this::doNotThrowException).isInstanceOf(Exception.class);
    }

    private void assertNoException(){
        Assertions.assertThatThrownBy(() -> assertException()).isInstanceOf(AssertionError.class);
    }

    private void doNotThrowException(){
        //This method will never throw exception
    }
}

使用 assertNull(...)。

@Test
public void foo() {
    try {
        //execute code that you expect not to throw Exceptions.
    } catch (Exception e){
        assertNull(e);
    }
}

你可以基于junit的断言创建任何类型的自定义断言，因为它们专门设计用于创建用户定义的断言，旨在与junit的断言完全相同：

static void assertDoesNotThrow(Executable executable) {
    assertDoesNotThrow(executable, "must not throw");
}
static void assertDoesNotThrow(Executable executable, String message) {
    try {
        executable.execute();
    } catch (Throwable err) {
        fail(message);
    }
}

现在正在测试所谓的场景methodMustNotThrow，并以junit风格记录所有失败：

//test and log with default and custom messages
//the following will succeed
assertDoesNotThrow(()->methodMustNotThrow(1));
assertDoesNotThrow(()->methodMustNotThrow(1), "custom facepalm");
//the following will fail
assertDoesNotThrow(()->methodMustNotThrow(2));
assertDoesNotThrow(()-> {throw new Exception("Hello world");}, "message");
//See implementation of methodMustNotThrow below

一般来说，在任何情况下，通过调用fail(someMessage)可以立即使测试失败，无论在何处都是有可能的，只要它有意义。这个方法就是为了这个目的而设计的。例如，在try/catch块中使用它，以便在测试用例中抛出任何异常时失败：

try{methodMustNotThrow(1);}catch(Throwable e){fail("must not throw");}
try{methodMustNotThrow(1);}catch(Throwable e){Assertions.fail("must not throw");}

这是我们测试方法的示例，假设我们有这样一个方法，在特定情况下必须不会失败，但它可能会失败：

void methodMustNotThrow(int x) throws Exception {
    if (x == 1) return;
    throw new Exception();
}

上述方法是一个简单的示例。但这适用于复杂情况，其中故障不太明显。 以下是导入：

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import static org.junit.jupiter.api.Assertions.*;

如果您想测试您的测试目标是否消耗了异常，只需将测试保留为（使用jMock2模拟协作者）：

@Test
public void consumesAndLogsExceptions() throws Exception {

    context.checking(new Expectations() {
        {
            oneOf(collaborator).doSth();
            will(throwException(new NullPointerException()));
        }
    });

    target.doSth();
 }

如果您的目标确实消耗了抛出的异常，测试将通过，否则测试将失败。

如果您想测试异常消耗逻辑，则情况会变得更加复杂。我建议将消耗委托给一个可以模拟的协作者。因此测试可以是：

@Test
public void consumesAndLogsExceptions() throws Exception {
    Exception e = new NullPointerException();
    context.checking(new Expectations() {
        {
            allowing(collaborator).doSth();
            will(throwException(e));

            oneOf(consumer).consume(e);
        }
    });

    target.doSth();
 }

但有时候如果你只想记录日志，它可能过于设计复杂了。在这种情况下，如果您坚持进行TDD，则可以参考这篇文章（http://java.dzone.com/articles/monitoring-declarative-transac, http://blog.novoj.net/2008/09/20/testing-aspect-pointcuts-is-there-an-easy-way/）。

我遇到了同样的情况，我需要检查异常在应该抛出时是否被抛出，而且只有在应该抛出时才抛出。最终我利用异常处理程序编写了以下代码：

    try {
        functionThatMightThrowException()
    }catch (Exception e){
        Assert.fail("should not throw exception");
    }
    RestOfAssertions();

我的主要收益在于它非常直接，检查“当且仅当”的另一种方式在相同的结构中也非常容易。

我在编写一些通用方法时遇到了这个问题

@Test
void testSomething() {
   checkGeneric(anComplexObect)
}

在https://newbedev.com/sonarqube-issue-add-at-least-one-assertion-to-this-test-case-for-unit-test-with-assertions中提出了一些注释的内容。
解决方案更简单。只需要将"checkGeneric"方法重命名为"assertGeneric"即可。

@Test
void testSomething() {
  assertGeneric(anComplexObect)
}

你可以使用 @Rule 并调用 reportMissingExceptionWithMessage 方法来实现，如下所示： 这是 Scala 代码。

您可以期望创建规则时不会抛出异常。

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

以下代码无法通过所有异常测试，包括已检查和未检查的异常：

@Test
public void testMyCode() {

    try {
        runMyTestCode();
    } catch (Throwable t) {
        throw new Error("fail!");
    }
}