参考案例：（本位使用markdown编写）
git.oschina实例：https://gitee.com/lhhTestTool/LhhMockito
# LhhMockito
mock 单元测试 Mockito进行实战演练
# Mockito是什么？
Mockito是mocking框架，它让你用简洁的API做测试。而且Mockito简单易学，它可读性强和验证语法简洁。
# Mockito资源
官网： http://mockito.org
API文档：http://docs.mockito.googlecode.com/hg/org/mockito/Mockito.html
源码：https://github.com/mockito/mockito
# 使用场景
提前创建测试; TDD（测试驱动开发）
团队可以并行工作
你可以创建一个验证或者演示程序
为无法访问的资源编写测试
Mock 可以交给用户
隔离系统
# 使用 Mockito 的大致流程
创建外部依赖的 Mock 对象, 然后将此 Mock 对象注入到测试类中.
执行测试代码.
校验测试代码是否执行正确.
# 添加maven依赖
```xml
org.mockito
mockito-all
1.9.5
test
```
Maven用户可以声明对`mockito-core`的依赖。 Mockito自动发布到Bintray的中心，并同步到Maven Central Repository。
`特别提醒`：使用手工依赖关系管理的Legacy构建可以使用`1. *“mockito-all”`分发。
它可以从Mockito的Bintray存储库或Bintray的中心下载。
在但是`Mockito 2. * “mockito-all”`发行已经停止，Mockito 2以上版本使用`“mockito-core”`。
```xml
org.mockito
mockito-core
2.7.19
test
```
# 添加引用
在程序中可以import org.mockito.Mockito，然后调用它的static方法。
`import static org.mockito.Mockito.*;`
# 使用介绍
## Mock 对象创建 方法`mock（...）`
用了 mock 静态方法来创建一个 Mock 对象. mock 方法接收一个 class 类型, 即我们需要 mock 的类型
```
@Test
public void createMockObject() {
// 使用 mock 静态方法创建 Mock 对象.
List mockedList = mock(List.class);
Assert.assertTrue(mockedList instanceof List);
// mock 方法不仅可以 Mock 接口类, 还可以 Mock 具体的类型.
ArrayList mockedArrayList = mock(ArrayList.class);
Assert.assertTrue(mockedArrayList instanceof List);
Assert.assertTrue(mockedArrayList instanceof ArrayList);
}
```
## 配置 Mock 对象使用
有了一个 Mock 对象后, 可以开始定制它的具体的行为.
### `when(...).thenReturn(...)` 指定一个返回结果 ，参数匹配
```
@Test
public void configMockObject() {
List mockedList = mock(List.class);
// 我们定制了当调用 mockedList.add("one") 时, 返回 true
when(mockedList.add("one")).thenReturn(true);
// 当调用 mockedList.size() 时, 返回 1
when(mockedList.size()).thenReturn(1);
Assert.assertTrue(mockedList.add("one"));
// 因为我们没有定制 add("two"), 因此返回默认值, 即 false.
Assert.assertFalse(mockedList.add("two"));
Assert.assertEquals(mockedList.size(), 1);
Iterator i = mock(Iterator.class);
when(i.next()).thenReturn("Hello,").thenReturn("Mockito!");
String result = i.next() + " " + i.next();
//assert
Assert.assertEquals("Hello, Mockito!", result);
}
```
`when(...).thenReturn(...)`: 链来定义一个行为.例如 "when(mockedList.add("one")).thenReturn(true)" 表示: 当调用了mockedList.add("one"), 那么返回 true.. 并且要注意的是, `when(...).thenReturn(...)` 方法链不仅仅要匹配方法的调用, 而且要方法的参数一样才行.
`when(...).thenReturn(...)`: 方法链可以指定多个返回值, 当这样做后, 如果多次调用指定的方法, 那么这个方法会依次返回这些值. 例如 "when(i.next()).thenReturn("Hello,").thenReturn("Mockito!");", 这句代码表示: 第一次调用 `i.next()` 时返回 "Hello,", 第二次调用 i.next() 时返回 "Mockito!".
### `doThrow(ExceptionX).when(x).methodCall` 指定一个抛出异常
含义是: 当调用了 `x.methodCall` 方法后, 抛出异常 `ExceptionX`.
```
@Test(expected = NoSuchElementException.class)
public void testForIOException() throws Exception {
Iterator i = mock(Iterator.class);
when(i.next()).thenReturn("Hello,").thenReturn("Mockito!"); // 1
String result = i.next() + " " + i.next(); // 2
Assert.assertEquals("Hello, Mockito!", result);
doThrow(new NoSuchElementException()).when(i).next(); // 3
i.next(); // 4
}
```
因此 `doThrow(new NoSuchElementException()).when(i).next()` 的含义就是: 当第三次调用 `i.next()` 后, 抛出异常 `NoSuchElementException`.(因为 i 这个迭代器只有两个元素)
### `verify()` 校验 Mock 对象的方法调用
Mockito 会追踪 Mock 对象的所用方法调用和调用方法时所传递的参数. 我们可以通过 `verify()` 静态方法来来校验指定的方法调用是否满足断言
```
@Test
public void testVerify() {
List mockedList = mock(List.class);
mockedList.add("one");
mockedList.add("two");
mockedList.add("three times");
mockedList.add("three times");
mockedList.add("three times");
when(mockedList.size()).thenReturn(5);
Assert.assertEquals(mockedList.size(), 5);
verify(mockedList, atLeastOnce()).add("one");
verify(mockedList, times(1)).add("two");
verify(mockedList, times(3)).add("three times");
verify(mockedList, never()).isEmpty();
}
```
它的含义了, 很简单:
第一句校验 mockedList.add("one") 至少被调用了 1 次(atLeastOnce)
第二句校验 mockedList.add("two") 被调用了 1 次(times(1))
第三句校验 mockedList.add("three times") 被调用了 3 次(times(3))
第四句校验 mockedList.isEmpty() 从未被调用(never)
### `spy()` 包装新的模拟对象
Mockito 提供的 `spy` 方法可以包装一个真实的 Java 对象, 并返回一个包装后的新对象. 若没有特别配置的话, 对这个新对象的所有方法调用, 都会委派给实际的 Java 对象
```
@Test
public void testSpy() {
List list = new LinkedList();
List spy = spy(list);
// 对 spy.size() 进行定制.
when(spy.size()).thenReturn(100);
spy.add("one");
spy.add("two");
// 因为我们没有对 get(0), get(1) 方法进行定制,
// 因此这些调用其实是调用的真实对象的方法.
Assert.assertEquals(spy.get(0), "one");
Assert.assertEquals(spy.get(1), "two");
Assert.assertEquals(spy.size(), 100);
}
```
例子中 实例化了一个 LinkedList 对象, 然后使用 spy() 方法对 list 对象进行部分模拟. 接着我们使用 when(...).thenReturn(...) 方法链来规定 spy.size() 方法返回值是 100. 随后我们给 spy 添加了两个元素, 然后再 调用 spy.get(0) 获取第一个元素.
这里有意思的地方是: 因为我们没有定制 add("one"), add("two"), get(0), get(1), 因此通过 spy 调用这些方法时, 实际上是委派给 list 对象来调用的.
然而我们 定义了 spy.size() 的返回值, 因此当调用 spy.size() 时, 返回 100.
### `verify(mockedList).addAll(argument.capture()) ` 参数捕获
通过 `verify(mockedList).addAll(argument.capture())` 语句来获取 `mockedList.addAll` 方法所传递的实参 list.
```
@Test
public void testCaptureArgument() {
List list = Arrays.asList("1", "2");
List mockedList = mock(List.class);
ArgumentCaptor argument = ArgumentCaptor.forClass(List.class);
mockedList.addAll(list);
verify(mockedList).addAll(argument.capture());
Assert.assertEquals(2, argument.getValue().size());
Assert.assertEquals(list, argument.getValue());
}
```
### RETURNS_SMART_NULLS
`RETURNS_SMART_NULLS`实现了Answer接口的对象，它是创建mock对象时的一个可选参数，`mock(Class,Answer)`。
在创建mock对象时，有的方法我们没有进行stubbing，所以调用时会放回Null这样在进行操作是很可能抛出NullPointerException。如果通过`RETURNS_SMART_NULLS`参数创建的`mock`对象在没有调用stubbed方法时会返回SmartNull。例如：返回类型是String，会返回"";是int，会返回0；是List，会返回空的List。另外，在控制台窗口中可以看到SmartNull的友好提示。
```
@Test
public void returnsSmartNullsTest() {
List mock = mock(List.class, RETURNS_SMART_NULLS);
System.out.println(mock.get(0));
//使用RETURNS_SMART_NULLS参数创建的mock对象，不会抛出NullPointerException异常。另外控制台窗口会提示信息“SmartNull returned by unstubbed get() method on mock”
System.out.println(mock.toArray().length);
}
```
### RETURNS_DEEP_STUBS
`RETURNS_DEEP_STUBS`也是创建mock对象时的备选参数
`RETURNS_DEEP_STUBS`参数程序会自动进行mock所需的对象，方法`deepstubsTest`和`deepstubsTest2`是等价的
```
@Test
public void deepstubsTest(){
Account account=mock(Account.class,RETURNS_DEEP_STUBS);
when(account.getRailwayTicket().getDestination()).thenReturn("Beijing");
account.getRailwayTicket().getDestination();
verify(account.getRailwayTicket()).getDestination();
assertEquals("Beijing",account.getRailwayTicket().getDestination());
}
@Test
public void deepstubsTest2(){
Account account=mock(Account.class);
RailwayTicket railwayTicket=mock(RailwayTicket.class);
when(account.getRailwayTicket()).thenReturn(railwayTicket);
when(railwayTicket.getDestination()).thenReturn("Beijing");
account.getRailwayTicket().getDestination();
verify(account.getRailwayTicket()).getDestination();
assertEquals("Beijing",account.getRailwayTicket().getDestination());
}
```
### 模拟方法体抛出异常 `doThrow`
```
@Test(expected = RuntimeException.class)
public void doThrow_when(){
List list = mock(List.class);
doThrow(new RuntimeException()).when(list).add(1);
list.add(1);
}
```
### 注解使用 `@Mock`
测试中我们在每个测试方法里都mock了一个List对象，为了避免重复的mock，是测试类更具有可读性，我们可以使用下面的注解方式来快速模拟对象：
```
@Mock
private List mockList;
```
在使用时必须在基类中添加初始化mock的代码
```
public class MockitoExample2 {
@Mock
private List mockList;
public MockitoExample2(){
MockitoAnnotations.initMocks(this); //必须初始化
}
@Test
public void shorthand(){
mockList.add(1);
verify(mockList).add(1);
}
}
```
或者使用`built-in runner：MockitoJUnitRunner`
```
@RunWith(MockitoJUnitRunner.class)
public class MockitoExample2 {
@Mock
private List mockList;
@Test
public void shorthand(){
mockList.add(1);
verify(mockList).add(1);
}
}
```
否则会提示mock 为null
资料： https://blog.csdn.net/shensky711/article/details/52771493
http://liuzhijun.iteye.com/blog/1512780
