Mockito是一個流行的Java模擬框架，用于編寫單元測試代碼時模擬（mock）和測試樁（stub）對象的行為。可輕松模擬Java類和接口的行為，幫助測試人員和開發(fā)人員更好地設(shè)計和執(zhí)行單元測試。

使用Mockito，開發(fā)人員可以模擬一個對象，使其表現(xiàn)出某些預(yù)期的行為，而無需使用真實對象。

這種技術(shù)通常用于在不使用復(fù)雜的集成測試環(huán)境的情況下測試代碼。Mockito可以協(xié)助進(jìn)行單元測試、集成測試和行為驅(qū)動開發(fā)（BDD）。

一、Mockito基礎(chǔ)知識

1、Mockito的優(yōu)點(diǎn)

• 使用簡單：Mockito的API簡單明了，易于學(xué)習(xí)和使用。
• 支持多種場景：Mockito支持各種測試場景，如單元測試、集成測試和BDD等。
• 良好的文檔：Mockito擁有全面的文檔和用戶群體，可以提供許多使用方案和實例。

2、Mockito的局限性

• 不支持靜態(tài)方法和final方法的模擬。
• 可能會過度使用，導(dǎo)致測試代碼的維護(hù)難度增加。

3、Mockito的常見概念

• Mock：指一個對象的虛擬實現(xiàn)，具有與真實對象相同的方法和屬性，但不會真正執(zhí)行其中的方法。
• Stub：指為某個方法調(diào)用提供預(yù)定義返回值的代碼，通常用于控制測試中的代碼路徑。
• Verify：指驗證Mock對象是否按照預(yù)期進(jìn)行了交互。Verify可用于驗證Mock對象的方法是否被調(diào)用了特定的次數(shù)，并且傳入了預(yù)期的參數(shù)。

4、Mockito的常見用法

• 創(chuàng)建Mock對象

List mockList = mock(List.class);

• Stub方法調(diào)用

when(mockList.get(0)).thenReturn("first");

• 驗證方法調(diào)用

verify(mockList).add("one");

• 模擬方法拋出異常

when(mockList.get(anyInt())).thenThrow(new RuntimeException());

• 模擬連續(xù)調(diào)用

Mockito提供了許多其他功能，如ArgumentMatchers用于匹配方法調(diào)用的參數(shù)、Annotations用于對Mock對象進(jìn)行注釋、Spy用于監(jiān)視真實對象等等。

通過學(xué)習(xí)和掌握Mockito的使用，可以更加高效地進(jìn)行單元測試和集成測試。

二、使用Mockito進(jìn)行模擬

1、使用Mockito進(jìn)行模擬的步驟和示例

Mockito可以通過模擬對象來測試代碼，步驟如下：

導(dǎo)入Mockito庫。在pom.xml文件中添加以下依賴：

<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>3.12.4</version>
<scope>test</scope>
</dependency>

創(chuàng)建要測試的類和方法

public class UserService {
private UserDao userDao;
public UserService(UserDao userDao) {
this.userDao = userDao;
}
public User getUserById(int id) {
return userDao.getUserById(id);
}
}
public interface UserDao {
User getUserById(int id);
}

創(chuàng)建一個模擬對象

UserDao userDao = mock(UserDao.class);

設(shè)置模擬對象的行為

when(userDao.getUserById(1)).thenReturn(new User(1, "John"));

運(yùn)行測試代碼

@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}

2、使用when()

Mockito的when()方法可以用于設(shè)置模擬對象的行為，例如：

when(mockObject.someMethod()).thenReturn(someValue);

示例代碼：

@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}

3、使用doReturn()

doReturn()方法與when()方法類似，可以用于設(shè)置模擬對象的行為，例如：

doReturn(someValue).when(mockObject).someMethod();

示例代碼：

@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
doReturn(new User(1, "John")).when(userDao).getUserById(1);
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}

4、使用mock()方法創(chuàng)建模擬對象

mock()方法可以用于創(chuàng)建模擬對象，例如：

SomeClass mockObject = mock(SomeClass.class);

示例代碼：

@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}

5、使用@Mock注解創(chuàng)建模擬對象

除了使用 ?mock()??? 方法創(chuàng)建模擬對象外，還可以使用 ??@Mock?? 注解來創(chuàng)建模擬對象。

首先需要在測試類中使用 ??@RunWith(MockitoJUnitRunner.class)?? 注解，以便在運(yùn)行測試時自動初始化模擬對象。

接著在測試類中使用 ??@Mock?? 注解創(chuàng)建模擬對象，如下所示：

@Mock
private UserDao userDao;

@Test
public void testGetUserById() {
UserService userService = new UserService(userDao);

使用 ??@Mock?? 注解創(chuàng)建模擬對象時，需要注意以下幾點(diǎn)：

• 被 ??@Mock??? 注解修飾的變量不能為 ??null??。
• 被 ??@Mock??? 注解修飾的變量默認(rèn)為 ??@Mock(answer = RETURNS_DEFAULTS)??。
• 可以通過 ??@Mock(answer =Answers.RETURNS_SMART_NULLS)??? 顯式指定返回智能 ??null??。
• 使用 ??@Mock?? 注解創(chuàng)建模擬對象時，Mockito 會自動創(chuàng)建并初始化模擬對象，并將其注入測試類中。

注意，使用 ??@Mock??? 注解創(chuàng)建的模擬對象需要在測試類中使用，否則會拋出 ??UnnecessaryStubbingException?? 異常。

6、使用@Spy注解進(jìn)行模擬對象的部分模擬

除了使用@Mock注解創(chuàng)建一個完整的模擬對象之外，Mockito還提供了@Spy注解來創(chuàng)建部分模擬對象，這樣可以在保留真實對象部分行為的同時，對其它行為進(jìn)行模擬。

下面是@Spy注解的使用示例：

public class ExampleServiceTest {
@Spy
private ExampleServiceImpl exampleServiceSpy;
@Test
public void testSomeMethod() {
// 對exampleServiceSpy進(jìn)行部分模擬，保留真實對象的部分行為
Mockito.doCallRealMethod().when(exampleServiceSpy).someMethod();
// 對someOtherMethod進(jìn)行模擬
Mockito.when(exampleServiceSpy.someOtherMethod()).thenReturn("mocked result");
// 執(zhí)行測試代碼，調(diào)用exampleServiceSpy.someMethod()方法
exampleServiceSpy.someMethod();
// 驗證someMethod()方法中是否調(diào)用了someOtherMethod()方法
Mockito.verify(exampleServiceSpy).someOtherMethod();
}
}

在這個例子中，我們使用了@Spy注解來創(chuàng)建一個ExampleServiceImpl對象的部分模擬。然后，我們使用了??Mockito.doCallRealMethod().when(exampleServiceSpy).someMethod();??來保留exampleServiceSpy對象中someMethod()方法的真實行為，而對someOtherMethod()方法進(jìn)行了模擬。

最后，我們調(diào)用了exampleServiceSpy.someMethod()方法，并驗證了someOtherMethod()方法是否被調(diào)用。

三、使用Mockito進(jìn)行測試樁

1、測試樁的作用和場景

使用Mockito進(jìn)行測試樁可以在單元測試中模擬方法的返回值或拋出異常，以便測試被測代碼在各種情況下的行為。

常見的使用場景包括：

• 測試被測代碼在異常情況下的行為。通過測試樁可以模擬方法拋出異常的場景，測試被測代碼在異常情況下是否能夠正確地處理異常。
• 測試被測代碼在特定情況下的行為。例如，測試一個方法在輸入為null時的行為，可以使用測試樁模擬方法的輸入為null的場景。
• 測試被測代碼與外部依賴的交互。通過模擬外部依賴的返回值或拋出異常，可以測試被測代碼在與外部依賴交互時的行為。
• 測試被測代碼的邊界條件。通過模擬外部依賴或方法的返回值，可以測試被測代碼在各種邊界情況下的行為，例如輸入為最大值或最小值的情況。
• 總之，測試樁可以幫助開發(fā)人員創(chuàng)建各種測試場景，以確保被測代碼的行為正確。

2、使用Mockito進(jìn)行測試樁的步驟和示例

使用Mockito進(jìn)行測試樁可以模擬需要的返回值或異常，以便在測試中測試需要的場景。

以下是使用Mockito進(jìn)行測試樁的步驟和示例：

創(chuàng)建需要進(jìn)行測試樁的對象或接口：

public interface UserService {
User getUserById(int userId);
}

使用Mockito進(jìn)行測試樁，例如模擬getUserById方法返回指定的User對象：

@Test
public void testGetUserById() {
UserService userService = Mockito.mock(UserService.class);
User expectedUser = new User("Alice", 20);
Mockito.when(userService.getUserById(Mockito.anyInt())).thenReturn(expectedUser);
User actualUser = userService.getUserById(1);
Assert.assertEquals(expectedUser, actualUser);
}

在這個示例中，我們使用Mockito.mock()方法創(chuàng)建了一個UserService對象的模擬對象userService，并使用Mockito.when()方法對getUserById方法進(jìn)行測試樁，指定了當(dāng)傳入任何整數(shù)時返回一個指定的User對象。然后我們使用模擬對象userService調(diào)用getUserById方法，并斷言返回的User對象是否是我們期望的值。

使用測試樁模擬拋出異常：

@Test(expected = UserNotFoundException.class)
public void testGetUserByIdWhenUserNotFound() {
UserService userService = Mockito.mock(UserService.class);
Mockito.when(userService.getUserById(Mockito.anyInt())).thenThrow(UserNotFoundException.class);
userService.getUserById(1);
}

在這個示例中，我們使用Mockito.when()方法對getUserById方法進(jìn)行測試樁，指定了當(dāng)傳入任何整數(shù)時拋出一個UserNotFoundException異常。然后我們使用模擬對象userService調(diào)用getUserById方法，并期望捕獲UserNotFoundException異常。

3、使用thenReturn()方法設(shè)置樁值

除了使用doReturn()方法進(jìn)行樁方法之外，我們還可以使用thenReturn()方法來設(shè)置樁值。當(dāng)樁方法返回一個值時，我們可以使用thenReturn()方法來指定這個值。

例如：

@Test
public void testGetPerson() {
// 創(chuàng)建模擬對象
PersonDao personDao = mock(PersonDao.class);
// 設(shè)置樁方法并返回模擬數(shù)據(jù)
when(personDao.getPerson(1)).thenReturn(new Person("Alice", 20));
// 執(zhí)行被測試方法
PersonService personService = new PersonService(personDao);
Person person = personService.getPerson(1);
// 驗證方法的返回值是否正確
assertEquals("Alice", person.getName());
assertEquals(20, person.getAge());
}

在這個例子中，我們通過when()方法設(shè)置樁方法，并使用thenReturn()方法指定了當(dāng)getPerson()方法傳入?yún)?shù)1時應(yīng)該返回的模擬數(shù)據(jù)。然后，我們執(zhí)行被測試的方法，并使用assertEquals()方法驗證方法的返回值是否正確。如果方法返回了我們預(yù)期的模擬數(shù)據(jù)，那么測試就通過了。

4、使用thenThrow()方法拋出異常

Mockito 的 thenThrow() 方法可以用來設(shè)置測試樁方法在執(zhí)行時拋出指定異常。這對于測試某些異常情況下的代碼行為非常有用。

使用 thenThrow() 方法非常簡單，只需要在樁方法后調(diào)用 thenThrow() 方法，并傳入要拋出的異常類型即可。

以下是一個示例：

@Test
public void testDoSomething() throws Exception {
SomeObject mockObject = mock(SomeObject.class);
when(mockObject.doSomething()).thenThrow(new RuntimeException("test exception"));
// 確保調(diào)用 doSomething() 時會拋出 RuntimeException
assertThrows(RuntimeException.class, () -> {
mockObject.doSomething();
});
}

在上面的示例中，我們使用 ??when()??? 方法對 ??doSomething()??? 方法進(jìn)行樁，然后調(diào)用 ??thenThrow()??? 方法并傳入一個 ??RuntimeException??? 對象。然后我們調(diào)用 ??doSomething()??? 方法，這時候會拋出一個運(yùn)行時異常。最后，我們使用 JUnit 的 ??assertThrows()?? 方法來驗證方法確實拋出了運(yùn)行時異常。

總的來說，使用 ??thenThrow()?? 方法可以幫助我們測試代碼在異常情況下的行為。

5、使用doAnswer()方法自定義樁方法

在某些情況下，可能需要自定義樁方法來滿足測試的需要。這時可以使用Mockito的doAnswer()方法來實現(xiàn)。

doAnswer()方法如下：

public <T> OngoingStubbing<T> doAnswer(Answer<?> answer)

doAnswer()方法的參數(shù)是一個Answer對象，該對象表示自定義的樁方法的行為。Answer接口中有一個方法??answer()??，該方法返回一個泛型對象，表示模擬方法的返回值。

下面是一個使用doAnswer()方法自定義樁方法的示例：

List<String> list = mock(List.class);
doAnswer(invocation -> {
Object[] args = invocation.getArguments();
String result = (String) args[0] + "Mockito";
return result;
}).when(list).get(anyInt());

這個例子中，我們自定義了List的get方法，將其返回值修改為輸入?yún)?shù)的字符串后面加上"Mockito"?？梢钥吹剑赿oAnswer()方法中，我們實現(xiàn)了Answer接口的??answer()??方法，并使用Invocation對象來獲取傳入的參數(shù)和返回值。最后使用when()方法來應(yīng)用樁方法。

6、使用@Captor注解進(jìn)行參數(shù)捕獲

Mockito提供了@Captor注解來捕獲模擬對象方法調(diào)用中傳入的參數(shù)。這個注解可以在測試用例中聲明一個參數(shù)，并將其注解為@Captor，Mockito會自動將模擬對象方法調(diào)用中的參數(shù)注入到這個參數(shù)中，以便我們進(jìn)行斷言或其他操作。

使用@Captor注解進(jìn)行參數(shù)捕獲的步驟和示例如下：

在測試用例類中創(chuàng)建@Captor注解，并初始化一個參數(shù)，例如：

@Captor
private ArgumentCaptor<String> captor;

在測試用例中使用模擬對象調(diào)用方法，并將參數(shù)傳遞給模擬對象，例如：

mockObject.doSomething("test");

使用Mockito.verify()方法驗證模擬對象方法的調(diào)用，并使用@Captor注解捕獲方法調(diào)用時傳遞的參數(shù)，例如：

verify(mockObject).doSomething(captor.capture());

對捕獲的參數(shù)進(jìn)行斷言或其他操作，例如：

assertEquals("test", captor.getValue());

這樣，就可以使用@Captor注解進(jìn)行參數(shù)捕獲，方便我們在測試用例中對方法參數(shù)進(jìn)行斷言和其他操作。

四、Mockito進(jìn)階用法

1、使用Mockito進(jìn)行異步測試

在異步編程中，我們經(jīng)常需要對異步方法進(jìn)行測試，確保它們能夠按照預(yù)期工作。Mockito提供了一些方法來處理異步測試場景，包括異步回調(diào)和等待異步結(jié)果。

下面是使用Mockito進(jìn)行異步測試的一些常見場景和示例。

模擬異步回調(diào)

在異步回調(diào)中，當(dāng)一個異步操作完成時，它將調(diào)用一個回調(diào)函數(shù)來通知調(diào)用方。Mockito提供了??Answer??接口，可以使用它來模擬異步回調(diào)函數(shù)。

示例：

@Test
public void testAsyncCallback() {
MyAsyncService service = mock(MyAsyncService.class);
when(service.doSomethingAsync(anyString(), any(Consumer.class))).thenAnswer(new Answer<Void>() {
@Override
public Void answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
String arg1 = (String) args[0];
Consumer<String> callback = (Consumer<String>) args[1];
callback.accept(arg1 + " is done");
return null;
}
});
MyAsyncClient client = new MyAsyncClient(service);
String result = client.doSomething("test");
assertEquals("test is done", result);
}

在這個示例中，我們使用??Answer???接口來模擬異步回調(diào)函數(shù)。當(dāng)??service.doSomethingAsync???方法被調(diào)用時，我們從參數(shù)中獲取回調(diào)函數(shù)并執(zhí)行它，然后返回??null??。在測試中，我們驗證異步客戶端返回的結(jié)果是否正確。

等待異步結(jié)果

在異步編程中，我們經(jīng)常需要等待異步操作完成后獲取結(jié)果。為了測試異步方法，我們需要等待異步操作完成后再斷言結(jié)果。Mockito提供了一些方法來處理這種場景。

示例：

@Test
public void testAsyncResult() throws Exception {
MyAsyncService service = mock(MyAsyncService.class);
CompletableFuture<String> future = new CompletableFuture<>();
when(service.doSomethingAsync(anyString())).thenReturn(future);
MyAsyncClient client = new MyAsyncClient(service);
CompletableFuture<String> result = client.doSomethingAsync("test");
assertFalse(result.isDone()); // 驗證異步方法還未完成
future.complete("test is done");
assertTrue(result.isDone()); // 驗證異步方法已完成
assertEquals("test is done", result.get()); // 驗證異步方法的結(jié)果是否正確
}

在這個示例中，我們使用??CompletableFuture???來模擬異步方法的結(jié)果。當(dāng)??service.doSomethingAsync???方法被調(diào)用時，我們返回一個??CompletableFuture???對象。在測試中，我們驗證異步方法是否已經(jīng)啟動，然后手動完成??CompletableFuture??對象并驗證結(jié)果是否正確。

需要注意的是，在使用??CompletableFuture???對象進(jìn)行異步測試時，我們需要等待異步操作完成后再獲取結(jié)果。

我們可以使用??isDone()???方法來判斷異步操作是否完成，使用??get()??方法來獲取異步操作的結(jié)果。

2、使用Mockito進(jìn)行參數(shù)匹配

在使用 Mockito 進(jìn)行單元測試時，我們通常需要對被測方法傳入不同的參數(shù)進(jìn)行測試。但有時候我們希望只測試特定的參數(shù)組合，這時候就需要使用參數(shù)匹配。

Mockito 提供了一系列的參數(shù)匹配器，可以根據(jù)參數(shù)類型和值來匹配參數(shù)。

常用的參數(shù)匹配器有：

• any()：匹配任何對象，例如 any(String.class) 匹配任何 String 類型的參數(shù)。
• eq()：匹配指定的對象，例如 eq("abc") 匹配參數(shù)值為 "abc" 的參數(shù)。
• isA()：匹配指定類型的參數(shù)，例如 isA(String.class) 匹配參數(shù)類型為 String 的參數(shù)。
• anyXxx()：匹配指定類型的基本數(shù)據(jù)類型，例如 anyInt() 匹配任何 int 類型的參數(shù)。

下面是使用 Mockito 進(jìn)行參數(shù)匹配的示例代碼：

// 定義被測類
public class UserService {
private UserDao userDao;
public UserService(UserDao userDao) {
this.userDao = userDao;
}
public User getUserByName(String name) {
return userDao.getUserByName(name);
}
}
// 定義 UserDao 接口
public interface UserDao {
User getUserByName(String name);
}
// 定義測試類
@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
@Mock
private UserDao userDao;
@InjectMocks
private UserService userService;
@Test
public void testGetUserByName() {
// 設(shè)置樁方法
when(userDao.getUserByName(any(String.class)))
.thenReturn(new User("Tom"));
// 調(diào)用被測方法
User user = userService.getUserByName("Tom");
// 驗證返回值
assertEquals("Tom", user.getName());
}
}

在上面的示例代碼中，我們使用了 any() 方法來匹配 getUserByName() 方法的參數(shù)，這樣就可以匹配任何字符串類型的參數(shù)，不需要具體指定參數(shù)值。這樣可以使測試代碼更加靈活和通用。

除了上面介紹的參數(shù)匹配器外，Mockito 還提供了很多其他的參數(shù)匹配器，具體可以參考 Mockito 的官方文檔。

3、使用Mockito進(jìn)行void方法的樁方法和驗證

Mockito可以用于樁方法和驗證void方法，下面將介紹如何使用Mockito來進(jìn)行void方法的樁方法和驗證。

void方法的樁方法

Mockito中有兩種方法可以用于void方法的樁方法，分別是doNothing()和doThrow()。

• doNothing()：表示當(dāng)void方法被調(diào)用時，不做任何事情。
• doThrow()：表示當(dāng)void方法被調(diào)用時，拋出一個指定的異常。

下面是示例代碼：

// 創(chuàng)建一個mock對象
List<String> mockList = mock(List.class);
// 對void方法進(jìn)行樁方法，表示當(dāng)調(diào)用add方法時，不做任何事情
doNothing().when(mockList).add(anyString());
// 對void方法進(jìn)行樁方法，表示當(dāng)調(diào)用clear方法時，拋出一個RuntimeException異常
doThrow(new RuntimeException()).when(mockList).clear();

void方法的驗證

Mockito中使用verify()方法來驗證void方法是否被調(diào)用，和之前提到的verify()方法類似，只是不需要設(shè)置返回值。

下面是示例代碼：

// 創(chuàng)建一個mock對象
List<String> mockList = mock(List.class);
// 調(diào)用void方法
mockList.clear();
// 驗證clear方法是否被調(diào)用過一次
verify(mockList).clear();

使用Mockito進(jìn)行void方法的樁方法和驗證和普通方法類似，只需要使用doNothing()、doThrow()方法進(jìn)行樁方法，使用verify()方法進(jìn)行驗證即可。

4、使用Mockito進(jìn)行mock靜態(tài)方法和final方法

Mockito 無法直接 Mock 靜態(tài)方法和 final 方法，因為它們不能被子類化和重載，但是 Mockito 可以與 PowerMock 等其他 Mock 框架結(jié)合使用來 Mock 靜態(tài)方法和 final 方法。

PowerMock 是一個 Java 開源框架，它結(jié)合了 EasyMock 和 Mockito 的功能，并添加了對靜態(tài)方法、final 方法、私有方法、構(gòu)造函數(shù)和靜態(tài)初始化塊的支持。

下面是使用 PowerMock 和 Mockito 來 Mock 靜態(tài)方法和 final 方法的步驟和示例：

在 Maven POM 文件中添加 PowerMock 和 Mockito 的依賴項：

<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-core</artifactId>
<version>2.0.9</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
<version>2.0.9</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>3.2.4</version>
<scope>test</scope>
</dependency>

2 使用 @RunWith(PowerMockRunner.class) 和 @PrepareForTest 注解來準(zhǔn)備需要 Mock 的類：

@RunWith(PowerMockRunner.class)
@PrepareForTest({ClassToMock.class})
public class MyClassTest {
...
}

3 使用 PowerMockito.mockStatic(ClassToMock.class) 方法來 Mock 靜態(tài)方法：

PowerMockito.mockStatic(ClassToMock.class);
Mockito.when(ClassToMock.staticMethod()).thenReturn(expectedValue);

4 使用 PowerMockito.whenNew(ClassToMock.class) 方法來 Mock 構(gòu)造函數(shù)：

PowerMockito.whenNew(ClassToMock.class).withArguments(argument1, argument2).thenReturn(mockInstance);

5 使用 PowerMockito.spy(mockInstance) 方法來創(chuàng)建一個 Spy 對象：

ClassToMock mockInstance = PowerMockito.spy(new ClassToMock());
Mockito.when(mockInstance.finalMethod()).thenReturn(expectedValue);

6 使用

PowerMockito.doCallRealMethod().when(mockInstance).nonFinalMethod() 方法來 Mock 非 final 方法：

PowerMockito.doCallRealMethod().when(mockInstance).nonFinalMethod();
Mockito.when(mockInstance.nonFinalMethod()).thenReturn(expectedValue);

7 在測試方法中，使用 PowerMockito.verifyStatic(ClassToMock.class) 方法來驗證靜態(tài)方法調(diào)用，使用 PowerMockito.verifyNew(ClassToMock.class) 方法來驗證構(gòu)造函數(shù)調(diào)用：

PowerMockito.verifyStatic(ClassToMock.class);
ClassToMock.staticMethod();
PowerMockito.verifyNew(ClassToMock.class).withArguments(argument1, argument2);

需要注意的是，Mock 靜態(tài)方法和 final 方法可能會影響代碼的可維護(hù)性和可讀性，應(yīng)該盡量避免使用它們。只有在必要時才使用它們，并且應(yīng)該選擇適當(dāng)?shù)?Mock 框架來保持代碼的簡潔性和可讀性。

五、總結(jié)

Mockito是一個流行的Java模擬框架，它可以幫助開發(fā)人員編寫單元測試，以便更好地驗證代碼的正確性。

Mockito提供了一些常用的方法，例如模擬對象、測試樁、參數(shù)匹配、異步測試等，這些方法可以大大簡化測試代碼的編寫和維護(hù)。

Mockito的優(yōu)點(diǎn)包括易學(xué)易用、廣泛支持、文檔豐富等，但也存在局限性，例如不支持mock final方法等。

對于開發(fā)人員而言，使用Mockito進(jìn)行單元測試可以提高代碼質(zhì)量，降低代碼維護(hù)成本，是一個非常值得掌握的技能。

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

最新評論