mockito使用教程
一、什么是 Mock 测试
Mock 测试就是在测试过程中，对于某些不容易构造（如 HttpServletRequest 必须在Servlet 容器中才能构造出来）或者不容易获取比较复杂的对象（如 JDBC 中的ResultSet 对象），用一个虚拟的对象（Mock 对象）来创建以便测试的测试方法。Mock 最大的功能是帮你把单元测试的耦合分解开，如果你的代码对另一个类或者接口有依赖，它能够帮你模拟这些依赖，并帮你验证所调用的依赖的行为。
先来看看下面这个示例：
从上图可以看出如果我们要对A进行测试，那么就要先把整个依赖树构建出来，也就是BCDE的实例。
一种替代方案就是使用mocks
从图中可以清晰的看出
mock对象就是在调试期间用来作为真实对象的替代品。
mock测试就是在测试过程中，对那些不容易构建的对象用一个虚拟对象来代替测试的方法就叫mock测试。
二、Mockito是什么
Mockito 是一个流行 mock 框架，可以和JUnit结合起来使用。Mockito 允许你创建和配置 mock 对象。使用Mockito可以明显的简化对外部依赖的测试类的开发。
I notice that Mockito was voted "the best mock framework for Java" on Stackoverflow.
三、使用方法
1、添加Maven依赖
<!-- mockito --> <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>1.8.5</version> <scope>test</scope> </dependency>
如果使用springboot的话，有自带可以不用引入
2、建议静态导入会使代码更简洁
import static org.mockito.Mockito.*; import static org.junit.Assert.*;
3、例子
3.1 创建一个mock对象，并校验
@Test public void Demo1() { // mock creation 创建mock对象 List mockedList = mock(List.class); //using mock object 使用mock对象 mockedList.add("one"); mockedList.clear(); //verification 验证 verify(mockedList).add("one"); verify(mockedList).clear(); }
3.2 使用测试桩
默认情况下，所有的函数都有返回值。mock函数默认返回的是null，一个空的集合或者一个被对象类型包装的内置类型，例如0、false对应的对象类型为Integer、Boolean；
测试桩函数可以被覆写 : 例如常见的测试桩函数可以用于初始化夹具，但是测试函数能够覆写它。请注意，覆写测试桩函数是一种可能存在潜在问题的做法；
一旦测试桩函数被调用，该函数将会一致返回固定的值；
上一次调用测试桩函数有时候极为重要-当你调用一个函数很多次时，最后一次调用可能是你所感兴趣的。
@Test public void Demo2() { // 你可以mock具体的类型,不仅只是接口 LinkedList mockedList = mock(LinkedList.class); // 测试桩（可以使用连续调用） when(mockedList.get(0)).thenReturn("first"); //when(mockedList.get(0)).thenReturn("first").thenReturn("second"); when(mockedList.get(1)).thenThrow(new RuntimeException()); // 输出“first” System.out.println(mockedList.get(0)); // 连续调用则输出“second” //System.out.println(mockedList.get(0)); // 抛出异常 System.out.println(mockedList.get(1)); // 因为get(999) 没有打桩，因此输出null System.out.println(mockedList.get(999)); // 验证get(0)被调用的次数 verify(mockedList).get(0); }
3.3 验证函数的确切、最少、从未调用次数
@Test public void Demo3() { // 你可以mock具体的类型,不仅只是接口 LinkedList mockedList = mock(LinkedList.class); //using mock mockedList.add("once"); mockedList.add("twice"); mockedList.add("twice"); mockedList.add("three times"); mockedList.add("three times"); mockedList.add("three times"); // 下面的两个验证函数效果一样,因为verify默认验证的就是times(1) verify(mockedList).add("once"); verify(mockedList, times(1)).add("once"); // 验证具体的执行次数 verify(mockedList, times(2)).add("twice"); verify(mockedList, times(3)).add("three times"); // 使用never()进行验证,never相当于times(0) verify(mockedList, never()).add("never happened"); // 使用atLeast()/atMost() verify(mockedList, atLeastOnce()).add("three times"); // mockedList.add("five times"); // mockedList.add("five times"); // mockedList.add("five times"); // mockedList.add("three times"); // mockedList.add("three times"); // mockedList.add("three times"); //最少or最多 verify(mockedList, atLeast(2)).add("five times"); verify(mockedList, atMost(5)).add("three times"); }
3.4 模拟异常
@Test public void Demo4() { LinkedList mockedList = mock(LinkedList.class); doThrow(new RuntimeException()).when(mockedList).clear(); // 调用这句代码会抛出异常 mockedList.clear(); }
3.5 验证执行执行顺序
@Test public void Demo5() { // A. 验证mock一个对象的函数执行顺序 List singleMock = mock(List.class); singleMock.add("was added first"); singleMock.add("was added second"); singleMock.contains("111"); singleMock.isEmpty(); singleMock.remove(0); singleMock.get(0); // 为该mock对象创建一个inOrder对象 InOrder inOrder = inOrder(singleMock); // 确保add函数首先执行的是add("was added first"),然后才是add("was added second") inOrder.verify(singleMock).add("was added first"); inOrder.verify(singleMock).add("was added second"); inOrder.verify(singleMock).contains("111"); inOrder.verify(singleMock).isEmpty(); inOrder.verify(singleMock).remove(0); inOrder.verify(singleMock).get(0); // // B .验证多个mock对象的函数执行顺序 // List firstMock = mock(List.class); // List secondMock = mock(List.class); // // firstMock.add("was called first"); // secondMock.add("was called second"); // // // 为这两个Mock对象创建inOrder对象 // InOrder inOrder = inOrder(firstMock, secondMock); // // // 验证它们的执行顺序 // inOrder.verify(firstMock).add("was called first"); // inOrder.verify(secondMock).add("was called second"); // Oh, and A + B can be mixed together at will }
3.6 spy
然而很多时候，你希望达到这样的效果：除非指定，否者调用这个对象的默认实现，同时又能拥有验证方法调用的功能。这正好是spy对象所能实现的效果。创建一个spy对象，以及spy对象的用法介绍如下：
@Test public void Demo6() { List list = new LinkedList(); List spy = spy(list); // 你可以为某些函数打桩 when(spy.size()).thenReturn(100); // 通过spy对象调用真实对象的函数 spy.add("one"); spy.add("two"); // 输出第一个元素 System.out.println(spy.get(0)); // 因为size()函数被打桩了,因此这里返回的是100 System.out.println(spy.size()); // 交互验证 verify(spy).add("one"); verify(spy).add("two"); }
3.7 在监控对象上使用when(Object)来进行打桩是不可能或者不切实际的。
因此，当使用监控对象时请考虑doReturn|Answer|Throw()函数族来进行打桩。
@Test public void Demo7(){ List list = new LinkedList(); List spy = spy(list); // 不可能 : 因为当调用spy.get(0)时会调用真实对象的get(0)函数,此时会发生IndexOutOfBoundsException异常，因为真实List对象是空的 //when(spy.get(0)).thenReturn("foo"); // 你需要使用doReturn()来打桩 doReturn("foo").when(spy).get(anyInt()); System.out.println(spy.get(0)); // doThrow(new RuntimeException()).when(spy).get(anyInt()); // System.out.println(spy.get(0)); }
3.8使用注解形式来模拟测试对象，必须在初始化fields (领域)，有2种方式初始化：
@RunWith(@MockitoJUnitRunner.class) 标注 JUnit 测试类 @Before 之前调用 MockitoAnnotations.initMocks(Object) @Before public void init(){ MockitoAnnotations.initMocks(this); }
或者
@RunWith(MockitoJUnitRunner.class)
这里补充一下几个注解的作用
一般项目测试是用@RunWith(SpringRunner.class)
这个运行器来启动的，有些教程使用的是SpringJUnit4ClassRunner这个运行器，我们可以查看源码，其实是同一个东西，
public final class SpringRunner extends SpringJUnit4ClassRunner { public SpringRunner(Class<?> clazz) throws InitializationError { super(clazz); } }
3.9 参数捕获
ArgumentCaptor类允许我们在verification期间访问方法的参数。得到方法的参数后我们可以使用它进行测试。
ArgumentCaptor是一个能够捕获参数值的特殊参数匹配器。捕获一个
Mock 对象的方法调用所传递的参数
@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()); assertEquals(2, argument.getValue().size()); assertEquals(list, argument.getValue()); }
3.10 RETURNS_SMART_NULLS 和 RETURNS_DEEP_STUBS
RETURNS_SMART_NULLS
(返回默认值-查看源码： ReturnsMoreEmptyValues)
RETURNS_SMART_NULLS
在创建mock对象时，有的方法我们没有进行stubbing，所以在调用的时候有时会返回Null这样在进行处理时就很可能抛出NullPointerException。如果通过RETURNS_SMART_NULLS参数来创建的mock对象在调用没有stubbed的方法时他将返回SmartNull。例如：返回类型是String它将返回空字符串””；是int，它将返回0；如果是List，它会返回一个空的List。另外，在堆栈中可以看到SmartNull的友好提示。
由于使用了RETURNS_SMART_NULLS参数来创建mock对象，所以在执行下面的操作时将不会抛出NullPointerException异常，另外堆栈也提示了相关的信息“SmartNull returned by unstubbed get() method on mock”。
@Test public void returnsSmartNullsTest() { //List mock = mock(List.class); 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
(判断是否需要返回默认值，否则创建mock对象 ReturnsDeepStubs)
RETURNS_DEEP_STUBS参数程序会自动进行mock所需的对象，方法deepstubsTest和deepstubsTest2是等价的
public class FakeEntity { private UserFakeEntity userFakeEntity; public UserFakeEntity getUserFakeEntity() { return userFakeEntity; } public void setUserFakeEntity(UserFakeEntity userFakeEntity) { this.userFakeEntity = userFakeEntity; } } @Test public void deepstubsTest() { //FakeEntity fakeEntity = mock(FakeEntity.class);//这样会NullPointerException FakeEntity fakeEntity = mock(FakeEntity.class, RETURNS_DEEP_STUBS); when(fakeEntity.getUserFakeEntity().getName()).thenReturn("Beijing"); System.out.println(fakeEntity.getUserFakeEntity().getName()); assertEquals("Beijing", fakeEntity.getUserFakeEntity().getName()); } @Test public void deepstubsTest2() { FakeEntity fakeEntity = mock(FakeEntity.class); UserFakeEntity userFakeEntity = mock(UserFakeEntity.class); when(fakeEntity.getUserFakeEntity()).thenReturn(userFakeEntity); when(userFakeEntity.getName()).thenReturn("Beijing"); System.out.println(fakeEntity.getUserFakeEntity().getName()); assertEquals("Beijing", fakeEntity.getUserFakeEntity().getName()); }
四、实战使用
4.1登录的例子
import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.mockito.runners.MockitoJUnitRunner; import org.springframework.boot.test.context.SpringBootTest; import static org.mockito.Mockito.*; //基于MockitoJUnitRunner的运行器 @RunWith(MockitoJUnitRunner.class) //@RunWith(SpringRunner.class) @SpringBootTest public class MockLoginTest { //自动将模拟对象或侦查域注入到被测试对象中。 //对被测类中@Autowired的对象，用@Mocks标注；对被测类自己，用@InjectMocks标注 @InjectMocks private UserServiceImpl userService; @Mock private UserRepository userDao; @Mock private BargainBlackListService bargainBlackListService; @Mock private DistributionUserService distributionUserService; @Mock private AuthorityService authorityService; @Before public void init(){ MockitoAnnotations.initMocks(this); } @Test public void loginTest() { //模拟方法动作 //spyUserService在调用getUserEntity方法的时候，指定返回事先定义好的userEntity UserService spyUserService = spy(userService); UserEntity userEntity = new UserEntity(); userEntity.setUserName("ppp"); doReturn(userEntity).when(spyUserService).getUserEntity(anyString()); when(bargainBlackListService.checkBlackList(anyString())).thenReturn(true); UserInfoDTO userInfoDTO = new UserInfoDTO(); userInfoDTO.setUserName("ppp"); userInfoDTO.setId("2c95808a644ade6801644ae37f730000"); spyUserService.updateUserInfo("0520b1d9-9806-4ec1-a095-dfcd8bea8fd6", userInfoDTO); } }
