Android单元测试之 Mockito
1. 介绍
1.1 Mock介绍
在了解Mockito的概念之前，需要先了解Mock。
mock是在测试过程中，对于一些不容易构造/获取的对象，用一个虚拟的Mock对象来创建以便测试的测试方法。
在平时开发中，当我们开发好一个功能，但是没有需要的测试环境时，往往我们互自己带“假数据”写死，进去测试。
这样做虽然能够帮助我们找到Bug，但是“假数据”对开发来说并不友好，这使得虚拟数据与业务层耦合在一起，我们不仅需要手动加入，还要手动删除，如果遇到复杂点的对象，还要考虑如何在运行中去构建。在这些环节中如果一些细节没有处理，可能打出来的包就有问题。作为一中测试的手段，这种做法容错率低。
但是在部分情况下上述的方法效率还是很高的（我也经常这么搞）。
而Mock基本上就是对上述的手段进行了优化。解耦了虚拟数据与业务层，并且更加系统化整个测试流程。
1.2 Mock优势
它有这些好处：
- 团队提效
当使用mock之后，各团队之间可以不需要再互相等待对方的进度，只需要约定好相互之间的数据规范（文档），即可使用mock构建一个可用的接口，然后尽快的进行开发和调试以及自测，提升开发进度的的同时，也将发现缺陷的时间点大大提前。 - 开启
TDD（Test-Driven Development）模式，即测试驱动开发
单元测试是TDD实现的基石，而TDD经常会碰到协同模块尚未开发完成的情况，但是有了mock，这些一切都不是问题。当接口定义好后，测试人员就可以创建一个Mock，把接口添加到自动化测试环境，提前创建测试。 - 测试覆盖率
假如有一个接口，有100个不同类型的返回，我们需要测试它在不同返回下，系统是否能够正常响应，但是有些返回在正常情况下基本不会发生，难道你要千方百计地给系统做各种手脚让他返回以便测试吗？比如，我们需要测试在当接口发生500错误的时候，app是否崩溃，别告诉我你一定要给服务端代码做些手脚让他返回500 。。。而使用mock，这一切就都好办了，想要什么返回就模拟什么返回，妈妈再也不用担心我的测试覆盖度了！ - 隔离系统 / 依赖隔离
假如我们需要调用一个post请求，为了获得某个响应，来看当前系统是否能正确处理返回的“响应”，但是这个post请求会造成数据库中数据的污染，那么就可以充分利用Mock，构造一个虚拟的post请求，我们给他指定返回就好了。
1.3 Mock例子
一个闹钟根据时间来进行提醒服务，如果过了下午5点钟就播放音频文件提醒大家下班了，如果我们要利用真实的对象来测试的话就只能苦苦等到下午五点，然后把耳朵放在音箱旁，我们应该利用mock对象来进行测试，这样我们就可以模拟控制时间了，而不用苦苦等待时钟转到下午5点钟了。下面是代码：
public abstract class Environmental{
// 是否正在播放音频
boolean playedWav=false;
// 获取当前时间
public abstract long getTime();
// 播放音频
public abstract void playWavFile(String fileName);
// 音频是否在播放
public abstract boolean wavWasPlayed();
// 重置音频
public abstract void resetWav();
}
业务代码：
public class SystemEnvironment extends Environmental{
public long getTime(){
return System.currentTimeMillis();
}
public void playWavFile(String fileName){
playedWav=true;
}
public boolean wavWasPlayed(){
return playedWav;
}
public void resetWav(){
playedWav=false;
}
}
下面是Mock对象，我们来Mock我们写好的方法
public class MockSystemEnvironment extends Environmental{
private long currentTime;
public long getTime(){
return currentTime;
}
public void setTime(long currentTime){
this.currentTime=currentTime;
}
public void playWavFile(String fileName){
playedWav=true;
}
public boolean wavWasPlayed(){
return playedWav;
}
public void resetWav(){
playedWav=false;
}
}
这样我们通过Mock出来的对象，就可以随时模拟时间的流动的。
1.4 Mockito介绍
Mockito是Mock框架下的一种实现，所以Mockito的测试思想就是Mock的测试思想。
目前Android较为普遍的单元测试工具的使用就是 Junit4+Mocikto， 除了Mockito还有像 powermock、jmock，从名字上就可以看出他们都离不开Mock对象。
注意 Junit和Mockito是可以组合使用的，它们本身并不冲突，反而相得益彰。
2. Mockito的使用
2.1 导入
Mockito在mockito包下，所以和junit4不一样，需要我们手动导入:
dependencies {
...
testImplementation "org.mockito:mockito-core:3.3.3"
androidTestImplementation 'org.mockito:mockito-android:3.3.3'
}
2.2 Mock类声明
我们来Mock一个List
var myList: MutableList<Int>? = null
@Before
fun setUp() {
// 初始化的函数
myList= mock(MutableList<Int>::class.java)
}
在测试开始，我们需要在初始化函数里面对需要Mock的对象调用 mock()方法来进行声明，或者我们可以通过注解的方式来声明：
@Mock
var myList: MutableList<Int>? = null
@Before
fun setUp() {
MockitoAnnotations.initMocks(this)
}
亦或是直接使用Junit的 @RunWith注解，进行初始化：
@RunWith(MockitoJUnitRunner::class)
class MyUnitTest {
@Mock
var myList: MutableList<Int>? = null
..
}
2.3 verify
2.3.1 verify
verify()用于检查是否发生了某些行为。我们可以在测试方法代码的末尾使用Mockito验证方法，以确保调用了指定的方法。- 我们可以使用
verifyNoMoreInteractions()来确保所有内容均已通过验证。如果仍然有任何方法验证，它将失败并提供正确的消息。 verifyZeroInteractions()行为与verifyNoMoreInteractions()方法相同。- 我们可以使用
inOrder()方法来验证方法调用的顺序。
来看一下代码：
@Test
fun test() {
myList?.add(1)
myList?.clear()
verify(myList)?.add(1)
verify(myList)?.clear()
}
还可以用来验证调用的次数，下面是用verify来判断函数调用了多少次：
@Test
fun test() {
myList?.size
verify(myList, times(0))?.add(1) // 判断add被调用了0次
verify(myList, times(1))?.size // 判断size被调用了1次
verify(myList, atLeast(1))?.size // 判断size被调用了至少一次
verify(myList, atLeastOnce())?.size // 同上，相同于atLiast(1)
verify(myList, atMost(2))?.size // 判断size被调用少于2次
verify(myList, never())?.clear() // 判断clear没有被调用过
verify(myList, only())?.clear() // 判断是否只调用过clear方法
}
2.3.2 verifyNoMorInteractions /
该方法调用后，表明之后再也没有Mock对象的交互了，所以一般用在测试方法的最后面。
// 表明之后再也没有myList的事情了， 这个地方可以跑通
verifyNoMoreInteractions(myList);
// 又操作了myList
myList.isEmpty();
// 因为之前已经声明不会再调用myList了，这里做了检查发现它使用过，所以这里会报错
verifyNoMoreInteractions(myList);
verifyZeroInteractions() 和该方法行为相同，不作赘述。
2.3.3 InOrder
可以使用 InOrder来验证调用的顺序：
@Test
fun test() {
myList?.size
mySet?.add(100)
myList?.add(1)
myList?.add(2)
myList?.clear()
mySet?.clear()
val inOrder = inOrder(myList, mySet)
inOrder.verify(myList)?.size
inOrder.verify(mySet)?.add(100)
inOrder.verify(myList)?.add(2)
// 测试可以通过
}
用来判断调用方法的顺序，也可以加入多个对象。
它就像字符串匹配中不连续子串的匹配~
2.4 when
when 像一个监听器，当事件触发时，会回调你想要的操作
下面是一个例子：
@RunWith(MockitoJUnitRunner::class)
class MyUnitTest {
@Mock
var myList: MutableList<Int>? = null
@Before
fun setUp() {
// 定义Mock行为，当调用 get（任何数）时，返回100
`when`(myList?.get(ArgumentMatchers.anyInt())).thenReturn(100)
}
@Test
fun test() {
// 调用Mock对象的行为
val res = myList?.get(1)
// 比较实际结果与预期结果
assertEquals(res, 100)
//测试通过
}
}
在初始化函数中，使用when()对Mock对象进行了监听，thenReturn() 就是回调，相当于Hook了Mock对象的返回结果。
除了thenReturn()，还有其他回调的Api，比如：
thenThrow() // 抛出一个异常
thenCallRealMethod() // 回调某个已经实现的方法
thenAnswer() // 捕捉数据别回调重写的方法
then() // 和 thenAnswer一样
2.5 doThrow
注：不知道为啥，使用Kotlin后，doThrow会莫名执行错误，而Java则没有问题，网上也没有找到解决办法，所以这里使用Java演示，可能Mokito使用在Kt上还是有一些坑的。
上一节中，有个语句是 when(...).thenThrow()，但是如果我们 when语句里的方法是 void返回类型，则编译不通过，如下：
public class ExampleService
{
public void hello(){
System.out.println("hello");
}
}
...
when(exampleService.hello()).thenThrow(new RuntimeException());
// 编译报错
这是因为 when语句的返回不能为void，所以这个时候需要使用 doThrow来解决：
public class ExampleServiceTest
{
@Mock
ExampleService exampleService;
@Before
public void setUp()
{
MockitoAnnotations.initMocks(this);
doThrow(new RuntimeException()).when(exampleService).hello();
}
@Test(expected = RuntimeException.class)
public void test()
{
exampleService.hello();
}
}
除了 doThrow()，还有其他针对于 void型函数的监听，比如：
doNothing() // 什么都不做
doReturn() // 返回一个值
doAnswer() // 回掉一个函数
3. Mokito spy和 @Spy
Mokito下测试除了针对于Mock类，还有 Spy类。
3.1 spy类介绍
spy类和mock类不同，他们有以下区别：
- mock对象：完全虚构，除了自定义的行为之外，没有其他行为
- spy对象：部分虚构对象，除了自定义行为外，其他行为参考真实对象的行为
也就是说 Mock对象是完全由虚拟数据构成的对象，而Spy对象则会监听真实对象的行为，又自定义了部分的行为。
3.2 spy对象的声明
声明spy对象和mock差不多，如下所示
Spy类：
open class MathHelper {
/**
* 计算斐波那契
*/
fun factorial(n: Int): Int {
return when {
n < 0 -> {
throw Exception("负数没有阶乘")
}
n <= 1 -> {
1
}
else -> {
n * factorial(n - 1)
}
}
}
}
测试类：
class SpyTest {
@Spy
var mathHelper: MathHelper? = null
@Before
fun setUp() {
MockitoAnnotations.initMocks(this)
//或者 ： mathHelper = spy(MathHelper::class.java)
}
@Test
fun test() {
Assert.assertEquals(mathHelper?.factorial(5), 120)
}
}
如果Spy的类是只有 有参构造函数的类，那么需要这样写才能初始化成功：
// 需要在声明时 new出来
@Spy
var mathHelper: MathHelper = MathHelper(1)
而Mock对象则不会。
所以这就看出，Spy对象是基于真实对象上的，它所走的方法其实就是用一个真实对象来走。
3.3 spy测试
来看下面的代码：
class SpyTest {
@Spy
var myList: MutableList<Int> = mutableListOf()
@Before
fun setUp() {
MockitoAnnotations.initMocks(this)
}
@Test
fun test() {
// doXX 会调用真实对象的方法
doReturn(1).`when`(myList)[100]
assertEquals(1, myList[100])
// 上面测试通过
// whenXX 不会调用真实对象的方法
`when`(myList[50]).thenReturn(1)
assertEquals(1, myList[50])
// 上面测试不通过
}
}
我们的 myList是空的，测试发现
- 当使用
do..when的语句时，会避免调用真实对象的方法，使用虚假的数据，测试通过 - 当使用
when...then语句时，会调用 spy对象真正的方法，因为 list本来是空的，所以取第50个值明显越界，所以测试不通过
spy在 PowerMock里面使用广泛，所以后面还会学习到它的用处
4. @InjectMocks注解
网上看到的解释非常令人难以理解，看得我 …disgusting
由于时间问题，后面再去看官方注释，所以这里
// TODO