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依赖
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
<version>1.10.19</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>3.0.0</version>
<scope>test</scope>
</dependency>
使用Powermock和Mockito测试静态方法: 依赖添加
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito</artifactId>
<version>1.6.3</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
<version>1.6.3</version>
<scope>test</scope>
</dependency>
添加junit依赖
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
写一个单元测试进行模拟:
package cn.chinotan;
import cn.chinotan.entity.User;
import cn.chinotan.entity.UserBak;
import cn.chinotan.service.UserBakService;
import cn.chinotan.service.UserService;
import cn.chinotan.service.impl.UserServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.assertj.core.util.Lists;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
import org.springframework.aop.framework.AopContext;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.Date;
import java.util.List;
import static org.mockito.Matchers.any;
import static org.powermock.api.mockito.PowerMockito.when;
/**
* @program: test
* @description: Mockito测试类
* @author: xingcheng
* @create: 2019-07-13 17:00
**/
@Slf4j
@RunWith(PowerMockRunner.class)
@PrepareForTest({AopContext.class})
@PowerMockIgnore("javax.management.*")
public class MyMockitoTest {
@InjectMocks
private UserServiceImpl userService;
@Mock
private UserService userServiceMock;
@Mock
private UserBakService userBakService;
@Test
public void testOne() {
// mock数据准备
PowerMockito.mockStatic(AopContext.class);
when(AopContext.currentProxy()).thenReturn(userServiceMock);
User user = new User();
user.setId(1L);
user.setName("xc");
List<User> userList = Lists.newArrayList(user);
when(userServiceMock.list(any())).thenReturn(userList);
UserBak userBak = new UserBak();
userBak.setId(1L);
userBak.setName("xc");
List<UserBak> userBakList = Lists.newArrayList(userBak);
when(userBakService.list(any())).thenReturn(userBakList);
// mock方法测试
List<UserBak> xc = userService.getBakByName("xc");
log.info("testOne{}", xc);
}
}
单元测试相关的service
package cn.chinotan.service.impl;
import cn.chinotan.entity.User;
import cn.chinotan.dao.UserMapper;
import cn.chinotan.entity.UserBak;
import cn.chinotan.service.UserBakService;
import cn.chinotan.service.UserService;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* 用户表 服务实现类
* </p>
*
* @author xingcheng
* @since 2019-02-16
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
@Autowired
private UserBakService userBakService;
@Override
public List<UserBak> getBakByName(String name) {
// 获取全部的男人用户id
UserService userService = (UserService) AopContext.currentProxy();
User user = new User();
user.setName(name);
Wrapper<User> wrapper = new QueryWrapper<>(user);
List<User> userList = userService.list(wrapper);
List<String> collectUserNameList = userList.stream().map(User::getName).collect(Collectors.toList());
QueryWrapper<UserBak> bakWrapper = new QueryWrapper<>();
bakWrapper.in("name", collectUserNameList);
return userBakService.list(bakWrapper);
}
}
要进行单元测试的类方法用
@InjectMocks
private UserServiceImpl userService;
进行注入,之后,方法内部实现需要调用的三方方法通过@mock进行模拟
@Mock
private UserService userServiceMock;
@Mock
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));
接下来简单介绍几个常用的方法
验证行为
@Test
public void verify_behaviour(){
//模拟创建一个List对象
List mock = mock(List.class);
//使用mock的对象
mock.add(1);
mock.clear();
//验证add(1)和clear()行为是否发生
verify(mock).add(1);
verify(mock).clear();
}
模拟我们所期望的结果
@Test
public void when_thenReturn(){
//mock一个Iterator类
Iterator iterator = mock(Iterator.class);
//预设当iterator调用next()时第一次返回hello,第n次都返回world
when(iterator.next()).thenReturn("hello").thenReturn("world");
//使用mock的对象
String result = iterator.next() + " " + iterator.next() + " " + iterator.next();
//验证结果
assertEquals("hello world world",result);
}
@Test(expected = IOException.class)
public void when_thenThrow() throws IOException {
OutputStream outputStream = mock(OutputStream.class);
OutputStreamWriter writer = new OutputStreamWriter(outputStream);
//预设当流关闭时抛出异常
doThrow(new IOException()).when(outputStream).close();
outputStream.close();
}
模拟方法体抛出异常
@Test(expected = RuntimeException.class)
public void doThrow_when(){
List list = mock(List.class);
doThrow(new RuntimeException()).when(list).add(1);
list.add(1);
}
参数匹配
@Test
public void with_arguments(){
Comparable comparable = mock(Comparable.class);
//预设根据不同的参数返回不同的结果
when(comparable.compareTo("Test")).thenReturn(1);
when(comparable.compareTo("Omg")).thenReturn(2);
assertEquals(1, comparable.compareTo("Test"));
assertEquals(2, comparable.compareTo("Omg"));
//对于没有预设的情况会返回默认值
assertEquals(0, comparable.compareTo("Not stub"));
}
除了匹配制定参数外,还可以匹配自己想要的任意参数
@Test
public void with_unspecified_arguments(){
List list = mock(List.class);
//匹配任意参数
when(list.get(anyInt())).thenReturn(1);
when(list.contains(argThat(new IsValid()))).thenReturn(true);
assertEquals(1, list.get(1));
assertEquals(1, list.get(999));
assertTrue(list.contains(1));
assertTrue(!list.contains(3));
}
private class IsValid extends ArgumentMatcher<List>{
@Override
public boolean matches(Object o) {
return o == 1 || o == 2;
}
}
注意:如果你使用了参数匹配,那么所有的参数都必须通过matchers来匹配,如下代码:
@Test
public void all_arguments_provided_by_matchers(){
Comparator comparator = mock(Comparator.class);
comparator.compare("nihao","hello");
//如果你使用了参数匹配,那么所有的参数都必须通过matchers来匹配
verify(comparator).compare(anyString(),eq("hello"));
//下面的为无效的参数匹配使用
//verify(comparator).compare(anyString(),"hello");
}
自定义参数匹配
@Test
public void argumentMatchersTest(){
//创建mock对象
List<String> mock = mock(List.class);
//argThat(Matches<T> matcher)方法用来应用自定义的规则,可以传入任何实现Matcher接口的实现类。
when(mock.addAll(argThat(new IsListofTwoElements()))).thenReturn(true);
mock.addAll(Arrays.asList("one","two","three"));
//IsListofTwoElements用来匹配size为2的List,因为例子传入List为三个元素,所以此时将失败。
verify(mock).addAll(argThat(new IsListofTwoElements()));
}
class IsListofTwoElements extends ArgumentMatcher<List>
{
public boolean matches(Object list)
{
return((List)list).size()==2;
}
}
捕获参数来进一步断言
@Test
public void capturing_args(){
PersonDao personDao = mock(PersonDao.class);
PersonService personService = new PersonService(personDao);
ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
personService.update(1,"jack");
verify(personDao).update(argument.capture());
assertEquals(1,argument.getValue().getId());
assertEquals("jack",argument.getValue().getName());
}
class Person{
private int id;
private String name;
Person(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
}
interface PersonDao{
public void update(Person person);
}
class PersonService{
private PersonDao personDao;
PersonService(PersonDao personDao) {
this.personDao = personDao;
}
public void update(int id,String name){
personDao.update(new Person(id,name));
}
}
使用方法预期回调接口生成期望值(Answer结构)
@Test
public void answerTest(){
when(mockList.get(anyInt())).thenAnswer(new CustomAnswer());
assertEquals("hello world:0",mockList.get(0));
assertEquals("hello world:999",mockList.get(999));
}
private class CustomAnswer implements Answer<String>{
@Override
public String answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
return "hello world:"+args[0];
}
}
也可使用匿名内部类实现
@Test
public void answer_with_callback(){
//使用Answer来生成我们我们期望的返回
when(mockList.get(anyInt())).thenAnswer(new Answer<Object>() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
return "hello world:"+args[0];
}
});
assertEquals("hello world:0",mockList.get(0));
assertEquals("hello world:999",mockList.get(999));
}
修改对未预设的调用返回默认期望
@Test
public void unstubbed_invocations(){
//mock对象使用Answer来对未预设的调用返回默认期望值
List mock = mock(List.class,new Answer() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
return 999;
}
});
//下面的get(1)没有预设,通常情况下会返回NULL,但是使用了Answer改变了默认期望值
assertEquals(999, mock.get(1));
//下面的size()没有预设,通常情况下会返回0,但是使用了Answer改变了默认期望值
assertEquals(999,mock.size());
}
用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);
//使用doReturn-when可以避免when-thenReturn调用真实对象api
doReturn(999).when(spy).get(999);
//预设size()期望值
when(spy.size()).thenReturn(100);
//调用真实对象的api
spy.add(1);
spy.add(2);
assertEquals(100,spy.size());
assertEquals(1,spy.get(0));
assertEquals(2,spy.get(1));
verify(spy).add(1);
verify(spy).add(2);
assertEquals(999,spy.get(999));
spy.get(2);
}
真实的部分mock
@Test
public void real_partial_mock(){
//通过spy来调用真实的api
List list = spy(new ArrayList());
assertEquals(0,list.size());
A a = mock(A.class);
//通过thenCallRealMethod来调用真实的api
when(a.doSomething(anyInt())).thenCallRealMethod();
assertEquals(999,a.doSomething(999));
}
class A{
public int doSomething(int i){
return i;
}
}
重置mock
@Test
public void reset_mock(){
List list = mock(List.class);
when(list.size()).thenReturn(10);
list.add(1);
assertEquals(10,list.size());
//重置mock,清除所有的互动和预设
reset(list);
assertEquals(0,list.size());
}
验证确切的调用次数
@Test
public void verifying_number_of_invocations(){
List list = mock(List.class);
list.add(1);
list.add(2);
list.add(2);
list.add(3);
list.add(3);
list.add(3);
//验证是否被调用一次,等效于下面的times(1)
verify(list).add(1);
verify(list,times(1)).add(1);
//验证是否被调用2次
verify(list,times(2)).add(2);
//验证是否被调用3次
verify(list,times(3)).add(3);
//验证是否从未被调用过
verify(list,never()).add(4);
//验证至少调用一次
verify(list,atLeastOnce()).add(1);
//验证至少调用2次
verify(list,atLeast(2)).add(2);
//验证至多调用3次
verify(list,atMost(3)).add(3);
}
连续调用
@Test(expected = RuntimeException.class)
public void consecutive_calls(){
//模拟连续调用返回期望值,如果分开,则只有最后一个有效
when(mockList.get(0)).thenReturn(0);
when(mockList.get(0)).thenReturn(1);
when(mockList.get(0)).thenReturn(2);
when(mockList.get(1)).thenReturn(0).thenReturn(1).thenThrow(new RuntimeException());
assertEquals(2,mockList.get(0));
assertEquals(2,mockList.get(0));
assertEquals(0,mockList.get(1));
assertEquals(1,mockList.get(1));
//第三次或更多调用都会抛出异常
mockList.get(1);
}
验证执行顺序
@Test
public void verification_in_order(){
List list = mock(List.class);
List list2 = mock(List.class);
list.add(1);
list2.add("hello");
list.add(2);
list2.add("world");
//将需要排序的mock对象放入InOrder
InOrder inOrder = inOrder(list,list2);
//下面的代码不能颠倒顺序,验证执行顺序
inOrder.verify(list).add(1);
inOrder.verify(list2).add("hello");
inOrder.verify(list).add(2);
inOrder.verify(list2).add("world");
}
确保模拟对象上无互动发生
@Test
public void verify_interaction(){
List list = mock(List.class);
List list2 = mock(List.class);
List list3 = mock(List.class);
list.add(1);
verify(list).add(1);
verify(list,never()).add(2);
//验证零互动行为
verifyZeroInteractions(list2,list3);
}
找出冗余的互动(即未被验证到的)
@Test(expected = NoInteractionsWanted.class)
public void find_redundant_interaction(){
List list = mock(List.class);
list.add(1);
list.add(2);
verify(list,times(2)).add(anyInt());
//检查是否有未被验证的互动行为,因为add(1)和add(2)都会被上面的anyInt()验证到,所以下面的代码会通过
verifyNoMoreInteractions(list);
List list2 = mock(List.class);
list2.add(1);
list2.add(2);
verify(list2).add(1);
//检查是否有未被验证的互动行为,因为add(2)没有被验证,所以下面的代码会失败抛出异常
verifyNoMoreInteractions(list2);
}
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方法,返回之前保存的数据。