模拟 Future 对象异常行为的测试策略与实践

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

// 假设 futureMock 是一个 Future<Class> 类型的 Mock 对象
Future<Class> 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("内部业务错误")));

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

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

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

public class ExampleProductionCode {
    private List<Future<Class>> 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<Future<Class>> getFutureData() {
        return futureData;
    }

    // 模拟一个 CompletableFuture 异步任务，可能抛出异常
    public Future<Class> createAndStartAsyncTask() {
        CompletableFuture<Class> 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<Class> createAndStartFutureTask() {
        FutureTask<Class> 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) {
            // 实际的数据添加逻辑
        }
    }
}

// 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<Class> 类型的 Mock 对象
    public Future<Class> 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<Future<Class>> 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); // 验证模拟的异常被处理
    }
}