Mockito-简单使用使用

2018/04/16 10:52
阅读数 39
参考案例:(本位使用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
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
<version>1.9.5</version>
<scope>test</scope>
</dependency>
```

Maven用户可以声明对`mockito-core`的依赖。 Mockito自动发布到Bintray的中心,并同步到Maven Central Repository。

`特别提醒`:使用手工依赖关系管理的Legacy构建可以使用`1. *“mockito-all”`分发。
它可以从Mockito的Bintray存储库或Bintray的中心下载。
在但是`Mockito 2. * “mockito-all”`发行已经停止,Mockito 2以上版本使用`“mockito-core”`。

```xml
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>2.7.19</version>
<scope>test</scope>
</dependency>
```

# 添加引用
在程序中可以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<String> list = Arrays.asList("1", "2");
List mockedList = mock(List.class);
ArgumentCaptor<List> 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





展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部