Mockito模拟Future异常及捕获验证方法

本文旨在解决在使用Mockito测试异步操作时，如何模拟Future.get()方法抛出异常并有效覆盖try-catch块的问题。核心方法是利用Mockito的spy功能，对捕获块内部执行的辅助方法进行监控，从而验证异常是否被正确捕获并处理，确保测试用例能够准确反映代码在异常情况下的行为。

1. 问题背景与挑战

在Java并发编程中，Future接口及其get()方法是获取异步任务结果的关键。然而，get()方法可能会抛出InterruptedException或ExecutionException，这要求我们在生产代码中编写相应的try-catch块进行处理。为了确保这些异常处理逻辑的健壮性，编写测试用例来覆盖这些捕获块变得至关重要。

常见的测试挑战在于，简单地使用Mockito.when().thenThrow()模拟Future.get()抛出异常后，可能难以直接验证捕获块是否被执行。因为测试的重点不仅仅是异常被抛出，更是代码在捕获到异常后所采取的后续行动。

2. 核心解决方案：利用Spy验证捕获块行为

解决此问题的关键在于：在捕获块内部执行一个可被验证的方法，并使用Mockito的spy功能来监控这个方法的调用。 这样，当Future.get()抛出异常并被捕获后，我们可以通过验证内部方法的调用来确认捕获块已被成功覆盖。

2.1 生产代码设计

为了实现可验证的捕获块，我们通常会将异常处理逻辑封装到一个独立的辅助服务中，或者至少确保捕获块内有一个可被外部观察到的副作用（如日志记录、状态更新等）。

以下是一个示例生产代码结构，其中collectAsyncResults方法遍历Future列表，并在捕获到异常时调用myService.logError()：

package de.playground.so74236327;

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

public class ExampleProductionCode {
    List<Future<Class>> futureData;
    EnginesData enginesData;
    MyService myService; // 辅助服务

    public ExampleProductionCode(MyService myService) {
        this.myService = myService;
        futureData = new ArrayList<>();
        enginesData = new EnginesData();
        // 示例：添加一些真实的Future对象
        futureData.add(createAndStartAsyncTask());
        futureData.add(createAndStartFutureTask());
    }

    public List<Future<Class>> getFutureData() {
        return futureData;
    }

    // 模拟异步任务创建，可能抛出异常
    public Future<Class> createAndStartAsyncTask() {
        CompletableFuture<Class> completableFuture = new CompletableFuture<>();
        Executors.newCachedThreadPool().submit(() -> {
            try {
                Thread.sleep(500);
                throw new InterruptedException("Simulated Interruption in AsyncTask");
            } catch (Exception e) {
                completableFuture.completeExceptionally(e); // 异常完成
            }
        });
        return completableFuture;
    }

    public Future<Class> createAndStartFutureTask() {
        FutureTask<Class> ftask = new FutureTask<>(() -> {
            Thread.sleep(500);
            throw new InterruptedException("Simulated Interruption in FutureTask");
        });
        ftask.run(); // 立即执行
        return ftask;
    }

    public void collectAsyncResults() {
        futureData.forEach(result -> {
            try {
                enginesData.add(result.get()); // 尝试获取结果
            } catch (InterruptedException | ExecutionException e) {
                // 捕获块：调用辅助服务记录错误
                myService.logError(e);
            }
        });
    }

    public class EnginesData {
        public void add(Class aclass) {
            // 实际业务逻辑
        }
    }
}

辅助服务MyService：

package de.playground.so74236327;

public class MyService {
    public void logError(Exception e) {
        // 实际的错误处理或日志记录逻辑
        System.err.println("Error logged: " + e.getMessage());
    }
}

2.2 测试用例实现

使用Mockito的@Mock注解创建Future的模拟对象，并使用Mockito.spy()创建MyService的间谍对象。

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
    public Future<Class> futureMock; // 模拟的Future对象

    @Test
    public void testInterruptedExceptionInFutureGet() throws ExecutionException, InterruptedException {
        // 1. 创建MyService的间谍对象
        MyService mySpy = spy(new MyService());

        // 2. 初始化生产代码，注入间谍对象
        ExampleProductionCode exampleProductionCode = new ExampleProductionCode(mySpy);
        List<Future<Class>> futureData = exampleProductionCode.getFutureData();

        // 3. 准备模拟异常
        InterruptedException interruptedException = new InterruptedException("Simulated Interrupted Exception from Mock");

        // 4. 配置futureMock，使其在调用get()时抛出异常
        // 注意：thenThrow()直接接受异常实例，而不是Future包装的异常
        when(futureMock.get()).thenThrow(interruptedException);

        // 5. 将模拟的Future对象添加到生产代码的Future列表中
        futureData.add(futureMock); // 现在futureData包含两个真实Future和一个模拟Future

        // 6. 初始验证：在collectAsyncResults()调用前，logError不应被调用
        verify(mySpy, times(0)).logError(interruptedException);

        // 7. 执行生产代码中的异步结果收集方法
        exampleProductionCode.collectAsyncResults();

        // 8. 最终验证：确认logError方法被调用了3次（2个真实Future的异常 + 1个模拟Future的异常）
        // 使用any(Exception.class)可以匹配任何异常类型
        verify(mySpy, times(3)).logError(any(Exception.class));
    }
}

3. 注意事项与常见问题

• thenThrow()的正确用法： 在模拟方法抛出异常时，thenThrow()方法直接接受一个Throwable（即异常对象）作为参数。例如：when(mockObject.method()).thenThrow(new MyException("message")); 错误的用法是：when(oneFutureData.get()).thenThrow(CompletableFuture.completedFuture(interruptedException)); 这段代码无法编译，因为它试图抛出一个CompletableFuture对象，而不是一个异常。

• 为什么需要spy？ 直接验证catch块本身是困难的，因为catch块只是一个代码区域。通过在catch块内部调用一个服务方法（例如myService.logError(e)），我们就可以将catch块的执行转化为对这个服务方法的一次调用。然后，使用spy来监控这个服务实例，就可以验证该方法是否被调用以及调用时的参数。spy允许我们部分模拟一个真实对象，即保留其原有行为，同时可以验证其方法调用。

• 覆盖多个异常类型： 如果catch块捕获了多种异常（如InterruptedException | ExecutionException），可以通过配置不同的thenThrow来分别模拟这些异常，并验证每次都能正确进入捕获块。

• 测试覆盖率工具： 使用JaCoCo等代码覆盖率工具时，如果捕获块内部没有任何可观测或可验证的行为，即使异常被抛出并捕获，覆盖率工具也可能无法准确报告该捕获块被执行。因此，引入myService.logError(e)这样的可验证行为，不仅有助于测试验证，也有助于提高覆盖率报告的准确性。

4. 总结

通过在try-catch块内部引入一个可被Mockito.spy()监控的辅助方法调用，我们能够有效地模拟Future.get()等异步操作的异常情况，并验证异常捕获块的逻辑是否被正确执行。这种方法将内部状态变化或副作用转化为外部可观察的行为，从而大大增强了测试的可靠性和可维护性，是编写健壮的异步代码测试用例的关键策略。