模拟Future对象异常行为的测试技巧

本文深入探讨了如何利用Mockito框架，在单元测试中模拟Future对象的异常行为，特别是`get()`方法抛出`InterruptedException`或`ExecutionException`，从而全面覆盖代码中的异常处理逻辑。文章强调了`thenThrow`的正确用法，即直接传入异常实例而非Future对象，并介绍了通过`Mockito.spy()`监视catch块内的副作用（如日志记录）来验证异常路径的方法。通过提供详细的示例代码，本文旨在帮助开发者编写更健壮的异步代码测试，确保程序在面对并发异常时能正确处理。重点讲解了如何验证包含 Future.get() 调用的 catch 块确实被触发，并执行了预期的异常处理逻辑。

本文深入探讨了在单元测试中，如何使用 Mockito 框架模拟 Future 对象的 get() 方法抛出 InterruptedException 或 ExecutionException，以有效覆盖代码中的异常处理逻辑。核心在于理解 thenThrow 的正确用法，以及通过 Mockito.spy() 监视在 catch 块内执行的副作用，从而验证异常路径的正确性。文章提供了详细的示例代码和最佳实践，帮助开发者编写健壮的异步代码测试。

一、理解 Future 异常处理与测试挑战

在 Java 并发编程中，Future 接口代表异步计算的结果。当通过 Future.get() 方法尝试获取结果时，可能会遇到两种受检异常：

• InterruptedException: 当线程在等待结果时被中断。
• ExecutionException: 当异步计算过程中抛出异常时，该异常会被包装在 ExecutionException 中抛出。

在编写单元测试时，为了确保代码对这些异常情况的处理是正确的，我们需要模拟 Future.get() 方法抛出这些异常，并验证相应的 catch 块是否被执行。然而，这常常面临以下挑战：

1. thenThrow 的误用: 开发者可能错误地尝试使用 when(mock.get()).thenThrow(someFutureContainingException)，但 thenThrow 方法期望的是一个 Throwable 实例，而非一个包装了异常的 Future 对象。
2. catch 块的验证: catch 块本身是代码逻辑，无法直接通过 Mockito 验证其“被执行”。要验证 catch 块是否被触发，我们需要在 catch 块内部执行一个可观测的动作（例如，调用一个日志服务、更新一个状态变量），然后通过 Mockito 验证这个动作是否发生。

二、Mockito 模拟 Future 异常的正确姿势

要让 Mockito 模拟的 Future 对象在调用 get() 方法时抛出异常，应直接使用 thenThrow 方法并传入异常实例。

基本语法：

import static org.mockito.Mockito.*;
import java.util.concurrent.Future;
import java.util.concurrent.InterruptedException;

// 假设 futureMock 是一个 Future 类型的 Mock 对象
Future futureMock = mock(Future.class);

// 模拟 futureMock.get() 抛出 InterruptedException
when(futureMock.get()).thenThrow(new InterruptedException("模拟中断异常"));

// 模拟 futureMock.get() 抛出 ExecutionException
// ExecutionException 通常包装了实际的业务异常
when(futureMock.get()).thenThrow(new ExecutionException("模拟执行异常", new RuntimeException("内部业务错误")));

请注意，thenThrow 期望的是一个 Exception 对象，而不是一个 CompletableFuture 或其他 Future 的实例。如果传入一个 Future，会导致编译错误或运行时错误。

三、验证 Catch 块执行的关键策略：Spy 与 Verify

仅仅模拟异常抛出不足以完成测试。核心在于如何验证包含 Future.get() 调用的 catch 块确实被触发并执行了预期的异常处理逻辑。

核心思想：

在 catch 块中，引入一个可被测试框架监视的“副作用”操作。这个操作可以是调用一个日志服务、统计异常次数、或者更新某个状态。然后，在测试中，我们可以使用 Mockito.spy() 来监视这个执行副作用的真实对象，并通过 Mockito.verify() 来确认该副作用方法是否被调用。

示例场景：

假设我们的业务逻辑在处理 Future 结果时，如果发生异常，会调用一个 MyService 的 logError 方法来记录错误。

1. 生产代码结构

首先，我们定义一个简单的服务 MyService 来处理错误日志：

// MyService.java
package de.playground.so74236327;

public class MyService {
    public void logError(Exception e) {
        // 实际的日志记录逻辑，例如：
        // System.err.println("Error occurred: " + e.getMessage());
        // logger.error("Async operation failed", e);
    }
}

接着，是包含 Future 异步结果收集逻辑的 ExampleProductionCode：

// ExampleProductionCode.java
package de.playground.so74236327;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class ExampleProductionCode {
    private List> futureData;
    private EnginesData enginesData;
    private MyService myService; // 注入 MyService

    public ExampleProductionCode(MyService myService) {
        this.myService = myService;
        futureData = new ArrayList<>();
        enginesData = new EnginesData();
        // 示例：添加一些真实的 Future 对象，它们也可能抛出异常
        futureData.add(createAndStartAsyncTask());
        futureData.add(createAndStartFutureTask());
    }

    public List> getFutureData() {
        return futureData;
    }

    // 模拟一个 CompletableFuture 异步任务，可能抛出异常
    public Future createAndStartAsyncTask() {
        CompletableFuture completableFuture = new CompletableFuture<>();
        Executors.newCachedThreadPool().submit(() -> {
            try {
                Thread.sleep(100); // 模拟耗时操作
                throw new InterruptedException("模拟 CompletableFuture 内部中断");
            } catch (Exception e) {
                completableFuture.completeExceptionally(e); // 异常完成
            }
        });
        return completableFuture;
    }

    // 模拟一个 FutureTask 异步任务，可能抛出异常
    public Future createAndStartFutureTask() {
        FutureTask ftask = new FutureTask<>(() -> {
            Thread.sleep(100); // 模拟耗时操作
            throw new InterruptedException("模拟 FutureTask 内部中断");
            // return MySOClass.class; // 正常返回
        });
        // 注意：FutureTask 的 run() 方法在当前线程执行任务
        // 如果要模拟异步执行，需要提交给 ExecutorService
        ftask.run();
        return ftask;
    }

    public void collectAsyncResults() {
        futureData.forEach(result -> {
            try {
                enginesData.add(result.get()); // 尝试获取结果
            } catch (InterruptedException | ExecutionException e) {
                // 当 Future.get() 抛出异常时，调用 MyService 的 logError 方法
                myService.logError(e); // 这是我们要在测试中验证的副作用
            }
        });
    }

    public class EnginesData {
        public void add(Class aclass) {
            // 实际的数据添加逻辑
        }
    }
}

2. 单元测试代码

现在，我们可以编写测试来验证 catch 块中的 myService.logError(e) 是否被调用。

// FutureExceptionTest.java
package de.playground.so74236327;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class) // 启用 Mockito 注解
public class FutureExceptionTest {

    @Mock // 声明一个 Future 类型的 Mock 对象
    public Future futureMock;

    @Test
    public void testInterruptedExceptionInFutureGet() throws ExecutionException, InterruptedException {
        // 1. 准备 Spy 对象：对 MyService 的真实实例进行 Spy
        // 这样可以调用 MyService 的真实方法，同时也能验证其方法调用
        MyService mySpy = spy(new MyService());

        // 2. 实例化生产代码类，并注入 Spy 对象
        // ExampleProductionCode 内部会创建两个真实的 Future 实例
        ExampleProductionCode exampleProductionCode = new ExampleProductionCode(mySpy);
        List> futureData = exampleProductionCode.getFutureData();

        // 3. 模拟 futureMock 的行为：当 get() 被调用时抛出 InterruptedException
        InterruptedException interruptedException = new InterruptedException("模拟中断异常");
        when(futureMock.get()).thenThrow(interruptedException);

        // 4. 将模拟的 Future 对象添加到生产代码的 Future 列表中
        // 这样在 collectAsyncResults() 中会处理到这个模拟对象
        futureData.add(futureMock);

        // 5. 在调用业务方法之前，验证 logError 尚未被调用
        verify(mySpy, times(0)).logError(interruptedException);

        // 6. 调用业务方法，该方法会遍历 Future 列表并调用 get()
        exampleProductionCode.collectAsyncResults();

        // 7. 验证 catch 块中的副作用：
        // 预期会有 3 次 logError 调用：
        // 1st: 来自 CompletableFuture.completeExceptionally() 导致的 ExecutionException (或 InterruptedException)
        // 2nd: 来自 FutureTask 内部抛出的 InterruptedException
        // 3rd: 来自我们模拟的 futureMock 抛出的 InterruptedException
        verify(mySpy, times(3)).logError(any(Exception.class));
        // 也可以更精确地验证特定异常实例：
        // verify(mySpy).logError(interruptedException); // 验证模拟的异常被处理
    }
}

代码解释：

• @ExtendWith(MockitoExtension.class): 启用 Mockito JUnit 5 扩展，允许使用 @Mock 等注解。
• @Mock public Future futureMock;: 声明一个 Future 接口的 Mock 对象。
• MyService mySpy = spy(new MyService());: 创建 MyService 的一个真实实例，并对其进行 spy。spy 允许我们调用真实对象的方法，同时也能记录这些方法的调用情况，以便后续 verify。
• when(futureMock.get()).thenThrow(interruptedException);: 这是关键的模拟部分。它指示当 futureMock 对象的 get() 方法被调用时，直接抛出 interruptedException。
• futureData.add(futureMock);: 将我们模拟的 futureMock 添加到 ExampleProductionCode 内部处理的 Future 列表中，确保它会被遍历到。
• verify(mySpy, times(3)).logError(any(Exception.class));: 这是验证 catch 块被触发的核心。它检查 mySpy 对象的 logError 方法是否被调用了 3 次（因为示例中除了模拟的 futureMock，还有两个真实的 Future 实例也会抛出异常）。any(Exception.class) 是一个参数匹配器，表示只要传入的是任何 Exception 类型的参数即可。

四、注意事项与最佳实践

1. 区分 InterruptedException 和 ExecutionException: Future.get() 方法签名中明确抛出这两种异常。在模拟时，根据需要选择抛出哪种异常。通常，业务逻辑错误会被包装在 ExecutionException 中，而线程中断则直接抛出 InterruptedException。
2. CompletableFuture.completeExceptionally() 的模拟: 如果你的代码中使用 CompletableFuture，其内部异常处理通常是通过 completeExceptionally(Throwable ex) 方法完成的。在测试中，你可以模拟 CompletableFuture 内部抛出异常，或者直接模拟 Future.get() 抛出 ExecutionException。
3. 测试的粒度与可读性: 尽量让每个测试方法关注一个特定的场景。例如，一个测试方法模拟 InterruptedException，另一个模拟 ExecutionException。
4. 避免过度模拟: 只有当你需要控制外部依赖的行为（如 Future.get() 的结果或异常）时才使用 Mock。对于业务逻辑本身，应尽量保持其真实性。
5. 明确 catch 块的职责: 确保你的 catch 块有明确的、可测试的副作用（如日志记录、状态更新、通知其他组件），这样才能有效地验证其执行。

五、总结

在 Java 中测试 Future 对象的异常处理逻辑，关键在于两点：一是使用 Mockito.when().thenThrow(exceptionInstance) 正确模拟 Future.get() 方法抛出异常；二是通过 Mockito.spy() 监视 catch 块内部执行的副作用，并使用 Mockito.verify() 验证这些副作用是否按预期发生。通过这种方法，我们可以有效地覆盖异步代码中的异常路径，确保其在面对错误时能够健壮地运行。

今天关于《模拟Future对象异常行为的测试技巧》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！