Mockito基础入门

我就是我 2022-05-14 00:57 249阅读 0赞

**目录**

使用Mockito的前期准备

什么是Mockito?

为什么需要Mockito?

Stub和Mock

开始Mockito学习

简单例子

验证行为

模拟我们所期望的结果

参数匹配器

验证调用次数

模拟方法体抛出异常

验证执行顺序

确保模拟对象上无互动发生

找出冗余的互动(即未被验证到的)

使用注解来快速模拟

连续调用

使用回调生成期望值

Spy-监控真实对象

修改对未预设的调用返回默认期望值

捕获参数来进一步断言

真实的部分mock

重置mock

--------------------

# 使用Mockito的前期准备 #

由于工作需要使用PowerMockito进行TDD测试，所以先来学习一下Mockito，网上的资料很多，所以我写这篇博客其实主要也是给自己写一下学习笔记。 推荐一下我学习的资料吧。

[mockito简单教程][mockito]

[学习Mockito][Mockito]

[Mockito 基础学习][Mockito 1]

[官方文档][Link 1]

[Mockito教程][Mockito 2]

[Mockito介绍和使用][Mockito 3]

[学习Mockito - 自定义参数匹配器][Mockito -]

虽然上面的内容其实都差不多，但是还是可以参考下。

# 什么是Mockito? #

首先来了解下什么是Mockito？Mockito是mocking框架（常见的Mocking框架有EasyMock、Mockito、PowerMock和JMockit），它让你用简洁的API做测试。而且Mockito简单易学，它可读性强和验证语法简洁。现在可以还看不出它功能的强大，往下学其实发现真的挺好用的。

# 为什么需要Mockito? #

其实用普通的junit也是可以进行TDD（测试驱动的开发）的，但为什么我们还需要使用Mockito。因为其实在单元测试中被测试的类往往会依赖很多其他的资源或者类，然后这些资源或者类可能又会依赖很多其他的东西。通过Mockito我们就可以来模拟我们需要的测试环境，隔离被测试的类和测试类之外的对象。具体的作用可以查看一下[Mockito介绍和使用][Mockito 3]，这里面说的很详细。

# Stub和Mock #

学习Mockito之前，需要先简单了解下Stub和Mock的区别。

Stub对象用来提供测试时所需要的测试数据,可以对各种交互设置相应的回应。例如我们可以设置方法调用的返回值等等。Mockito中when(…).thenReturn(…) 这样的语法便是设置方法调用的返回值。另外也可以设置方法在何时调用会抛异常等。

Mock对象用来验证测试中所依赖对象间的交互是否能够达到预期。Mockito中用 verify(…).methodXxx(…)语法来验证 methodXxx方法是否按照预期进行了调用。

在Mocking框架中所谓的mock对象实际上是作为上述的stub和mock对象同时使用的。因为它既可以设置方法调用返回值，又可以验证方法的调用。

# 开始Mockito学习 #

首先是添加maven的依赖：

<dependency>
                <groupId>org.mockito</groupId>
                <artifactId>mockito-all</artifactId>
                <version>1.9.5</version>
                <scope>test</scope>
            </dependency>

然后需要junit的配合使用：

<dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.11</version>
                <scope>test</scope>
            </dependency>

然后为了使代码更简洁，最好在测试类中导入静态资源：

import static org.mockito.Mockito.*;
    import static org.junit.Assert.*;

## 简单例子 ##

@Test
        public void simpleTest(){
            Iterator i = mock(Iterator.class);
            when(i.next()).thenReturn("Hello").thenReturn("World");
            String result = i.next() + " " + i.next();
            //验证
            verify(i,times(2)).next();
            assertEquals("Hello World",result);
        }

上面的例子分了三步：

**1.创建mock对象：**

创建Mock对象的语法为,mock(class or interface)。例子中创建了Iterator接口的mock对象

**2.设置方法调用的预期返回：**

通过when(mock.someMethod()).thenReturn(value) 来设定mock对象某个方法调用时的返回值。例子中我们对Iterator接口的next()方法调用进行了预期设定,当调用next()方法时会返回”Hello”,由于连续设定了返回值,因此当第二次调用时将返回“World”。

**3.验证方法调用**

接下来对mock对象的next()方法进行了一系列实际的调用。mock对象一旦建立便会自动记录自己的交互行为,所以我们可以有选择的对它的交互行为进行验证。在Mockito中验证mock对象交互行为的方法是verify(mock).someMethod(…)。于是用此方法验证了next()方法调用,因为调用了两次,所以在verify中我们指定了time参数。最后assert返回值是否和预期一样。

## 验证行为 ##

@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
    	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"));
    	}

Mockito通过equals()方法,来对方法参数进行验证。但有时我们需要更加灵活的参数需求,比如,匹配任何的String类型的参数等等。参数匹配器就是一个能够满足这些需求的工具。

Mockito框架中的Matchers类内建了很多参数匹配器,而我们常用的Mockito对象便是继承自Matchers。这些内建的参数匹配器如,anyInt()匹配任何int类型参数,anyString()匹配任何字符串,anySet()匹配任何Set等。下面通过例子来说明如何使用内建的参数匹配器:

@Test
        public void argumentMatchersTest(){
            List<String> mock = mock(List.class);
            when(mock.get(anyInt())).thenReturn("Hello").thenReturn("World");
            String result = mock.get(100) + " " + mock.get(200);
            verify(mock, times(2)).get(anyInt());
            assertEquals("Hello World",result);
    
        }

Stubbing时使用内建参数匹配器：

例子中,首先mock了List接口,然后用迭代的方式模拟了get方法的返回值,这里用了anyInt()参数匹配器来匹配任何的int类型的参数。所以当第一次调用get方法时输入任意参数为100方法返回”Hello”,第二次调用时输入任意参数200返回值”World”。

Verfiy时使用参数匹配器：

最后进行verfiy验证的时候也可将参数指定为anyInt()匹配器,那么它将不关心调用时输入的参数的具体参数值。

注意：如果使用了参数匹配器,那么所有的参数需要由匹配器来提供,否则将会报错。假如我们使用参数匹配器stubbing了mock对象的方法,那么在verify的时候也需要使用它。

@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");
    	}

除了匹配制定参数外，还可以匹配自己想要的任意参数。具体的可以参考下：[学习Mockito - 自定义参数匹配器][Mockito -]

@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;
    		}
    	}

自定义参数匹配器的时候需要继承ArgumentMatcher抽象类。argThat(Matcher<T> matcher)方法用来应用自定义的规则，可以传入任何实现Matcher接口的实现类。

## **验证调用次数** ##

@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);
    	}

验证方法调用的次数：

如果要验证Mock对象的某个方法调用次数,则需给verify方法传入相关的验证参数,它的调用接口是verify(T mock, VerificationMode mode)。如: verify(mock,times(3)).someMethod(argument)验证mock对象someMethod(argument)方法是否调用了三次。times(N)参数便是验证调用次数的参数,N代表方法调用次数。其实verify方法中如果不传调用次数的验证参数,它默认传入的便是times(1),即验证mock对象的方法是否只被调用一次,如果有多次调用测试方法将会失败。

Mockito除了提供times(N)方法供我们调用外,还提供了很多可选的方法: never() 没有被调用,相当于times(0)

atLeast(N) 至少被调用N次

atLeastOnce() 相当于atLeast(1)

atMost(N) 最多被调用N次

## 模拟方法体抛出异常 ##

@Test(expected = RuntimeException.class)
        public void doThrow_when(){
            List list = mock(List.class);
            doThrow(new RuntimeException()).when(list).add(1);
            list.add(1);
        }

## 验证执行顺序 ##

import org.mockito.InOrder;
    
       @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");
        }

验证方法调用的顺序:

Mockito同样支持对不同Mock对象不同方法的调用次序进行验证。进行次序验证是,我们需要创建InOrder对象来进行支持。

创建InOrder对象:

inOrder方法可以传入多个mock对象作为参数,这样便可对这些mock对象的方法进行调用顺序的验证。

## 确保模拟对象上无互动发生 ##

@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);
           
        }

验证的基本方法：

我们已经熟悉了使用verify(mock).someMethod(…)来验证方法的调用。例子中,我们mock了List接口,然后调用了mock对象的一些方法。验证是否调用了list.add(1)方法可以通过verify(list).add(1)来进行。verify方法的调用不关心是否模拟了add(1)方法的返回值,只关心mock对象后,是否执行了list.add(1),如果没有执行,测试方法将不会通过。

验证未曾执行的方法：

在verify方法中可以传入never()方法参数来确认list.add(2)方法不曾被执行过。

## 找出冗余的互动(即未被验证到的) ##

@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);
    	}

## 使用注解来快速模拟 ##

在上面的测试中我们在每个测试方法里都mock了一个List对象，为了避免重复的mock，是测试类更具有可读性，我们可以使用下面的注解方式来快速模拟对象：

@Mock
    	private List mockList;

OK，我们再用注解的mock对象试试

@Test
    	public void shorthand(){
    		mockList.add(1);
    		verify(mockList).add(1);
    	}

运行这个测试类你会发现报错了，mock的对象为NULL，为此我们必须在基类中添加初始化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);
    	}
    }

更多的注解还有@Captor,@Spy,@InjectMocks

Mockito对Annotation的支持

Mockito支持对变量进行注解,例如将mock对象设为测试类的属性,然后通过注解的方式@Mock来定义它,这样有利于减少重复代码,增强可读性,易于排查错误等。除了支持@Mock,Mockito支持的注解还有@Spy(监视真实的对象), @Captor(参数捕获器),@InjectMocks(mock对象自动注入)。

Annotation的初始化

只有Annotation还不够,要让它们工作起来还需要进行初始化工作。初始化的方法为:MockitoAnnotations.initMocks(testClass)参数testClass是你所写的测试类。一般情况下在Junit4的@Before定义的方法中执行初始化工作,如下:

@Before
    public void initMocks() {
        MockitoAnnotations.initMocks(this);
    }

使用@Mock注解来定义mock对象有如下的优点:

1.方便mock对象的创建

2.减少mock对象创建的重复代码

3.提高测试代码可读性

4.变量名字作为mock对象的标示,所以易于排错

@InjectMocks注解:

通过这个注解,可实现自动注入mock对象。当前版本只支持setter的方式进行注入,Mockito首先尝试类型注入,如果有多个类型相同的mock对象,那么它会根据名称进行注入。当注入失败的时候Mockito不会抛出任何异常,所以你可能需要手动去验证它的安全性。

## 连续调用 ##

@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 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));
    	}

## Spy-监控真实对象 ##

Mock对象只能调用stubbed方法,调用不了它真实的方法。但Mockito可以监视一个真实的对象,这时对它进行方法调用时它将调用真实的方法,同时也可以stubbing这个对象的方法让它返回我们的期望值。另外不论是否是真实的方法调用都可以进行verify验证。和创建mock对象一样,对于final类、匿名类和Java 的基本类型是无法进行spy的。

*  Mock不是真实的对象，它只是用类型的class创建了一个虚拟对象，并可以设置对象行为
 *  Spy是一个真实的对象，但它可以设置对象行为

使用spy来监控真实的对象，需要注意的是此时我们需要谨慎的使用when-then语句，而改用do-when语句

@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);
    	}

## 修改对未预设的调用返回默认期望值 ##

@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());
    	}

## 捕获参数来进一步断言 ##

@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));
    		}
    	}

## 真实的部分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());
    	}

Mock对象的重置

Mockito提供了reset(mock1,mock2……)方法,用来重置mock对象。当mock对象被重置后,它将回到刚创建完的状态,没有任何stubbing和方法调用。这个特性平时是很少用到的,因为我们大都为每个test方法创建mock,所以没有必要对它进行重置。官方提供这个特性的唯一目的是使得我们能在有容器注入的mock 对象中工作更为方便。所以,当决定要使用这个方法的时候,首先应该考虑一下我们的测试代码是否简洁和专注,测试方法是否已经超长了。

[mockito]: https://blog.csdn.net/sdyy321/article/details/38757135/
[Mockito]: https://wenku.baidu.com/view/8def451a227916888486d73f.html
[Mockito 1]: https://www.jianshu.com/p/0cbf17be650a
[Link 1]: http://static.javadoc.io/org.mockito/mockito-core/2.21.0/org/mockito/Mockito.html
[Mockito 2]: https://www.cnblogs.com/Ming8006/p/6297333.html
[Mockito 3]: https://blog.csdn.net/lpsnow0531/article/details/78864809
[Mockito -]: http://hotdog.iteye.com/blog/911584