# LhhMockito

**Repository Path**: OldWrod/LhhMockito

## Basic Information

- **Project Name**: LhhMockito
- **Description**: mock 单元测试 Mockito进行实战演练
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2018-04-13
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 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