Junit mockito解耦合測試

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

1、相關網址

　　官網：http://mockito.org/

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

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

2、什么是Mock測試

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

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

　　當我們需要測試A類的時候，如果沒有 Mock，則我們需要把整個依賴樹都構建出來，而使用 Mock 的話就可以將結構分解開，像下面這樣：

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

3、mock使用的場景和好處

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

4、一些特點

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

 

5、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>  

6、使用

　　首先我們需要引入靜態資源

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層的方法，在后面會補上。

　　致謝：感謝您的閱讀！