常见的场景
有些时候我们需要测试有回调的函数,这意味着它们是异步执行的。这些方法测试起来并不那么容易，使用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<String> result);
public void onFail(int code);
}
DummyCaller类 ：
public class DummyCaller implements DummyCallback {
// 执行异步操作的代理类
private final DummyCollaborator dummyCollaborator;
// 执行结果
private List<String> result = new ArrayList<String>();
public DummyCaller(DummyCollaborator dummyCollaborator) {
this.dummyCollaborator = dummyCollaborator;
}
public void doSomethingAsynchronously() {
dummyCollaborator.doSomethingAsynchronously(this);
}
public List<String> getResult() {
return this.result;
}
@Override
public void onSuccess(List<String> 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<DummyCallback> 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<String> 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<String> 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)));
}
