使用Powermock和mockito來進行單元測試
簡介
Mockito是一個流行的Mocking框架。它使用起來簡單,學習成本很低,而且具
有非常簡潔的API,測試程式碼的可讀性很高。因此它十分受歡迎,使用者群越來越
多,很多的開源的軟體也選擇了Mockito。
要想了解更多有關Mockito的資訊,請訪問它的官方網站:http://mockito.org/
Stub 和Mock
在開始使用Mockito之前,先簡單的瞭解一下Stub和Mock的區別。
Stub物件用來提供測試時所需要的測試資料,可以對各種互動設定相應的迴應。
例如我們可以設定方法呼叫的返回值等等。Mockito中when(…).thenReturn(…)
這樣的語法便是設定方法呼叫的返回值。另外也可以設定方法在何時呼叫會拋異
常等。
Mock物件用來驗證測試中所依賴物件間的互動是否能夠達到預期。Mockito中用
verify(…).methodXxx(…) 語法來驗證 methodXxx 方法是否按照預期進行了調
用。
有關stub和mock的詳細論述見,Martin Fowler文章《Mocks Aren't Stub》
http://martinfowler.com/articles/mocksArentStubs.html
在 Mocking 框架中所謂的mock 物件實際上是作為上述的stub 和mock 物件同時
使用的。因為它既可以設定方法呼叫返回值,又可以驗證方法的呼叫。
Mockito 的獲取
Jar 包的獲取
可以訪問下面的連結來下載最新的Jar包,筆者使用的當前最新版為:1.8.5
http://code.google.com/p/mockito/downloads/list
Maven
如果專案是通過Maven管理的,需要在專案的Pom.xml中增加如下的依賴:
<dependencies>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
<version>1.8.5</version>
<scope>test</scope>
</dependency>
</dependencies>
從一個例項開始
Mocktio包的引入
在程式中可以import org.mockito.Mockito;然後呼叫它的static方法,或者
import static org.mockito.Mockito.*;個人傾向於後者,因為這樣可以更方
便些。
一個簡單的例子
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.util.Iterator;
import org.junit.Test;
/**
*
* @author Brian Zhao
*/
public class SimpleTest {
@Test
public void simpleTest(){
//arrange
Iterator i=mock(Iterator.class);
when(i.next()).thenReturn("Hello").thenReturn("World");
//act
String result=i.next()+" "+i.next();
//verify
verify(i, times(2)).next();
//assert
assertEquals("Hello World", result);
}
}
在上面的例子中包含了Mockito的基本功能:
建立 Mock 物件
建立Mock物件的語法為,mock(class or interface)。例子中建立了Iterator
介面的mock物件。
設定方法呼叫的預期返回
通過when(mock.someMethod()).thenReturn(value) 來設定mock物件某個方
法呼叫時的返回值。例子中我們對Iterator介面的next()方法呼叫進行了預期
設定,當呼叫next()方法時會返回”Hello”,由於連續設定了返回值,因此當第
二次呼叫時將返回”World”。
驗證方法呼叫
接下來對mock物件的next()方法進行了一系列實際的呼叫。mock物件一旦建
立便會自動記錄自己的互動行為,所以我們可以有選擇的對它的互動行為進行驗
證。在Mockito中驗證mock物件互動行為的方法是
verify(mock).someMethod(…)。於是用此方法驗證了next()方法呼叫,因為調
用了兩次,所以在verify中我們指定了times引數(times的具體應用在後面
會繼續介紹)。最後assert返回值是否和預期一樣。
Mock物件的建立和Stubbing
Mock 物件的建立
mock(Class<T> classToMock)
mock(Class<T> classToMock, String name)
可以對類和介面進行mock 物件的建立,建立的時候可以為mock 物件命名,也
可以忽略命名引數。為mock 物件命名的好處就是除錯的時候會很方便,比如,
我們mock 多個物件,在測試失敗的資訊中會把有問題的mock 物件打印出來,
有了名字我們可以很容易定位和辨認出是哪個mock物件出現的問題。另外它也
有限制,對於final類、匿名類和Java的基本型別是無法進行mock的。
Mock 物件的期望行為及返回值設定
我們已經瞭解到可以通過when(mock.someMethod()).thenReturn(value) 來
設定mock物件的某個方法呼叫時的返回值,但它也同樣有限制對於static和final
修飾的方法是無法進行設定的。下面來詳細的介紹一下有關方法及返回值的設定:
首先假設我們建立Iterator介面的mock物件
Iterator<String> i = mock(Iterator.class);
對方法設定返回值
when(i.next()).thenReturn("Hello")
對方法設定返回異常
when(i.next()).thenThrow(new RuntimeException())
Mockito支援迭代風格的返回值設定
第一種方式
when(i.next()).thenReturn("Hello").thenReturn("World")
第二種方式
when(i.next()).thenReturn("Hello", "World")
上面的設定相當於:
when(i.next()).thenReturn("Hello")
when(i.next()).thenReturn("World")
第一次呼叫i.next()將返回”Hello”,第二次的呼叫會返回”World”。
Stubbing的另一種語法
doReturn(Object) 設定返回值
doReturn("Hello").when(i).next();
迭代風格
doReturn("Hello").doReturn("World").when(i).next();
返回值的次序為從左至右,第一次呼叫返回”Hello”,第二次返回”World”。
doThrow(Throwable) 設定返回異常
doThrow(new RuntimeException()).when(i).next();
因為這種語法的可讀性不如前者,所以能使用前者的情況下儘量使用前者,當然
在後面要介紹的Spy除外。
對 void 方法進行方法預期設定
void方法的模擬不支援when(mock.someMethod()).thenReturn(value)這樣的
語法,只支援下面的方式:
doNothing() 模擬不做任何返回(mock物件void方法的預設返回)
doNothing().when(i).remove();
doThrow(Throwable) 模擬返回異常
doThrow(new RuntimeException()).when(i).remove();
迭代風格
doNothing().doThrow(new RuntimeException()).when(i).remove();
第一次呼叫remove方法什麼都不做,第二次呼叫丟擲RuntimeException異常。
Argument Matcher(引數匹配器)
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 argumentMatchersTest(){
Map mapMock = mock(Map.class);
when(mapMock.put(anyInt(), anyString())).thenReturn("world");
mapMock.put(1, "hello");
verify(mapMock).put(anyInt(), eq("hello"));
}
在最後的驗證時如果只輸入字串”hello”是會報錯的,必須使用Matchers 類內
建的eq方法。如果將anyInt()換成1進行驗證也需要用eq(1)。
詳細的內建引數匹配器請參考:
http://docs.mockito.googlecode.com/hg/org/mockito/Matchers.html
Mock物件的行為驗證
之前介紹瞭如何設定mock物件預期呼叫的方法及返回值。下面介紹方法呼叫的
驗證,而它關注點則在mock 物件的互動行為上,比如驗證mock 物件的某個方
法呼叫引數,呼叫次數,順序等等。下面來看例子:
@Test
public void verifyTestTest() {
List<String> mock = mock(List.class);
List<String> mock2 = mock(List.class);
when(mock.get(0)).thenReturn("hello");
mock.get(0);
mock.get(1);
mock.get(2);
mock2.get(0);
verify(mock).get(2);
verify(mock, never()).get(3);
verifyNoMoreInteractions(mock);
verifyZeroInteractions(mock2);
}
驗證的基本方法
我們已經熟悉了使用verify(mock).someMethod(…)來驗證方法的呼叫。例子中,
我們mock 了List 介面,然後呼叫了mock 物件的一些方法。驗證是否呼叫了
mock.get(2)方法可以通過verify(mock).get(2)來進行。verify 方法的呼叫不
關心是否模擬了get(2)方法的返回值,只關心mock 物件後,是否執行了
mock.get(2),如果沒有執行,測試方法將不會通過。
驗證未曾執行的方法
在verify方法中可以傳入never()方法引數來確認mock.get(3)方法不曾被執行過。
另外還有很多呼叫次數相關的引數將會在下面提到。
查詢多餘的方法呼叫
verifyNoMoreInteractions()方法可以傳入多個mock物件作為引數,用來驗證傳入
的這些mock 物件是否存在沒有驗證過的呼叫方法。本例中傳入引數mock,測
試將不會通過,因為我們只verify了mock物件的get(2)方法,沒有對get(0)和get(1)
進行驗證。為了增加測試的可維護性,官方不推薦我們過於頻繁的在每個測試方
法中都使用它,因為它只是測試的一個工具,只在你認為有必要的時候才用。
查詢沒有互動的mock物件
verifyZeroInteractions()也是一個測試工具,原始碼和verifyNoMoreInteractions()的實
現是一樣的,為了提高邏輯的可讀性,所以只不過名字不同。在例子中,它的目
的是用來確認mock2物件沒有進行任何互動,但mock2執行了get(0)方法,所以
這裡測試會報錯。由於它和verifyNoMoreInteractions()方法實現的原始碼都一樣,
因此如果在verifyZeroInteractions(mock2)執行之前對mock.get(0)進行了
驗證那麼測試將會通過。
對 Mock物件方法的呼叫次數、順序和超時進行驗證
驗證方法呼叫的次數
如果要驗證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次
超時驗證
Mockito 提供對超時的驗證,但是目前不支援在下面提到的順序驗證中使用。進
行超時驗證和上述的次數驗證一樣,也要在verify 中進行引數的傳入,引數為
timeout(int millis),timeout方法中輸入的是毫秒值。下面看例子:
驗證someMethod()是否能在指定的100毫秒中執行完畢
verify(mock, timeout(100)).someMethod();
結果和上面的例子一樣,在超時驗證的同時可進行呼叫次數驗證,預設次數為1
verify(mock, timeout(100).times(1)).someMethod();
在給定的時間內完成執行次數
verify(mock, timeout(100).times(2)).someMethod();
給定的時間內至少執行兩次
verify(mock, timeout(100).atLeast(2)).someMethod();
另外timeout也支援自定義的驗證模式,
verify(mock, new Timeout(100,
yourOwnVerificationMode)).someMethod();
驗證方法呼叫的順序
Mockito 同樣支援對不同Mock 物件不同方法的呼叫次序進行驗證。進行次序驗
證是,我們需要建立InOrder物件來進行支援。例:
建立 mock物件
List<String> firstMock = mock(List.class);
List<String> secondMock = mock(List.class);
呼叫mock物件方法
firstMock.add("was called first");
firstMock.add("was called first");
secondMock.add("was called second");
secondMock.add("was called third");
建立InOrder 物件
inOrder方法可以傳入多個mock物件作為引數,這樣便可對這些mock物件的方
法進行呼叫順序的驗證InOrder inOrder = inOrder( secondMock,
firstMock );
驗證方法呼叫
接下來我們要呼叫InOrder物件的verify方法對mock方法的呼叫順序進行驗證。
注意,這裡必須是你對呼叫順序的預期。
InOrder物件的verify方法也支援呼叫次數驗證,上例中,我們期望
firstMock.add("was called first")方法先執行並執行兩次,所以進行了下
面的驗證inOrder.verify(firstMock,times(2)).add("was called first")。
其次執行了secondMock.add("was called second")方法,繼續驗證此方法的
執行inOrder.verify(secondMock).add("was called second")。如果mock
方法的呼叫順序和InOrder中verify的順序不同,那麼測試將執行失敗。
InOrder的verifyNoMoreInteractions()方法
它用於確認上一個順序驗證方法之後,mock 物件是否還有多餘的互動。它和
Mockito提供的靜態方法verifyNoMoreInteractions 不同,InOrder的驗證是基於順
序的,另外它只驗證建立它時所提供的mock 物件,在本例中只對firstMock 和
secondMock有效。例如:
inOrder.verify(secondMock).add("was called second");
inOrder.verifyNoMoreInteractions();
在驗證secondMock.add("was called second")方法之後,加上InOrder的
verifyNoMoreInteractions方法,表示此方法呼叫後再沒有多餘的互動。例子
中會報錯,因為在此方法之後還執行了secondMock.add("was called third")。
現在將上例改成:
inOrder.verify(secondMock).add("was called third");
inOrder.verifyNoMoreInteractions();
測試會恢復為正常,因為在secondMock.add("was called third")之後已經沒
有多餘的方法呼叫了。如果這裡換成Mockito類的verifyNoMoreInteractions方法測
試還是會報錯,它查詢的是mock物件中是否存在沒有驗證的呼叫方法,和順序
是無關的。
Mock物件的重置
Mockito提供了reset(mock1,mock2……)方法,用來重置mock物件。當mock物件
被重置後,它將回到剛建立完的狀態,沒有任何stubbing和方法呼叫。這個特性
平時是很少用到的,因為我們大都為每個test 方法建立mock,所以沒有必要對
它進行重置。官方提供這個特性的唯一目的是使得我們能在有容器注入的mock
物件中工作更為方便。所以,當決定要使用這個方法的時候,首先應該考慮一下
我們的測試程式碼是否簡潔和專注,測試方法是否已經超長了。
Answer介面(方法預期回撥介面)的應用
Answer介面說明
對mock物件的方法進行呼叫預期的設定,可以通過thenReturn()來指定返回值,
thenThrow()指定返回時所拋異常,通常來說這兩個方法足以應對一般的需求。但
有時我們需要自定義方法執行的返回結果,Answer 介面就是滿足這樣的需求而
存在的。另外,建立mock 物件的時候所呼叫的方法也可以傳入Answer 的例項
mock(java.lang.Class<T> classToMock, Answer defaultAnswer),它可以用來處理那
些mock物件沒有stubbing的方法的返回值。
InvocationOnMock 物件的方法
Answer 介面定義了引數為InvocationOnMock 物件的answer 方法,利用
InvocationOnMock提供的方法可以獲取mock 方法的呼叫資訊。下面是它提供的
方法:
getArguments() 呼叫後會以Object陣列的方式返回mock方法呼叫的引數。
getMethod() 返回java.lang.reflect.Method 物件
getMock() 返回mock物件
callRealMethod() 真實方法呼叫,如果mock的是介面它將會丟擲異常
通過一個例子來看一下Answer 的使用。我們自定義CustomAnswer 類,它實現
了Answer介面,返回值為String型別。
public class CustomAnswer implements Answer<String> {
public String answer(InvocationOnMock invocation) throws
Throwable {
Object[] args = invocation.getArguments();
Integer num = (Integer)args[0];
if( num>3 ){
return "yes";
} else {
throw new RuntimeException();
}
}
}
這個返回值是這樣的邏輯,如果呼叫mock某個方法輸入的引數大於3返回”yes”,
否則丟擲異常。
Answer介面的使用
應用方式如下:
首先對List介面進行mock
List<String> mock = mock(List.class);
指定方法的返回處理類CustomAnswer,因為引數為4大於3所以返回字串”yes”
when(mock.get(4)).thenAnswer(new CustomAnswer());
另外一種方式
doAnswer(new CustomAnswer()).when(mock.get(4));
對void方__________法也可以指定Answer來進行返回處理,如:
doAnswer(new xxxAnswer()).when(mock).clear();
當設定了Answer後,指定方法的呼叫結果就由我們定義的Answer介面來處理了。
另外我們也可以使用匿名內部類來進行應用:
@Test
public void customAnswerTest(){
List<String> mock = mock(List.class);
when(mock.get(4)).thenAnswer(new Answer(){
public String answer(InvocationOnMock invocation) throws
Throwable {
Object[] args = invocation.getArguments();
Integer num = (Integer)args[0];
if( num>3 ){
return "yes";
} else {
throw new RuntimeException();
}
}
});
System.out.println(mock.get(4));
}
自定義引數匹配器
Mockito引數匹配器的實現使用了Hamcrest框架(一個書寫匹配器物件時允許直
接定義匹配規則的框架,網址:http://code.google.com/p/hamcrest/)。它已經提供了
許多規則供我們使用, Mockito在此基礎上也內建了很規則。但有時我們還是需
要更靈活的匹配,所以需要自定義引數匹配器。
ArgumentMatcher 抽象類
自定義引數匹配器的時候需要繼承ArgumentMatcher抽象類,它實現了Hamcrest
框架的Matcher介面,定義了describeTo方法,所以我們只需要實現matches 方
法在其中定義規則即可。
下面自定義的引數匹配器是匹配size大小為2 的List:
class IsListOfTwoElements extends ArgumentMatcher<List> {
public boolean matches(Object list) {
return ((List) list).size() == 2;
}
}
@Test
public void argumentMatchersTest(){
List mock = mock(List.class);
when(mock.addAll(argThat(new
IsListOfTwoElements()))).thenReturn(true);
mock.addAll(Arrays.asList("one", "two", "three"));
verify(mock).addAll(argThat(new IsListOfTwoElements()));
}
argThat(Matcher<T> matcher)方法用來應用自定義的規則,可以傳入任何實現
Matcher 介面的實現類。上例中在stubbing 和verify addAll 方法時通過
argThat(Matcher<T> matcher) , 傳入了自定義的引數匹配器
IsListOfTwoElements 用來匹配size 大小為2 的List。因為例子中傳入List
的元素為三個,所以測試將失敗。
較複雜的引數匹配將會降低測試程式碼的可讀性。有時實現引數物件的equals()
方法是個不錯的選擇(Mockito預設使用equals()方法進行引數匹配),它可以
使測試程式碼更為整潔。另外,有些場景使用引數捕獲器(ArgumentCaptor)要比
自定義引數匹配器更加合適。
利用ArgumentCaptor(引數捕獲器)捕獲方法引數進行驗證
在某些場景中,不光要對方法的返回值和呼叫進行驗證,同時需要驗證一系列交
互後所傳入方法的引數。那麼我們可以用引數捕獲器來捕獲傳入方法的引數進行
驗證,看它是否符合我們的要求。
ArgumentCaptor 介紹
通過 ArgumentCaptor 物件的forClass(Class<T> clazz)方法來構建ArgumentCaptor
物件。然後便可在驗證時對方法的引數進行捕獲,最後驗證捕獲的引數值。如果
方法有多個引數都要捕獲驗證,那就需要建立多個ArgumentCaptor物件處理。
ArgumentCaptor的Api
argument.capture() 捕獲方法引數
argument.getValue() 獲取方法引數值,如果方法進行了多次呼叫,它將返回
最後一個引數值
argument.getAllValues() 方法進行多次呼叫後,返回多個引數值
應用例項
@Test
public void argumentCaptorTest() {
List mock = mock(List.class);
List mock2 = mock(List.class);
mock.add("John");
mock2.add("Brian");
mock2.add("Jim");
ArgumentCaptor argument = ArgumentCaptor.forClass(String.class);
verify(mock).add(argument.capture());
assertEquals("John", argument.getValue());
verify(mock2, times(2)).add(argument.capture());
assertEquals("Jim", argument.getValue());
assertArrayEquals(new
Object[]{"Brian","Jim"},argument.getAllValues().toArray());
}
首先構建ArgumentCaptor需要傳入捕獲引數的物件,例子中是String。接著要在
verify 方法的引數中呼叫argument.capture()方法來捕獲輸入的引數,之後
argument變數中就儲存了引數值,可以用argument.getValue()獲取。當某個
物件進行了多次呼叫後,如mock2 物件,這時呼叫argument.getValue()獲取
到的是最後一次呼叫的引數。如果要獲取所有的引數值可以呼叫
argument.getAllValues(),它將返回引數值的List。
在某種程度上引數捕獲器和引數匹配器有很大的相關性。它們都用來確保傳入
mock 物件引數的正確性。然而,當自定義的引數匹配器的重用性較差時,用參
數捕獲器會更合適,只需在最後對引數進行驗證即可。
Spy-物件的監視
Mock 物件只能呼叫stubbed 方法,調用不了它真實的方法。但Mockito 可以監
視一個真實的物件,這時對它進行方法呼叫時它將呼叫真實的方法,同時也可以
stubbing 這個物件的方法讓它返回我們的期望值。另外不論是否是真實的方法調
用都可以進行verify驗證。和建立mock物件一樣,對於final類、匿名類和Java
的基本型別是無法進行spy的。
監視物件
監視一個物件需要呼叫spy(T object)方法,如:List spy = spy(new
LinkedList());那麼spy變數就在監視LinkedList例項。
被監視物件的Stubbing
stubbing 被監視物件的方法時要慎用when(Object),如:
List spy = spy(new LinkedList());
//Impossible: real method is called so spy.get(0) throws
IndexOutOfBoundsException (the list is yet empty)
when(spy.get(0)).thenReturn("foo");
//You have to use doReturn() for stubbing
doReturn("foo").when(spy).get(0);
當呼叫when(spy.get(0)).thenReturn("foo")時,會呼叫真實物件的get(0),由於list
是空的所以會丟擲IndexOutOfBoundsException 異常,用doReturn 可以避免這種
情況的發生,因為它不會去呼叫get(0)方法。
下面是官方文件給出的例子:
@Test
public void spyTest2() {
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");
}
RETURNS_SMART_NULLS 和RETURNS_DEEP_STUBS
RETURNS_SMART_NULLS
RETURNS_SMART_NULLS是實現了Answer介面的物件,它是建立mock物件時的
一個可選引數,mock(Class, Answer)。在建立mock物件時,有的方法我們沒有進
行stubbing,所以在呼叫的時候有時會返回Null這樣在進行處理時就很可能丟擲
NullPointerException。如果通過RETURNS_SMART_NULLS引數來建立的mock物件
在呼叫沒有stubbed的方法時他將返回SmartNull。例如:返回型別是String 它將
返回空字串””;是int,它將返回0;如果是List,它會返回一個空的List。另
外,在堆疊中可以看到SmartNull的友好提示。
@Test
public void returnsSmartNullsTest() {
List mock = mock(List.class, RETURNS_SMART_NULLS);
System.out.println(mock.get(0));
System.out.println(mock.toArray().length);
}
由於使用了RETURNS_SMART_NULLS 引數來建立mock 物件,所以在執行下面的
操作時將不會丟擲NullPointerException 異常,另外堆疊也提示了相關的資訊
“SmartNull returned by unstubbed get() method on mock”。
RETURNS_DEEP_STUBS
同上面的引數一樣RETURNS_DEEP_STUBS也是一個建立mock物件時的備選引數。
例如我們有Account 物件和RailwayTicket 物件,RailwayTicket 是Account 的一個
屬性。
public class Account {
private RailwayTicket railwayTicket;
public RailwayTicket getRailwayTicket() {
return railwayTicket;
}
public void setRailwayTicket(RailwayTicket railwayTicket) {
this.railwayTicket = railwayTicket;
}
}
public class RailwayTicket {
private String destination;
public String getDestination() {
return destination;
}
public void setDestination(String destination) {
this.destination = destination;
}
}
下面通過RETURNS_DEEP_STUBS來建立mock 物件。
@Test
public void deepstubsTest(){
Account account = mock(Account.class, RETURNS_DEEP_STUBS);
when(account.getRailwayTicket().getDestination()).thenReturn("
Beijing");
account.getRailwayTicket().getDestination();
verify(account.getRailwayTicket()).getDestination();
assertEquals("Beijing",
account.getRailwayTicket().getDestination());
}
上例中,我們只建立了Account 的mock 物件,沒有對RailwayTicket 建立mock,
因為通過RETURNS_DEEP_STUBS引數程式會自動進行mock所需要的物件,所以
上面的例子等價於:
@Test
public void deepstubsTest2(){
Account account = mock(Account.class);
RailwayTicket railwayTicket = mock(RailwayTicket.class);
when(account.getRailwayTicket()).thenReturn(railwayTicket);
when(railwayTicket.getDestination()).thenReturn("Beijing");
account.getRailwayTicket().getDestination();
verify(account.getRailwayTicket()).getDestination();
assertEquals("Beijing",
account.getRailwayTicket().getDestination());
}
為了程式碼整潔和確保它的可讀性,我們應該少用這個特性。
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);
}
除了上述的初始化的方法外,還可以使用Mockito 提供的Junit Runner:
MockitoJUnitRunner這樣就省略了上面的步驟。
@RunWith(MockitoJUnit44Runner.class)
public class ExampleTest {
...
}
@Mock 註解
使用@Mock註解來定義mock物件有如下的優點:
1. 方便mock物件的建立
2. 減少mock物件建立的重複程式碼
3. 提高測試程式碼可讀性
4. 變數名字作為mock物件的標示,所以易於排錯
@Mock註解也支援自定義name 和answer屬性。下面是官方給出的@Mock使用
的例子:
public class ArticleManagerTest extends SampleBaseTestCase {
@Mock
private ArticleCalculator calculator;
@Mock(name = "dbMock")
private ArticleDatabase database;
@Mock(answer = RETURNS_MOCKS)
private UserProvider userProvider;
private ArticleManager manager;
@Before
public void setup() {
manager = new ArticleManager(userProvider, database,
calculator);
}
}
public class SampleBaseTestCase {
@Before
public void initMocks() {
MockitoAnnotations.initMocks(this);
}
}
@Spy 註解
Spy的使用方法請參閱前面的章節,在此不再贅述,下面是使用方法:
public class Test{
@Spy
Foo spyOnFoo = new Foo();
@Before
public void init(){
MockitoAnnotations.initMocks(this);
}
...
}
@Captor 註解
@Captor是引數捕獲器的註解,有關用法見前章,通過註解的方式也可以更便捷
的對它進行定義。使用例子如下:
public class Test {
@Captor
ArgumentCaptor<AsyncCallback<Foo>> captor;
@Before
public void init() {
MockitoAnnotations.initMocks(this);
}
@Test
public void shouldDoSomethingUseful() {
// ...
verify(mock.doStuff(captor.capture()));
assertEquals("foo", captor.getValue());
}
}
@InjectMocks 註解
通過這個註解,可實現自動注入mock 物件。當前版本只支援setter 的方式進行
注入,Mockito 首先嚐試型別注入,如果有多個型別相同的mock 物件,那麼它
會根據名稱進行注入。當注入失敗的時候Mockito不會丟擲任何異常,所以你可
能需要手動去驗證它的安全性。
例:
@RunWith(MockitoJUnit44Runner.class)
public class ArticleManagerTest {
@Mock
private ArticleCalculator calculator;
@Mock
private ArticleDatabase database;
@Spy
private UserProvider userProvider = new ConsumerUserProvider();
@InjectMocks
private ArticleManager manager = new ArticleManager();
@Test
public void shouldDoSomething() {
manager.initiateArticle();
verify(database).addListener(any(ArticleListener.class));
}
}
上例中, ArticleDatabase 是ArticleManager 的一個屬性, 由於
ArticleManager 是註解@InjectMocks 標註的,所以會根據型別自動呼叫它的
setter方法為它設定ArticleDatabase。
首先了解mockito 才能知道powermock,看名字就知道powermock更強,下面來介紹
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito</artifactId>
<version>1.4.10</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
<version>1.4.10</version>
<scope>test</scope>
</dependency>
下面我將以Power Mock的mockito的版本來講述如何使用Power Mock。
測試目標類:
public class ClassUnderTest { public boolean callArgumentInstance(File file) { return file.exists(); } public boolean callInternalInstance(String path) { File file = new File(path); return file.exists(); } public boolean callFinalMethod(ClassDependency refer) { return refer.isAlive(); } public boolean callSystemFinalMethod(String str) { return str.isEmpty(); } public boolean callStaticMethod() { return ClassDependency.isExist(); } public String callSystemStaticMethod(String str) { return System.getProperty(str); } public boolean callPrivateMethod() { return isExist(); } private boolean isExist() { // do something return false; } }
依賴類:
public class ClassDependency { public static boolean isExist() { // do something return false; } public final boolean isAlive() { // do something return false; } }
接下來,對6個測試用例進行逐個的講解。
首先需要使用@RunWith(PowerMockRunner.class)將測試用例的runner改為PowerMockRunner
1、testCallArgumentInstance:Mock引數傳遞的物件
@Test public void testCallArgumentInstance() { File file = PowerMockito.mock(File.class); ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.when(file.exists()).thenReturn(true); Assert.assertTrue(underTest.callArgumentInstance(file)); }
需要mock的物件是由引數傳進去的,這是最普通的一種mock方式,jMock,EasyMock,Mockito都能實現。
步驟:
a、通過PowerMockito.mock(File.class)創建出一個mock物件
b、然後再通過PowerMockito.when(file.exists()).thenReturn(false);來指定這個mock物件具體的行為
c、再將mock物件作為引數傳遞個測試方法,執行測試方法。
2、testCallInternalInstance:Mock方法內部new出來的物件
@Test @PrepareForTest(ClassUnderTest.class) public void testCallInternalInstance() throws Exception { File file = PowerMockito.mock(File.class); ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.whenNew(File.class).withArguments("bbb").thenReturn(file); PowerMockito.when(file.exists()).thenReturn(true); Assert.assertTrue(underTest.callInternalInstance("bbb")); }
需要mock的物件是在方法內部new出來的,這是一種比較常見的mock方式。
步驟(已經講過的步驟省略):
a、通過PowerMockito.whenNew(File.class).withArguments("bbb").thenReturn(file)來指定當以引數為bbb建立File物件的時候,返回已經mock的File物件。
b、在測試方法之上加註解@PrepareForTest(ClassUnderTest.class),註解裡寫的類是需要mock的new物件程式碼所在的類。
3、testCallFinalMethod:Mock普通物件的final方法。
@Test @PrepareForTest(ClassDependency.class) public void testCallFinalMethod() { ClassDependency depencency = PowerMockito.mock(ClassDependency.class); ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.when(depencency.isAlive()).thenReturn(true); Assert.assertTrue(underTest.callFinalMethod(depencency)); }
Mock的步驟和之前的一樣,只是需要在測試方法之上加註解@PrepareForTest(ClassDependency.class),註解裡寫的類是需要mock的final方法所在的類。
4、testCallStaticMethod:Mock靜態方法。
@Test @PrepareForTest(ClassDependency.class) public void testCallStaticMethod() { ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.mockStatic(ClassDependency.class); PowerMockito.when(ClassDependency.isExist()).thenReturn(true); Assert.assertTrue(underTest.callStaticMethod()); }
步驟:
a、通過PowerMockito.mockStatic(ClassDependency.class);表示需要mock這個類裡的靜態方法
b、在測試方法之上加註解@PrepareForTest(ClassDependency.class),註解裡寫的類是需要mock的靜態方法所在的類。
5、testCallSystemStaticMethod:Mock JDK中類的靜態方法。
testCallSystemFinalMethod:Mock JDK物件的final方法。
@Test @PrepareForTest(ClassUnderTest.class) public void testCallSystemStaticMethod() { ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.mockStatic(System.class); PowerMockito.when(System.getProperty("aaa")).thenReturn("bbb"); Assert.assertEquals("bbb", underTest.callJDKStaticMethod("aaa")); } @Test @PrepareForTest(ClassUnderTest.class) public void testCallSystemFinalMethod() { String str = PowerMockito.mock(String.class); ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.when(str.isEmpty()).thenReturn(false); Assert.assertFalse(underTest.callJDKFinalMethod(str)); }
和Mock普通物件的靜態方法、final方法一樣,只不過註解裡寫的類不一樣@PrepareForTest(ClassUnderTest.class),註解裡寫的類是需要呼叫系統方法所在的類。
6、testCallPrivateMethod:Mock私有方法。
@Test @PrepareForTest(ClassUnderTest.class) public void testCallPrivateMethod() throws Exception { ClassUnderTest underTest = PowerMockito.mock(ClassUnderTest.class); PowerMockito.when(underTest.callPrivateMethod()).thenCallRealMethod(); PowerMockito.when(underTest, "isExist").thenReturn(true); Assert.assertTrue(underTest.callPrivateMethod()); }
和Mock普通方法一樣,只是需要加註解@PrepareForTest(ClassUnderTest.class),註解裡寫的類是私有方法所在的類。
完整的測試用例類:
@RunWith(PowerMockRunner.class) public class TestClassUnderTest { @Test public void testCallArgumentInstance() { File file = PowerMockito.mock(File.class); ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.when(file.exists()).thenReturn(true); Assert.assertTrue(underTest.callArgumentInstance(file)); } @Test @PrepareForTest(ClassUnderTest.class) public void testCallInternalInstance() throws Exception { File file = PowerMockito.mock(File.class); ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.whenNew(File.class).withArguments("bbb").thenReturn(file); PowerMockito.when(file.exists()).thenReturn(true); Assert.assertTrue(underTest.callInternalInstance("bbb")); } @Test @PrepareForTest(ClassDependency.class) public void testCallFinalMethod() { ClassDependency depencency = PowerMockito.mock(ClassDependency.class); ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.when(depencency.isAlive()).thenReturn(true); Assert.assertTrue(underTest.callFinalMethod(depencency)); } @Test @PrepareForTest(ClassUnderTest.class) public void testCallSystemFinalMethod() { String str = PowerMockito.mock(String.class); ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.when(str.isEmpty()).thenReturn(false); Assert.assertFalse(underTest.callSystemFinalMethod(str)); } @Test @PrepareForTest(ClassDependency.class) public void testCallStaticMethod() { ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.mockStatic(ClassDependency.class); PowerMockito.when(ClassDependency.isExist()).thenReturn(true); Assert.assertTrue(underTest.callStaticMethod()); } @Test @PrepareForTest(ClassUnderTest.class) public void testCallSystemStaticMethod() { ClassUnderTest underTest = new ClassUnderTest(); PowerMockito.mockStatic(System.class); PowerMockito.when(System.getProperty("aaa")).thenReturn("bbb"); Assert.assertEquals("bbb", underTest.callSystemStaticMethod("aaa")); } @Test @PrepareForTest(ClassUnderTest.class) public void testCallPrivateMethod() throws Exception { ClassUnderTest underTest = PowerMockito.mock(ClassUnderTest.class); PowerMockito.when(underTest.callPrivateMethod()).thenCallRealMethod(); PowerMockito.when(underTest, "isExist").thenReturn(true); Assert.assertTrue(underTest.callPrivateMethod()); } }
------------------------------------------------------------
下面是我自己的例子
mock靜態類
private void prepareForGosServiceFactory()
{
ClassPathXmlApplicationContext ctx=PowerMockito.mock(ClassPathXmlApplicationContext.class);
try {
PowerMockito.whenNew(ClassPathXmlApplicationContext.class).withAnyArguments().thenReturn(ctx);
UpdateSoService updateSoService=PowerMockito.mock(UpdateSoService.class);
PowerMockito.when(ctx.getBean("wrapUpdateOrderHessianCall")).thenReturn(updateSoService);
PowerMockito.mockStatic(GosServiceFactory.class);
PowerMockito.when(GosServiceFactory.getUpdateOrderService()).thenReturn(updateSoService);
PowerMockito.when(updateSoService.updateRemarkIdByOrderId(Mockito.any(RemarkInput.class)));
} catch (Exception e) {
}
}
@Test
public void testDigExperience() {
long peid = 1234L;
int siteId = 1;
String ip = "127.0.0.1";
org.mockito.Mockito.when(productExperienceDao.countExperienceDig(peid, ip)).thenReturn(0L);// mock 返回值
org.mockito.Mockito.doNothing().when(productExperienceDao).updateExperienceUpNum(peid,siteId); // mock void方法
org.mockito.Mockito.doNothing().when(productExperienceDao).updateExperienceDownNum(peid, siteId);
ProductExperienceDig ped = new ProductExperienceDig();
org.mockito.Mockito.when(productExperienceDao.insertPED(ped)).thenReturn(0L);
target.digExperience_pe(peid, ip, 1l, "up");
target.digExperience_pe(peid, ip, 1l, "down");
}
//一個方法重複呼叫多次,返回值不同的情況,可以這樣寫
org.mockito.Mockito.when(productExperienceDao.getProductExperienceByIdAndProductIdAndSiteType(Mockito.anyLong(),Mockito.anyLong(),Mockito.anyInt()))
.thenReturn(experienceOld,experienceOld1,experienceOld2,experienceOld3,experienceOld4);
org.mockito.Mockito.when(productExperienceDao.queryBoutqueAndTopMostPEByMainProdIds(Mockito.anyList(),Mockito.anyInt(), Mockito.anyInt())).thenReturn(yhdMap);