Mockito模拟Futureget异常及验证方法

本文深入解析了在Java单元测试中，如何利用Mockito框架模拟`Future.get()`方法抛出`InterruptedException`或`ExecutionException`，并有效验证代码中`catch`块的执行情况。重点阐述了`thenThrow()`的正确使用方式，强调直接传入异常实例而非包裹`Throwable`的`Future`对象。为确保测试覆盖率，文章提出引入可观察的服务方法，并结合`Mockito.spy()`和`verify()`机制，监视和断言异常处理逻辑的执行。通过实例代码，详细展示了如何准备Mock对象、模拟异常抛出、以及验证服务方法是否被正确调用，为开发者提供了模拟异步任务异常处理的有效方法，从而提升代码的健壮性和可测试性。

本文深入探讨了在单元测试中，如何使用Mockito正确模拟Future对象的get()方法抛出InterruptedException或ExecutionException，以及如何有效验证代码中的catch块是否被正确执行。核心在于理解thenThrow()的正确用法，以及通过引入可观察的服务方法并结合Mockito的spy()和verify()机制，确保异常处理逻辑得到了充分测试覆盖。

在Java并发编程中，Future接口及其get()方法是获取异步任务结果的关键。然而，get()方法声明可能抛出InterruptedException和ExecutionException，这使得在编写单元测试时，模拟这些异常的发生以覆盖相应的catch块成为一项常见的挑战。本教程将详细阐述如何克服这一挑战。

理解Future.get()与异常模拟的挑战

当我们的业务代码处理Future结果时，通常会包含一个try-catch块来捕获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) {
        // 实际的错误日志记录或处理逻辑
    }
}

在测试上述代码中的catch块时，我们希望模拟result.get()抛出异常。初学者可能会尝试使用类似when(oneFutureData.get()).thenThrow(CompletableFuture.completedFuture(interruptedException));的方式，但这通常会导致编译错误或无法达到预期效果。原因在于thenThrow()期望直接接收一个Throwable实例，而不是一个包裹了Throwable的Future对象。

正确模拟Future.get()抛出异常

要让一个被Mock的Future对象在调用get()时抛出特定异常，正确的Mockito语法是直接传入异常实例：

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

验证catch块的执行

仅仅模拟异常的抛出不足以证明catch块被覆盖。单元测试的目的是验证代码的行为，这意味着我们需要一个可观察的副作用来确认catch块确实被执行了。在上述示例中，我们在catch块中调用了myService.logError(e)。我们可以利用Mockito的spy()功能来监视这个服务方法。

spy()允许我们对真实对象进行部分模拟，即我们可以在调用真实方法的同时，验证这些方法的调用情况。

以下是完整的测试用例示例：

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、MyService以及EnginesData的完整实现。这些实现应与问题描述中的生产代码结构相符。

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

关键点与注意事项

1. thenThrow()的参数类型： 确保thenThrow()方法接收的是一个Throwable实例，而不是一个Future或CompletableFuture对象。
2. 可观察的副作用： 为了验证catch块的执行，必须在catch块内部执行一个可被外部测试代码观察到的操作，例如调用一个服务方法、修改一个共享变量等。
3. spy()与verify()： 当需要验证真实对象的某个方法是否被调用时，spy()是比mock()更合适的选择。spy()允许对象的大部分行为保持真实，同时可以对特定方法进行验证或桩化。verify()则用于断言方法被调用的次数和参数。
4. 异常类型匹配： 确保模拟抛出的异常类型与Future.get()方法签名中声明的异常类型（InterruptedException或ExecutionException）以及catch块捕获的异常类型相匹配。
5. 测试的隔离性： 尽管本例为了演示完整流程包含了生产代码中的真实Future创建，但在实际单元测试中，应尽量隔离被测试单元，确保测试结果仅受控于模拟对象。

总结

通过本教程，我们学习了如何在Mockito中高效地模拟Future.get()方法抛出异常，并验证相应的catch块是否被正确触发。核心在于理解thenThrow()的正确用法，以及通过引入可观测的服务方法，并结合spy()和verify()机制来构建健壮的单元测试，从而确保异步任务的异常处理逻辑得到了充分的测试覆盖。这种方法不仅适用于Future，也适用于任何需要测试异常处理逻辑的场景。

理论要掌握，实操不能落！以上关于《Mockito模拟Futureget异常及验证方法》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！