Mock is Useful and Necessary

Unit Test

一般来说，我们应该为一个类中每一个对外公开的方法创建单元测试。书写单元测试的一般步骤应该是这样的：

创建对应的需要测试的类的实例；根据具体需要测试的方法来决定是否需要创建实例对象，静态方法不需要对应实例，实例方法则需要。
调用需要测试的方法；调用具体的类方法或者是在上一步的实例对象上调用实例方法。
使用Assert语句来断言。判断方法的返回值和我们预期的值是否相等，相等则测试通过；否则会抛出AssertionError，测试失败。JUnit不会立即终止执行，而是会统一记录这些失败的，等到所有Test Class执行完毕后最后给出结果反馈。

很简单，对吧？Not Exactly！！！上面的步骤其实是建立在测试方法有返回值的情况下的，如果一个方法仅仅执行某些动作，并没有返回值呢？

public class SomeActions {

    ActionsImp imp;

    public SomeActions(ActionsImp imp) {
        this.imp = imp;
    }

    public void noResultAction(int value){
        imp.doSomething(value);
    }
}

我们怎么测试SomeActions中的noResultAction方法？因为没有可用的返回值可用来比对，为了测试这个方法，我们只能换个角度去验证imp对象的doSomething方法被调用，且调用参数为value值。Oh，No！How To Do？别担心，一切的一切，使用Mock框架就行！

What is Mock & How to Use

到底什么是Mock呢？Mock的英文解释是模拟、伪造。废话不多说，Mock框架其实就是允许我们模拟需要测试的类，从而可以验证或者代理这个Mock类的某些行为。可能比较难理解，直接上代码说明如何使用mock。这里我们使用Mockito，它是广泛使用的mock框架之一。
　因为我们基于Android Studio，所以首先需要在build.gradle文件中添加Mockito的依赖：

testCompile 'org.mockito:mockito-core:2.0.73-beta'

要Mock一个类，首先需要调用Mockito.mock方法，mock方法有多个重载版本，但每个方法都需要指定一个Class类型参数用来指代需要mock的类，mock方法的返回值类型为Mock类的类型。使用Mock返回的对象，我们基本上可以为所欲为了！

    //Let's import Mockito statically so that the code looks clearer
   import static org.mockito.Mockito.*;
  
   //mock creation
   List mockedList = mock(List.class);

验证mock对象的某些方法被正确调用

//using mock object
mockedList.add("one");
mockedList.clear();

//verification
verify(mockedList).add("one");
verify(mockedList).clear();

- 验证mock对象某些方法的调用次数
```java
//using mock
mockedList.add("once");

mockedList.add("twice");
mockedList.add("twice");

mockedList.add("three times");
mockedList.add("three times");
mockedList.add("three times");

//following two verifications work exactly the same - times(1) is used by default
verify(mockedList).add("once");
verify(mockedList, times(1)).add("once");

//exact number of invocations verification
verify(mockedList, times(2)).add("twice");
verify(mockedList, times(3)).add("three times");

//verification using never(). never() is an alias to times(0)
verify(mockedList, never()).add("never happened");

//verification using atLeast()/atMost()
verify(mockedList, atLeastOnce()).add("three times");
verify(mockedList, atLeast(2)).add("five times");
verify(mockedList, atMost(5)).add("three times");

验证和mock对象的交互情况

//using mocks - only mockOne is interacted
mockOne.add("one");

//ordinary verification
verify(mockOne).add("one");

//verify that method was never called on a mock
verify(mockOne, never()).add("two");

//verify that other mocks were not interacted
verifyZeroInteractions(mockTwo, mockThree);

//using mocks
mockedList.add("one");
mockedList.add("two");

verify(mockedList).add("one");

//following verification will fail
verifyNoMoreInteractions(mockedList);

- 代理mock对象的某些方法的行为
```java
 //You can mock concrete classes, not just interfaces
 LinkedList mockedList = mock(LinkedList.class);

 //stubbing
 when(mockedList.get(0)).thenReturn("first");
 when(mockedList.get(1)).thenThrow(new RuntimeException());

 //following prints "first"
 System.out.println(mockedList.get(0));

 //following throws runtime exception
 System.out.println(mockedList.get(1));

 //following prints "null" because get(999) was not stubbed
 System.out.println(mockedList.get(999));

 //Although it is possible to verify a stubbed invocation, usually it's just redundant
 //If your code cares what get(0) returns, then something else breaks (often even before verify() gets executed).
 //If your code doesn't care what get(0) returns, then it should not be stubbed. Not convinced? See here.
 verify(mockedList).get(0);

- 默认情况下，调用mock对象的带返回值的方法会返回默认的值，比如返回null、0值或者false等。
- 允许多次代理mock对象的同一个方法，但具体的行为取决于该方法最近的一次代理行为。
- mock对象的代理方法，允许多次调用，只有不覆盖它的代理行为，那么每次调用的执行相同的行为或者返回相同的值
- 相同的方法和参数唯一确认一个代理。比如你可以分别代理get(int)方法在参数分别为0和1时的不同行为。

代理mock对象的void方法

doThrow(new RuntimeException()).when(mockedList).clear();

   //following throws RuntimeException:
   mockedList.clear();

mock对象方法的参数匹配

//stubbing using built-in anyInt() argument matcher 
when(mockedList.get(anyInt())).thenReturn("element"); 
//stubbing using custom matcher (let's say isValid() returns your own matcher implementation):
when(mockedList.contains(argThat(isValid()))).thenReturn(true); 
//following prints "element" 
System.out.println(mockedList.get(999)); 
//**you can also verify using an argument matcher** 
verify(mockedList).get(anyInt());

mock对象方法的参数捕获

ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
   verify(mock).doSomething(argument.capture());
   assertEquals("John", argument.getValue().getName());

Mockito还有其他用法，这里就不一一列举了，请自行参考Mockito类的说明文档。回到最开始的问题，现在我们可以使用Mockito轻松加愉快的创建对应测试方法测试noResultAction方法了。如下：

@Test
    public void testNoResultAction() throws Exception {
        ActionsImp mock = Mockito.mock(ActionsImp.class);
        SomeActions someActions = new SomeActions(mock);
        someActions.noResultAction(5);
        Mockito.verify(mock).doSomething(5);
    }

Othes

请注意，只有事先经过mock返回的mock对象，才能在其上运用上面的操作。

先Mock，再使用！

最后，在稍微提一下Mockito的原理！Mock框架一般都是基于Java提供的动态代理或者cglib(code generation lib)。由于Java动态代理仅仅支持接口，在mock一个具体的类时，mockito使用的是cglib库来创建动态代理对象。这里，我们不再深究mockito的实现原理！