使用Mockito测试Java Future对象中的异常处理

package de.playground.so74236327;

public class MyService {
    public void logError(Exception e) {
        // 实际的错误记录逻辑，例如写入日志文件或发送告警
        System.err.println("Error logged: " + e.getMessage());
    }
}

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; // 注入MyService

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

    // ... 其他方法，如getFutureData()，getEngineData()，createAndStartAsyncTask()，createAndStartFutureTask() ...
    // createAndStartAsyncTask 和 createAndStartFutureTask 内部可以模拟抛出InterruptedException

    public void collectAsyncResults() {
        futureData.forEach(result -> {
            try {
                enginesData.add(result.get()); // 尝试获取Future结果
            } catch (InterruptedException | ExecutionException e) {
                // 关键：在捕获块中调用可验证的服务方法
                myService.logError(e);
            }
        });
    }

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

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 JUnit 5扩展
public class FutureExceptionTest {

    @Mock // 使用@Mock注解创建Future的模拟对象
    public Future<Class> futureMock;

    @Test
    public void testInterruptedException() throws ExecutionException, InterruptedException {
        // 1. Spy MyService实例
        // 我们需要监视MyService的真实行为，以便验证logError是否被调用
        MyService mySpy = spy(new MyService());

        // 2. 实例化生产代码，并注入spy后的MyService
        ExampleProductionCode exampleProductionCode = new ExampleProductionCode(mySpy);

        // 获取Future列表，其中包含两个真实Future对象（它们可能内部抛异常）
        List<Future<Class>> futureData = exampleProductionCode.getFutureData();

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

        // 4. 配置futureMock的get()方法在调用时抛出异常
        // 注意：这里直接thenThrow(interruptedException)，而不是thenThrow(CompletableFuture.completedFuture(interruptedException))
        when(futureMock.get()).thenThrow(interruptedException);

        // 5. 将模拟的futureMock添加到futureData列表中
        // 这样在collectAsyncResults执行时，会有一个Future对象是模拟的，会抛出我们设定的异常
        futureData.add(futureMock);

        // 在collectAsyncResults()调用之前，logError应该没有被调用过
        verify(mySpy, times(0)).logError(interruptedException);

        // 6. 执行生产代码中包含Future.get()调用的方法
        exampleProductionCode.collectAsyncResults();

        // 7. 验证logError方法是否被调用
        // 假设collectAsyncResults()处理了3个Future：
        // - 两个来自ExampleProductionCode内部创建的真实Future，它们可能抛出异常。
        // - 一个是我们添加的futureMock，它会抛出interruptedException。
        // 因此，logError应该被调用3次（如果所有Future都导致异常）。
        verify(mySpy, times(3)).logError(any(Exception.class)); // 验证任何Exception类型的调用
        // 如果想验证特定异常，可以这样：
        // verify(mySpy, times(1)).logError(interruptedException); // 验证模拟的InterruptedException被捕获
    }
}