Junit mockito解耦合測試

　　Mock測試是單元測試的重要方法之一。

一、相關網址

　　官網：http://mockito.org/

　　項目源碼：https://github.com/mockito/mockito

　　api：http://site.mockito.org/mockito/docs/current/org/mockito/Mockito.html

二、什麼是Mock測試

　　Mock 測試就是在測試過程當中，對於某些不容易構造（如 HttpServletRequest 必須在Servlet 容器中才能構造出來）或者不容易獲取比較複雜的對象（如 JDBC 中的ResultSet 對象），用一個虛擬的對象（Mock 對象）來建立以便測試的測試方法。

　　Mock 最大的功能是幫你把單元測試的耦合分解開，若是你的代碼對另外一個類或者接口有依賴，它可以幫你模擬這些依賴，並幫你驗證所調用的依賴的行爲。

　　當咱們須要測試A類的時候，若是沒有 Mock，則咱們須要把整個依賴樹都構建出來，而使用 Mock 的話就能夠將結構分解開，像下面這樣：

　　只需提供mock B 和mock C 的返回便可的，不須要知道其底層具體是怎麼實現的。

三、mock使用的場景和好處

• 真實的對象具備不肯定的行爲，產生不可預測效果。（如：股票行情，天氣預報），咱們常常會遇到測試的時候須要去數據庫中查詢某些數據，可是未知的，就算是知道的，假若有一天數據被刪除了或者被修改了，很難進行迴歸測試。
• 真實對象很難被建立的，真實對象的某些行爲很難被觸發。
• 真實對象實際上還不存在的。如：某個接口依賴其餘系統的服務或者該接口還沒開發出來。咱們就可使用mock假設其返回的數據進行測試。而不用等待其開發完接口，咱們再進行測試。提升開發的效率

四、一些特色

• 能夠 mock 具體類而不單止是接口
• 一點註解語法糖 - @Mock
• 乾淨的驗證錯誤是 - 點擊堆棧跟蹤，看看在測試中的失敗驗證;點擊異常的緣由來導航到代碼中的實際互動。堆棧跟蹤老是乾乾淨淨。
• 容許靈活有序的驗證（例如：你任意有序 verify ，而不是每個單獨的交互）
• 支持「詳細的用戶號碼的時間」以及「至少一 次」驗證
• 靈活的驗證或使用參數匹配器的 stub （ anyObject() ， anyString() 或 refEq() 用於基於反射的相等匹配）
• 容許建立 自定義的參數匹配器 或者使用現有的 hamcrest 匹配器

 

五、maven配置

1）Junit的maven

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

2）mockito的maven

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

六、使用

　　首先咱們須要引入靜態資源

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

 

1）驗證行爲

@Test  
public void verify_behaviour(){  
    //模擬建立一個List對象  
    List mock = mock(List.class);  
    //使用mock的對象  
    mock.add(1);  
    mock.clear();    //清空mock對象 
    //驗證add(1)和clear()行爲是否發生  
    verify(mock).add(1);  
    verify(mock).clear();  
}  

 

 2）模擬咱們所指望的結果

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

3）參數匹配

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

4）驗證確切的調用次數

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

5）模擬方法體拋出異常

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

6）驗證執行順序

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

7）確保模擬對象上無互動發生

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

8）找出冗餘的互動(即未被驗證到的)

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

9）使用註解的方式來快速模擬

　　在上面的測試中咱們在每一個測試方法裏都mock了一個List對象，爲了不重複的mock，是測試類更具備可讀性，咱們可使用下面的（@Mock）註解方式來快速模擬對象：

@Mock  
private List mockList;   

　　咱們再用註解的mock對象試試

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

　　運行這個測試類你會發現報錯了，mock的對象（mockList）爲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

10）連續調用

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

11）使用回調生成指望值

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

12）監控真實對象

　　使用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);  
}  

13）修改對未預設的調用返回默認指望值

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

14）捕獲參數來進一步斷言

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

15）真實的部分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;  
    }  
}  

16）重置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());  
}  

 　　後面還有在一個類中調用另一個類的方法，咱們但願模擬這樣類方法的返回，如：Controller中調用了Service的方法，咱們要模擬Service方法返回的數據，Sevice調用了Dao層，咱們要模擬返回Dao層的方法，在後面會補上。

　　致謝：感謝您的閱讀！