使用 Mockito 模拟 Runnable 创建线程

Question

我有一个实现Runnable 的类，称为DoThingInALoop。它被提供给第二个类，它将从中创建一个线程，调用这个线程Boss。 Boss 可以告诉 runnable 退出并让线程终止。稍后，它可以使用相同的DoThingInALoop 创建一个新线程。

当我为Boss 编写单元测试时，我想模拟DoThingInALoop，因为它不是被测对象。然而，DoThingInALoop 扩展了一个类Loop，而Loop 的代码实际上是在Boss 产生的线程中执行的。该代码当然会遇到NullPointerExceptions，因为没有设置任何成员变量，因为该对象被模拟了。

如何防止 Java 的 Thread“看穿”模拟？

public class Loop implements Runnable {
    private final Object member = new Object();
    public final void run() {
        // This code runs, but it shouldn't
        synchronized (member) { // Throws NPE
            ...
        }
        // Hook for subclasses
        try {
            subclassRun();
        } finally {
            // Mandatory cleanup (unrelated to question)
        }
}

public class DoThingInALoop extends Loop {
    public void subclassRun() { ... }
    public void stopDoingThingsInALoop() {
        // Set instance member that on next loop iteration signals thread to return
    }
}

public class Boss {
    private final DoThingsInALoop toBeMocked;
    public Boss(final DoThingsInALoop toBeMocked) {
        this.toBeMocked = toBeMocked;
    }
    public void start() {
        // Simplified
        new Thread(toBeMocked).start();
    }
    public void stop() {
        toBeMocked.stopDoingThingsInALoop();
    }
}


public class TestClass {
    @Test
    public void aTest() {
        // Setup Mocks
        DoThingsInALoop mockLoop = mock(DoThingsInALoop.class);
        Boss boss = new Boss(mockLoop);

        // Run test
        boss.start();

        // After the above line runs, a new thread is started and
        // the run() method of `Loop` executes until the NPE
        // is hit when it attempts to access a member variable
        // which is of course not set because it is a mocked object

        ...
    }
}

Answer 1

我认为这对 Mockito 来说太过分了。

我会将线程执行封装在一个新类中，您可以轻松地模拟它（我们称之为Executor）。

public class Executor {
    public void execute(Runnable runnable) {
        new Thread(runnable).start();
    }
}

然后在创建Thread的地方使用Executor。

public class Boss {
    private final DoThingInALoop toBeMocked;
    private final Executor executor;

    public Boss(final Executor executor, final DoThingInALoop toBeMocked) {
        this.executor = executor;
        this.toBeMocked = toBeMocked;
    }

    public void start() {
        executor.execute(toBeMocked);
    }
}

在您的测试中，您只需要模拟Executor。

    DoThingInALoop mockLoop = Mockito.mock(DoThingInALoop.class);
    Executor mockExecutor = Mockito.mock(Executor.class);
    Boss boss = new Boss(mockExecutor, mockLoop);

    boss.start();

    // No NPE aynymore
    verify(mockExecutor).execute(mockLoop);

另一种选择是尝试PowerMock