一、Mockito與PowerMock簡述

Mockito與PowerMock都是Java流行的一種Mock框架，使用Mock技術能讓我們隔離外部依賴以便對我們自己的業(yè)務邏輯代碼進行單元測試，在編寫單元測試時，不需要再進行繁瑣的初始化工作，在需要調(diào)用某一個接口時，直接模擬一個假方法，并任意指定方法的返回值。

Mockito的工作原理是通過創(chuàng)建依賴對象的proxy，所有的調(diào)用先經(jīng)過proxy對象，proxy對象攔截了所有的請求再根據(jù)預設的返回值進行處理。PowerMock則在Mockito原有的基礎上做了擴展，通過修改類字節(jié)碼并使用自定義ClassLoader加載運行的方式來實現(xiàn)mock靜態(tài)方法、final方法、private方法、系統(tǒng)類的功能。

從兩者的項目結(jié)構中就可以看出，PowerMock直接依賴于Mockito，所以如果項目中已經(jīng)導入了PowerMock包就不需要再單獨導入Mockito包，如果兩者同時導入還要小心PowerMock和Mockito不同版本之間的兼容問題：

Mockito包依賴：

org.mockito

mockito-core

2.23.0

test

PowerMock包依賴：

org.powermock

powermock-module-junit4

2.0.0-RC.3

test

org.powermock

powermock-api-mockito2

2.0.0-RC.3

test

二、Mockito的使用

Mockito一般通過創(chuàng)建mock或spy對象，并制定具體返回規(guī)則來實現(xiàn)模擬的功能，在調(diào)用完成后還可以進行方法調(diào)用驗證以檢驗程序邏輯是否正確。mock和spy對象的區(qū)別是mock對象對于未指定處理規(guī)則的調(diào)用會按方法返回值類型返回該類型的默認值(如int、long則返回0，boolean則返回false，對象則返回null，void則什么都不做)，而spy對象在未指定處理規(guī)則時則會直接調(diào)用真實方法。

以下3個類是我們的項目中需要用到的一些業(yè)務類：

//實體類

public class Node {

private int num;

private String name;

//以下忽略所有構造方法和get、set方法

}

//本地負責實現(xiàn)具體業(yè)務的業(yè)務類

public class LocalServiceImpl implements ILocalService {

//外部依賴

@Autowired

private IRemoteService remoteService;

//具體業(yè)務處理方法

@Override

public Node getRemoteNode(int num) {

return remoteService.getRemoteNode(num);

}

//以下忽略其他業(yè)務調(diào)用方法，在后面例子中補充

}

//外部依賴業(yè)務類，由其他人實現(xiàn)，可能我們的業(yè)務類寫好了別人還沒寫好

public class RemoteServiceImpl implements IRemoteService {

//外部類提供的一些業(yè)務方法

@Override

public Node getRemoteNode(int num) {

return new Node(num, "Node from remote service");

}

//其他業(yè)務方法在后面例子中補充

}

下面是Mockito具體使用的一些示例：

mock外部依賴對象，并注入到我們的業(yè)務類中，以便在單元測試中進行模擬調(diào)用：

@RunWith(MockitoJUnitRunner.class) //讓測試運行于Mockito環(huán)境

public class LocalServiceImplMockTest {

@InjectMocks //此注解表示這個對象需要被注入mock對象

private LocalServiceImpl localService;

@Mock //此注解會自動創(chuàng)建1個mock對象并注入到@InjectMocks對象中

private RemoteServiceImpl remoteService;

//如果不使用上述注解，可以使用@Before方法來手動進行mock對象的創(chuàng)建和注入，但會幾行很多代碼

/*

private LocalServiceImpl localService;

private RemoteServiceImpl remoteService;

@Before

public void setUp() throws Exception {

localService = new LocalServiceImpl();

remoteService = Mockito.mock(RemoteServiceImpl.class); //創(chuàng)建Mock對象

Whitebox.setInternalState(localService, "remoteService", remoteService); //注入依賴對象

}

*/

@Test

public void testMock() {

Node target = new Node(1, "target"); //創(chuàng)建一個Node對象作為返回值

Mockito.when(remoteService.getRemoteNode(1)).thenReturn(target); //指定當remoteService.getRemoteNode(int)方法傳入?yún)?shù)為1時返回target對象

Node result = localService.getRemoteNode(1); //調(diào)用我們的業(yè)務方法，業(yè)務方法內(nèi)部調(diào)用依賴對象方法

assertEquals(target, result); //可以斷言我們得到的返回值其實就是target對象

assertEquals(1, result.getNum()); //具體屬性和我們指定的返回值相同

assertEquals("target", result.getName()); //具體屬性和我們指定的返回值相同

Node result2 = localService.getRemoteNode(2); //未指定參數(shù)為2時對應的返回規(guī)則

assertNull(result2); //未指定時返回為null

}

}

spy外部依賴對象，并注入到我們的業(yè)務類中：

@RunWith(MockitoJUnitRunner.class)

public class LocalServiceImplSpyTest {

@InjectMocks

private LocalServiceImpl localService;

@Spy //注意這里使用的是@Spy注解

private RemoteServiceImpl remoteService;

//注意如果自己創(chuàng)建spy對象的話要這么寫：

/*

remoteService = new RemoteServiceImpl(); //先創(chuàng)建一個具體實例

remoteService = Mockito.spy(remoteService); //再調(diào)用Mockito.spy(T)方法創(chuàng)建spy對象

*/

@Test

public void testSpy() {

Node target = new Node(1, "target"); //創(chuàng)建一個Node對象作為返回值

Mockito.when(remoteService.getRemoteNode(1)).thenReturn(target); //指定當remoteService.getRemoteNode(int)方法傳入?yún)?shù)為1時返回target對象

Node result = localService.getRemoteNode(1); //調(diào)用我們的業(yè)務方法，業(yè)務方法內(nèi)部調(diào)用依賴對象方法

assertEquals(target, result); //可以斷言我們得到的返回值其實就是target對象

assertEquals(1, result.getNum()); //具體屬性和我們指定的返回值相同

assertEquals("target", result.getName()); //具體屬性和我們指定的返回值相同

Node result2 = localService.getRemoteNode(2); //未指定參數(shù)為2時的調(diào)用規(guī)則，所以會直接調(diào)用真實對象，返回remote創(chuàng)建的節(jié)點

assertEquals(2, result2.getNum());

assertEquals("Node from remote service", result2.getName()); //remoteService創(chuàng)建Node對象時設置name屬性為"Node from remote service"

}

}

使用ArgumentMatchers的any系列方法指定多種返回值，有any()、anyInt()、anyString()、anyByte()、anyLong()等等，可以看下ArgumentMatchers類源碼中定義的所有方法：

@Test

public void testAny() {

Node target = new Node(1, "target");

when(remoteService.getRemoteNode(anyInt())).thenReturn(target); //靜態(tài)導入Mockito.when和ArgumentMatchers.anyInt后可以簡化代碼提升可讀性

Node result = localService.getRemoteNode(20); //上面指定了調(diào)用remoteService.getRemoteNode(int)時，不管傳入什么參數(shù)都會返回target對象

assertEquals(target, result); //可以斷言我們得到的返回值其實就是target對象

assertEquals(1, result.getNum()); //具體屬性和我們指定的返回值相同

assertEquals("target", result.getName()); //具體屬性和我們指定的返回值相同

}

指定mock對象多次調(diào)用的返回值：

/**

* 指定mock多次調(diào)用返回值

*/

@Test

public void testMultipleReturn() {

Node target1 = new Node(1, "target");

Node target2 = new Node(1, "target");

Node target3 = new Node(1, "target");

when(remoteService.getRemoteNode(anyInt())).thenReturn(target1).thenReturn(target2).thenReturn(target3);

//第一次調(diào)用返回target1、第二次返回target2、第三次返回target3

Node result1 = localService.getRemoteNode(1); //第1次調(diào)用

assertEquals(target1, result1);

Node result2 = localService.getRemoteNode(2); //第2次調(diào)用

assertEquals(target2, result2);

Node result3 = localService.getRemoteNode(3); //第3次調(diào)用

assertEquals(target3, result3);

}

指定mock對象拋出異常(注意如果方法中未聲明會拋出異常，只能指定拋出運行時異常，如果仍指定為拋出受檢查異常，運行時會報錯誤org.mockito.exceptions.base.MockitoException: Checked exception is invalid for this method!)：

//RemoteServiceImpl方法：

@Override

public Node getRemoteNode(String name) throws MockException {

if (StringUtils.isEmpty(name)) {

throw new MockException("name不能為空", name);

}

return new Node(name);

}

//LocalServiceImpl方法

@Override

public Node getRemoteNode(String name) throws MockException {

try {

return remoteService.getRemoteNode(name);

} catch (IllegalArgumentException e) {

throw e;

}

}

/**

* 指定mock對象已聲明異常拋出的方法拋出受檢查異常

*/

@Test

public void testExceptionDeclare() {

try {

Node target = new Node(1, "target");

when(remoteService.getRemoteNode("name")).thenReturn(target).thenThrow(new MockException(

"message", "exception")); //第一次調(diào)用正常返回，第二次則拋出一個Exception

Node result1 = localService.getRemoteNode("name");

assertEquals(target, result1); //第一次調(diào)用正常返回

Node result2 = localService.getRemoteNode("name"); //第二次調(diào)用不會正常返回，會拋出異常

assertEquals(target, result2);

} catch (MockException e) {

assertEquals("exception", e.getName()); //驗證是否返回指定異常內(nèi)容

assertEquals("message", e.getMessage()); //驗證是否返回指定異常內(nèi)容

}

}

/**

* 指定mock對象為聲明異常拋出的方法拋出運行時異常

*/

@Test

public void testRuntimeException() {

Node target = new Node(1, "target");

when(remoteService.getRemoteNode(1)).thenThrow(new RuntimeException("exception")); //指定調(diào)用時拋出一個運行時異常

try {

Node result = localService.getRemoteNode(1);

assertEquals(target, result);

} catch (RuntimeException e) {

assertEquals("exception", e.getMessage());

}

}

/**

* 指定mock對象未聲明異常拋出的方法拋出受檢查異常，以下方法執(zhí)行會報錯

*/

@Test

public void testNotDefineCheckedException() {

Node target = new Node(1, "target");

when(remoteService.getRemoteNode(1)).thenThrow(new IOException("io exception"));

try {

Node result = localService.getRemoteNode(1);

assertEquals(target, result);

} catch (Exception e) {

assertEquals("io exception", e.getMessage());

}

}

mock void方法拋異常、什么都不做：

//RemoteServiceImpl方法：

@Override

public void doSometing() {

System.out.println("remote service do something!");

}

//LocalServiceImpl方法

@Override

public void remoteDoSomething() {

remoteService.doSometing();

}

//注意void方法沒有返回值，所以mock規(guī)則寫法順序不一樣

doNothing().when(remoteService).doSometing();

doThrow(new RuntimeException("exception")).when(remoteService).doSometing();

校驗mock對象的調(diào)用情況(除Mockito中的never()、times(int)方法外，還有atLeast(int)、atLeastOne()、atMost(int)等方法)：

/**

* 校驗mock對象和方法的調(diào)用情況

*

*/

public void testVerify() {

Node target = new Node(1, "target");

when(remoteService.getRemoteNode(anyInt())).thenReturn(target);

verify(remoteService, never()).getRemoteNode(1); //mock方法未調(diào)用過

localService.getRemoteNode(1);

Mockito.verify(remoteService, times(1)).getRemoteNode(anyInt()); //目前mock方法調(diào)用過1次

localService.getRemoteNode(2);

verify(remoteService, times(2)).getRemoteNode(anyInt()); //目前mock方法調(diào)用過2次

verify(remoteService, times(1)).getRemoteNode(2); //目前mock方法參數(shù)為2只調(diào)用過1次

}

利用ArgumentCaptor捕獲方法參數(shù)進行mock方法參數(shù)校驗

/**

* 利用ArgumentCaptor捕獲方法參數(shù)進行mock方法參數(shù)校驗

*/

@Test

public void testCaptor() throws Exception {

Node target = new Node(1, "target");

when(remoteService.getRemoteNode(anyString())).thenReturn(target);

localService.getRemoteNode("name1");

localService.getRemoteNode("name2");

verify(remoteService, atLeastOnce()).getRemoteNode(localCaptor.capture()); //設置captor

assertEquals("name2", localCaptor.getValue()); //獲取最后一次調(diào)用的參數(shù)

List list = localCaptor.getAllValues(); //按順序獲取所有傳入的參數(shù)

assertEquals("name1", list.get(0));

assertEquals("name2", list.get(1));

}

mock對象調(diào)用真實方法：

/**

* mock對象調(diào)用真實方法

*/

@Test

public void testCallRealMethod() {

when(remoteService.getRemoteNode(anyInt())).thenCallRealMethod(); //設置調(diào)用真實方法

Node result = localService.getRemoteNode(1);

assertEquals(1, result.getNum());

assertEquals("Node from remote service", result.getName());

}

重置mock對象：

//重置mock，清除所有的調(diào)用記錄和返回規(guī)則

Mockito.reset(remoteService);

校驗mock對象0調(diào)用和未被驗證的調(diào)用

/**

* 校驗mock對象0調(diào)用和未被驗證的調(diào)用

*/

@Test(expected = NoInteractionsWanted.class)

public void testInteraction() {

verifyZeroInteractions(remoteService); //目前還未被調(diào)用過，執(zhí)行不報錯

Node target = new Node(1, "target");

when(remoteService.getRemoteNode(anyInt())).thenReturn(target);

localService.getRemoteNode(1);

localService.getRemoteNode(2);

verify(remoteService, times(2)).getRemoteNode(anyInt());

// 參數(shù)1和2的兩次調(diào)用都會被上面的anyInt()校驗到，所以沒有未被校驗的調(diào)用了

verifyNoMoreInteractions(remoteService);

reset(remoteService);

localService.getRemoteNode(1);

localService.getRemoteNode(2);

verify(remoteService, times(1)).getRemoteNode(1);

// 參數(shù)2的調(diào)用不會被上面的校驗到，所以執(zhí)行會拋異常

verifyNoMoreInteractions(remoteService);

}

三、PowerMock的使用

PowerMock的使用與Mockito有一些不同，首先是測試類上的@RunWith注解需要修改為：

@RunWith(PowerMockRunner.class)

第二是需要使用到@PrepareForTest注解(PrepareFotTest注解會修改傳入?yún)?shù)類的字節(jié)碼，通過修改字節(jié)碼達到模擬final、static、私有方法、系統(tǒng)類等的功能)，此注解可寫在類上也可寫在方法上：

@PrepareForTest(RemoteServiceImpl.class)

mock new關鍵字

//LocalServiceImpl

@Override

public Node getLocalNode(int num, String name) {

return new Node(num, name);

}

/**

* mock new關鍵字

*/

@Test

@PrepareForTest(LocalServiceImpl.class) //PrepareForTest修改local類的字節(jié)碼以覆蓋new的功能

public void testNew() throws Exception {

Node target = new Node(1, "target");

//當傳入任意int且name屬性為"name"時，new對象返回為target

//當參數(shù)條件使用了any系列方法時，剩余的參數(shù)都得使用相應的模糊匹配規(guī)則，如eq("name")代表參數(shù)等于"name"

//剩余還有isNull(), isNotNull(), isA()等方法

PowerMockito.whenNew(Node.class).withArguments(anyInt(), eq("name")).thenReturn(target);

Node result = localService.getLocalNode(2, "name");

assertEquals(target, result); //返回值為target

assertEquals(1, result.getNum());

assertEquals("target", result.getName());

//未指定name為"test"的返回值，默認返回null

Node result2 = localService.getLocalNode(1, "test");

assertNull(result2);

}

mock final方法

//RemoteServiceImpl

@Override

public final Node getFinalNode() {

return new Node(1, "final node");

}

/**

* mock final方法

*/

@Test

@PrepareForTest(RemoteServiceImpl.class) //final方法在RemoteServiceImpl類中

public void testFinal() {

Node target = new Node(2, "mock");

PowerMockito.when(remoteService.getFinalNode()).thenReturn(target); //指定返回值

Node result = remoteService.getFinalNode(); //直接調(diào)用final方法，返回mock后的值

assertEquals(target, result); //驗證返回值

assertEquals(2, result.getNum());

assertEquals("mock", result.getName());

}

mock static方法

//Node

public static Node getStaticNode() {

return new Node(1, "static node");

}

/**

* mock static方法

*/

@Test

@PrepareForTest(Node.class) //static方法定義在Node類中

public void testStatic() {

Node target = new Node(2, "mock");

PowerMockito.mockStatic(Node.class); //mock static方法前需要加這一句

PowerMockito.when(Node.getStaticNode()).thenReturn(target); //指定返回值

Node result = Node.getStaticNode(); //直接調(diào)用static方法，返回mock后的值

assertEquals(target, result); //驗證返回值

assertEquals(2, result.getNum());

assertEquals("mock", result.getName());

}

mock private方法

//RemoteServiceImpl

@Override

public Node getPrivateNode() {

return privateMethod();

}

//RemoteServiceImpl

private Node privateMethod() {

return new Node(1, "private node");

}

/**

* mock 私有方法

*/

@Test

@PrepareForTest(RemoteServiceImpl.class) //private方法定義在RemoteServiceImpl類中

public void testPrivate() throws Exception {

Node target = new Node(2, "mock");

//按照真實代碼調(diào)用privateMethod方法

PowerMockito.when(remoteService.getPrivateNode()).thenCallRealMethod();

//私有方法無法訪問，類似反射傳遞方法名和參數(shù)，此處無參數(shù)故未傳

PowerMockito.when(remoteService, "privateMethod").thenReturn(target);

Node result = remoteService.getPrivateNode();

assertEquals(target, result); //驗證返回值

assertEquals(2, result.getNum());

assertEquals("mock", result.getName());

}

mock 系統(tǒng)類方法

//RemoteServiceImpl

@Override

public Node getSystemPropertyNode() {

return new Node(System.getProperty("abc"));

}

/**

* mock 系統(tǒng)類方法

*/

@Test

@PrepareForTest(RemoteServiceImpl.class) //類似new關鍵字，系統(tǒng)類方法的調(diào)用在類RemoteServiceImpl中，所以這里填的是RemoteServiceImpl

public void testSystem() {

PowerMockito.mockStatic(System.class); //調(diào)用的是系統(tǒng)類的靜態(tài)方法，所以要加這一句

PowerMockito.when(System.getProperty("abc")).thenReturn("mock"); //設置System.getProperty("abc")返回"mock"

PowerMockito.when(remoteService.getSystemPropertyNode()).thenCallRealMethod(); //設置mock對象調(diào)用實際方法

Node result = remoteService.getSystemPropertyNode(); //按代碼會返回一個name屬性為"mock"的對象

assertEquals(0, result.getNum()); //int默認值為0

assertEquals("mock", result.getName()); //remoteService對象中調(diào)用System.getProperty("abc")返回的是上面設置的"mock"

}

項目代碼已上傳至GitHub：MockDemo

總結(jié)

以上是生活随笔為你收集整理的powermockito教程_Mockito与PowerMock的使用基础教程的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。