Spring boot 整合mockito

public interface PersonDao {

Person getPerson(int id);

boolean update(Person person);

}

service

public class PersonService {

private final PersonDao personDao;

public PersonService(PersonDao personDao) {

this.personDao = personDao;

}

public boolean update(int id, String name) {

Person person = personDao.getPerson(id);

if (person == null) {

return false;

}

Person personUpdate = new Person(person.getId(), name);

return personDao.update(personUpdate);

}

}

在test目录写测试代码:

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import static org.mockito.Matchers.eq;

import static org.mockito.Matchers.isA;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;

import org.junit.Before;

import org.junit.Test;

import com.demo.mockito.bean.Person;

import com.demo.mockito.dao.PersonDao;

import com.demo.mockito.service.PersonService;

/**

• @ClassName: PersonServiceTest

• @Description: TODO

• @author 刘彦青

• @date 2018年7月31日

*/

public class PersonServiceTest {

private PersonDao mockDao;

private PersonService personService;

@Before

public void setUp() throws Exception {

//模拟PersonDao对象

mockDao = mock(PersonDao.class);

when(mockDao.getPerson(1)).thenReturn(new Person(1, “Person1”));

when(mockDao.update(isA(Person.class))).thenReturn(true);

personService = new PersonService(mockDao);

}

@Test

public void testUpdate() throws Exception {

boolean result = personService.update(1, “new name”);

assertTrue(“must true”, result);

//验证是否执行过一次getPerson(1)

verify(mockDao, times(1)).getPerson(eq(1));

//验证是否执行过一次update

verify(mockDao, times(1)).update(isA(Person.class));

}

@Test

public void testUpdateNotFind() throws Exception {

boolean result = personService.update(2, “new name”);

assertFalse(“must true”, result);

//验证是否执行过一次getPerson(1)

verify(mockDao, times(1)).getPerson(eq(1));

//验证是否执行过一次update

verify(mockDao, never()).update(isA(Person.class));

}

}

Mockito使用示例

===========

模拟对象

---

// 模拟LinkedList 的一个对象

LinkedList mockedList = mock(LinkedList.class);

// 此时调用get方法，会返回null，因为还没有对方法调用的返回值做模拟

System.out.println(mockedList.get(0));

模拟方法调用的返回值

---

// 模拟获取第一个元素时，返回字符串first。 给特定的方法调用返回固定值在官方说法中称为stub。

when(mockedList.get(0)).thenReturn(“first”);

// 此时打印输出first

System.out.println(mockedList.get(0));

模拟方法调用抛出异常

---

// 模拟获取第二个元素时，抛出RuntimeException

when(mockedList.get(1)).thenThrow(new RuntimeException());

// 此时将会抛出RuntimeException

System.out.println(mockedList.get(1));

如果一个函数没有返回值类型，那么可以使用此方法模拟异常抛出

doThrow(new RuntimeException(“clear exception”)).when(mockedList).clear();

mockedList.clear();

模拟调用方法时的参数匹配

---

// anyInt()匹配任何int参数，这意味着参数为任意值，其返回值均是element

when(mockedList.get(anyInt())).thenReturn(“element”);

// 此时打印是element

System.out.println(mockedList.get(999));

模拟方法调用次数

---

// 调用add一次

mockedList.add(“once”);

// 下面两个写法验证效果一样，均验证add方法是否被调用了一次

verify(mockedList).add(“once”);

verify(mockedList, times(1)).add(“once”);

校验行为

---

// mock creation

List mockedList = mock(List.class);

// using mock object

mockedList.add(“one”);

mockedList.clear();

//verification

verify(mockedList).add(“one”);

verify(mockedList).clear();

模拟方法调用(Stubbing)

---

//You can mock concrete classes, not just interfaces

LinkedList mockedList = mock(LinkedList.class);

//stubbing

when(mockedList.get(0)).thenReturn(“first”);

when(mockedList.get(1)).thenThrow(new RuntimeException());

//following prints “first”

System.out.println(mockedList.get(0));

//following throws runtime exception

System.out.println(mockedList.get(1));

//following prints “null” because get(999) was not stubbed

System.out.println(mockedList.get(999));

verify(mockedList).get(0);

参数匹配

---

//stubbing using built-in anyInt() argument matcher

when(mockedList.get(anyInt())).thenReturn(“element”);

//stubbing using custom matcher (let’s say isValid() returns your own matcher implementation):

when(mockedList.contains(argThat(isValid()))).thenReturn(“element”);

//following prints “element”

System.out.println(mockedList.get(999));

//you can also verify using an argument matcher

verify(mockedList).get(anyInt());

//argument matchers can also be written as Java 8 Lambdas

verify(mockedList).add(someString -> someString.length() > 5);

校验方法调用次数

---

//using mock

mockedList.add(“once”);

mockedList.add(“twice”);

mockedList.add(“twice”);

mockedList.add(“three times”);

mockedList.add(“three times”);

mockedList.add(“three times”);

//following two verifications work exactly the same - times(1) is used by default

verify(mockedList).add(“once”);

verify(mockedList, times(1)).add(“once”);

//exact number of invocations verification

verify(mockedList, times(2)).add(“twice”);

verify(mockedList, times(3)).add(“three times”);

//verification using never(). never() is an alias to times(0)

verify(mockedList, never()).add(“never happened”);

//verification using atLeast()/atMost()

verify(mockedList, atLeastOnce()).add(“three times”);

verify(mockedList, atLeast(2)).add(“five times”);

verify(mockedList, atMost(5)).add(“three times”);

模拟无返回方法抛出异常

---

doThrow(new RuntimeException()).when(mockedList).clear();

//following throws RuntimeException:

mockedList.clear();

校验方法调用顺序

---

// A. Single mock whose methods must be invoked in a particular order

List singleMock = mock(List.class);

//using a single mock

singleMock.add(“was added first”);

singleMock.add(“was added second”);

//create an inOrder verifier for a single mock

InOrder inOrder = inOrder(singleMock);

//following will make sure that add is first called with "was added first, then with “was added second”

inOrder.verify(singleMock).add(“was added first”);

inOrder.verify(singleMock).add(“was added second”);

// B. Multiple mocks that must be used in a particular order

List firstMock = mock(List.class);

List secondMock = mock(List.class);

//using mocks

firstMock.add(“was called first”);

secondMock.add(“was called second”);

//create inOrder object passing any mocks that need to be verified in order

InOrder inOrder = inOrder(firstMock, secondMock);

//following will make sure that firstMock was called before 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

校验方法是否从未调用

---

//using mocks - only mockOne is interacted

mockOne.add(“one”);

//ordinary verification

verify(mockOne).add(“one”);

//verify that method was never called on a mock

verify(mockOne, never()).add(“two”);

//verify that other mocks were not interacted

verifyZeroInteractions(mockTwo, mockThree);

快速创建Mock对象

---

public class ArticleManagerTest {

@Mock private ArticleCalculator calculator;

@Mock private ArticleDatabase database;

@Mock private UserProvider userProvider;

@Before

public void before(){

MockitoAnnotations.initMocks(this);

}

}

自定义返回不同结果

---

when(mock.someMethod(“some arg”))

.thenThrow(new RuntimeException()) // 第一次会抛出异常

.thenReturn(“foo”); // 第二次会返回这个结果

//First call: throws runtime exception:

mock.someMethod(“some arg”); // 第一次

//Second call: prints “foo”

System.out.println(mock.someMethod(“some arg”)); // 第二次

//Any consecutive call: prints “foo” as well (last stubbing wins).

System.out.println(mock.someMethod(“some arg”)); // 第n次(n> 2)，依旧以最后返回最后一个配置

对返回结果进行拦截

---

when(mock.someMethod(anyString())).thenAnswer(new Answer() {

Object answer(InvocationOnMock invocation) {

Object[] args = invocation.getArguments();

Object mock = invocation.getMock();

return "called with arguments: " + args;

}

});

//the following prints “called with arguments: foo”

System.out.println(mock.someMethod(“foo”));

Mock函数操作

---

可以通过doThrow(), doAnswer(), doNothing(), doReturn() and doCallRealMethod() 来自定义函数操作。

暗中调用真实对象

---

List list = new LinkedList();

List spy = spy(list);

//optionally, you can stub out some methods:

when(spy.size()).thenReturn(100);

//using the spy calls real methods

spy.add(“one”);

spy.add(“two”);

//prints “one” - the first element of a list

System.out.println(spy.get(0));

//size() method was stubbed - 100 is printed

System.out.println(spy.size());

//optionally, you can verify

verify(spy).add(“one”);

verify(spy).add(“two”);

改变默认返回值

---

Foo mock = mock(Foo.class, Mockito.RETURNS_SMART_NULLS);

Foo mockTwo = mock(Foo.class, new YourOwnAnswer());

捕获函数的参数值

---

ArgumentCaptor argument = ArgumentCaptor.forClass(Person.class);

verify(mock).doSomething(argument.capture());

assertEquals(“John”, argument.getValue().getName());

部分Mock

---

//you can create partial mock with spy() method:

List list = spy(new LinkedList());

//you can enable partial mock capabilities selectively on mocks:

Foo mock = mock(Foo.class);

//Be sure the real implementation is ‘safe’.

//If real implementation throws exceptions or depends on specific state of the object then you’re in trouble.

when(mock.someMethod()).thenCallRealMethod();

重置Mock