如何在Mockito中正确模拟Future.get()方法抛出异常并验证异常处理

public class ExampleProductionCode {
    // ... 其他成员和方法 ...
    private MyService myService; // 用于处理异常的服务

    public ExampleProductionCode(MyService myService) {
        this.myService = myService;
        // ...
    }

    public void collectAsyncResults() {
        // enginesData 是一个用于收集结果的容器
        EnginesData enginesData = this.getEngineData();
        futureData.forEach(result -> {
            try {
                enginesData.add(result.get()); // 尝试获取Future结果
            } catch (InterruptedException | ExecutionException e) {
                // 期望被测试的catch块
                myService.logError(e); // 在catch块中执行一个可观察的操作
            }
        });
    }

    // 内部类或辅助类
    public class EnginesData { /* ... */ }
}

public class MyService {
    public void logError(Exception e) {
        // 实际的错误日志记录或处理逻辑
    }
}

import org.mockito.Mockito;
import java.util.concurrent.Future;
import java.util.concurrent.InterruptedException;
import java.util.concurrent.ExecutionException;

// 假设 futureMock 是一个通过 @Mock 注解或 Mockito.mock() 创建的 Future<Class> 实例
Future<Class> futureMock = Mockito.mock(Future.class);
InterruptedException interruptedException = new InterruptedException("模拟中断异常");

// 当 futureMock.get() 被调用时，抛出 interruptedException
Mockito.when(futureMock.get()).thenThrow(interruptedException);

// 如果需要模拟 ExecutionException
ExecutionException executionException = new ExecutionException("模拟执行异常", new Throwable("内部原因"));
Mockito.when(futureMock.get()).thenThrow(executionException);

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 java.util.ArrayList; // 导入 ArrayList

import static org.mockito.Mockito.*;

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

    @Mock // 声明一个 Future 的 Mock 对象
    public Future<Class> futureMock;

    @Test
    public void testInterruptedExceptionInFutureGet() throws ExecutionException, InterruptedException {
        // 1. 准备被测试的服务实例
        // MyService 是一个真实的服务，我们对其进行 spy
        MyService mySpy = spy(new MyService());

        // ExampleProductionCode 依赖 MyService，注入 spy 后的 MyService
        ExampleProductionCode exampleProductionCode = new ExampleProductionCode(mySpy);

        // 获取生产代码中用于处理 Future 对象的列表
        List<Future<Class>> futureData = exampleProductionCode.getFutureData();

        // 2. 模拟异常
        InterruptedException interruptedException = new InterruptedException("模拟中断异常");
        // 当 futureMock.get() 被调用时，抛出 interruptedException
        when(futureMock.get()).thenThrow(interruptedException);

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

        // 在调用 collectAsyncResults() 之前，验证 logError 尚未被调用
        verify(mySpy, times(0)).logError(interruptedException);

        // 3. 执行被测试的方法
        // collectAsyncResults() 方法会遍历 futureData 并调用 Future.get()
        exampleProductionCode.collectAsyncResults();

        // 4. 验证 catch 块是否被执行
        // 验证 mySpy 的 logError 方法是否被调用了指定次数，并传入了任意 Exception
        // 这里假设 exampleProductionCode 内部原有2个 Future，加上我们添加的1个 Mock Future，总共会调用3次
        verify(mySpy, times(3)).logError(any(Exception.class));
    }
}

// ExampleProductionCode.java
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 EnginesData getEngineData() {
        return enginesData;
    }

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

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

    // 模拟另一个异步任务，可能抛出异常
    public Future<Class> createAndStartFutureTask() {
        FutureTask<Class> ftask = new FutureTask<>(() -> {
            Thread.sleep(50); // 模拟耗时操作
            throw new InterruptedException("模拟FutureTask内部中断");
        });
        // 注意：这里直接运行 ftask.run()，通常异步任务由 ExecutorService 提交
        // 在实际场景中，FutureTask 会提交给 ExecutorService
        // 为了演示，这里简化直接运行
        new Thread(ftask).start(); // 在单独线程中启动，以便 get() 阻塞
        return ftask;
    }

    public void collectAsyncResults() {
        ExampleProductionCode.EnginesData enginesData = this.getEngineData();
        futureData.forEach(result -> {
            try {
                enginesData.add(result.get());
            } catch (InterruptedException | ExecutionException e) {
                myService.logError(e); // 异常处理逻辑
            }
        });
    }

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

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

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