清代杰出思想家章學誠有一句名言：“學必求其心得，業必貴其專精。”
意思是：學習上一定要追求心得體會，事業上一定要貴以專注精深。做技術就是這樣，一件事如果做到了極致，就必然會有所心得體會。作者最近在一個項目上，追求單元測試覆蓋率到極致，所以才有了這篇心得體會。
上一篇文章《Java單元測試技巧之PowerMock》除了介紹單元測試基礎知識外，主要介紹了“為什么要編寫單元測試”。很多同學讀完后，還是不能快速地編寫單元測試用例。而這篇文章，立足于“如何來編寫單元測試用例”，能夠讓同學們“有章可循”，能快速地編寫出單元測試用例。
一編寫單元測試用例
1測試框架簡介
Mockito是一個單元測試模擬框架，可以讓你寫出優雅、簡潔的單元測試代碼。Mockito采用了模擬技術，模擬了一些在應用中依賴的復雜對象，從而把測試對象和依賴對象隔離開來。
PowerMock是一個單元測試模擬框架，是在其它單元測試模擬框架的基礎上做出擴展。通過提供定制的類加載器以及一些字節碼篡改技術的應用，PowerMock實現了對靜態方法、構造方法、私有方法以及final方法的模擬支持等強大的功能。但是，正因為PowerMock進行了字節碼篡改，導致部分單元測試用例并不被JaCoco統計覆蓋率。
通過作者多年單元測試的編寫經驗，優先推薦使用Mockito提供的功能；只有在Mockito提供的功能不能滿足需求時，才會采用PowerMock提供的功能；但是，不推薦使用影響JaCoco統計覆蓋率的PowerMock功能。在本文中，我們也不會對影響JaCoco統計覆蓋率的PowerMock功能進行介紹。
下面，將以Mockito為主、以PowerMock為輔，介紹一下如何編寫單元測試用例。
2測試框架引入
為了引入Mockito和PowerMock包，需要在maven項目的pom.xml文件中加入以下包依賴：

org.powermockpowermock-core$powermock.version</version><scope>test</scope></dependency><dependency><groupId>org.powermock</groupId><artifactId>powermock?api?mockito2</artifactId><version>${powermock.version}testorg.powermockpowermock-module-junit4${powermock.version}test
其中，powermock.version為2.0.9，為當前的最新版本，可根據實際情況修改。在PowerMock包中，已經包含了對應的Mockito和JUnit包，所以無需單獨引入Mockito和JUnit包。
3典型代碼案例
一個典型的服務代碼案例如下：

/**用戶服務類/@ServicepublicclassUserService{/*服務相關//*用戶DAO/@AutowiredprivateUserDAOuserDAO;/*標識生成器/@AutowiredprivateIdGeneratoridGenerator;
/*參數相關//可以修改/@Value("${userService.canModify}")privateBooleancanModify;
/創建用戶@paramuserCreate用戶創建@return用戶標識/publicLongcreateUser(UserVOuserCreate){//獲取用戶標識LonguserId=userDAO.getIdByName(userCreate.getName());
//根據存在處理//根據存在處理:不存在則創建if(Objects.isNull(userId)){userId=idGenerator.next();UserDOcreate=newUserDO();create.setId(userId);create.setName(userCreate.getName());userDAO.create(create);}//根據存在處理:已存在可修改elseif(Boolean.TRUE.equals(canModify)){UserDOmodify=newUserDO();modify.setId(userId);modify.setName(userCreate.getName());userDAO.modify(modify);}//根據存在處理:已存在禁修改else{thrownewUnsupportedOperationException(“不支持修改”);}
//返回用戶標識returnuserId;}}
4測試用例編寫
采用Mockito和PowerMock單元測試模擬框架，編寫的單元測試用例如下：
UserServiceTest.java

/**用戶服務測試類/@RunWith(PowerMockRunner.class)publicclassUserServiceTest{/*模擬依賴對象//*用戶DAO/@MockprivateUserDAOuserDAO;/*標識生成器/@MockprivateIdGeneratoridGenerator;
/*定義被測對象//*用戶服務/@InjectMocksprivateUserServiceuserService;
/**在測試之前/@BeforepublicvoidbeforeTest(){//注入依賴對象Whitebox.setInternalState(userService,“canModify”,Boolean.TRUE);}
/**測試:創建用戶-新/@TestpublicvoidtestCreateUserWithNew(){//模擬依賴方法//模擬依賴方法:userDAO.getByNameMockito.doReturn(null).when(userDAO).getIdByName(Mockito.anyString());//模擬依賴方法:idGenerator.nextLonguserId=1L;Mockito.doReturn(userId).when(idGenerator).next();
//調用被測方法Stringtext=ResourceHelper.getResourceAsString(getClass(),“userCreateVO.json”);UserVOuserCreate=JSON.parseObject(text,UserVO.class);Assert.assertEquals(“用戶標識不一致”,userId,userService.createUser(userCreate));
//驗證依賴方法//驗證依賴方法:userDAO.getByNameMockito.verify(userDAO).getIdByName(userCreate.getName());//驗證依賴方法:idGenerator.nextMockito.verify(idGenerator).next();//驗證依賴方法:userDAO.createArgumentCaptoruserCreateCaptor=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);}
/**測試:創建用戶-舊/@TestpublicvoidtestCreateUserWithOld(){//模擬依賴方法//模擬依賴方法:userDAO.getByNameLonguserId=1L;Mockito.doReturn(userId).when(userDAO).getIdByName(Mockito.anyString());
//調用被測方法Stringtext=ResourceHelper.getResourceAsString(getClass(),“userCreateVO.json”);UserVOuserCreate=JSON.parseObject(text,UserVO.class);Assert.assertEquals(“用戶標識不一致”,userId,userService.createUser(userCreate));
//驗證依賴方法//驗證依賴方法:userDAO.getByNameMockito.verify(userDAO).getIdByName(userCreate.getName());//驗證依賴方法:userDAO.modifyArgumentCaptoruserModifyCaptor=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);}
/**測試:創建用戶-異常/@TestpublicvoidtestCreateUserWithException(){//注入依賴對象Whitebox.setInternalState(userService,“canModify”,Boolean.FALSE);
//模擬依賴方法//模擬依賴方法:userDAO.getByNameLonguserId=1L;Mockito.doReturn(userId).when(userDAO).getIdByName(Mockito.anyString());
//調用被測方法Stringtext=ResourceHelper.getResourceAsString(getClass(),“userCreateVO.json”);UserVOuserCreate=JSON.parseObject(text,UserVO.class);UnsupportedOperationExceptionexception=Assert.assertThrows(“返回異常不一致”,UnsupportedOperationException.class,()->userService.createUser(userCreate));Assert.assertEquals(“異常消息不一致”,“不支持修改”,exception.getMessage());}}
userCreateVO.json
1
{“name”:“test”}
userCreateDO.json
1
{“id”:1,“name”:“test”}
userModifyDO.json
1
{“id”:1,“name”:“test”}
通過執行以上測試用例，可以看到對源代碼進行了100%的行覆蓋。
二測試用例編寫流程
通過上一章編寫Java類單元測試用例的實踐，可以總結出以下Java類單元測試用例的編寫流程：
單元測試用例編寫流程
上面一共有3個測試用例，這里僅以測試用例testCreateUserWithNew(測試：創建用戶-新)為例說明。
1定義對象階段
第1步是定義對象階段，主要包括定義被測對象、模擬依賴對象（類成員）、注入依賴對象（類成員）3大部分。
定義被測對象
在編寫單元測試時，首先需要定義被測對象，或直接初始化、或通過Spy包裝……其實，就是把被測試服務類進行實例化。
1
2
3
4
/*定義被測對象//*用戶服務/@InjectMocksprivateUserServiceuserService;
模擬依賴對象（類成員）
在一個服務類中，我們定義了一些類成員對象——服務（Service）、數據訪問對象（DAO）、參數（Value）等。在Spring框架中，這些類成員對象通過@Autowired、@Value等方式注入，它們可能涉及復雜的環境配置、依賴第三方接口服務……但是，在單元測試中，為了解除對這些類成員對象的依賴，我們需要對這些類成員對象進行模擬。
1
2
3
4
5
6
7
/*模擬依賴對象//*用戶DAO/@MockprivateUserDAOuserDAO;/*標識生成器/@MockprivateIdGeneratoridGenerator;
注入依賴對象（類成員）
當模擬完這些類成員對象后，我們需要把這些類成員對象注入到被測試類的實例中。以便在調用被測試方法時，可能使用這些類成員對象，而不至于拋出空指針異常。
1
2
3
4
5
6
7
8
9
10
11
12
/*定義被測對象//*用戶服務/@InjectMocksprivateUserServiceuserService;/**在測試之前/@BeforepublicvoidbeforeTest(){//注入依賴對象Whitebox.setInternalState(userService,“canModify”,Boolean.TRUE);}
2模擬方法階段
第2步是模擬方法階段，主要包括模擬依賴對象（參數或返回值）、模擬依賴方法2大部分。
模擬依賴對象（參數或返回值）
通常，在調用一個方法時，需要先指定方法的參數，然后獲取到方法的返回值。所以，在模擬方法之前，需要先模擬該方法的參數和返回值。
1
LonguserId=1L;
模擬依賴方法
在模擬完依賴的參數和返回值后，就可以利用Mockito和PowerMock的功能，進行依賴方法的模擬。如果依賴對象還有方法調用，還需要模擬這些依賴對象的方法。
1
2
3
4
5
//模擬依賴方法//模擬依賴方法:userDAO.getByNameMockito.doReturn(null).when(userDAO).getIdByName(Mockito.anyString());//模擬依賴方法:idGenerator.nextMockito.doReturn(userId).when(idGenerator).next();
3調用方法階段
第3步是調用方法階段，主要包括模擬依賴對象（參數）、調用被測方法、驗證參數對象（返回值）3步。
模擬依賴對象（參數）
在調用被測方法之前，需要模擬被測方法的參數。如果這些參數還有方法調用，還需要模擬這些參數的方法。
1
2
Stringtext=ResourceHelper.getResourceAsString(getClass(),“userCreateVO.json”);UserVOuserCreate=JSON.parseObject(text,UserVO.class);
調用被測方法
在準備好參數對象后，就可以調用被測試方法了。如果被測試方法有返回值，需要定義變量接收返回值；如果被測試方法要拋出異常，需要指定期望的異常。
1
userService.createUser(userCreate)
驗證數據對象（返回值）
在調用被測試方法后，如果被測試方法有返回值，需要驗證這個返回值是否符合預期；如果被測試方法要拋出異常，需要驗證這個異常是否滿足要求。
1
Assert.assertEquals(“用戶標識不一致”,userId,userService.createUser(userCreate));
4驗證方法階段
第4步是驗證方法階段，主要包括驗證依賴方法、驗證數據對象（參數）、驗證依賴對象3步。
驗證依賴方法
作為一個完整的測試用例，需要對每一個模擬的依賴方法調用進行驗證。
1
2
3
4
5
6
7
8
//驗證依賴方法//驗證依賴方法:userDAO.getByNameMockito.verify(userDAO).getIdByName(userCreate.getName());//驗證依賴方法:idGenerator.nextMockito.verify(idGenerator).next();//驗證依賴方法:userDAO.createArgumentCaptoruserCreateCaptor=ArgumentCaptor.forClass(UserDO.class);Mockito.verify(userDAO).create(userCreateCaptor.capture());
驗證數據對象（參數）
對應一些模擬的依賴方法，有些參數對象是被測試方法內部生成的。為了驗證代碼邏輯的正確性，就需要對這些參數對象進行驗證，看這些參數對象值是否符合預期。
1
2
text=ResourceHelper.getResourceAsString(getClass(),“userCreateDO.json”);Assert.assertEquals(“用戶創建不一致”,text,JSON.toJSONString(userCreateCaptor.getValue()));
驗證依賴對象
作為一個完整的測試用例，應該保證每一個模擬的依賴方法調用都進行了驗證。正好，Mockito提供了一套方法，用于驗證模擬對象所有方法調用都得到了驗證。
1
2
//驗證依賴對象Mockito.verifyNoMoreInteractions(idGenerator,userDAO);
三定義被測對象
在編寫單元測試時，首先需要定義被測對象，或直接初始化、或通過Spy包裝……其實，就是把被測試服務類進行實例化。
1直接構建對象
直接構建一個對象，總是簡單又直接。
1
UserServiceuserService=newUserService();
2利用Mockito.spy方法
Mockito提供一個spy功能，用于攔截那些尚未實現或不期望被真實調用的方法，默認所有方法都是真實方法，除非主動去模擬對應方法。所以，利用spy功能來定義被測對象，適合于需要模擬被測類自身方法的情況，適用于普通類、接口和虛基類。
1
2
3
UserServiceuserService=Mockito.spy(newUserService());UserServiceuserService=Mockito.spy(UserService.class);AbstractOssServiceossService=Mockito.spy(AbstractOssService.class);
3利用@Spy注解
@Spy注解跟Mockito.spy方法一樣，可以用來定義被測對象，適合于需要模擬被測類自身方法的情況，適用于普通類、接口和虛基類。@Spy注解需要配合@RunWith注解使用。
1
2
3
4
5
6
7
@RunWith(PowerMockRunner.class)publicclassCompanyServiceTest{@SpyprivateUserServiceuserService=newUserService();
…}
注意：@Spy注解對象需要初始化。如果是虛基類或接口，可以用Mockito.mock方法實例化。
4利用@InjectMocks注解
@InjectMocks注解用來創建一個實例，并將其它對象（@Mock、@Spy或直接定義的對象）注入到該實例中。所以，@InjectMocks注解本身就可以用來定義被測對象。@InjectMocks注解需要配合@RunWith注解使用。
1
2
3
4
5
6
7
@RunWith(PowerMockRunner.class)publicclassUserServiceTest{@InjectMocksprivateUserServiceuserService;…
}
四模擬依賴對象
在編寫單元測試用例時，需要模擬各種依賴對象——類成員、方法參數和方法返回值。
1直接構建對象
如果需要構建一個對象，最簡單直接的方法就是——定義對象并賦值。
1
2
3
4
5
6
LonguserId=1L;StringuserName=“admin”;UserDOuser=newUser();user.setId(userId);user.setName(userName);ListuserIdList=Arrays.asList(1L,2L,3L);
2反序列化對象
如果對象字段或層級非常龐大，采用直接構建對象方法，可能會編寫大量構建程序代碼。這種情況，可以考慮反序列化對象，將會大大減少程序代碼。由于JSON字符串可讀性高，這里就以JSON為例，介紹反序列化對象。
反序列化模型對象
1
2
Stringtext=ResourceHelper.getResourceAsString(getClass(),“user.json”);UserDOuser=JSON.parseObject(text,UserDO.class);
反序列化集合對象
1
2
Stringtext=ResourceHelper.getResourceAsString(getClass(),“userList.json”);ListuserList=JSON.parseArray(text,UserDO.class);
反序列化映射對象
1
2
Stringtext=ResourceHelper.getResourceAsString(getClass(),“userMap.json”);MapuserMap=JSON.parseObject(text,newTypeReference>(){});
3利用Mockito.mock方法
Mockito提供一個mock功能，用于攔截那些尚未實現或不期望被真實調用的方法，默認所有方法都已被模擬——方法為空并返回默認值（null或0），除非主動執行doCallRealMethod或thenCallRealMethod操作，才能夠調用真實的方法。
利用Mockito.mock方法模擬依賴對象，主要用于以下幾種情形：
1.只使用類實例，不使用類屬性；
2.類屬性太多，但使用其中少量屬性（可以mock屬性返回值）；
3.類是接口或虛基類，并不關心其具體實現類。
1
2
MockClassmockClass=Mockito.mock(MockClass.class);ListuserIdList=(List)Mockito.mock(List.class);
4利用@Mock注解
@Mock注解跟Mockito.mock方法一樣，可以用來模擬依賴對象，適用于普通類、接口和虛基類。@Mock注解需要配合@RunWith注解使用。
1
2
3
4
5
6
7
@RunWith(PowerMockRunner.class)publicclassUserServiceTest{@MockprivateUserDAOuserDAO;…
}
5利用Mockito.spy方法
Mockito.spy方法跟Mockito.mock方法功能相似，只是Mockito.spy方法默認所有方法都是真實方法，除非主動去模擬對應方法。
1
2
3
UserServiceuserService=Mockito.spy(newUserService());UserServiceuserService=Mockito.spy(UserService.class);AbstractOssServiceossService=Mockito.spy(AbstractOssService.class);
6利用@Spy注解
@Spy注解跟Mockito.spy方法一樣，可以用來模擬依賴對象，適用于普通類、接口和虛基類。@Spy注解需要配合@RunWith注解使用。
1
2
3
4
5
6
7
@RunWith(PowerMockRunner.class)publicclassCompanyServiceTest{@SpyprivateUserServiceuserService=newUserService();
…}
注意：@Spy注解對象需要初始化。如果是虛基類或接口，可以用Mockito.mock方法實例化。
五注入依賴對象
當模擬完這些類成員對象后，我們需要把這些類成員對象注入到被測試類的實例中。以便在調用被測試方法時，可能使用這些類成員對象，而不至于拋出空指針異常。
1利用Setter方法注入
如果類定義了Setter方法，可以直接調用方法設置字段值。
1
2
userService.setMaxCount(100);userService.setUserDAO(userDAO);
2利用ReflectionTestUtils.setField方法注入
JUnit提供ReflectionTestUtils.setField方法設置屬性字段值。
1
2
ReflectionTestUtils.setField(userService,“maxCount”,100);ReflectionTestUtils.setField(userService,“userDAO”,userDAO);
3利用Whitebox.setInternalState方法注入
PowerMock提供Whitebox.setInternalState方法設置屬性字段值。
1
2
Whitebox.setInternalState(userService,“maxCount”,100);Whitebox.setInternalState(userService,“userDAO”,userDAO);
4利用@InjectMocks注解注入
@InjectMocks注解用來創建一個實例，并將其它對象（@Mock、@Spy或直接定義的對象）注入到該實例中。@InjectMocks注解需要配合@RunWith注解使用。
1
2
3
4
5
6
7
8
9
10
@RunWith(PowerMockRunner.class)publicclassUserServiceTest{@MockprivateUserDAOuserDAO;privateBooleancanModify;
@InjectMocksprivateUserServiceuserService;…}
5設置靜態常量字段值
有時候，我們需要對靜態常量對象進行模擬，然后去驗證是否執行了對應分支下的方法。比如：需要模擬Lombok的@Slf4j生成的log靜態常量。但是，Whitebox.setInternalState方法和@InjectMocks注解并不支持設置靜態常量，需要自己實現一個設置靜態常量的方法：
1
2
3
4
5
6
7
publicfinalclassFieldHelper{publicstaticvoidsetStaticFinalField(Classclazz,StringfieldName,ObjectfieldValue)throwsNoSuchFieldException,IllegalAccessException{Fieldfield=clazz.getDeclaredField(fieldName);FieldUtils.removeFinalModifier(field);FieldUtils.writeStaticField(field,fieldValue,true);}}
具體使用方法如下：
1
FieldHelper.setStaticFinalField(UserService.class,“log”,log);
注意：經過測試，該方法對于int、Integer等基礎類型并不生效，應該是編譯器常量優化導致。
六模擬依賴方法
在模擬完依賴的參數和返回值后，就可以利用Mockito和PowerMock的功能，進行依賴方法的模擬。如果依賴對象還有方法調用，還需要模擬這些依賴對象的方法。
1根據返回模擬方法
模擬無返回值方法
1
Mockito.doNothing().when(userDAO).delete(userId);
模擬方法單個返回值
1
2
Mockito.doReturn(user).when(userDAO).get(userId);Mockito.when(userDAO.get(userId)).thenReturn(user);
模擬方法多個返回值
直接列舉出多個返回值：
1
2
Mockito.doReturn(record0,record1,record2,null).when(recordReader).read();Mockito.when(recordReader.read()).thenReturn(record0,record1,record2,null);
轉化列表為多個返回值：
1
2
3
ListrecordList=…;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());
模擬方法定制返回值
可利用Answer定制方法返回值：
1
2
3
4
5
6
7
MapuserMap=…;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)));
模擬方法拋出單個異常
指定單個異常類型：
1
2
Mockito.doThrow(PersistenceException.class).when(userDAO).get(Mockito.anyLong());Mockito.when(userDAO.get(Mockito.anyLong())).thenThrow(PersistenceException.class);
指定單個異常對象：
1
2
Mockito.doThrow(exception).when(userDAO).get(Mockito.anyLong());Mockito.when(userDAO.get(Mockito.anyLong())).thenThrow(exception);
模擬方法拋出多個異常
指定多個異常類型：
1
2
Mockito.doThrow(PersistenceException.class,RuntimeException.class).when(userDAO).get(Mockito.anyLong());Mockito.when(userDAO.get(Mockito.anyLong())).thenThrow(PersistenceException.class,RuntimeException.class);
指定多個異常對象：
1
2
Mockito.doThrow(exception1,exception2).when(userDAO).get(Mockito.anyLong());Mockito.when(userDAO.get(Mockito.anyLong())).thenThrow(exception1,exception2);
直接調用真實方法
1
2
Mockito.doCallRealMethod().when(userService).getUser(userId);Mockito.when(userService.getUser(userId)).thenCallRealMethod();
2根據參數模擬方法
Mockito提供do-when語句和when-then語句模擬方法。
模擬無參數方法
對于無參數的方法模擬：
1
2
Mockito.doReturn(deleteCount).when(userDAO).deleteAll();Mockito.when(userDAO.deleteAll()).thenReturn(deleteCount);
模擬指定參數方法
對于指定參數的方法模擬：
1
2
Mockito.doReturn(user).when(userDAO).get(userId);Mockito.when(userDAO.get(userId)).thenReturn(user);
模擬任意參數方法
在編寫單元測試用例時，有時候并不關心傳入參數的具體值，可以使用Mockito參數匹配器的any方法。Mockito提供了anyInt、anyLong、anyString、anyList、anySet、anyMap、any(Classclazz)等方法來表示任意值。
1
2
Mockito.doReturn(user).when(userDAO).get(Mockito.anyLong());Mockito.when(userDAO.get(Mockito.anyLong())).thenReturn(user);
模擬可空參數方法
Mockito參數匹配器的any具體方法，并不能夠匹配null對象。而Mockito提供一個nullable方法，可以匹配包含null對象的任意對象。此外，Mockito.any()方法也可以用來匹配可空參數。
1
2
3
4
Mockito.doReturn(user).when(userDAO).queryCompany(Mockito.anyLong(),Mockito.nullable(Long.class));Mockito.when(userDAO.queryCompany(Mockito.anyLong(),Mockito.any())).thenReturn(user);
模擬必空參數方法
同樣，如果要匹配null對象，可以使用isNull方法，或使用eq(null)。
1
2
Mockito.doReturn(user).when(userDAO).queryCompany(Mockito.anyLong(),Mockito.isNull());Mockito.when(userDAO.queryCompany(Mockito.anyLong(),Mockito.eq(null))).thenReturn(user);
模擬不同參數方法
Mockito支持按不同的參數分別模擬同一方法。
1
2
3
Mockito.doReturn(user1).when(userDAO).get(1L);Mockito.doReturn(user2).when(userDAO).get(2L);…
注意：如果一個參數滿足多個模擬方法條件，會以最后一個模擬方法為準。
模擬可變參數方法
對于一些變長度參數方法，可以按實際參數個數進行模擬：
1
2
Mockito.when(userService.delete(Mockito.anyLong()).thenReturn(true);Mockito.when(userService.delete(1L,2L,3L).thenReturn(true);
也可以用Mockito.any()模擬一個通用匹配方法：
1
Mockito.when(userService.delete(Mockito.any()).thenReturn(true);
注意：Mockito.any()并不等于Mockito.any(Classtype),前者可以匹配null和類型T的可變參數，后者只能匹配T必填參數。
3模擬其它特殊方法
模擬final方法
PowerMock提供對final方法的模擬，方法跟模擬普通方法一樣。但是，需要把對應的模擬類添加到@PrepareForTest注解中。
1
2
3
4
5
6
//添加@PrepareForTest注解@PrepareForTest({UserService.class})
//跟模擬普通方法完全一致Mockito.doReturn(userId).when(idGenerator).next();Mockito.when(idGenerator.next()).thenReturn(userId);
模擬私有方法
PowerMock提供提對私有方法的模擬，但是需要把私有方法所在的類放在@PrepareForTest注解中。
1
2
PowerMockito.doReturn(true).when(UserService.class,“isSuper”,userId);PowerMockito.when(UserService.class,“isSuper”,userId).thenReturn(true);
模擬構造方法
PowerMock提供PowerMockito.whenNew方法來模擬構造方法，但是需要把使用構造方法的類放在@PrepareForTest注解中。
1
2
PowerMockito.whenNew(UserDO.class).withNoArguments().thenReturn(userDO);PowerMockito.whenNew(UserDO.class).withArguments(userId,userName).thenReturn(userDO);
模擬靜態方法
PowerMock提供PowerMockito.mockStatic和PowerMockito.spy來模擬靜態方法類，然后就可以模擬靜態方法了。同樣，需要把對應的模擬類添加到@PrepareForTest注解中。
1
2
3
4
5
6
7
8
//模擬對應的類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模擬的靜態方法類。
七調用被測方法
在準備好參數對象后，就可以調用被測試方法了。
如果把方法按訪問權限分類，可以簡單地分為有訪問權限和無訪問權限兩種。但實際上，Java語言中提供了public、protected、private和缺失共4種權限修飾符，在不同的環境下又對應不同的訪問權限。具體映射關系如下：
修飾符本類本包子類其它
public有有有有
protected有有有無
缺省有有無無
private有無無無
下面，將根據有訪問權限和無訪問權限兩種情況，來介紹如何調用被測方法。
1調用構造方法
調用有訪問權限的構造方法
可以直接調用有訪問權限的構造方法。
1
2
UserDOuser=newUser();UserDOuser=newUser(1L,“admin”);
調用無訪問權限的構造方法
調用無訪問權限的構造方法，可以使用PowerMock提供的Whitebox.invokeConstructor方法。
1
2
Whitebox.invokeConstructor(NumberHelper.class);Whitebox.invokeConstructor(User.class,1L,“admin”);
備注：該方法也可以調用有訪問權限的構造方法，但是不建議使用。
2調用普通方法
調用有訪問權限的普通方法
可以直接調用有訪問權限的普通方法。
1
2
userService.deleteUser(userId);Useruser=userService.getUser(userId);
調用無權限訪問的普通方法
調用無訪問權限的普通方法，可以使用PowerMock提供的Whitebox.invokeMethod方法。
1
Useruser=(User)Whitebox.invokeMethod(userService,“isSuper”,userId);
也可以使用PowerMock提供Whitebox.getMethod方法和PowerMockito.method方法，可以直接獲取對應類方法對象。然后，通過Method的invoke方法，可以調用沒有訪問權限的方法。
1
2
3
Methodmethod=Whitebox.getMethod(UserService.class,“isSuper”,Long.class);Methodmethod=PowerMockito.method(UserService.class,“isSuper”,Long.class);Useruser=(User)method.invoke(userService,userId);
備注：該方法也可以調用有訪問權限的普通方法，但是不建議使用。
3調用靜態方法
調用有權限訪問的靜態方法
可以直接調用有訪問權限的靜態方法。
1
booleanisPositive=NumberHelper.isPositive(-1);
調用無權限訪問的靜態方法
調用無權限訪問的靜態方法，可以使用PowerMock提供的Whitebox.invokeMethod方法。
1
Stringvalue=(String)Whitebox.invokeMethod(JSON.class,“toJSONString”,object);
備注：該方法也可以調用有訪問權限的靜態方法，但是不建議使用。
八驗證依賴方法
在單元測試中，驗證是確認模擬的依賴方法是否按照預期被調用或未調用的過程。
Mockito提供了許多方法來驗證依賴方法調用，給我們編寫單元測試用例帶來了很大的幫助。
1根據參數驗證方法調用
驗證無參數方法調用
1
Mockito.verify(userDAO).deleteAll();
驗證指定參數方法調用
1
2
Mockito.verify(userDAO).delete(userId);Mockito.verify(userDAO).delete(Mockito.eq(userId));
驗證任意參數方法調用
1
Mockito.verify(userDAO).delete(Mockito.anyLong());
驗證可空參數方法調用
1
Mockito.verify(userDAO).queryCompany(Mockito.anyLong(),Mockito.nullable(Long.class));
驗證必空參數方法調用
1
Mockito.verify(userDAO).queryCompany(Mockito.anyLong(),Mockito.isNull());
驗證可變參數方法調用
對于一些變長度參數方法，可以按實際參數個數進行驗證：
1
2
Mockito.verify(userService).delete(Mockito.any(Long.class));Mockito.verify(userService).delete(1L,2L,3L);
也可以用Mockito.any()進行通用驗證：
1
Mockito.verify(userService).delete(Mockito.any());
2驗證方法調用次數
驗證方法默認調用1次
1
Mockito.verify(userDAO).delete(userId);
驗證方法從不調用
1
Mockito.verify(userDAO,Mockito.never()).delete(userId);
驗證方法調用n次
1
Mockito.verify(userDAO,Mockito.times(n)).delete(userId);
驗證方法調用至少1次
1
Mockito.verify(userDAO,Mockito.atLeastOnce()).delete(userId);
驗證方法調用至少n次
1
Mockito.verify(userDAO,Mockito.atLeast(n)).delete(userId);
驗證方法調用最多1次
1
Mockito.verify(userDAO,Mockito.atMostOnce()).delete(userId);
驗證方法調用最多n次
1
Mockito.verify(userDAO,Mockito.atMost(n)).delete(userId);
驗證方法調用指定n次
Mockito允許按順序進行驗證方法調用，未被驗證到的方法調用將不會被標記為已驗證。
1
Mockito.verify(userDAO,Mockito.call(n)).delete(userId);
驗證對象及其方法調用1次
用于驗證對象及其方法調用1次，如果該對象還有別的方法被調用或者該方法調用了多次，都將導致驗證方法調用失敗。
1
Mockito.verify(userDAO,Mockito.only()).delete(userId);
相當于：
1
2
Mockito.verify(userDAO).delete(userId);Mockito.verifyNoMoreInteractions(userDAO);
3驗證方法調用并捕獲參數值
Mockito提供ArgumentCaptor類來捕獲參數值，通過調用forClass(Classclazz)方法來構建一個ArgumentCaptor對象，然后在驗證方法調用時來捕獲參數，最后獲取到捕獲的參數值并驗證。如果一個方法有多個參數都要捕獲并驗證，那就需要創建多個ArgumentCaptor對象。
ArgumentCaptor的主要接口方法：
1.capture方法，用于捕獲方法參數；
2.getValue方法，用于獲取捕獲的參數值，如果捕獲了多個參數值，該方法只返回最后一個參數值；
3.getAllValues方法，用戶獲取捕獲的所有參數值。
使用ArgumentCaptor.forClass方法定義參數捕獲器
在測試用例方法中，直接使用ArgumentCaptor.forClass方法定義參數捕獲器。
1
2
3
ArgumentCaptoruserCaptor=ArgumentCaptor.forClass(UserDO.class);Mockito.verify(userDAO).modify(userCaptor.capture());UserDOuser=userCaptor.getValue();
注意：定義泛型類的參數捕獲器時，存在強制類型轉換，會引起編譯器警告。
使用@Captor注解定義參數捕獲器
也可以用Mockito提供的@Captor注解，在測試用例類中定義參數捕獲器。

@RunWith(PowerMockRunner.class)publicclassUserServiceTest{@CaptorprivateArgumentCaptoruserCaptor;@TestpublicvoidtestModifyUser(){…Mockito.verify(userDAO).modify(userCaptor.capture());UserDOuser=userCaptor.getValue();}}
注意：定義泛型類的參數捕獲器時，由于是Mockito自行初始化，不會引起編譯器警告。
捕獲多次方法調用的參數值列表
1
2
3
ArgumentCaptoruserCaptor=ArgumentCaptor.forClass(UserDO.class);Mockito.verify(userDAO,Mockito.atLeastOnce()).modify(userCaptor.capture());ListuserList=userCaptor.getAllValues();
4驗證其它特殊方法
驗證final方法調用
final方法的驗證跟普通方法類似，這里不再累述。
驗證私有方法調用
PowerMockito提供verifyPrivate方法驗證私有方法調用。
1
PowerMockito.verifyPrivate(myClass,times(1)).invoke(“unload”,any(List.class));
驗證構造方法調用
PowerMockito提供verifyNew方法驗證構造方法調用。
1
2
PowerMockito.verifyNew(MockClass.class).withNoArguments();PowerMockito.verifyNew(MockClass.class).withArguments(someArgs);
驗證靜態方法調用
PowerMockito提供verifyStatic方法驗證靜態方法調用。
1
2
PowerMockito.verifyStatic(StringUtils.class);StringUtils.isEmpty(string);
九驗證數據對象
JUnit測試框架中Assert類就是斷言工具類，主要驗證單元測試中實際數據對象與期望數據對象一致。在調用被測方法時，需要對返回值和異常進行驗證；在驗證方法調用時，也需要對捕獲的參數值進行驗證。
1驗證數據對象空值
驗證數據對象為空
通過JUnit提供的Assert.assertNull方法驗證數據對象為空。
1
Assert.assertNull(“用戶標識必須為空”,userId);
驗證數據對象非空
通過JUnit提供的Assert.assertNotNull方法驗證數據對象非空。
1
Assert.assertNotNull(“用戶標識不能為空”,userId);
2驗證數據對象布爾值
驗證數據對象為真
通過JUnit提供的Assert.assertTrue方法驗證數據對象為真。
1
Assert.assertTrue(“返回值必須為真”,NumberHelper.isPositive(1));
驗證數據對象為假
通過JUnit提供的Assert.assertFalse方法驗證數據對象為假。
1
Assert.assertFalse(“返回值必須為假”,NumberHelper.isPositive(-1));
3驗證數據對象引用
在單元測試用例中，對于一些參數或返回值對象，不需要驗證對象具體取值，只需要驗證對象引用是否一致。
驗證數據對象一致
JUnit提供的Assert.assertSame方法驗證數據對象一致。

UserDOexpectedUser=…;Mockito.doReturn(expectedUser).when(userDAO).get(userId);UserDOactualUser=userService.getUser(userId);Assert.assertSame(“用戶必須一致”,expectedUser,actualUser);
驗證數據對象不一致
JUnit提供的Assert.assertNotSame方法驗證數據對象一致。

UserDOexpectedUser=…;Mockito.doReturn(expectedUser).when(userDAO).get(userId);UserDOactualUser=userService.getUser(otherUserId);Assert.assertNotSame(“用戶不能一致”,expectedUser,actualUser);
4驗證數據對象值
JUnit提供Assert.assertEquals、Assert.assertNotEquals、Assert.assertArrayEquals方法組，可以用來驗證數據對象值是否相等。
驗證簡單數據對象
對于簡單數據對象（比如：基礎類型、包裝類型、實現了equals的數據類型……），可以直接通過JUnit的Assert.assertEquals和Assert.assertNotEquals方法組進行驗證。
1
2
Assert.assertNotEquals(“用戶名稱不一致”,“admin”,userName);Assert.assertEquals(“賬戶金額不一致”,10000.0D,accountAmount,1E-6D);
驗證簡單數組或集合對象
對于簡單數組對象（比如：基礎類型、包裝類型、實現了equals的數據類型……），可以直接通過JUnit的Assert.assertArrayEquals方法組進行驗證。對于簡單集合對象，也可以通過Assert.assertEquals方法驗證。

Long[]userIds=…;Assert.assertArrayEquals(“用戶標識列表不一致”,newLong[]{1L,2L,3L},userIds);
ListuserIdList=…;Assert.assertEquals(“用戶標識列表不一致”,Arrays.asList(1L,2L,3L),userIdList);
驗證復雜數據對象
對于復雜的JavaBean數據對象，需要驗證JavaBean數據對象的每一個屬性字段。

UserDOuser=…;Assert.assertEquals(“用戶標識不一致”,Long.valueOf(1L),user.getId());Assert.assertEquals(“用戶名稱不一致”,“admin”,user.getName());Assert.assertEquals(“用戶公司標識不一致”,Long.valueOf(1L),user.getCompany().getId());…
驗證復雜數組或集合對象
對于復雜的JavaBean數組和集合對象，需要先展開數組和集合對象中每一個JavaBean數據對象，然后驗證JavaBean數據對象的每一個屬性字段。

ListexpectedUserList=…;ListactualUserList=…;Assert.assertEquals(“用戶列表長度不一致”,expectedUserList.size(),actualUserList.size());UserDO[]expectedUsers=expectedUserList.toArray(newUserDO[0]);UserDO[]actualUsers=actualUserList.toArray(newUserDO[0]);for(inti=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());…}
通過序列化驗證數據對象
如上一節例子所示，當數據對象過于復雜時，如果采用Assert.assertEquals依次驗證每個JavaBean對象、驗證每一個屬性字段，測試用例的代碼量將會非常龐大。這里，推薦使用序列化手段簡化數據對象的驗證，比如利用JSON.toJSONString方法把復雜的數據對象轉化為字符串，然后再使用Assert.assertEquals方法進行驗證字符串。但是，序列化值必須具備有序性、一致性和可讀性。
1
2
3
ListuserList=…;Stringtext=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=…;Stringtext=ResourceHelper.getResourceAsString(getClass(),“userMap.json”);Assert.assertEquals(“用戶映射不一致”,text,JSON.toJSONString(userMap,SerializerFeature.MapSortField));
驗證數據對象私有屬性字段
有時候，單元測試用例需要對復雜對象的私有屬性字段進行驗證。而PowerMockito提供的Whitebox.getInternalState方法，獲取輕松地獲取到私有屬性字段值。
1
2
MapperScannerConfigurerconfigurer=myBatisConfiguration.buildMapperScannerConfigurer();Assert.assertEquals(“基礎包不一致”,“com.alibaba.example”,Whitebox.getInternalState(configurer,“basePackage”));
5驗證異常對象內容
異常作為Java語言的重要特性，是Java語言健壯性的重要體現。捕獲并驗證異常數據內容，也是測試用例的一種。
通過@Test注解驗證異常對象
JUnit的注解@Test提供了一個expected屬性，可以指定一個期望的異常類型，用來捕獲并驗證異常。但是，這種方式只能驗證異常類型，并不能驗證異常原因和消息。

@Test(expected=ExampleException.class)publicvoidtestGetUser(){//模擬依賴方法Mockito.doReturn(null).when(userDAO).get(userId);
//調用被測方法userService.getUser(userId);}
通過@Rule注解驗證異常對象
如果想要驗證異常原因和消息，就需求采用@Rule注解定義ExpectedException對象，然后在測試方法的前面聲明要捕獲的異常類型、原因和消息。

@RuleprivateExpectedExceptionexception=ExpectedException.none();@TestpublicvoidtestGetUser(){//模擬依賴方法LonguserId=123L;Mockito.doReturn(null).when(userDAO).get(userId);//調用被測方法exception.expect(ExampleException.class);exception.expectMessage(String.format(“用戶(%s)不存在”,userId));userService.getUser(userId);}
通過Assert.assertThrows驗證異常對象
在最新版的JUnit中，提供了一個更為簡潔的異常驗證方式——Assert.assertThrows方法。

@TestpublicvoidtestGetUser(){//模擬依賴方法LonguserId=123L;Mockito.doReturn(null).when(userDAO).get(userId);//調用被測方法ExampleExceptionexception=Assert.assertThrows(“異常類型不一致”,ExampleException.class,()->userService.getUser(userId));Assert.assertEquals(“異常消息不一致”,“處理異常”,exception.getMessage());}
十驗證依賴對象
1驗證模擬對象沒有任何方法調用
Mockito提供了verifyNoInteractions方法，可以驗證模擬對象在被測試方法中沒有任何調用。
1
Mockito.verifyNoInteractions(idGenerator,userDAO);
2驗證模擬對象沒有更多方法調用
Mockito提供了verifyNoMoreInteractions方法，在驗證模擬對象所有方法調用后使用，可以驗證模擬對象所有方法調用是否都得到驗證。如果模擬對象存在任何未驗證的方法調用，就會拋出NoInteractionsWanted異常。
1
Mockito.verifyNoMoreInteractions(idGenerator,userDAO);
備注：Mockito的verifyZeroInteractions方法與verifyNoMoreInteractions方法功能相同，但是目前前者已經被廢棄。
3清除模擬對象所有方法調用標記
在編寫單元測試用例時，為了減少單元測試用例數和代碼量，可以把多組參數定義在同一個單元測試用例中，然后用for循環依次執行每一組參數的被測方法調用。為了避免上一次測試的方法調用影響下一次測試的方法調用驗證，最好使用Mockito提供clearInvocations方法清除上一次的方法調用。

//清除所有對象調用Mockito.clearInvocations();//清除指定對象調用Mockito.clearInvocations(idGenerator,userDAO);
十一典型案例及解決方案
這里，只收集了幾個經典案例，解決了特定環境下的特定問題。
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的類加載器加載，需要采用系統類加載器來加載。
?……
對于這些問題，可以根據提示信息查閱相關資料解決，這里就不再累述了。
2捕獲參數值已變更問題
在編寫單元測試用例時，通常采用ArgumentCaptor進行參數捕獲，然后對參數對象值進行驗證。如果參數對象值沒有變更，這個步驟就沒有任何問題。但是，如果參數對象值在后續流程中發生變更，就會導致驗證參數值失敗。

publicvoidreadData(RecordReaderrecordReader,intbatchSize,Function<Record,T>dataParser,Predicate<List>dataStorage){try{//依次讀取數據Recordrecord;booleanisContinue=true;ListdataList=newArrayList<>(batchSize);while(Objects.nonNull(record=recordReader.read())&&isContinue){//解析添加數據Tdata=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(IOExceptione){Stringmessage=READ_DATA_EXCEPTION;log.warn(message,e);thrownewExampleException(message,e);}}
測試用例

@TestpublicvoidtestReadData()throwsException{//模擬依賴方法//模擬依賴方法:recordReader.readRecordrecord0=Mockito.mock(Record.class);Recordrecord1=Mockito.mock(Record.class);Recordrecord2=Mockito.mock(Record.class);TunnelRecordReaderrecordReader=Mockito.mock(TunnelRecordReader.class);Mockito.doReturn(record0,record1,record2,null).when(recordReader).read();//模擬依賴方法:dataParser.applyObjectobject0=newObject();Objectobject1=newObject();Objectobject2=newObject();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>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>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());}
問題現象
執行單元測試用例失敗，拋出以下異常信息：
1
java.lang.AssertionError:數據列表不一致expected:<[[java.lang.Object@1e3469df,java.lang.Object@79499fa],[java.lang.Object@48531d5]]>butwas:<[[],[]]>
問題原因
由于參數dataList在調用dataStorage.test方法后，都被主動調用dataList.clear方法進行清空。由于ArgumentCaptor捕獲的是對象引用，所以最后捕獲到了同一個空列表。
解決方案
可以在模擬依賴方法dataStorage.test時，保存傳入參數的當前值進行驗證。代碼如下：

@TestpublicvoidtestReadData()throwsException{//模擬依賴方法…//模擬依賴方法:dataStorage.testListdataList=newArrayList<>();Predicate<List>dataStorage=Mockito.mock(Predicate.class);Mockito.doAnswer(invocation->dataList.addAll((List)invocation.getArgument(0))).when(dataStorage).test(Mockito.anyList());//調用測試方法odpsService.readData(recordReader,2,dataParser,dataStorage);//驗證依賴方法…//驗證依賴方法:dataStorage.testMockito.verify(dataStorage,Mockito.times(2)).test(Mockito.anyList());Assert.assertEquals(“數據列表不一致”,Arrays.asList(object0,object1,object2),dataList);}
3模擬Lombok的log對象問題
Lombok的@Slf4j注解，廣泛地應用于Java項目中。在某些代碼分支里，可能只有log記錄日志的操作，為了驗證這個分支邏輯被正確執行，需要在單元測試用例中對log記錄日志的操作進行驗證。
原始方法

@Slf4j@ServicepublicclassExampleService{publicvoidrecordLog(intcode){if(code1){log.info(“執行分支1”);return;}if(code2){log.info(“執行分支2”);return;}log.info(“執行默認分支”);}…}
測試用例

@RunWith(PowerMockRunner.class)publicclassExampleServiceTest{@MockprivateLoggerlog;@InjectMocksprivateExampleServiceexampleService;@TestpublicvoidtestRecordLog1(){exampleService.recordLog(1);Mockito.verify(log).info(“執行分支1”);}}
問題現象
執行單元測試用例失敗，拋出以下異常信息：
1
2
Wantedbutnotinvoked:logger.info(“執行分支1”);
原因分析
經過調式跟蹤，發現ExampleService中的log對象并沒有被注入。通過編譯發現，Lombok的@Slf4j注解在ExampleService類中生成了一個靜態常量log，而@InjectMocks注解并不支持靜態常量的注入。
解決方案
采用作者實現的FieldHelper.setStaticFinalField方法，可以實現對靜態常量的注入模擬對象。

@RunWith(PowerMockRunner.class)publicclassExampleServiceTest{@MockprivateLoggerlog;@InjectMocksprivateExampleServiceexampleService;@BeforepublicvoidbeforeTest()throwsException{FieldHelper.setStaticFinalField(ExampleService.class,“log”,log);}@TestpublicvoidtestRecordLog1(){exampleService.recordLog(1);Mockito.verify(log).info(“執行分支1”);}}
4兼容Pandora等容器問題
阿里巴巴的很多中間件，都是基于Pandora容器的，在編寫單元測試用例時，可能會遇到一些坑。
原始方法

@Slf4jpublicclassMetaqMessageSender{@AutowiredprivateMetaProducermetaProducer;publicStringsendMetaqMessage(StringtopicName,StringtagName,StringmessageKey,StringmessageBody){try{//組裝消息內容Messagemessage=newMessage();message.setTopic(topicName);message.setTags(tagName);message.setKeys(messageKey);message.setBody(messageBody.getBytes(StandardCharsets.UTF_8));//發送消息請求SendResultsendResult=metaProducer.send(message);if(sendResult.getSendStatus()!=SendStatus.SEND_OK){Stringmsg=String.format(“發送標簽(%s)消息(%s)狀態錯誤(%s)”,tagName,messageKey,sendResult.getSendStatus());log.warn(msg);thrownewReconsException(msg);}log.info(String.format(“發送標簽(%s)消息(%s)狀態成功:%s”,tagName,messageKey,sendResult.getMsgId()));//返回消息標識returnsendResult.getMsgId();}catch(MQClientException|RemotingException|MQBrokerException|InterruptedExceptione){//記錄消息異常Thread.currentThread().interrupt();Stringmessage=String.format(“發送標簽(%s)消息(%s)狀態異常:%s”,tagName,messageKey,e.getMessage());log.warn(message,e);thrownewReconsException(message,e);}}}
測試用例

@RunWith(PowerMockRunner.class)publicclassMetaqMessageSenderTest{@MockprivateMetaProducermetaProducer;@InjectMocksprivateMetaqMessageSendermetaqMessageSender;@TestpublicvoidtestSendMetaqMessage()throwsException{//模擬依賴方法SendResultsendResult=newSendResult();sendResult.setMsgId(“msgId”);sendResult.setSendStatus(SendStatus.SEND_OK);Mockito.doReturn(sendResult).when(metaProducer).send(Mockito.any(Message.class));
//調用測試方法StringtopicName=“topicName”;StringtagName=“tagName”;StringmessageKey=“messageKey”;StringmessageBody=“messageBody”;StringmessageId=metaqMessageSender.sendMetaqMessage(topicName,tagName,messageKey,messageBody);Assert.assertEquals(“messageId不一致”,sendResult.getMsgId(),messageId);
//驗證依賴方法ArgumentCaptormessageCaptor=ArgumentCaptor.forClass(Message.class);Mockito.verify(metaProducer).send(messageCaptor.capture());Messagemessage=messageCaptor.getValue();Assert.assertEquals(“topicName不一致”,topicName,message.getTopic());Assert.assertEquals(“tagName不一致”,tagName,message.getTags());Assert.assertEquals(“messageKey不一致”,messageKey,message.getKeys());Assert.assertEquals(“messageBody不一致”,messageBody,newString(message.getBody()));}}
問題現象
執行單元測試用例失敗，拋出以下異常信息：
1
java.lang.RuntimeException:com.alibaba.rocketmq.client.producer.SendResultwasloadedbyorg.powermock.core.classloader.javassist.JavassistMockClassLoader@5d43661b,itshouldbeloadedbyPandoraContainer.Cannotloadthisfakesdkclass.
原因分析
基于Pandora容器的中間件，需要使用Pandora容器加載。在上面測試用例中，使用了PowerMock容器加載，從而導致拋出類加載異常。
解決方案
首先，把PowerMockRunner替換為PandoraBootRunner。其次，為了使@Mock、@InjectMocks等Mockito注解生效，需要調用MockitoAnnotations.initMocks(this)方法進行初始化。

@RunWith(PandoraBootRunner.class)publicclassMetaqMessageSenderTest{…@BeforepublicvoidbeforeTest(){MockitoAnnotations.initMocks(this);}…}
十二消除類型轉換警告
在編寫測試用例時，特別是泛型類型轉換時，很容易產生類型轉換警告。常見類型轉換警告如下：

Typesafety:UncheckedcastfromObjecttoListTypesafety:UncheckedinvocationforClass(Class)ofthegenericmethodforClass(Class)oftypeArgumentCaptorTypesafety:TheexpressionoftypeArgumentCaptorneedsuncheckedconversiontoconformtoArgumentCaptor<Map<String,Object>>
作為一個有代碼潔癖的輕微強迫癥程序員，是絕對不容許這些類型轉換警告產生的。于是，總結了以下方法來解決這些類型轉換警告。
1利用注解初始化
Mockito提供@Mock注解來模擬類實例，提供@Captor注解來初始化參數捕獲器。由于這些注解實例是通過測試框架進行初始化的，所以不會產生類型轉換警告。
問題代碼

Map<Long,String>resultMap=Mockito.mock(Map.class);ArgumentCaptor<Map<String,Object>>parameterMapCaptor=ArgumentCaptor.forClass(Map.class);
建議代碼

@MockprivateMap<Long,String>resultMap;@CaptorprivateArgumentCaptor<Map<String,Object>>parameterMapCaptor; cfda
2利用臨時類或接口
我們無法獲取泛型類或接口的class實例，但是很容易獲取具體類的class實例。這個解決方案的思路是——先定義繼承泛型類的具體子類，然后mock、spy、forClass以及any出這個具體子類的實例，然后把具體子類實例轉換為父類泛型實例。
問題代碼

Function<Record,Object>dataParser=Mockito.mock(Function.class);AbstractDynamicValue<Long,Integer>dynamicValue=Mockito.spy(AbstractDynamicValue.class);ArgumentCaptor<ActionRequest>requestCaptor=ArgumentCaptor.forClass(ActionRequest.class);
建議代碼

/*定義臨時類或接口/privateinterfaceDataParserextendsFunction<Record,Object>{};privatestaticabstractclassAbstractTemporaryDynamicValueextendsAbstractDynamicValue<Long,Integer>{};privatestaticclassVoidActionRequestextendsActionRequest{};
/*使用臨時類或接口/Function<Record,Object>dataParser=Mockito.mock(DataParser.class);AbstractDynamicValue<Long,Integer>dynamicValue=Mockito.spy(AbstractTemporaryDynamicValue.class);ArgumentCaptor<ActionRequest>requestCaptor=ArgumentCaptor.forClass(VoidActionRequest.class);
3利用CastUtils.cast方法
SpringData包中提供一個CastUtils.cast方法，可以用于類型的強制轉換。這個解決方案的思路是——利用CastUtils.cast方法屏蔽類型轉換警告。
問題代碼

Function<Record,Object>dataParser=Mockito.mock(Function.class);ArgumentCaptor<ActionRequest>requestCaptor=ArgumentCaptor.forClass(ActionRequest.class);Map<Long,Double>scoreMap=(Map<Long,Double>)method.invoke(userService);
建議代碼

Function<Record,Object>dataParser=CastUtils.cast(Mockito.mock(Function.class));ArgumentCaptor<ActionRequest>requestCaptor=CastUtils.cast(ArgumentCaptor.forClass(ActionRequest.class));Map<Long,Double>scoreMap=CastUtils.cast(method.invoke(userService));
這個解決方案，不需要定義注解，也不需要定義臨時類或接口，能夠讓測試用例代碼更為精簡，所以作者重點推薦使用。如果不愿意引入SpringData包，也可以自己參考實現該方法，只是該方法會產生類型轉換警告。
注意：CastUtils.cast方法本質是——先轉換為Object類型，再強制轉換對應類型，本身不會對類型進行校驗。所以，CastUtils.cast方法好用，但是不要亂用，否則就是大坑（只有執行時才能發現問題）。
4利用類型自動轉換方法
在Mockito中，提供形式如下的方法——泛型類型只跟返回值有關，而跟輸入參數無關。這樣的方法，可以根據調用方法的參數類型自動轉換，而無需手動強制類型轉換。如果手動強制類型轉換，反而會產生類型轉換警告。

TgetArgument(intindex);publicstaticTany(www.szhtw.com.cn/xingyezixun.html);publicstaticsynchronizedTinvokeMethod(Objectinstance,StringmethodToExecute,Object…arguments)throwsException;
問題代碼
1
2
3
4
Mockito.doAnswer(invocation->dataList.addAll((List)invocation.getArgument(0))).when(dataStorage).test(Mockito.anyList());Mockito.doThrow(e).when(workflow).beginToPrepare((ActionRequest)Mockito.any());Map<Long,Double>scoreMap=(Map<Long,Double>)Whitebox.invokeMethod(userService,“getScoreMap”);
建議代碼

Mockito.doAnswer(invocation->dataList.addAll(invocation.getArgument(0))).when(dataStorage).test(Mockito.anyList());Mockito.doThrow(e).when(workflow).beginToPrepare(Mockito.any());Map<Long,Double>scoreMap=Whitebox.invokeMethod(userService,“getScoreMap”);
其實，SpringData的CastUtils.cast方法之所以這么強悍，也是采用了類型自動轉化方法。
5利用doReturn-when語句代替when-thenReturn語句
Mockito的when-thenReturn語句需要對返回類型強制校驗，而doReturn-when語句不會對返回類型強制校驗。利用這個特性，可以利用doReturn-when語句代替when-thenReturn語句解決類型轉換警告。
問題代碼

ListvalueList=Mockito.mock(List.class);Mockito.when(listOperations.range(KEY,start,end)).thenReturn(valueList);
建議代碼

List<?>valueList=Mockito.mock(List.class);Mockito.doReturn(valueList).when(listOperations).range(KEY,start,end);
6利用Whitebox.invokeMethod方法代替Method.invoke方法
JDK提供的Method.invoke方法返回的是Object類型，轉化為具體類型時需要強制轉換，會產生類型轉換警告。而PowerMock提供的Whitebox.invokeMethod方法返回類型可以自動轉化，不會產生類型轉換警告
問題代碼

Methodmethod=PowerMockito.method(UserService.class,“getScoreMap”);Map<Long,Double>scoreMap=(Map<Long,Double>)method.invokeMethod(userService);
建議代碼
1
Map<Long,Double>scoreMap=Whitebox.invokeMethod(userService,“getScoreMap”);
7利用instanceof關鍵字
在具體類型強制轉換時，建議利用instanceof關鍵字先判斷類型，否則會產生類型轉換警告。
問題代碼

JSONArrayjsonArray=(JSONArray)object;…
建議代碼

if(objectinstanceofJSONArray){JSONArrayjsonArray=(JSONArray)object;…}
8利用Class.cast方法
在泛型類型強制轉換時，會產生類型轉換警告。可以采用泛型類的cast方法轉換，從而避免產生類型轉換警告。
問題代碼

publicstaticVparseValue(Stringtext,Classclazz){if(Objects.equals(clazz,String.class)){return(V)text;}returnJSON.parseObject(text,clazz);}
建議代碼

publicstaticVparseValue(Stringtext,Classclazz){if(Objects.equals(clazz,String.class)){returnclazz.cast(text);}returnJSON.parseObject(text,clazz);}
9避免不必要的類型轉換
有時候，沒有必要進行類型轉換，就盡量避免類型轉換。比如：把Object類型轉換為具體類型，但又把具體類型當Object類型使用，就沒有必要進行類型轉換。像這種情況，可以合并表達式或定義基類變量，從而避免不必要的類型轉化。
問題代碼

BooleanisSupper=(Boolean)method.invokeMethod(userService,userId);Assert.assertEquals(“期望值不為真”,Boolean.TRUE,isSupper);
ListuserList=(Map<Long,Double>)method.invokeMethod(userService,companyId);Assert.assertEquals(“期望值不一致”,expectedJson,JSON.toJSONString(userList));
建議代碼

Assert.assertEquals(“期望值不為真”,Boolean.TRUE,method.invokeMethod(userService,userId));
ObjectuserList=method.invokeMethod(userService,companyId);Assert.assertEquals(“期望值不一致”,expectedJson,JSON.toJSONString(userList));
后記
登妙峰山記
山高路遠車難騎，
精疲力盡人易棄。
多少妙峰登頂者，
又練心境又練力！
騎行的人，一定要沉得住氣、要吃得了苦、要耐得住寂寞、要意志堅定不移、要體力夠猛夠持久……恰好，這也正是技術人所要具備的精神。只要技術人做到了這些，練就了好的“心境”和“體力”，才有可能登上技術的“妙峰山”。

總結

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

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