Java异常测试技巧与旧代码处理方法

本文探讨了在Java中测试内部捕获并处理的异常所面临的挑战。我们将首先分析为何直接使用assertThrows无法测试被“吞噬”的异常，随后提出最佳实践，即通过重构代码来提高可测试性，例如重新抛出异常或返回状态指示器。最后，针对无法修改的遗留代码，我们将介绍如何通过验证日志输出等副作用来间接测试内部异常的发生。

1. 理解测试内部异常的挑战

在Java单元测试中，我们经常使用JUnit的assertThrows来验证方法是否按预期抛出特定类型的异常。然而，当一个方法内部捕获并处理了异常，而没有将其重新抛出或以其他方式向调用者发出信号时，assertThrows将无法检测到这个内部异常的发生。

考虑以下两个类：

// Class A
public class A {
    private static Logger logger = LoggerFactory.getLogger("A"); // 初始化方式可能需要调整以方便测试
    private B b;

    public A() {
        // 实际应用中可能通过依赖注入来获取B的实例
        b = new B(); 
    }

    public void methodA() {
        b.methodB();
        logger.info("A");
    }
}

// Class B
public class B {
    private static Logger logger = LoggerFactory.getLogger("B"); // 初始化方式可能需要调整以方便测试

    public B() {
        // 构造函数
    }

    public void methodB() {
        try {
            throw new Exception("NULL"); // 内部抛出异常
        } catch(Exception e) {
            logger.info("Exception thrown"); // 捕获并记录，但未重新抛出
        }
    }
}

在上述代码中，Class B的methodB()方法内部抛出了一个Exception，但立即在catch块中捕获并仅记录了日志，并未将异常传播出去。Class A的methodA()方法调用了b.methodB()。

当我们尝试测试methodA()是否会因为methodB()内部的异常而抛出异常时，会遇到问题：

@Test
public void testException() {
    A a = new A();
    // 错误用法：assertThrows期望a.methodA()本身抛出异常
    // 但实际上，methodA()的调用链中，异常被methodB()吞噬了
    assertThrows(Exception.class, () -> a.methodA()); 
}

运行上述测试会得到AssertionFailedError: Expected java.lang.Exception to be thrown, but nothing was thrown.。这是因为a.methodA()方法本身并没有抛出任何异常，它只是调用了b.methodB()，而b.methodB()已经处理了内部异常。assertThrows只能验证方法签名中声明抛出或运行时实际抛出的异常，而无法“看透”方法内部被捕获的异常。

2. 最佳实践：重构代码以提高可测试性

从设计的角度来看，Class B中“吞噬”异常而不向调用者发出任何信号的做法通常被认为是反模式。它隐藏了潜在的错误，使得调用者无法得知操作是否成功，也极大地降低了代码的可测试性。

为了提高代码的可测试性并遵循良好的异常处理实践，我们应该重构Class B。

2.1 重新抛出或封装异常

最直接的解决方案是让methodB()在捕获异常后选择重新抛出，或者抛出一个更具体的自定义异常。这样，调用者（Class A或测试方法）就能感知到异常的发生并进行相应的处理。

修改后的 Class B：

// Class B (重构后 - 重新抛出异常)
public class B {
    private static Logger logger = LoggerFactory.getLogger("B");

    public void methodB() throws MyCustomException { // 声明抛出异常
        try {
            throw new Exception("Internal Error in B");
        } catch(Exception e) {
            logger.error("Exception occurred in B, re-throwing.", e);
            throw new MyCustomException("Failed to process in B", e); // 封装并重新抛出
        }
    }
}

// 自定义异常
class MyCustomException extends RuntimeException {
    public MyCustomException(String message) {
        super(message);
    }
    public MyCustomException(String message, Throwable cause) {
        super(message, cause);
    }
}

修改后的 Class A（如果需要处理异常）：

// Class A (如果需要处理B抛出的异常)
public class A {
    private static Logger logger = LoggerFactory.getLogger("A");
    private B b;

    public A(B b) { // 通过构造函数注入B，便于测试
        this.b = b;
    }

    public void methodA() throws MyCustomException { // 声明可能抛出异常
        try {
            b.methodB();
            logger.info("A processed successfully.");
        } catch (MyCustomException e) {
            logger.error("Error in A due to B's failure.", e);
            throw e; // A可以选择继续向上抛出
        }
    }
}

对应的测试方法：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.*;

public class ATest {

    @Test
    public void testMethodAThrowsExceptionWhenBThrows() {
        // Mock B，让其在被调用时抛出异常
        B mockB = mock(B.class);
        doThrow(new MyCustomException("Mocked B failure")).when(mockB).methodB();

        A a = new A(mockB); // 注入Mocked B

        // 现在可以验证A.methodA()是否抛出了MyCustomException
        assertThrows(MyCustomException.class, () -> a.methodA());

        // 也可以验证B的methodB是否被调用了
        verify(mockB, times(1)).methodB();
    }
}

2.2 返回状态或结果对象

如果业务逻辑不允许方法抛出异常（例如，在某些回调或异步场景中），那么可以设计方法返回一个包含操作结果（包括成功/失败状态和可能的错误信息）的对象。

修改后的 Class B：

import java.util.Optional;

// 定义一个结果类
class OperationResult {
    private final boolean success;
    private final String errorMessage;

    public OperationResult(boolean success, String errorMessage) {
        this.success = success;
        this.errorMessage = errorMessage;
    }

    public static OperationResult success() {
        return new OperationResult(true, null);
    }

    public static OperationResult failure(String message) {
        return new OperationResult(false, message);
    }

    public boolean isSuccess() {
        return success;
    }

    public Optional getErrorMessage() {
        return Optional.ofNullable(errorMessage);
    }
}

// Class B (重构后 - 返回结果对象)
public class B {
    private static Logger logger = LoggerFactory.getLogger("B");

    public OperationResult methodB() {
        try {
            throw new Exception("Internal Error in B");
            // return OperationResult.success(); // 模拟成功路径
        } catch(Exception e) {
            logger.error("Exception occurred in B: {}", e.getMessage());
            return OperationResult.failure("Operation failed due to: " + e.getMessage());
        }
    }
}

修改后的 Class A：

// Class A (如果需要处理B返回的结果)
public class A {
    private static Logger logger = LoggerFactory.getLogger("A");
    private B b;

    public A(B b) { // 依赖注入B
        this.b = b;
    }

    public boolean methodA() {
        OperationResult result = b.methodB();
        if (result.isSuccess()) {
            logger.info("A processed successfully.");
            return true;
        } else {
            logger.warn("A operation failed: {}", result.getErrorMessage().orElse("Unknown error"));
            return false; // A根据B的结果返回自己的状态
        }
    }
}

对应的测试方法：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.*;

public class ATest {

    @Test
    public void testMethodAReturnsFalseWhenBReportsFailure() {
        B mockB = mock(B.class);
        // 配置mockB在methodB被调用时返回一个失败的结果
        when(mockB.methodB()).thenReturn(OperationResult.failure("Mocked B failure"));

        A a = new A(mockB);

        // 验证A.methodA()是否返回false
        assertFalse(a.methodA());

        // 验证B的methodB是否被调用了
        verify(mockB, times(1)).methodB();
    }

    @Test
    public void testMethodAReturnsTrueWhenBReportsSuccess() {
        B mockB = mock(B.class);
        when(mockB.methodB()).thenReturn(OperationResult.success());

        A a = new A(mockB);
        assertTrue(a.methodA());
        verify(mockB, times(1)).methodB();
    }
}

3. 应对遗留代码的策略：验证副作用

在某些情况下，我们可能无法修改遗留代码（如Class B），但仍然需要测试其内部异常的发生。此时，我们不能直接测试异常本身，而需要测试异常发生后产生的“副作用”。最常见的副作用就是日志记录。

3.1 验证日志输出

如果内部异常被捕获并记录了日志，我们可以通过验证日志系统是否接收到特定的日志消息来间接证明异常的发生。这通常需要借助模拟（Mocking）框架和对日志系统的配置。

为了使日志可测试，Class B的Logger实例最好能够被注入，而不是静态地获取。

修改 Class B 构造函数以允许注入 Logger：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class B {
    private final Logger logger; // 非静态，可注入

    public B(Logger logger) { // 构造函数注入Logger
        this.logger = logger;
    }

    // 默认构造函数，用于生产环境
    public B() {
        this(LoggerFactory.getLogger("B"));
    }

    public void methodB() {
        try {
            throw new Exception("NULL");
        } catch(Exception e) {
            logger.info("Exception thrown"); // 捕获并记录
        }
    }
}

测试方法（使用 Mockito 验证日志）：

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import static org.mockito.Mockito.*;

public class BTest {

    @Test
    public void testMethodBLogsExceptionWhenThrownInternally() {
        // 创建一个Mock Logger
        Logger mockLogger = mock(Logger.class);

        // 创建B的实例，并注入Mock Logger
        B b = new B(mockLogger);

        // 调用methodB
        b.methodB();

        // 验证mockLogger的info方法是否被调用，且参数是否包含预期的字符串
        // 使用 ArgumentCaptor 可以捕获更复杂的参数
        verify(mockLogger, times(1)).info(eq("Exception thrown")); 

        // 如果想验证更具体的日志内容，例如包含异常堆栈，可能需要捕获Argument
        // ArgumentCaptor messageCaptor = ArgumentCaptor.forClass(String.class);
        // verify(mockLogger).info(messageCaptor.capture());
        // assertTrue(messageCaptor.getValue().contains("Exception thrown"));
    }
}

注意事项：

• Logger 注入： 最佳实践是将Logger作为依赖注入，这样可以轻松地在测试中替换为Mock对象。如果Logger是静态的且无法修改，测试会变得更加复杂，可能需要使用PowerMock等高级Mocking框架，或者重定向System.err/System.out（不推荐用于生产日志）。
• 测试粒度： 这种方法测试的是Class B的日志行为，而不是Class A。如果你的目标是测试Class A在Class B内部发生异常时的行为，并且Class B无法修改，那么Class A本身也不会抛出异常。在这种情况下，你需要决定Class A在调用b.methodB()后是否有其他可观察的副作用（例如，Class A自己的日志、状态改变等），并测试这些副作用。

4. 总结与注意事项

测试内部捕获并处理的异常是一个挑战，其根本原因在于代码设计隐藏了关键的运行时信息。

• 最佳实践： 始终优先考虑重构代码。让方法在发生异常时重新抛出异常（或其封装），或者返回一个明确指示操作结果的状态/结果对象。这不仅使代码更易于测试，也提高了其可维护性和健壮性。
• 遗留代码策略： 当无法修改底层代码时，通过验证异常引发的副作用（如日志输出）是间接测试内部异常的有效方法。这通常需要依赖注入和Mocking框架来隔离和控制日志组件。
• 测试关注点： 单元测试应关注被测试单元的预期行为和可观察的输出。如果一个内部异常被完全吞噬且没有任何可观察的副作用，那么从外部来看，这个异常从未发生过，对其进行测试也就失去了意义。在这种情况下，我们应该质疑代码的设计本身。