簡介：?立足于“如何來編寫單元測試用例”，讓大家“有章可循”，快速編寫出單元測試用例。

作者 | 常意
來源 | 阿里技術公眾號

溫馨提示：本文較長，同學們可收藏后再看 :)

前言

清代杰出思想家章學誠有一句名言：“學必求其心得，業必貴其專精。”

意思是：學習上一定要追求心得體會，事業上一定要貴以專注精深。做技術就是這樣，一件事如果做到了極致，就必然會有所心得體會。作者最近在一個項目上，追求單元測試覆蓋率到極致，所以才有了這篇心得體會。

上一篇文章《Java單元測試技巧之PowerMock》除了介紹單元測試基礎知識外，主要介紹了“為什么要編寫單元測試”。很多同學讀完后，還是不能快速地編寫單元測試用例。而這篇文章，立足于“如何來編寫單元測試用例”，能夠讓同學們“有章可循”，能快速地編寫出單元測試用例。

1.編寫單元測試用例

1.1.測試框架簡介

Mockito是一個單元測試模擬框架，可以讓你寫出優雅、簡潔的單元測試代碼。Mockito采用了模擬技術，模擬了一些在應用中依賴的復雜對象，從而把測試對象和依賴對象隔離開來。

PowerMock是一個單元測試模擬框架，是在其它單元測試模擬框架的基礎上做出擴展。 通過提供定制的類加載器以及一些字節碼篡改技術的應用，PowerMock實現了對靜態方法、構造方法、私有方法以及final方法的模擬支持等強大的功能。但是，正因為PowerMock進行了字節碼篡改，導致部分單元測試用例并不被JaCoco統計覆蓋率。

通過作者多年單元測試的編寫經驗，優先推薦使用Mockito提供的功能；只有在Mockito提供的功能不能滿足需求時，才會采用PowerMock提供的功能；但是，不推薦使用影響JaCoco統計覆蓋率的PowerMock功能。在本文中，我們也不會對影響JaCoco統計覆蓋率的PowerMock功能進行介紹。

下面，將以Mockito為主、以PowerMock為輔，介紹一下如何編寫單元測試用例。

1.2.測試框架引入

為了引入Mockito和PowerMock包，需要在maven項目的pom.xml文件中加入以下包依賴：

其中，powermock.version為2.0.9，為當前的最新版本，可根據實際情況修改。在PowerMock包中，已經包含了對應的Mockito和JUnit包，所以無需單獨引入Mockito和JUnit包。

1.3.典型代碼案例

一個典型的服務代碼案例如下：

/*** 用戶服務類*/ @Service public class UserService {/** 服務相關 *//** 用戶DAO */@Autowiredprivate UserDAO userDAO;/** 標識生成器 */@Autowiredprivate IdGenerator idGenerator;/** 參數相關 *//** 可以修改 */@Value("${userService.canModify}")private Boolean canModify;/*** 創建用戶* * @param userCreate 用戶創建* @return 用戶標識*/public Long createUser(UserVO userCreate) {// 獲取用戶標識Long userId = userDAO.getIdByName(userCreate.getName());// 根據存在處理// 根據存在處理: 不存在則創建if (Objects.isNull(userId)) {userId = idGenerator.next();UserDO create = new UserDO();create.setId(userId);create.setName(userCreate.getName());userDAO.create(create);}// 根據存在處理: 已存在可修改else if (Boolean.TRUE.equals(canModify)) {UserDO modify = new UserDO();modify.setId(userId);modify.setName(userCreate.getName());userDAO.modify(modify);}// 根據存在處理: 已存在禁修改else {throw new UnsupportedOperationException("不支持修改");}// 返回用戶標識return userId;} }

1.4.測試用例編寫

采用Mockito和PowerMock單元測試模擬框架，編寫的單元測試用例如下：

UserServiceTest.java：

/*** 用戶服務測試類*/ @RunWith(PowerMockRunner.class) public class UserServiceTest {/** 模擬依賴對象 *//** 用戶DAO */@Mockprivate UserDAO userDAO;/** 標識生成器 */@Mockprivate IdGenerator idGenerator;/** 定義被測對象 *//** 用戶服務 */@InjectMocksprivate UserService userService;/*** 在測試之前*/@Beforepublic void beforeTest() {// 注入依賴對象Whitebox.setInternalState(userService, "canModify", Boolean.TRUE);}/*** 測試: 創建用戶-新*/@Testpublic void testCreateUserWithNew() {// 模擬依賴方法// 模擬依賴方法: userDAO.getByNameMockito.doReturn(null).when(userDAO).getIdByName(Mockito.anyString());// 模擬依賴方法: idGenerator.nextLong userId = 1L;Mockito.doReturn(userId).when(idGenerator).next();// 調用被測方法String text = ResourceHelper.getResourceAsString(getClass(), "userCreateVO.json");UserVO userCreate = JSON.parseObject(text, UserVO.class);Assert.assertEquals("用戶標識不一致", userId, userService.createUser(userCreate));// 驗證依賴方法// 驗證依賴方法: userDAO.getByNameMockito.verify(userDAO).getIdByName(userCreate.getName());// 驗證依賴方法: idGenerator.nextMockito.verify(idGenerator).next();// 驗證依賴方法: userDAO.createArgumentCaptor < UserDO> userCreateCaptor = ArgumentCaptor.forClass(UserDO.class);Mockito.verify(userDAO).create(userCreateCaptor.capture());text = ResourceHelper.getResourceAsString(getClass(), "userCreateDO.json");Assert.assertEquals("用戶創建不一致", text, JSON.toJSONString(userCreateCaptor.getValue()));// 驗證依賴對象Mockito.verifyNoMoreInteractions(idGenerator, userDAO);}/*** 測試: 創建用戶-舊*/@Testpublic void testCreateUserWithOld() {// 模擬依賴方法// 模擬依賴方法: userDAO.getByNameLong userId = 1L;Mockito.doReturn(userId).when(userDAO).getIdByName(Mockito.anyString());// 調用被測方法String text = ResourceHelper.getResourceAsString(getClass(), "userCreateVO.json");UserVO userCreate = JSON.parseObject(text, UserVO.class);Assert.assertEquals("用戶標識不一致", userId, userService.createUser(userCreate));// 驗證依賴方法// 驗證依賴方法: userDAO.getByNameMockito.verify(userDAO).getIdByName(userCreate.getName());// 驗證依賴方法: userDAO.modifyArgumentCaptor < UserDO> userModifyCaptor = ArgumentCaptor.forClass(UserDO.class);Mockito.verify(userDAO).modify(userModifyCaptor.capture());text = ResourceHelper.getResourceAsString(getClass(), "userModifyDO.json");Assert.assertEquals("用戶修改不一致", text, JSON.toJSONString(userModifyCaptor.getValue()));// 驗證依賴對象Mockito.verifyNoInteractions(idGenerator);Mockito.verifyNoMoreInteractions(userDAO);}/*** 測試: 創建用戶-異常*/@Testpublic void testCreateUserWithException() {// 注入依賴對象Whitebox.setInternalState(userService, "canModify", Boolean.FALSE);// 模擬依賴方法// 模擬依賴方法: userDAO.getByNameLong userId = 1L;Mockito.doReturn(userId).when(userDAO).getIdByName(Mockito.anyString());// 調用被測方法String text = ResourceHelper.getResourceAsString(getClass(), "userCreateVO.json");UserVO userCreate = JSON.parseObject(text, UserVO.class);UnsupportedOperationException exception = Assert.assertThrows("返回異常不一致",UnsupportedOperationException.class, () -> userService.createUser(userCreate));Assert.assertEquals("異常消息不一致", "不支持修改", exception.getMessage());} }

userCreateVO.json：

{"name":"test"}

userCreateDO.json：

{"id":1,"name":"test"}

userModifyDO.json：

{"id":1,"name":"test"}

通過執行以上測試用例，可以看到對源代碼進行了100%的行覆蓋。

2.測試用例編寫流程

通過上一章編寫Java類單元測試用例的實踐，可以總結出以下Java類單元測試用例的編寫流程：

單元測試用例編寫流程

?

上面一共有3個測試用例，這里僅以測試用例testCreateUserWithNew(測試: 創建用戶-新)為例說明。

2.1.定義對象階段

第1步是定義對象階段，主要包括定義被測對象、模擬依賴對象（類成員）、注入依賴對象（類成員）3大部分。

2.1.1.定義被測對象

在編寫單元測試時，首先需要定義被測對象，或直接初始化、或通過Spy包裝……其實，就是把被測試服務類進行實例化。

/** 定義被測對象 */ /** 用戶服務 */ @InjectMocks private UserService userService;

2.1.2.模擬依賴對象（類成員）

在一個服務類中，我們定義了一些類成員對象——服務（Service）、數據訪問對象（DAO）、參數（Value）等。在Spring框架中，這些類成員對象通過@Autowired、@Value等方式注入，它們可能涉及復雜的環境配置、依賴第三方接口服務……但是，在單元測試中，為了解除對這些類成員對象的依賴，我們需要對這些類成員對象進行模擬。

/** 模擬依賴對象 */ /** 用戶DAO */ @Mock private UserDAO userDAO; /** 標識生成器 */ @Mock private IdGenerator idGenerator;

2.1.3.注入依賴對象（類成員）

當模擬完這些類成員對象后，我們需要把這些類成員對象注入到被測試類的實例中。以便在調用被測試方法時，可能使用這些類成員對象，而不至于拋出空指針異常。

/** 定義被測對象 */ /** 用戶服務 */ @InjectMocks private UserService userService;/*** 在測試之前*/ @Before public void beforeTest() {// 注入依賴對象Whitebox.setInternalState(userService, "canModify", Boolean.TRUE); }

2.2.模擬方法階段

第2步是模擬方法階段，主要包括模擬依賴對象（參數或返回值）、模擬依賴方法2大部分。

2.2.1.模擬依賴對象（參數或返回值）

通常，在調用一個方法時，需要先指定方法的參數，然后獲取到方法的返回值。所以，在模擬方法之前，需要先模擬該方法的參數和返回值。

Long userId = 1L;

2.2.2.模擬依賴方法

在模擬完依賴的參數和返回值后，就可以利用Mockito和PowerMock的功能，進行依賴方法的模擬。如果依賴對象還有方法調用，還需要模擬這些依賴對象的方法。

// 模擬依賴方法 // 模擬依賴方法: userDAO.getByName Mockito.doReturn(null).when(userDAO).getIdByName(Mockito.anyString()); // 模擬依賴方法: idGenerator.next Mockito.doReturn(userId).when(idGenerator).next();

2.3.調用方法階段

第3步是調用方法階段，主要包括模擬依賴對象（參數）、調用被測方法、驗證參數對象（返回值）3步。

2.3.1.模擬依賴對象（參數）

在調用被測方法之前，需要模擬被測方法的參數。如果這些參數還有方法調用，還需要模擬這些參數的方法。

String text = ResourceHelper.getResourceAsString(getClass(), "userCreateVO.json"); UserVO userCreate = JSON.parseObject(text, UserVO.class);

2.3.2.調用被測方法

在準備好參數對象后，就可以調用被測試方法了。如果被測試方法有返回值，需要定義變量接收返回值；如果被測試方法要拋出異常，需要指定期望的異常。

userService.createUser(userCreate)

2.3.3.驗證數據對象（返回值）

在調用被測試方法后，如果被測試方法有返回值，需要驗證這個返回值是否符合預期；如果被測試方法要拋出異常，需要驗證這個異常是否滿足要求。

Assert.assertEquals("用戶標識不一致", userId, userService.createUser(userCreate));

2.4.驗證方法階段

第4步是驗證方法階段，主要包括驗證依賴方法、驗證數據對象（參數）、驗證依賴對象3步。

2.4.1.驗證依賴方法

作為一個完整的測試用例，需要對每一個模擬的依賴方法調用進行驗證。

// 驗證依賴方法 // 驗證依賴方法: userDAO.getByName Mockito.verify(userDAO).getIdByName(userCreate.getName()); // 驗證依賴方法: idGenerator.next Mockito.verify(idGenerator).next(); // 驗證依賴方法: userDAO.create ArgumentCaptor < UserDO> userCreateCaptor = ArgumentCaptor.forClass(UserDO.class); Mockito.verify(userDAO).create(userCreateCaptor.capture());

2.4.2.驗證數據對象（參數）

對應一些模擬的依賴方法，有些參數對象是被測試方法內部生成的。為了驗證代碼邏輯的正確性，就需要對這些參數對象進行驗證，看這些參數對象值是否符合預期。

text = ResourceHelper.getResourceAsString(getClass(), "userCreateDO.json"); Assert.assertEquals("用戶創建不一致", text, JSON.toJSONString(userCreateCaptor.getValue()));

2.4.3.驗證依賴對象

作為一個完整的測試用例，應該保證每一個模擬的依賴方法調用都進行了驗證。正好，Mockito提供了一套方法，用于驗證模擬對象所有方法調用都得到了驗證。

// 驗證依賴對象 Mockito.verifyNoMoreInteractions(idGenerator, userDAO);

3.定義被測對象

在編寫單元測試時，首先需要定義被測對象，或直接初始化、或通過Spy包裝……其實，就是把被測試服務類進行實例化。

3.1.直接構建對象

直接構建一個對象，總是簡單又直接。

UserService userService = new UserService();

3.2.利用Mockito.spy方法

Mockito提供一個spy功能，用于攔截那些尚未實現或不期望被真實調用的方法，默認所有方法都是真實方法，除非主動去模擬對應方法。所以，利用spy功能來定義被測對象，適合于需要模擬被測類自身方法的情況，適用于普通類、接口和虛基類。

UserService userService = Mockito.spy(new UserService()); UserService userService = Mockito.spy(UserService.class); AbstractOssService ossService = Mockito.spy(AbstractOssService.class);

3.3.利用@Spy注解

@Spy注解跟Mockito.spy方法一樣，可以用來定義被測對象，適合于需要模擬被測類自身方法的情況，適用于普通類、接口和虛基類。@Spy注解需要配合@RunWith注解使用。

@RunWith(PowerMockRunner.class) public class CompanyServiceTest {@Spyprivate UserService userService = new UserService();... }

注意：@Spy注解對象需要初始化。如果是虛基類或接口，可以用Mockito.mock方法實例化。

3.4.利用@InjectMocks注解

@InjectMocks注解用來創建一個實例，并將其它對象（@Mock、@Spy或直接定義的對象）注入到該實例中。所以，@InjectMocks注解本身就可以用來定義被測對象。@InjectMocks注解需要配合@RunWith注解使用。

@RunWith(PowerMockRunner.class) public class UserServiceTest {@InjectMocksprivate UserService userService;... }

4.模擬依賴對象

在編寫單元測試用例時，需要模擬各種依賴對象——類成員、方法參數和方法返回值。

4.1.直接構建對象

如果需要構建一個對象，最簡單直接的方法就是——定義對象并賦值。

Long userId = 1L; String userName = "admin"; UserDO user = new User(); user.setId(userId); user.setName(userName); List < Long> userIdList = Arrays.asList(1L, 2L, 3L);

4.2.反序列化對象

如果對象字段或層級非常龐大，采用直接構建對象方法，可能會編寫大量構建程序代碼。這種情況，可以考慮反序列化對象，將會大大減少程序代碼。由于JSON字符串可讀性高，這里就以JSON為例，介紹反序列化對象。

反序列化模型對象：

String text = ResourceHelper.getResourceAsString(getClass(), "user.json"); UserDO user = JSON.parseObject(text, UserDO.class);

反序列化集合對象：

String text = ResourceHelper.getResourceAsString(getClass(), "userList.json"); List < UserDO> userList = JSON.parseArray(text, UserDO.class);

反序列化映射對象：

String text = ResourceHelper.getResourceAsString(getClass(), "userMap.json"); Map < Long, UserDO> userMap = JSON.parseObject(text, new TypeReference < Map < Long, UserDO>>() {});

4.3.利用Mockito.mock方法

Mockito提供一個mock功能，用于攔截那些尚未實現或不期望被真實調用的方法，默認所有方法都已被模擬——方法為空并返回默認值（null或0），除非主動執行doCallRealMethod或thenCallRealMethod操作，才能夠調用真實的方法。

利用Mockito.mock方法模擬依賴對象，主要用于以下幾種情形：

只使用類實例，不使用類屬性；

類屬性太多，但使用其中少量屬性（可以mock屬性返回值）；

類是接口或虛基類，并不關心其具體實現類。

MockClass mockClass = Mockito.mock(MockClass.class); List < Long> userIdList = (List < Long>)Mockito.mock(List.class);

4.4.利用@Mock注解

@Mock注解跟Mockito.mock方法一樣，可以用來模擬依賴對象，適用于普通類、接口和虛基類。@Mock注解需要配合@RunWith注解使用。

@RunWith(PowerMockRunner.class) public class UserServiceTest {@Mockprivate UserDAO userDAO;... }

4.5.利用Mockito.spy方法

Mockito.spy方法跟Mockito.mock方法功能相似，只是Mockito.spy方法默認所有方法都是真實方法，除非主動去模擬對應方法。

UserService userService = Mockito.spy(new UserService()); UserService userService = Mockito.spy(UserService.class); AbstractOssService ossService = Mockito.spy(AbstractOssService.class);

4.6.利用@Spy注解

@Spy注解跟Mockito.spy方法一樣，可以用來模擬依賴對象，適用于普通類、接口和虛基類。@Spy注解需要配合@RunWith注解使用。

@RunWith(PowerMockRunner.class) public class CompanyServiceTest {@Spyprivate UserService userService = new UserService();... }

注意：@Spy注解對象需要初始化。如果是虛基類或接口，可以用Mockito.mock方法實例化。

5.注入依賴對象

當模擬完這些類成員對象后，我們需要把這些類成員對象注入到被測試類的實例中。以便在調用被測試方法時，可能使用這些類成員對象，而不至于拋出空指針異常。

5.1.利用Setter方法注入

如果類定義了Setter方法，可以直接調用方法設置字段值。

userService.setMaxCount(100); userService.setUserDAO(userDAO);

5.2.利用ReflectionTestUtils.setField方法注入

JUnit提供ReflectionTestUtils.setField方法設置屬性字段值。

ReflectionTestUtils.setField(userService, "maxCount", 100); ReflectionTestUtils.setField(userService, "userDAO", userDAO);

5.3.利用Whitebox.setInternalState方法注入

PowerMock提供Whitebox.setInternalState方法設置屬性字段值。

Whitebox.setInternalState(userService, "maxCount", 100); Whitebox.setInternalState(userService, "userDAO", userDAO);

5.4.利用@InjectMocks注解注入

@InjectMocks注解用來創建一個實例，并將其它對象（@Mock、@Spy或直接定義的對象）注入到該實例中。@InjectMocks注解需要配合@RunWith注解使用。

@RunWith(PowerMockRunner.class) public class UserServiceTest {@Mockprivate UserDAO userDAO;private Boolean canModify;@InjectMocksprivate UserService userService;... }

5.5.設置靜態常量字段值

有時候，我們需要對靜態常量對象進行模擬，然后去驗證是否執行了對應分支下的方法。比如：需要模擬Lombok的@Slf4j生成的log靜態常量。但是，Whitebox.setInternalState方法和@InjectMocks注解并不支持設置靜態常量，需要自己實現一個設置靜態常量的方法：

public final class FieldHelper {public static void setStaticFinalField(Class< ?> clazz, String fieldName, Object fieldValue) throws NoSuchFieldException, IllegalAccessException {Field field = clazz.getDeclaredField(fieldName);FieldUtils.removeFinalModifier(field);FieldUtils.writeStaticField(field, fieldValue, true);} }

具體使用方法如下：

FieldHelper.setStaticFinalField(UserService.class, "log", log);

注意：經過測試，該方法對于int、Integer等基礎類型并不生效，應該是編譯器常量優化導致。

6.模擬依賴方法

在模擬完依賴的參數和返回值后，就可以利用Mockito和PowerMock的功能，進行依賴方法的模擬。如果依賴對象還有方法調用，還需要模擬這些依賴對象的方法。

6.1.根據返回模擬方法

6.1.1.模擬無返回值方法

Mockito.doNothing().when(userDAO).delete(userId);

6.1.2.模擬方法單個返回值

Mockito.doReturn(user).when(userDAO).get(userId); Mockito.when(userDAO.get(userId)).thenReturn(user);

6.1.3.模擬方法多個返回值

直接列舉出多個返回值：

Mockito.doReturn(record0, record1, record2, null).when(recordReader).read(); Mockito.when(recordReader.read()).thenReturn(record0, record1, record2, null);

轉化列表為多個返回值：

List< Record> recordList = ...; Mockito.doReturn(recordList.get(0), recordList.subList(1, recordList.size()).toArray()).when(recordReader).read(); Mockito.when(recordReader.read()).thenReturn(recordList.get(0), recordList.subList(1, recordList.size()).toArray());

6.1.4.模擬方法定制返回值

可利用Answer定制方法返回值：

Map< Long, UserDO> userMap = ...; Mockito.doAnswer(invocation -> userMap.get(invocation.getArgument(0))).when(userDAO).get(Mockito.anyLong()); Mockito.when(userDAO.get(Mockito.anyLong())).thenReturn(invocation -> userMap.get(invocation.getArgument(0))); Mockito.when(userDAO.get(Mockito.anyLong())).then(invocation -> userMap.get(invocation.getArgument(0)));

6.1.5.模擬方法拋出單個異常

指定單個異常類型：

Mockito.doThrow(PersistenceException.class).when(userDAO).get(Mockito.anyLong()); Mockito.when(userDAO.get(Mockito.anyLong())).thenThrow(PersistenceException.class);

指定單個異常對象：

Mockito.doThrow(exception).when(userDAO).get(Mockito.anyLong()); Mockito.when(userDAO.get(Mockito.anyLong())).thenThrow(exception);

6.1.6.模擬方法拋出多個異常

指定多個異常類型：

Mockito.doThrow(PersistenceException.class, RuntimeException.class).when(userDAO).get(Mockito.anyLong()); Mockito.when(userDAO.get(Mockito.anyLong())).thenThrow(PersistenceException.class, RuntimeException.class);

指定多個異常對象：

Mockito.doThrow(exception1, exception2).when(userDAO).get(Mockito.anyLong()); Mockito.when(userDAO.get(Mockito.anyLong())).thenThrow(exception1, exception2);

6.1.7.直接調用真實方法

Mockito.doCallRealMethod().when(userService).getUser(userId); Mockito.when(userService.getUser(userId)).thenCallRealMethod();

6.2.根據參數模擬方法

Mockito提供do-when語句和when-then語句模擬方法。

6.2.1.模擬無參數方法

對于無參數的方法模擬：

Mockito.doReturn(deleteCount).when(userDAO).deleteAll(); Mockito.when(userDAO.deleteAll()).thenReturn(deleteCount);

6.2.2.模擬指定參數方法

對于指定參數的方法模擬：

Mockito.doReturn(user).when(userDAO).get(userId); Mockito.when(userDAO.get(userId)).thenReturn(user);

6.2.3.模擬任意參數方法

在編寫單元測試用例時，有時候并不關心傳入參數的具體值，可以使用Mockito參數匹配器的any方法。Mockito提供了anyInt、anyLong、anyString、anyList、anySet、anyMap、any(Class clazz)等方法來表示任意值。

Mockito.doReturn(user).when(userDAO).get(Mockito.anyLong()); Mockito.when(userDAO.get(Mockito.anyLong())).thenReturn(user);

6.2.4.模擬可空參數方法

Mockito參數匹配器的any具體方法，并不能夠匹配null對象。而Mockito提供一個nullable方法，可以匹配包含null對象的任意對象。此外，Mockito.any()方法也可以用來匹配可空參數。

Mockito.doReturn(user).when(userDAO).queryCompany(Mockito.anyLong(), Mockito.nullable(Long.class)); Mockito.when(userDAO.queryCompany(Mockito.anyLong(), Mockito< Long>.any())).thenReturn(user);

6.2.5.模擬必空參數方法

同樣，如果要匹配null對象，可以使用isNull方法，或使用eq(null)。

Mockito.doReturn(user).when(userDAO).queryCompany(Mockito.anyLong(), Mockito.isNull()); Mockito.when(userDAO.queryCompany(Mockito.anyLong(), Mockito.eq(null))).thenReturn(user);

6.2.6.模擬不同參數方法

Mockito支持按不同的參數分別模擬同一方法。

Mockito.doReturn(user1).when(userDAO).get(1L); Mockito.doReturn(user2).when(userDAO).get(2L); ...

注意：如果一個參數滿足多個模擬方法條件，會以最后一個模擬方法為準。

6.2.7.模擬可變參數方法

對于一些變長度參數方法，可以按實際參數個數進行模擬：

Mockito.when(userService.delete(Mockito.anyLong()).thenReturn(true); Mockito.when(userService.delete(1L, 2L, 3L).thenReturn(true);

也可以用Mockito.any()模擬一個通用匹配方法:

Mockito.when(userService.delete(Mockito.< Long>any()).thenReturn(true);

注意：Mockito.< T>any()并不等于Mockito.any(Class< T> type),前者可以匹配null和類型T的可變參數，后者只能匹配T必填參數。

6.3.模擬其它特殊方法

6.3.1.模擬final方法

PowerMock提供對final方法的模擬，方法跟模擬普通方法一樣。但是，需要把對應的模擬類添加到@PrepareForTest注解中。

// 添加@PrepareForTest注解 @PrepareForTest({UserService.class})// 跟模擬普通方法完全一致 Mockito.doReturn(userId).when(idGenerator).next(); Mockito.when(idGenerator.next()).thenReturn(userId);

6.3.2.模擬私有方法

PowerMock提供提對私有方法的模擬，但是需要把私有方法所在的類放在@PrepareForTest注解中。

PowerMockito.doReturn(true).when(UserService.class, "isSuper", userId); PowerMockito.when(UserService.class, "isSuper", userId).thenReturn(true);

6.3.3.模擬構造方法

PowerMock提供PowerMockito.whenNew方法來模擬構造方法，但是需要把使用構造方法的類放在@PrepareForTest注解中。

PowerMockito.whenNew(UserDO.class).withNoArguments().thenReturn(userDO); PowerMockito.whenNew(UserDO.class).withArguments(userId, userName).thenReturn(userDO);

6.3.4.模擬靜態方法

PowerMock提供PowerMockito.mockStatic和PowerMockito.spy來模擬靜態方法類，然后就可以模擬靜態方法了。同樣，需要把對應的模擬類添加到@PrepareForTest注解中。

// 模擬對應的類 PowerMockito.mockStatic(HttpHelper.class); PowerMockito.spy(HttpHelper.class);// 模擬對應的方法 PowerMockito.when(HttpHelper.httpPost(SERVER_URL)).thenReturn(response); PowerMockito.doReturn(response).when(HttpHelper.class, "httpPost", SERVER_URL); PowerMockito.when(HttpHelper.class, "httpPost", SERVER_URL).thenReturn(response);

注意：第一種方式不適用于PowerMockito.spy模擬的靜態方法類。

7.調用被測方法

在準備好參數對象后，就可以調用被測試方法了。

如果把方法按訪問權限分類，可以簡單地分為有訪問權限和無訪問權限兩種。但實際上，Java語言中提供了public、protected、private和缺失共4種權限修飾符，在不同的環境下又對應不同的訪問權限。具體映射關系如下：

修飾符本類本包子類其它

public	有	有	有	有
protected	有	有	有	無
缺省	有	有	無	無
private	有	無	無	無

下面，將根據有訪問權限和無訪問權限兩種情況，來介紹如何調用被測方法。

7.1.調用構造方法

7.1.1.調用有訪問權限的構造方法

可以直接調用有訪問權限的構造方法。

UserDO user = new User(); UserDO user = new User(1L, "admin");

7.1.2.調用無訪問權限的構造方法

調用無訪問權限的構造方法，可以使用PowerMock提供的Whitebox.invokeConstructor方法。

Whitebox.invokeConstructor(NumberHelper.class); Whitebox.invokeConstructor(User.class, 1L, "admin");

備注：該方法也可以調用有訪問權限的構造方法，但是不建議使用。

7.2.調用普通方法

7.2.1.調用有訪問權限的普通方法

可以直接調用有訪問權限的普通方法。

userService.deleteUser(userId); User user = userService.getUser(userId);

7.2.2.調用無權限訪問的普通方法

調用無訪問權限的普通方法，可以使用PowerMock提供的Whitebox.invokeMethod方法。

User user = (User)Whitebox.invokeMethod(userService, "isSuper", userId);

也可以使用PowerMock提供Whitebox.getMethod方法和PowerMockito.method方法，可以直接獲取對應類方法對象。然后，通過Method的invoke方法，可以調用沒有訪問權限的方法。

Method method = Whitebox.getMethod(UserService.class, "isSuper", Long.class); Method method = PowerMockito.method(UserService.class, "isSuper", Long.class); User user = (User)method.invoke(userService, userId);

備注：該方法也可以調用有訪問權限的普通方法，但是不建議使用。

7.3.調用靜態方法

7.3.1.調用有權限訪問的靜態方法

可以直接調用有訪問權限的靜態方法。

boolean isPositive = NumberHelper.isPositive(-1);

7.3.2.調用無權限訪問的靜態方法

調用無權限訪問的靜態方法，可以使用PowerMock提供的Whitebox.invokeMethod方法。

String value = (String)Whitebox.invokeMethod(JSON.class, "toJSONString", object);

備注：該方法也可以調用有訪問權限的靜態方法，但是不建議使用。

8.驗證依賴方法

在單元測試中，驗證是確認模擬的依賴方法是否按照預期被調用或未調用的過程。Mockito提供了許多方法來驗證依賴方法調用，給我們編寫單元測試用例帶來了很大的幫助。

8.1.根據參數驗證方法調用

8.1.1.驗證無參數方法調用

Mockito.verify(userDAO).deleteAll();

8.1.2.驗證指定參數方法調用

Mockito.verify(userDAO).delete(userId); Mockito.verify(userDAO).delete(Mockito.eq(userId));

8.1.3.驗證任意參數方法調用

Mockito.verify(userDAO).delete(Mockito.anyLong());

8.1.4.驗證可空參數方法調用

Mockito.verify(userDAO).queryCompany(Mockito.anyLong(), Mockito.nullable(Long.class));

8.1.5.驗證必空參數方法調用

Mockito.verify(userDAO).queryCompany(Mockito.anyLong(), Mockito.isNull());

8.1.6.驗證可變參數方法調用

對于一些變長度參數方法，可以按實際參數個數進行驗證：

Mockito.verify(userService).delete(Mockito.any(Long.class)); Mockito.verify(userService).delete(1L, 2L, 3L);

也可以用Mockito.any()進行通用驗證:

Mockito.verify(userService).delete(Mockito.< Long>any());

8.2.驗證方法調用次數

8.2.1.驗證方法默認調用1次

Mockito.verify(userDAO).delete(userId);

8.2.2.驗證方法從不調用

Mockito.verify(userDAO, Mockito.never()).delete(userId);

8.2.3.驗證方法調用n次

Mockito.verify(userDAO, Mockito.times(n)).delete(userId);

8.2.4.驗證方法調用至少1次

Mockito.verify(userDAO, Mockito.atLeastOnce()).delete(userId);

8.2.5.驗證方法調用至少n次

Mockito.verify(userDAO, Mockito.atLeast(n)).delete(userId);

8.2.2.驗證方法調用最多1次

Mockito.verify(userDAO, Mockito.atMostOnce()).delete(userId);

8.2.6.驗證方法調用最多n次

Mockito.verify(userDAO, Mockito.atMost(n)).delete(userId);

8.2.7.驗證方法調用指定n次

Mockito允許按順序進行驗證方法調用，未被驗證到的方法調用將不會被標記為已驗證。

Mockito.verify(userDAO, Mockito.call(n)).delete(userId);

8.2.8.驗證對象及其方法調用1次

用于驗證對象及其方法調用1次，如果該對象還有別的方法被調用或者該方法調用了多次，都將導致驗證方法調用失敗。

Mockito.verify(userDAO, Mockito.only()).delete(userId);

相當于：

Mockito.verify(userDAO).delete(userId); Mockito.verifyNoMoreInteractions(userDAO);

8.3.驗證方法調用并捕獲參數值

Mockito提供ArgumentCaptor類來捕獲參數值，通過調用forClass(Class< T> clazz)方法來構建一個ArgumentCaptor對象，然后在驗證方法調用時來捕獲參數，最后獲取到捕獲的參數值并驗證。如果一個方法有多個參數都要捕獲并驗證，那就需要創建多個ArgumentCaptor對象。

ArgumentCaptor的主要接口方法：

capture方法，用于捕獲方法參數；

getValue方法，用于獲取捕獲的參數值，如果捕獲了多個參數值，該方法只返回最后一個參數值；

getAllValues方法，用戶獲取捕獲的所有參數值。

8.3.1.使用ArgumentCaptor.forClass方法定義參數捕獲器

在測試用例方法中，直接使用ArgumentCaptor.forClass方法定義參數捕獲器。

注意：定義泛型類的參數捕獲器時，存在強制類型轉化，會引起編譯器警告。

8.3.2.使用@Captor注解定義參數捕獲器

也可以用Mockito提供的@Captor注解，在測試用例類中定義參數捕獲器。

@RunWith(PowerMockRunner.class) public class UserServiceTest {@Captorprivate ArgumentCaptor< UserDO> userCaptor;@Testpublic void testModifyUser() {...Mockito.verify(userDAO).modify(userCaptor.capture());UserDO user = userCaptor.getValue();} }

注意：定義泛型類的參數捕獲器時，由于是Mockito自行初始化，不會引起編譯器告警。

8.3.3.捕獲多次方法調用的參數值列表

8.4.驗證其它特殊方法

8.4.1.驗證final方法調用

final方法的驗證跟普通方法類似，這里不再累述。

8.4.2.驗證私有方法調用

PowerMockito提供verifyPrivate方法驗證私有方法調用。

PowerMockito.verifyPrivate(myClass, times(1)).invoke("unload", any(List.class));

8.4.3.驗證構造方法調用

PowerMockito提供verifyNew方法驗證構造方法調用。

PowerMockito.verifyNew(MockClass.class).withNoArguments(); PowerMockito.verifyNew(MockClass.class).withArguments(someArgs);

8.4.4.驗證靜態方法調用

PowerMockito提供verifyStatic方法驗證靜態方法調用。

PowerMockito.verifyStatic(StringUtils.class); StringUtils.isEmpty(string);

9.驗證數據對象

JUnit測試框架中Assert類就是斷言工具類，主要驗證單元測試中實際數據對象與期望數據對象一致。在調用被測方法時，需要對返回值和異常進行驗證；在驗證方法調用時，也需要對捕獲的參數值進行驗證。

9.1.驗證數據對象空值

9.1.1.驗證數據對象為空

通過JUnit提供的Assert.assertNull方法驗證數據對象為空。

Assert.assertNull("用戶標識必須為空", userId);

9.1.2.驗證數據對象非空

通過JUnit提供的Assert.assertNotNull方法驗證數據對象非空。

Assert.assertNotNull("用戶標識不能為空", userId);

9.2.驗證數據對象布爾值

9.2.1.驗證數據對象為真

通過JUnit提供的Assert.assertTrue方法驗證數據對象為真。

Assert.assertTrue("返回值必須為真", NumberHelper.isPositive(1));

9.2.2.驗證數據對象為假

通過JUnit提供的Assert.assertFalse方法驗證數據對象為假。

Assert.assertFalse("返回值必須為假", NumberHelper.isPositive(-1));

9.3.驗證數據對象引用

在單元測試用例中，對于一些參數或返回值對象，不需要驗證對象具體取值，只需要驗證對象引用是否一致。

9.3.1.驗證數據對象一致

JUnit提供的Assert.assertSame方法驗證數據對象一致。

UserDO expectedUser = ...; Mockito.doReturn(expectedUser).when(userDAO).get(userId); UserDO actualUser = userService.getUser(userId); Assert.assertSame("用戶必須一致", expectedUser, actualUser);

9.3.1.驗證數據對象不一致

JUnit提供的Assert.assertNotSame方法驗證數據對象一致。

UserDO expectedUser = ...; Mockito.doReturn(expectedUser).when(userDAO).get(userId); UserDO actualUser = userService.getUser(otherUserId); Assert.assertNotSame("用戶不能一致", expectedUser, actualUser);

9.4.驗證數據對象值

JUnit提供Assert.assertEquals、Assert.assertNotEquals、Assert.assertArrayEquals方法組，可以用來驗證數據對象值是否相等。

9.4.1.驗證簡單數據對象

對于簡單數據對象（比如：基礎類型、包裝類型、實現了equals的數據類型……），可以直接通過JUnit的Assert.assertEquals和Assert.assertNotEquals方法組進行驗證。

Assert.assertNotEquals("用戶名稱不一致", "admin", userName); Assert.assertEquals("賬戶金額不一致", 10000.0D, accountAmount, 1E-6D);

9.4.2.驗證簡單數組或集合對象

對于簡單數組對象（比如：基礎類型、包裝類型、實現了equals的數據類型……），可以直接通過JUnit的Assert.assertArrayEquals方法組進行驗證。對于簡單集合對象，也可以通過Assert.assertEquals方法驗證。

Long[] userIds = ...; Assert.assertArrayEquals("用戶標識列表不一致", new Long[] {1L, 2L, 3L}, userIds);List< Long> userIdList = ...; Assert.assertEquals("用戶標識列表不一致", Arrays.asList(1L, 2L, 3L), userIdList);

9.4.3.驗證復雜數據對象

對于復雜的JavaBean數據對象，需要驗證JavaBean數據對象的每一個屬性字段。

UserDO user = ...; Assert.assertEquals("用戶標識不一致", Long.valueOf(1L), user.getId()); Assert.assertEquals("用戶名稱不一致", "admin", user.getName()); Assert.assertEquals("用戶公司標識不一致", Long.valueOf(1L), user.getCompany().getId()); ...

9.4.4.驗證復雜數組或集合對象

對于復雜的JavaBean數組和集合對象，需要先展開數組和集合對象中每一個JavaBean數據對象，然后驗證JavaBean數據對象的每一個屬性字段。

List< UserDO> expectedUserList = ...; List< UserDO> actualUserList = ...; Assert.assertEquals("用戶列表長度不一致", expectedUserList.size(), actualUserList.size()); UserDO[] expectedUsers = expectedUserList.toArray(new UserDO[0]); UserDO[] actualUsers = actualUserList.toArray(new UserDO[0]); for (int i = 0; i < actualUsers.length; i++) {Assert.assertEquals(String.format("用戶(%s)標識不一致", i), expectedUsers[i].getId(), actualUsers[i].getId());Assert.assertEquals(String.format("用戶(%s)名稱不一致", i), expectedUsers[i].getName(), actualUsers[i].getName()); Assert.assertEquals("用戶公司標識不一致", expectedUsers[i].getCompany().getId(), actualUsers[i].getCompany().getId());... }

9.4.5.通過序列化驗證數據對象

如上一節例子所示，當數據對象過于復雜時，如果采用Assert.assertEquals依次驗證每個JavaBean對象、驗證每一個屬性字段，測試用例的代碼量將會非常龐大。這里，推薦使用序列化手段簡化數據對象的驗證，比如利用JSON.toJSONString方法把復雜的數據對象轉化為字符串，然后再使用Assert.assertEquals方法進行驗證字符串。但是，序列化值必須具備有序性、一致性和可讀性。

List< UserDO> userList = ...; String text = ResourceHelper.getResourceAsString(getClass(), "userList.json"); Assert.assertEquals("用戶列表不一致", text, JSON.toJSONString(userList));

通常使用JSON.toJSONString方法把Map對象轉化為字符串，其中key-value的順序具有不確定性，無法用于驗證兩個對象是否一致。這里，JSON提供序列化選項SerializerFeature.MapSortField(映射排序字段)，可以用于保證序列化后的key-value的有序性。

Map< Long, Map< String, Object>> userMap = ...; String text = ResourceHelper.getResourceAsString(getClass(), "userMap.json"); Assert.assertEquals("用戶映射不一致", text, JSON.toJSONString(userMap, SerializerFeature.MapSortField));

9.4.6.驗證數據對象私有屬性字段

有時候，單元測試用例需要對復雜對象的私有屬性字段進行驗證。而PowerMockito提供的Whitebox.getInternalState方法，獲取輕松地獲取到私有屬性字段值。

MapperScannerConfigurer configurer = myBatisConfiguration.buildMapperScannerConfigurer(); Assert.assertEquals("基礎包不一致", "com.alibaba.example", Whitebox.getInternalState(configurer, "basePackage"));

9.5.驗證異常對象內容

異常作為Java語言的重要特性，是Java語言健壯性的重要體現。捕獲并驗證異常數據內容，也是測試用例的一種。

9.5.1.通過@Test注解驗證異常對象

JUnit的注解@Test提供了一個expected屬性，可以指定一個期望的異常類型，用來捕獲并驗證異常。但是，這種方式只能驗證異常類型，并不能驗證異常原因和消息。

@Test(expected = ExampleException.class) public void testGetUser() {// 模擬依賴方法Mockito.doReturn(null).when(userDAO).get(userId);// 調用被測方法userService.getUser(userId); }

9.5.2.通過@Rule注解驗證異常對象

如果想要驗證異常原因和消息，就需求采用@Rule注解定義ExpectedException對象，然后在測試方法的前面聲明要捕獲的異常類型、原因和消息。

@Rule private ExpectedException exception = ExpectedException.none(); @Test public void testGetUser() {// 模擬依賴方法Long userId = 123L;Mockito.doReturn(null).when(userDAO).get(userId);// 調用被測方法exception.expect(ExampleException.class);exception.expectMessage(String.format("用戶(%s)不存在", userId));userService.getUser(userId); }

9.5.3.通過Assert.assertThrows驗證異常對象

在最新版的JUnit中，提供了一個更為簡潔的異常驗證方式——Assert.assertThrows方法。

@Test public void testGetUser() {// 模擬依賴方法Long userId = 123L;Mockito.doReturn(null).when(userDAO).get(userId);// 調用被測方法ExampleException exception = Assert.assertThrows("異常類型不一致", ExampleException.class, () -> userService.getUser(userId));Assert.assertEquals("異常消息不一致", "處理異常", exception.getMessage()); }

10.驗證依賴對象

10.1.驗證模擬對象沒有任何方法調用

Mockito提供了verifyNoInteractions方法，可以驗證模擬對象在被測試方法中沒有任何調用。

Mockito.verifyNoInteractions(idGenerator, userDAO);

10.2.驗證模擬對象沒有更多方法調用

Mockito提供了verifyNoMoreInteractions方法，在驗證模擬對象所有方法調用后使用，可以驗證模擬對象所有方法調用是否都得到驗證。如果模擬對象存在任何未驗證的方法調用，就會拋出NoInteractionsWanted異常。

Mockito.verifyNoMoreInteractions(idGenerator, userDAO);

備注：Mockito的verifyZeroInteractions方法與verifyNoMoreInteractions方法功能相同，但是目前前者已經被廢棄。

10.3.清除模擬對象所有方法調用標記

在編寫單元測試用例時，為了減少單元測試用例數和代碼量，可以把多組參數定義在同一個單元測試用例中，然后用for循環依次執行每一組參數的被測方法調用。為了避免上一次測試的方法調用影響下一次測試的方法調用驗證，最好使用Mockito提供clearInvocations方法清除上一次的方法調用。

// 清除所有對象調用 Mockito.clearInvocations(); // 清除指定對象調用 Mockito.clearInvocations(idGenerator, userDAO);

11.典型案例分析

這里，只收集了幾個經典案例，解決了特定環境下的特定問題。

11.1.測試框架特性導致問題

在編寫單元測試用例時，或多或少會遇到一些問題，大多數是由于對測試框架特性不熟悉導致，比如：

Mockito不支持對靜態方法、構造方法、final方法、私有方法的模擬；

Mockito的any相關的參數匹配方法并不支持可空參數和空參數；

采用Mockito的參數匹配方法時，其它參數不能直接用常量或變量，必須使用Mockito的eq方法；

使用when-then語句模擬Spy對象方法會先執行真實方法，應該使用do-when語句；

PowerMock對靜態方法、構造方法、final方法、私有方法的模擬需要把對應的類添加到@PrepareForTest注解中；

PowerMock模擬JDK的靜態方法、構造方法、final方法、私有方法時，需要把使用這些方法的類加入到@PrepareForTest注解中，從而導致單元測試覆蓋率不被統計；

PowerMock使用自定義的類加載器來加載類，可能導致系統類加載器認為有類型轉化問題；需要加上@PowerMockIgnore({"javax.crypto.*"})注解，來告訴PowerMock這個包不要用PowerMock的類加載器加載，需要采用系統類加載器來加載。

……

對于這些問題，可以根據提示信息查閱相關資料解決，這里就不再累述了。

11.2.捕獲參數值已變更問題

在編寫單元測試用例時，通常采用ArgumentCaptor進行參數捕獲，然后對參數對象值進行驗證。如果參數對象值沒有變更，這個步驟就沒有任何問題。但是，如果參數對象值在后續流程中發生變更，就會導致驗證參數值失敗。

原始代碼：

public < T> void readData(RecordReader recordReader, int batchSize, Function< Record, T> dataParser, Predicate< List<T>> dataStorage) {try {// 依次讀取數據Record record;boolean isContinue = true;List< T> dataList = new ArrayList<>(batchSize);while (Objects.nonNull(record = recordReader.read()) && isContinue) {// 解析添加數據T data = dataParser.apply(record);if (Objects.nonNull(data)) {dataList.add(data);}// 批量存儲數據if (dataList.size() == batchSize) {isContinue = dataStorage.test(dataList);dataList.clear();}}// 存儲剩余數據if (CollectionUtils.isNotEmpty(dataList)) {dataStorage.test(dataList);dataList.clear();}} catch (IOException e) {String message = READ_DATA_EXCEPTION;log.warn(message, e);throw new ExampleException(message, e);} }

測試用例：

@Test public void testReadData() throws Exception {// 模擬依賴方法// 模擬依賴方法: recordReader.readRecord record0 = Mockito.mock(Record.class);Record record1 = Mockito.mock(Record.class);Record record2 = Mockito.mock(Record.class);TunnelRecordReader recordReader = Mockito.mock(TunnelRecordReader.class);Mockito.doReturn(record0, record1, record2, null).when(recordReader).read();// 模擬依賴方法: dataParser.applyObject object0 = new Object();Object object1 = new Object();Object object2 = new Object();Function< Record, Object> dataParser = Mockito.mock(Function.class);Mockito.doReturn(object0).when(dataParser).apply(record0);Mockito.doReturn(object1).when(dataParser).apply(record1);Mockito.doReturn(object2).when(dataParser).apply(record2);// 模擬依賴方法: dataStorage.testPredicate< List< Object>> dataStorage = Mockito.mock(Predicate.class);Mockito.doReturn(true).when(dataStorage).test(Mockito.anyList());// 調用測試方法odpsService.readData(recordReader, 2, dataParser, dataStorage);// 驗證依賴方法// 模擬依賴方法: recordReader.readMockito.verify(recordReader, Mockito.times(4)).read();// 模擬依賴方法: dataParser.applyMockito.verify(dataParser, Mockito.times(3)).apply(Mockito.any(Record.class));// 驗證依賴方法: dataStorage.testArgumentCaptor< List< Object>> recordListCaptor = ArgumentCaptor.forClass(List.class);Mockito.verify(dataStorage, Mockito.times(2)).test(recordListCaptor.capture());Assert.assertEquals("數據列表不一致", Arrays.asList(Arrays.asList(object0, object1), Arrays.asList(object2)), recordListCaptor.getAllValues()); }

問題現象：

執行單元測試用例失敗，拋出以下異常信息：

java.lang.AssertionError: 數據列表不一致 expected:<[[java.lang.Object@1e3469df, java.lang.Object@79499fa], [java.lang.Object@48531d5]]> but was:<[[], []]>

問題原因：

由于參數dataList在調用dataStorage.test方法后，都被主動調用dataList.clear方法進行清空。由于ArgumentCaptor捕獲的是對象引用，所以最后捕獲到了同一個空列表。

解決方案：

可以在模擬依賴方法dataStorage.test時，保存傳入參數的當前值進行驗證。代碼如下：

11.3.模擬Lombok的log對象問題

Lombok的@Slf4j注解，廣泛地應用于Java項目中。在某些代碼分支里，可能只有log記錄日志的操作，為了驗證這個分支邏輯被正確執行，需要在單元測試用例中對log記錄日志的操作進行驗證。

原始方法：

@Slf4j @Service public class ExampleService {public void recordLog(int code) {if (code == 1) {log.info("執行分支1");return;}if (code == 2) {log.info("執行分支2");return;}log.info("執行默認分支");}... }

測試用例：

@RunWith(PowerMockRunner.class) public class ExampleServiceTest {@Mockprivate Logger log;@InjectMocksprivate ExampleService exampleService;@Testpublic void testRecordLog1() {exampleService.recordLog(1);Mockito.verify(log).info("執行分支1");} }

問題現象：

執行單元測試用例失敗，拋出以下異常信息：

Wanted but not invoked: logger.info("執行分支1");

原因分析：

經過調式跟蹤，發現ExampleService中的log對象并沒有被注入。通過編譯發現，Lombok的@Slf4j注解在ExampleService類中生成了一個靜態常量log，而@InjectMocks注解并不支持靜態常量的注入。

解決方案：

采用作者實現的FieldHelper.setStaticFinalField方法，可以實現對靜態常量的注入模擬對象。

@RunWith(PowerMockRunner.class) public class ExampleServiceTest {@Mockprivate Logger log;@InjectMocksprivate ExampleService exampleService;@Beforepublic void beforeTest() throws Exception {FieldHelper.setStaticFinalField(ExampleService.class, "log", log);}@Testpublic void testRecordLog1() {exampleService.recordLog(1);Mockito.verify(log).info("執行分支1");} }

11.4.兼容Pandora等容器問題

阿里巴巴的很多中間件，都是基于Pandora容器的，在編寫單元測試用例時，可能會遇到一些坑。

原始方法：

@Slf4j public class MetaqMessageSender {@Autowiredprivate MetaProducer metaProducer;public String sendMetaqMessage(String topicName, String tagName, String messageKey, String messageBody) {try {// 組裝消息內容Message message = new Message();message.setTopic(topicName);message.setTags(tagName);message.setKeys(messageKey);message.setBody(messageBody.getBytes(StandardCharsets.UTF_8));// 發送消息請求SendResult sendResult = metaProducer.send(message);if (sendResult.getSendStatus() != SendStatus.SEND_OK) {String msg = String.format("發送標簽(%s)消息(%s)狀態錯誤(%s)", tagName, messageKey, sendResult.getSendStatus());log.warn(msg);throw new ReconsException(msg);}log.info(String.format("發送標簽(%s)消息(%s)狀態成功:%s", tagName, messageKey, sendResult.getMsgId()));// 返回消息標識return sendResult.getMsgId();} catch (MQClientException | RemotingException | MQBrokerException | InterruptedException e) {// 記錄消息異常Thread.currentThread().interrupt();String message = String.format("發送標簽(%s)消息(%s)狀態異常:%s", tagName, messageKey, e.getMessage());log.warn(message, e);throw new ReconsException(message, e);}} }

測試用例：

@RunWith(PowerMockRunner.class) public class MetaqMessageSenderTest {@Mockprivate MetaProducer metaProducer;@InjectMocksprivate MetaqMessageSender metaqMessageSender;@Testpublic void testSendMetaqMessage() throws Exception {// 模擬依賴方法SendResult sendResult = new SendResult();sendResult.setMsgId("msgId");sendResult.setSendStatus(SendStatus.SEND_OK);Mockito.doReturn(sendResult).when(metaProducer).send(Mockito.any(Message.class));// 調用測試方法String topicName = "topicName";String tagName = "tagName";String messageKey = "messageKey";String messageBody = "messageBody";String messageId = metaqMessageSender.sendMetaqMessage(topicName, tagName, messageKey, messageBody);Assert.assertEquals("messageId不一致", sendResult.getMsgId(), messageId);// 驗證依賴方法ArgumentCaptor< Message> messageCaptor = ArgumentCaptor.forClass(Message.class);Mockito.verify(metaProducer).send(messageCaptor.capture());Message message = messageCaptor.getValue();Assert.assertEquals("topicName不一致", topicName, message.getTopic());Assert.assertEquals("tagName不一致", tagName, message.getTags());Assert.assertEquals("messageKey不一致", messageKey, message.getKeys());Assert.assertEquals("messageBody不一致", messageBody, new String(message.getBody()));} }

問題現象：

執行單元測試用例失敗，拋出以下異常信息：

java.lang.RuntimeException: com.alibaba.rocketmq.client.producer.SendResult was loaded by org.powermock.core.classloader.javassist.JavassistMockClassLoader@5d43661b, it should be loaded by Pandora Container. Can not load this fake sdk class.

原因分析：

基于Pandora容器的中間件，需要使用Pandora容器加載。在上面測試用例中，使用了PowerMock容器加載，從而導致拋出類加載異常。

解決方案：

首先，把PowerMockRunner替換為PandoraBootRunner。其次，為了使@Mock、@InjectMocks等Mockito注解生效，需要調用MockitoAnnotations.initMocks(this)方法進行初始化。

@RunWith(PandoraBootRunner.class) public class MetaqMessageSenderTest {...@Beforepublic void beforeTest() {MockitoAnnotations.initMocks(this);}... }

12.消除類型轉換警告

在編寫測試用例時，特別是泛型類型轉換時，很容易產生類型轉換警告。常見類型轉換警告如下：

作為一個有代碼潔癖的輕微強迫癥程序員，是絕對不容許這些類型轉換警告產生的。于是，總結了以下方法來解決這些類型轉換警告。

12.1.利用注解初始化

Mockito提供@Mock注解來模擬類實例，提供@Captor注解來初始化參數捕獲器。由于這些注解實例是通過測試框架進行初始化的，所以不會產生類型轉換警告。

問題代碼：

建議代碼：

12.2.利用臨時類或接口

我們無法獲取泛型類或接口的class實例，但是很容易獲取具體類的class實例。這個解決方案的思路是——先定義繼承泛型類的具體子類，然后mock、spy、forClass以及any出這個具體子類的實例，然后把具體子類實例轉換為父類泛型實例。

問題代碼：

建議代碼：

12.3.利用CastUtils.cast方法

SpringData包中提供一個CastUtils.cast方法，可以用于類型的強制轉換。這個解決方案的思路是——利用CastUtils.cast方法屏蔽類型轉換警告。

問題代碼：

建議代碼：

這個解決方案，不需要定義注解，也不需要定義臨時類或接口，能夠讓測試用例代碼更為精簡，所以作者重點推薦。如果不愿意引入SpringData包，也可以自己參考實現該方法，只是該方法會產生類型轉換警告。

注意：CastUtils.cast方法本質是——先轉換為Object類型，再強制轉換對應類型，本身不會對類型進行校驗。所以，CastUtils.cast方法好用，但是不要亂用，否則就是大坑（只有執行時才能發現問題）。

12.4.利用類型自動轉換

在Mockito中，提供形式如下的方法——泛型類型只跟返回值有關，而跟輸入參數無關。這樣的方法，可以根據調用方法的參數類型自動轉換，而無需手動強制類型轉換。如果手動強制類型轉換，反而會產生類型轉換警告。

問題代碼：

建議代碼：

其實，SpringData的CastUtils.cast方法之所以這么強悍，也是采用了類型自動轉化方法。

12.5.利用doReturn-when語句代替when-thenReturn語句

Mockito的when-thenReturn語句需要對返回類型強制校驗，而doReturn-when語句不會對返回類型強制校驗。利用這個特性，可以利用doReturn-when語句代替when-thenReturn語句解決類型轉換警告。

問題代碼：

建議代碼：

12.6.利用instanceof關鍵字

JDK提供的Method.invoke方法返回的是Object類型，轉化為具體類型時需要強制轉換，會產生類型轉換警告。而PowerMock提供的Whitebox.invokeMethod方法返回類型可以自動轉化，不會產生類型轉換警告。

問題代碼：

建議代碼：

12.7.利用instanceof關鍵字

在具體類型強制轉換時，建議利用instanceof關鍵字先判斷類型，否則會產生類型轉換警告。

JSONArray jsonArray = (JSONArray)object; ...

建議代碼：

if (object instanceof JSONArray) {JSONArray jsonArray = (JSONArray)object;... }

12.8.利用Class.cast方法

在泛型類型強制轉換時，會產生類型轉換警告。可以采用泛型類的cast方法轉換，從而避免產生類型轉換警告。

問題代碼：

建議代碼：

12.9.避免不必要的類型轉換

有時候，沒有必要進行類型轉換，就盡量避免類型轉換。比如：把Object類型轉換為具體類型，但又把具體類型當Object類型使用，就沒有必要進行類型轉換。像這種情況，可以合并表達式或定義基類變量，從而避免不必要的類型轉化。

問題代碼：

建議代碼：

后記

登妙峰山記
山高路遠車難騎，
精疲力盡人易棄。
多少妙峰登頂者，
又練心境又練力！

騎行的人，一定要沉得住氣、要吃得了苦、要耐得住寂寞、要意志堅定不移、要體力夠猛夠持久……恰好，這也正是技術人所要具備的精神。只要技術人做到了這些，練就了好的“心境”和“體力”，才有可能登上技術的“妙峰山”。

原文鏈接

本文為阿里云原創內容，未經允許不得轉載。

總結

以上是生活随笔為你收集整理的Java编程技巧之单元测试用例编写流程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。