使用Mockito对异步方法进行单元测试

• 原文链接 : Unit testing asynchronous methods with Mockito

常见的场景

有些时候我们需要测试有回调的函数,这意味着它们是异步执行的。这些方法测试起来并不那么容易，使用Thread.sleep(milliseconds)来等待它们执行完成只能说是一种蹩脚的实现，并且会让你的测试具有不确定性。那么我们如何来对异步函数进行测试呢？Mockito拯救了我们！

示例

假设我们有一个实现了DummyCallback接口的DummyCaller类，在DummyCaller中有一个doSomethingAsynchronously()函数，该函数会调用DummyCollaborator类的doSomethingAsynchronously(DummyCallback callback)函数，在调用该函数时将这个callback参数设置为该DummyCaller对象。当doSomethingAsynchronously(DummyCallback callback)的任务在后台线程中执行完成之后就会回调这个callback。还是直接看代码会更容易理解 :

DummyCallback接口 ：

public interface DummyCallback {
    public void onSuccess(List result);
    public void onFail(int code);
}

DummyCaller类 ：

public class DummyCaller implements DummyCallback {
    // 执行异步操作的代理类
    private final DummyCollaborator dummyCollaborator;
    // 执行结果
    private List result = new ArrayList();

    public DummyCaller(DummyCollaborator dummyCollaborator) {
        this.dummyCollaborator = dummyCollaborator;
    }

    public void doSomethingAsynchronously() {
        dummyCollaborator.doSomethingAsynchronously(this);
    }

    public List getResult() {
        return this.result;
    }

    @Override
    public void onSuccess(List result) {
        this.result = result;
        System.out.println("On success");
    }

    @Override
    public void onFail(int code) {
        System.out.println("On Fail");
    }
}

真正的异步执行操作的DummyCollaborator类：

public class DummyCollaborator {

    public static int ERROR_CODE = 1;

    public DummyCollaborator() {
        // empty
    }

    public void doSomethingAsynchronously (final DummyCallback callback) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                    callback.onSuccess(Collections.EMPTY_LIST);
                } catch (InterruptedException e) {
                    callback.onFail(ERROR_CODE);
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

创建我们的测试类

我们有2种不同的选择来测试我们的异步函数，但是首先我们先创建一个DummyCollaboratorCallerTest测试类。

public class DummyCollaboratorCallerTest {

    // 要测试的类型
    private DummyCaller dummyCaller;

    @Mock
    private DummyCollaborator mockDummyCollaborator;

    @Captor
    private ArgumentCaptor dummyCallbackArgumentCaptor;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        dummyCaller = new DummyCaller(mockDummyCollaborator);
    }
}

在setup函数中我们使用MockitoAnotations来初始化 Mock和ArgumentCaptor,我们暂时还不需要关心它们。

在这里我们需要关心的是在测试执行之前初始化了Mock对象和被测试的类，这些初始化代码都在setup中。记住，所有要测试的函数都要被测试两次。

让我们来看看下面的两种测试方案。

【为我们的回调设置一个Anwser】

我们使用doAnswer()来为一个函数进行打桩以测试异步函数的测试用例。doAnswer一般和when配合使用，当条件满足是，执行对应的Answer的answer方法，如果answer方法抛出异常，那么测试不通过。

这意味着我们需要理解返回一个回调（同步的），当被测试的方法被调用时我们生成了一个通用的anwser,这个回调会被执行。最后，我们调用了doSomethingAsynchronously函数，并且验证了状态和交互结果。

@Test
    public void testDoSomethingAsynchronouslyUsingDoAnswer() {
        final List results = Arrays.asList("One", "Two", "Three");
        // 为callback执行一个同步anwser
        doAnswer(new Answer() {
            @Override
            public Object answer(InvocationOnMock invocation) throws Throwable {
                ((DummyCallback)invocation.getArguments()[0]).onSuccess(results);
                return null;
            }
        }).when(mockDummyCollaborator).doSomethingAsynchronously(
                any(DummyCallback.class));

        // 调用被测试的函数
        dummyCaller.doSomethingAsynchronously();

        // 验证状态与结果
        verify(mockDummyCollaborator, times(1)).doSomethingAsynchronously(
                any(DummyCallback.class));
        assertThat(dummyCaller.getResult(), is(equalTo(results)));
    }

【使用ArgumentCaptor】

第二种实现是使用ArgumentCaptor。在这里我们的callback是异步的: 我们通过ArgumentCaptor捕获传递到DummyCollaborator对象的DummyCallback回调。

最终，我们可以在测试函数级别进行所有验证，当我们想验证状态和交互结果时可以调用onSuccess()。

@Test
    public void testDoSomethingAsynchronouslyUsingArgumentCaptor() {
        // 调用要被测试发函数
        dummyCaller.doSomethingAsynchronously();

        final List results = Arrays.asList("One", "Two", "Three");

        // Let's call the callback. ArgumentCaptor.capture() works like a matcher.
        verify(mockDummyCollaborator, times(1)).doSomethingAsynchronously(
                dummyCallbackArgumentCaptor.capture());

        // 在执行回调之前验证结果
        assertThat(dummyCaller.getResult().isEmpty(), is(true));

        // 调用回调的onSuccess函数
        dummyCallbackArgumentCaptor.getValue().onSuccess(results);

        // 再次验证结果
        assertThat(dummyCaller.getResult(), is(equalTo(results)));
    }