1.1 Mockito是什么？
MOCK意思是模拟的意思，主要被用来进行数据的人工组织，不会真正地调用第三方服务器，类似redis，mysql等都不会调用，也不用关心数据底层是如何进行处理的，我们要做的只是将本单元的逻辑进行单元测试，验证数据的逻辑处理性，而其中mock较好的框架就是Mockito。
Mockito是mocking框架，它让你用简洁的API做测试。而且Mockito简单易学，它可读性强和验证语法简洁。
1.2 为什么需要Mock
测试驱动的开发( TDD)要求我们先写单元测试，再写实现代码。在写单元测试的过程中，我们往往会遇到要测试的类有很多依赖，这些依赖的类/对象/资源又有别的依赖，从而形成一个大的依赖树，要在单元测试的环境中完整地构建这样的依赖，是一件很困难的事情。如下图所示：
为了测试类A，我们需要Mock B类和C类（用虚拟对象来代替）如下图所示：
1.3 Stub和Mock异同
- 相同：Stub和Mock都是模拟外部依赖
- 不同：Stub是完全模拟一个外部依赖， 而Mock还可以用来判断测试通过还是失败
1.4 Mockito资源
- 官网： http://mockito.org
- API文档：http://docs.mockito.googlecode.com/hg/org/mockito/Mockito.html
- 项目源码：https://github.com/mockito/mockito
1.5 使用场景
- 提前创建测试; TDD（测试驱动开发）
- 团队可以并行工作
- 你可以创建一个验证或者演示程序
- 为无法访问的资源编写测试
- Mock 可以交给用户
- 隔离系统
2 使用Mockito
添加maven依赖
1<dependency> 2 <groupId>org.mockito</groupId> 3 <artifactId>mockito-all</artifactId> 4 <version>1.10.19</version> 5 <scope>test</scope> 6</dependency> 7 8<dependency> 9 <groupId>org.mockito</groupId> 10 <artifactId>mockito-core</artifactId> 11 <version>3.0.0</version> 12 <scope>test</scope> 13</dependency>
使用Powermock和Mockito测试静态方法: 依赖添加
1<dependency> 2 <groupId>org.powermock</groupId> 3 <artifactId>powermock-api-mockito</artifactId> 4 <version>1.6.3</version> 5 <scope>test</scope> 6</dependency> 7 8<dependency> 9 <groupId>org.powermock</groupId> 10 <artifactId>powermock-module-junit4</artifactId> 11 <version>1.6.3</version> 12 <scope>test</scope> 13</dependency>
添加junit依赖
1<dependency> 2 <groupId>junit</groupId> 3 <artifactId>junit</artifactId> 4 <version>4.11</version> 5 <scope>test</scope> 6</dependency>
写一个单元测试进行模拟：
1package cn.chinotan; 2 3import cn.chinotan.entity.User; 4import cn.chinotan.entity.UserBak; 5import cn.chinotan.service.UserBakService; 6import cn.chinotan.service.UserService; 7import cn.chinotan.service.impl.UserServiceImpl; 8import lombok.extern.slf4j.Slf4j; 9import org.assertj.core.util.Lists; 10import org.junit.Test; 11import org.junit.runner.RunWith; 12import org.mockito.InjectMocks; 13import org.mockito.Matchers; 14import org.mockito.Mock; 15import org.powermock.api.mockito.PowerMockito; 16import org.powermock.core.classloader.annotations.PowerMockIgnore; 17import org.powermock.core.classloader.annotations.PrepareForTest; 18import org.powermock.modules.junit4.PowerMockRunner; 19import org.powermock.modules.junit4.PowerMockRunnerDelegate; 20import org.springframework.aop.framework.AopContext; 21import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; 22 23import java.util.Date; 24import java.util.List; 25 26import static org.mockito.Matchers.any; 27import static org.powermock.api.mockito.PowerMockito.when; 28 29/** 30 * @program: test 31 * @description: Mockito测试类 32 * @author: xingcheng 33 * @create: 2019-07-13 17:00 34 **/ 35@Slf4j 36@RunWith(PowerMockRunner.class) 37@PrepareForTest({AopContext.class}) 38@PowerMockIgnore("javax.management.*") 39public class MyMockitoTest { 40 41 @InjectMocks 42 private UserServiceImpl userService; 43 44 @Mock 45 private UserService userServiceMock; 46 47 @Mock 48 private UserBakService userBakService; 49 50 @Test 51 public void testOne() { 52 // mock数据准备 53 PowerMockito.mockStatic(AopContext.class); 54 when(AopContext.currentProxy()).thenReturn(userServiceMock); 55 User user = new User(); 56 user.setId(1L); 57 user.setName("xc"); 58 List<User> userList = Lists.newArrayList(user); 59 when(userServiceMock.list(any())).thenReturn(userList); 60 UserBak userBak = new UserBak(); 61 userBak.setId(1L); 62 userBak.setName("xc"); 63 List<UserBak> userBakList = Lists.newArrayList(userBak); 64 when(userBakService.list(any())).thenReturn(userBakList); 65 // mock方法测试 66 List<UserBak> xc = userService.getBakByName("xc"); 67 log.info("testOne{}", xc); 68 } 69 70}
单元测试相关的service
1package cn.chinotan.service.impl; 2 3import cn.chinotan.entity.User; 4import cn.chinotan.dao.UserMapper; 5import cn.chinotan.entity.UserBak; 6import cn.chinotan.service.UserBakService; 7import cn.chinotan.service.UserService; 8import com.baomidou.mybatisplus.core.conditions.Wrapper; 9import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; 10import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; 11import org.springframework.aop.framework.AopContext; 12import org.springframework.beans.factory.annotation.Autowired; 13import org.springframework.stereotype.Service; 14 15import java.util.List; 16import java.util.stream.Collectors; 17 18/** 19 * <p> 20 * 用户表 服务实现类 21 * </p> 22 * 23 * @author xingcheng 24 * @since 2019-02-16 25 */ 26@Service 27public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService { 28 29 @Autowired 30 private UserBakService userBakService; 31 32 @Override 33 public List<UserBak> getBakByName(String name) { 34 // 获取全部的男人用户id 35 UserService userService = (UserService) AopContext.currentProxy(); 36 User user = new User(); 37 user.setName(name); 38 Wrapper<User> wrapper = new QueryWrapper<>(user); 39 List<User> userList = userService.list(wrapper); 40 List<String> collectUserNameList = userList.stream().map(User::getName).collect(Collectors.toList()); 41 QueryWrapper<UserBak> bakWrapper = new QueryWrapper<>(); 42 bakWrapper.in("name", collectUserNameList); 43 return userBakService.list(bakWrapper); 44 } 45 46}
要进行单元测试的类方法用
1 @InjectMocks 2 private UserServiceImpl userService;
进行注入，之后，方法内部实现需要调用的三方方法通过@mock进行模拟
1 @Mock 2 private UserService userServiceMock; 3 4 @Mock 5 private UserBakService userBakService;
运行单元测试，可以看到是通过代理进行调用的
最后方法也根据我们设定好的数据进行了输出，并没有进行调用mysql的操作：这样的好处时在生产环境跑单元测试时也不会影响数据库的数据
注意这次调用：有通过AopContext来获取当前代理类的操作，但是当前单元测试并没有走spring的生命周期，bean也没有交给spring进行管理，那么调用这个静态方法肯定是要报错的，那么如何解决呢？
解决方法很简单，只要把这个静态方法也mock掉就可以了：
主要通过
@PrepareForTest({AopContext.class})
PowerMockito.mockStatic(AopContext.class); when(AopContext.currentProxy()).thenReturn(userServiceMock);
这两步操作，就可以轻松实现。
细心的小伙伴一定注意到了
@PowerMockIgnore("javax.management.*")
因为PowerMock的工作原理即是使用自定义的类加载器来加载被修改过的类，从而达到打桩的目的，使用Powermock后会提示classloader错误，因此待测试类中使用到了XML解析相关的包和类，那么测试类前同样需要增加@PowerMockIgnore({"org.xml.*", "javax.xml.*"})，消除类加载器引入报错。
剩余还有mock调用返回值是void的方法时的写法：
PowerMockito.doNothing().when(casService).addSupplier(anyLong(), any(ServiceKey.class));
接下来简单介绍几个常用的方法
验证行为
1@Test 2public void verify_behaviour(){ 3 //模拟创建一个List对象 4 List mock = mock(List.class); 5 //使用mock的对象 6 mock.add(1); 7 mock.clear(); 8 //验证add(1)和clear()行为是否发生 9 verify(mock).add(1); 10 verify(mock).clear(); 11}
模拟我们所期望的结果
1@Test 2public void when_thenReturn(){ 3 //mock一个Iterator类 4 Iterator iterator = mock(Iterator.class); 5 //预设当iterator调用next()时第一次返回hello，第n次都返回world 6 when(iterator.next()).thenReturn("hello").thenReturn("world"); 7 //使用mock的对象 8 String result = iterator.next() + " " + iterator.next() + " " + iterator.next(); 9 //验证结果 10 assertEquals("hello world world",result); 11} 12 13 14@Test(expected = IOException.class) 15public void when_thenThrow() throws IOException { 16 OutputStream outputStream = mock(OutputStream.class); 17 OutputStreamWriter writer = new OutputStreamWriter(outputStream); 18 //预设当流关闭时抛出异常 19 doThrow(new IOException()).when(outputStream).close(); 20 outputStream.close(); 21}
模拟方法体抛出异常
1@Test(expected = RuntimeException.class) 2public void doThrow_when(){ 3 List list = mock(List.class); 4 doThrow(new RuntimeException()).when(list).add(1); 5 list.add(1); 6}
参数匹配
1@Test 2public void with_arguments(){ 3 Comparable comparable = mock(Comparable.class); 4 //预设根据不同的参数返回不同的结果 5 when(comparable.compareTo("Test")).thenReturn(1); 6 when(comparable.compareTo("Omg")).thenReturn(2); 7 assertEquals(1, comparable.compareTo("Test")); 8 assertEquals(2, comparable.compareTo("Omg")); 9 //对于没有预设的情况会返回默认值 10 assertEquals(0, comparable.compareTo("Not stub")); 11}
除了匹配制定参数外，还可以匹配自己想要的任意参数
1@Test 2public void with_unspecified_arguments(){ 3 List list = mock(List.class); 4 //匹配任意参数 5 when(list.get(anyInt())).thenReturn(1); 6 when(list.contains(argThat(new IsValid()))).thenReturn(true); 7 assertEquals(1, list.get(1)); 8 assertEquals(1, list.get(999)); 9 assertTrue(list.contains(1)); 10 assertTrue(!list.contains(3)); 11} 12 13private class IsValid extends ArgumentMatcher<List>{ 14 @Override 15 public boolean matches(Object o) { 16 return o == 1 || o == 2; 17 } 18}
注意：如果你使用了参数匹配，那么所有的参数都必须通过matchers来匹配，如下代码：
1@Test 2public void all_arguments_provided_by_matchers(){ 3 Comparator comparator = mock(Comparator.class); 4 comparator.compare("nihao","hello"); 5 //如果你使用了参数匹配，那么所有的参数都必须通过matchers来匹配 6 verify(comparator).compare(anyString(),eq("hello")); 7 //下面的为无效的参数匹配使用 8 //verify(comparator).compare(anyString(),"hello"); 9}
自定义参数匹配
1@Test 2public void argumentMatchersTest(){ 3 //创建mock对象 4 List<String> mock = mock(List.class); 5 6 //argThat(Matches<T> matcher)方法用来应用自定义的规则，可以传入任何实现Matcher接口的实现类。 7 when(mock.addAll(argThat(new IsListofTwoElements()))).thenReturn(true); 8 9 mock.addAll(Arrays.asList("one","two","three")); 10 //IsListofTwoElements用来匹配size为2的List，因为例子传入List为三个元素，所以此时将失败。 11 verify(mock).addAll(argThat(new IsListofTwoElements())); 12} 13 14class IsListofTwoElements extends ArgumentMatcher<List> 15{ 16 public boolean matches(Object list) 17 { 18 return((List)list).size()==2; 19 } 20}
捕获参数来进一步断言
1@Test 2public void capturing_args(){ 3 PersonDao personDao = mock(PersonDao.class); 4 PersonService personService = new PersonService(personDao); 5 6 ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class); 7 personService.update(1,"jack"); 8 verify(personDao).update(argument.capture()); 9 assertEquals(1,argument.getValue().getId()); 10 assertEquals("jack",argument.getValue().getName()); 11} 12 13 class Person{ 14 private int id; 15 private String name; 16 17 Person(int id, String name) { 18 this.id = id; 19 this.name = name; 20 } 21 22 public int getId() { 23 return id; 24 } 25 26 public String getName() { 27 return name; 28 } 29} 30 31interface PersonDao{ 32 public void update(Person person); 33} 34 35class PersonService{ 36 private PersonDao personDao; 37 38 PersonService(PersonDao personDao) { 39 this.personDao = personDao; 40 } 41 42 public void update(int id,String name){ 43 personDao.update(new Person(id,name)); 44 } 45}
使用方法预期回调接口生成期望值（Answer结构）
1@Test 2public void answerTest(){ 3 when(mockList.get(anyInt())).thenAnswer(new CustomAnswer()); 4 assertEquals("hello world:0",mockList.get(0)); 5 assertEquals("hello world:999",mockList.get(999)); 6} 7 8private class CustomAnswer implements Answer<String>{ 9 @Override 10 public String answer(InvocationOnMock invocation) throws Throwable { 11 Object[] args = invocation.getArguments(); 12 return "hello world:"+args[0]; 13 } 14}
也可使用匿名内部类实现
1@Test 2public void answer_with_callback(){ 3 //使用Answer来生成我们我们期望的返回 4 when(mockList.get(anyInt())).thenAnswer(new Answer<Object>() { 5 @Override 6 public Object answer(InvocationOnMock invocation) throws Throwable { 7 Object[] args = invocation.getArguments(); 8 return "hello world:"+args[0]; 9 } 10 }); 11 assertEquals("hello world:0",mockList.get(0)); 12 assertEquals("hello world:999",mockList.get(999)); 13}
修改对未预设的调用返回默认期望
1@Test 2public void unstubbed_invocations(){ 3 //mock对象使用Answer来对未预设的调用返回默认期望值 4 List mock = mock(List.class,new Answer() { 5 @Override 6 public Object answer(InvocationOnMock invocation) throws Throwable { 7 return 999; 8 } 9 }); 10 //下面的get(1)没有预设，通常情况下会返回NULL，但是使用了Answer改变了默认期望值 11 assertEquals(999, mock.get(1)); 12 //下面的size()没有预设，通常情况下会返回0，但是使用了Answer改变了默认期望值 13 assertEquals(999,mock.size()); 14}
用spy监控真实对象
-
Mock不是真实的对象，它只是用类型的class创建了一个虚拟对象，并可以设置对象行为
-
Spy是一个真实的对象，但它可以设置对象行为
-
InjectMocks创建这个类的对象并自动将标记@Mock、@Spy等注解的属性值注入到这个中
@Test(expected = IndexOutOfBoundsException.class) public void spy_on_real_objects(){ List list = new LinkedList(); List spy = spy(list); //下面预设的spy.get(0)会报错，因为会调用真实对象的get(0)，所以会抛出越界异常 //when(spy.get(0)).thenReturn(3);
1//使用doReturn-when可以避免when-thenReturn调用真实对象api 2doReturn(999).when(spy).get(999); 3//预设size()期望值 4when(spy.size()).thenReturn(100); 5//调用真实对象的api 6spy.add(1); 7spy.add(2); 8assertEquals(100,spy.size()); 9assertEquals(1,spy.get(0)); 10assertEquals(2,spy.get(1)); 11verify(spy).add(1); 12verify(spy).add(2); 13assertEquals(999,spy.get(999)); 14spy.get(2);}
真实的部分mock
1@Test 2public void real_partial_mock(){ 3 //通过spy来调用真实的api 4 List list = spy(new ArrayList()); 5 assertEquals(0,list.size()); 6 A a = mock(A.class); 7 //通过thenCallRealMethod来调用真实的api 8 when(a.doSomething(anyInt())).thenCallRealMethod(); 9 assertEquals(999,a.doSomething(999)); 10} 11 12 13class A{ 14 public int doSomething(int i){ 15 return i; 16 } 17}
重置mock
1@Test 2public void reset_mock(){ 3 List list = mock(List.class); 4 when(list.size()).thenReturn(10); 5 list.add(1); 6 assertEquals(10,list.size()); 7 //重置mock，清除所有的互动和预设 8 reset(list); 9 assertEquals(0,list.size()); 10}
验证确切的调用次数
1@Test 2public void verifying_number_of_invocations(){ 3 List list = mock(List.class); 4 list.add(1); 5 list.add(2); 6 list.add(2); 7 list.add(3); 8 list.add(3); 9 list.add(3); 10 //验证是否被调用一次，等效于下面的times(1) 11 verify(list).add(1); 12 verify(list,times(1)).add(1); 13 //验证是否被调用2次 14 verify(list,times(2)).add(2); 15 //验证是否被调用3次 16 verify(list,times(3)).add(3); 17 //验证是否从未被调用过 18 verify(list,never()).add(4); 19 //验证至少调用一次 20 verify(list,atLeastOnce()).add(1); 21 //验证至少调用2次 22 verify(list,atLeast(2)).add(2); 23 //验证至多调用3次 24 verify(list,atMost(3)).add(3); 25}
连续调用
1@Test(expected = RuntimeException.class) 2public void consecutive_calls(){ 3 //模拟连续调用返回期望值，如果分开，则只有最后一个有效 4 when(mockList.get(0)).thenReturn(0); 5 when(mockList.get(0)).thenReturn(1); 6 when(mockList.get(0)).thenReturn(2); 7 when(mockList.get(1)).thenReturn(0).thenReturn(1).thenThrow(new RuntimeException()); 8 assertEquals(2,mockList.get(0)); 9 assertEquals(2,mockList.get(0)); 10 assertEquals(0,mockList.get(1)); 11 assertEquals(1,mockList.get(1)); 12 //第三次或更多调用都会抛出异常 13 mockList.get(1); 14}
验证执行顺序
1@Test 2public void verification_in_order(){ 3 List list = mock(List.class); 4 List list2 = mock(List.class); 5 list.add(1); 6 list2.add("hello"); 7 list.add(2); 8 list2.add("world"); 9 //将需要排序的mock对象放入InOrder 10 InOrder inOrder = inOrder(list,list2); 11 //下面的代码不能颠倒顺序，验证执行顺序 12 inOrder.verify(list).add(1); 13 inOrder.verify(list2).add("hello"); 14 inOrder.verify(list).add(2); 15 inOrder.verify(list2).add("world"); 16}
确保模拟对象上无互动发生
1@Test 2public void verify_interaction(){ 3 List list = mock(List.class); 4 List list2 = mock(List.class); 5 List list3 = mock(List.class); 6 list.add(1); 7 verify(list).add(1); 8 verify(list,never()).add(2); 9 //验证零互动行为 10 verifyZeroInteractions(list2,list3); 11}
找出冗余的互动(即未被验证到的)
1@Test(expected = NoInteractionsWanted.class) 2public void find_redundant_interaction(){ 3 List list = mock(List.class); 4 list.add(1); 5 list.add(2); 6 verify(list,times(2)).add(anyInt()); 7 //检查是否有未被验证的互动行为，因为add(1)和add(2)都会被上面的anyInt()验证到，所以下面的代码会通过 8 verifyNoMoreInteractions(list); 9 10 List list2 = mock(List.class); 11 list2.add(1); 12 list2.add(2); 13 verify(list2).add(1); 14 //检查是否有未被验证的互动行为，因为add(2)没有被验证，所以下面的代码会失败抛出异常 15 verifyNoMoreInteractions(list2); 16}
Mockito并不是创建一个真实的对象，而是模拟这个对象，他用简单的when(mock.method(params)).thenRetrun(result)语句设置mock对象的行为，如下语句：
// 设置mock对象的行为 － 当调用其get方法获取第0个元素时，返回"first" Mockito.when(mockedList.get(0)).thenReturn("first");
在Mock对象的时候，创建一个proxy对象，保存被调用的方法名（get），以及调用时候传递的参数（0），然后在调用thenReturn方法时再把“first”保存起来，这样，就有了构建一个stub方法所需的所有信息，构建一个stub。当get方法被调用的时候，实际上调用的是之前保存的proxy对象的get方法，返回之前保存的数据。