Mockito模擬進行單元測試

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方法，返回以前保存的數據。