Mockito 如何验证 Executor 方法调用

本文将探讨在使用 Mockito 框架进行单元测试时，如何验证在 Executor.execute() 方法内部调用的方法。 当被验证的方法调用发生在由 Executor 执行的异步任务中时，直接使用 Mockito.verify() 可能会导致验证失败，因为验证线程和实际执行线程不同。 解决此问题的一种有效方法是使用同步执行器，例如 SynchronousExecutor，它可以强制任务同步执行，从而简化测试并确保方法调用可以被正确验证。

问题背景

在单元测试中，我们经常需要验证某个方法是否被调用以及调用了多少次。当方法调用发生在异步执行的环境中，例如通过 Executor 框架提交的任务，验证过程会变得复杂。 默认情况下，Executor 会在不同的线程中执行任务，这导致 Mockito 的验证机制无法直接捕获到方法调用。

解决方案：使用 SynchronousExecutor

SynchronousExecutor 是一个简单的 Executor 实现，它会在调用线程中立即执行提交的任务，而不是将其提交到单独的线程。 这使得我们可以像同步代码一样验证方法调用。

步骤如下：

1. 创建 SynchronousExecutor 实例：

   Executor executor = new SynchronousExecutor();

2. 将 SynchronousExecutor 注入到被测试类中：

   这一步至关重要，确保被测试类使用我们控制的 Executor 实例。 具体注入方式取决于被测试类的设计，可以使用构造函数注入、setter 方法注入或字段注入。 例如，如果被测试类如下：

   public class MyClass {
       private final Executor executor;
       private final MessageHandler messageHandler;
   
       public MyClass(Executor executor, MessageHandler messageHandler) {
           this.executor = executor;
           this.messageHandler = messageHandler;
       }
   
       public void doSomething(Message message) {
           executor.execute(() -> prepareContext(message));
       }
   
       private void prepareContext(Message message) {
           messageHandler.handleMessage(message);
       }
   }

   那么在测试中，我们需要这样创建 MyClass 实例：

   MessageHandler messageHandler = Mockito.mock(MessageHandler.class);
   Executor executor = new SynchronousExecutor();
   MyClass myClass = new MyClass(executor, messageHandler);

3. 执行被测试方法：

   Message message = new Message(); // 假设 Message 是一个类
   myClass.doSomething(message);

4. 验证方法调用：

   Mockito.verify(messageHandler).handleMessage(message);

示例代码

以下是一个完整的示例，展示如何使用 SynchronousExecutor 验证 handleMessage 方法的调用：

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import java.util.concurrent.Executor;

import static org.mockito.Mockito.verify;

class MyClassTest {

    interface MessageHandler {
        void handleMessage(Message message);
    }

    static class Message {}

    static class MyClass {
        private final Executor executor;
        private final MessageHandler messageHandler;

        public MyClass(Executor executor, MessageHandler messageHandler) {
            this.executor = executor;
            this.messageHandler = messageHandler;
        }

        public void doSomething(Message message) {
            executor.execute(() -> prepareContext(message));
        }

        private void prepareContext(Message message) {
            messageHandler.handleMessage(message);
        }
    }

    static class SynchronousExecutor implements Executor {
        @Override
        public void execute(Runnable command) {
            command.run();
        }
    }

    @Test
    void testHandleMessageIsCalled() {
        MessageHandler messageHandler = Mockito.mock(MessageHandler.class);
        Executor executor = new SynchronousExecutor();
        MyClass myClass = new MyClass(executor, messageHandler);
        Message message = new Message();

        myClass.doSomething(message);

        verify(messageHandler).handleMessage(message);
    }
}

注意事项

• 确保被测试类可以通过依赖注入的方式接收 Executor 实例。
• SynchronousExecutor 仅适用于单元测试环境，不应在生产环境中使用。
• 对于更复杂的异步场景，可能需要使用更高级的测试技术，例如使用 CountDownLatch 或其他同步机制来等待异步任务完成。

总结

通过使用 SynchronousExecutor，我们可以轻松地验证在 Executor.execute() 方法内部调用的方法。 这种方法简化了单元测试，并确保我们可以准确地验证异步代码的行为。 记住，这种方法主要用于单元测试，不应在生产代码中使用。在生产环境中，应该使用真实的异步 Executor 实现，并使用适当的监控和日志记录来跟踪异步任务的执行情况。