本文是我們名為“ 用Mockito進行測試 ”的學院課程的一部分。

在本課程中，您將深入了解Mockito的魔力。 您將了解有關“模擬”，“間諜”和“部分模擬”的信息，以及它們相應的Stubbing行為。 您還將看到使用測試雙打和對象匹配器進行驗證的過程。 最后，討論了使用Mockito的測試驅動開發（TDD），以了解該庫如何適合TDD的概念。 在這里查看 ！

目錄

1.簡介 2.模擬，存根，間諜–名稱是什么？ 3.存根方法 4.存根返回值

4.1。 使用答案 4.2。 有關行為驅動開發測試約定的說明 4.3。 在Eclipse中使用Mockito靜態方法的提示 4.4。 使用多個模擬 4.5。 測試自己！ 測試更新！

5.參數匹配器 6.間諜和部分存根 7.結論 8.下載源代碼

1.簡介

在本教程中，我們將深入研究使用Mockito存根類和接口。

2.模擬，存根，間諜–名稱是什么？

嘲笑中的許多術語可以互換使用，也可以作為動詞和名詞使用。 我們現在將對這些術語進行定義，以避免將來造成混淆。

• 模擬（名詞） –一個對象，充當另一個對象的雙精度對象。
• 模擬（動詞） –創建模擬對象或對方法進行存根。
• 間諜（名詞） –裝飾現有對象并允許對該對象的方法進行存根和對該對象的調用進行驗證的對象。
• 間諜（動詞） –創建和使用間諜對象。
• 存根（名詞） –可以在調用方法時提供“罐頭答案”的對象。
• 存根（動詞） –創建固定答案。
• Partial Mock，Partial Stub（動詞） –間諜的另一個術語，其中包括某些方法的代碼。

從技術上講，Mockito是一個測試間諜框架，而不是模擬框架，因為它允許我們創建間諜和驗證行為，以及創建具有殘存行為的模擬對象。

正如在上一教程中所看到的，我們可以使用when().thenReturn()方法對給定接口或類的行為進行存根。 現在，我們將研究為Mocks和Spies提供存根的所有方式。

3.存根方法

給定以下界面：

public interface Printer {void printTestPage();}

以下是基于它的基于字符串緩沖區的簡單化“字處理器”類：

public class StringProcessor {private Printer printer;private String currentBuffer;public StringProcessor(Printer printer) {this.printer = printer;}public Optional<String> statusAndTest() {printer.printTestPage();return Optional.ofNullable(currentBuffer);}}

我們要編寫一個測試方法，該方法將在構造后測試當前緩沖區是否不存在，并處理測試頁的打印。

這是我們的測試班：

public class StringProcessorTest {private Printer printer;@Testpublic void internal_buffer_should_be_absent_after_construction() {// GivenStringProcessor processor = new StringProcessor(printer);// WhenOptional<String> actualBuffer = processor.statusAndTest();// ThenassertFalse(actualBuffer.isPresent());} }

我們知道statusAndTest()將涉及對Printer的printTestPage()方法的調用，并且printer引用未初始化，因此如果執行此測試，我們將以NullPointerException結尾。 為了避免這種情況，我們只需要注釋測試類以告訴JUnit使用Mockito運行它，并注釋Printer作為一個模擬，以告訴mockito為此創建一個模擬。

@RunWith(MockitoJUnitRunner.class) public class StringProcessorTest {@Mockprivate Printer printer;@Testpublic void internal_buffer_should_be_absent_after_construction() {// GivenStringProcessor processor = new StringProcessor(printer);// WhenOptional<String> actualBuffer = processor.statusAndTest();// ThenassertFalse(actualBuffer.isPresent());}}

現在我們可以執行測試，Mockito將為我們創建Printer的實現，并將其實例分配給printer變量。 我們將不再獲得NullPointerException。

但是，如果Printer是一類實際完成某些工作的類，例如打印物理測試頁，該怎么辦？ 如果我們選擇了@Spy而不是創建@Mock怎么辦？ 記住，除非被偵聽，否則間諜會在類上調用間諜的真實方法。 我們希望避免在調用該方法時做任何實際的事情。 讓我們做一個簡單的Printer實現：

public class SysoutPrinter implements Printer {@Overridepublic void printTestPage() {System.out.println("This is a test page");}}

并將其作為間諜添加到我們的測試類中，并添加一個新方法來測試使用它：

@Spyprivate SysoutPrinter sysoutPrinter;@Testpublic void internal_buffer_should_be_absent_after_construction_sysout() {// GivenStringProcessor processor = new StringProcessor(sysoutPrinter);// WhenOptional<String> actualBuffer = processor.statusAndTest();// ThenassertFalse(actualBuffer.isPresent());}

如果現在執行此測試，您將在控制臺上看到以下輸出：

This is a test page

這證實了我們的測試用例實際上是在執行SysoutPrinter類的真實方法，這是因為它是Spy而不是Mock。 如果該類實際執行了測試頁的實際物理打印，那將是非常不希望的！

當我們執行部分模擬或Spy時，可以使用org.mockito.Mockito.doNothing()調用的方法進行存根以確保其中沒有任何org.mockito.Mockito.doNothing() 。

讓我們添加以下導入和測試：

import static org.mockito.Mockito.*;@Testpublic void internal_buffer_should_be_absent_after_construction_sysout_with_donothing() {// GivenStringProcessor processor = new StringProcessor(sysoutPrinter);doNothing().when(sysoutPrinter).printTestPage();// WhenOptional<String> actualBuffer = processor.statusAndTest();// ThenassertFalse(actualBuffer.isPresent());}

注意方法doNothing.when(sysoutPrinter).printTestPage() ：這告訴Mockito當調用@Spy sysoutPrinter的void方法printTestPage ，不應執行真正的方法，而應執行任何操作。 現在，當我們執行此測試時，屏幕上看不到任何輸出。

如果未連接物理打印機，如果我們擴展打印機接口以引發新的PrinterNotConnectedException異常該怎么辦？ 我們如何測試這種情況？

首先，讓我們創建一個非常簡單的新異常類。

public class PrinterNotConnectedException extends Exception {private static final long serialVersionUID = -6643301294924639178L;}

并修改我們的界面以將其拋出：

void printTestPage() throws PrinterNotConnectedException;

如果拋出異常，我們還需要修改StringProcessor以執行某些操作。 為了簡單起見，我們只將異常拋出給調用類。

public Optional<String> statusAndTest() throws PrinterNotConnectedException

現在我們要測試異常是否傳遞給調用類，因此我們必須強制打印機拋出異常。 與doNothing()類似，我們可以使用doThrow強制執行異常。

讓我們添加以下測試：

@Test(expected = PrinterNotConnectedException.class)public void printer_not_connected_exception_should_be_thrown_up_the_stack() throws Exception {// GivenStringProcessor processor = new StringProcessor(printer);doThrow(new PrinterNotConnectedException()).when(printer).printTestPage();// WhenOptional<String> actualBuffer = processor.statusAndTest();// ThenassertFalse(actualBuffer.isPresent());}

在這里，我們看到可以使用doThrow()拋出所需的任何異常。 在這種情況下，我們將拋出滿足我們測試要求的PrinterNotConnectedException 。

現在我們已經學習了如何對void方法進行存根，讓我們看一下返回一些數據。

4.存根返回值

讓我們開始創建一個數據訪問對象，以持久性地從數據庫中檢索客戶對象。 該DAO將使用內部的企業java EntityManager接口進行實際的數據庫交互。

為了使用EntityManager我們將使用JPA 2.0的Hibernate實現，將以下依賴項添加到pom.xml中：

<dependency><groupId>org.hibernate.javax.persistence</groupId><artifactId>hibernate-jpa-2.0-api</artifactId><version>1.0.1.Final</version></dependency>

現在，我們將創建一個簡單的Customer實體來表示要保留的Customer。

@Entity public class Customer {@Id @GeneratedValueprivate long id;private String name;private String address;public Customer() {}public Customer(long id, String name, String address) {super();this.id = id;this.name = name;this.address = address;}public long getId() {return id;}public void setId(long id) {this.id = id;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public String getName() {return name;}public void setName(String name) {this.name = name;}}

現在，我們將創建一個框架DAO，該框架使用@PersistenceContext配置注入的EntityManager 。 我們不必擔心使用Java持久性體系結構（JPA）或它如何工作-我們將使用Mockito完全繞過它，但這是Mockito實際應用的一個很好的示例。

public class CustomerDAO {@PersistenceContextEntityManager em;public CustomerDAO(EntityManager em) {this.em = em;}}

我們將在DAO中添加基本的“檢索和更新”功能，并使用Mockito對其進行測試。

首先使用Retrieve方法-我們將傳遞一個ID并從數據庫中返回適當的Customer（如果存在）。

public Optional<Customer> findById(long id) throws Exception {return Optional.ofNullable(em.find(Customer.class, id));}

在這里，我們使用Java Optional來避免對結果進行空檢查。

現在，我們可以添加測試以在找到客戶但找不到客戶的位置測試此方法–我們將使用Mockito方法org.mockito.Mockito.when存根find()方法以在每種情況下返回適當的Optional。然后thenReturn()

讓我們如下創建Test類（為Mockito方法import static org.mockito.Mockito.*; ）：

@RunWith(MockitoJUnitRunner.class) public class CustomerDAOTest {private CustomerDAO dao;@Mockprivate EntityManager mockEntityManager;@Beforepublic void setUp() throws Exception {dao = new CustomerDAO(mockEntityManager);}@Testpublic void finding_existing_customer_should_return_customer() throws Exception {// Givenlong expectedId = 10;String expectedName = "John Doe";String expectedAddress = "21 Main Street";Customer expectedCustomer = new Customer(expectedId, expectedName, expectedAddress);when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(expectedCustomer);// WhenOptional<Customer> actualCustomer = dao.findById(expectedId);// ThenassertTrue(actualCustomer.isPresent());assertEquals(expectedId, actualCustomer.get().getId());assertEquals(expectedName, actualCustomer.get().getName());assertEquals(expectedAddress, actualCustomer.get().getAddress());} }

我們看到了用于啟用模仿， EntityManger并將其注入到測試中的類的常用樣板。 讓我們看一下測試方法。

第一行涉及創建具有已知期望值的Customer ，然后我們看到對Mockito的調用告訴我們，當使用我們提供的特定輸入參數調用EntityManager.find()方法時，該客戶將返回此客戶。 然后，我們執行findById()方法和一組斷言的實際執行，以確保獲得所需的值。

讓我們剖析Mockito調用：

when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(expectedCustomer);

這演示了Mockito強大而優雅的語法。 讀起來幾乎像普通的英語。 當find()的方法mockEntityManager對象被稱為與特定輸入Customer.class和expectedId ，然后返回expectedCustomer對象。

如果您使用未告知其期望的參數調用Mock，則它將僅返回null，如以下測試所示：

@Testpublic void invoking_mock_with_unexpected_argument_returns_null() throws Exception {// Givenlong expectedId = 10L;long unexpectedId = 20L;String expectedName = "John Doe";String expectedAddress = "21 Main Street";Customer expectedCustomer = new Customer(expectedId, expectedName, expectedAddress);when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(expectedCustomer);// WhenOptional<Customer> actualCustomer = dao.findById(unexpectedId);// ThenassertFalse(actualCustomer.isPresent());}

您還可以將Mock存根幾次，以實現不同的行為，具體取決于輸入。 讓我們讓Mock根據輸入的ID返回其他客戶：

@Testpublic void invoking_mock_with_different_argument_returns_different_customers() throws Exception {// Givenlong expectedId1 = 10L;String expectedName1 = "John Doe";String expectedAddress1 = "21 Main Street";Customer expectedCustomer1 = new Customer(expectedId1, expectedName1, expectedAddress1);long expectedId2 = 20L;String expectedName2 = "Jane Deer";String expectedAddress2 = "46 High Street";Customer expectedCustomer2 = new Customer(expectedId2, expectedName2, expectedAddress2);when(mockEntityManager.find(Customer.class, expectedId1)).thenReturn(expectedCustomer1);when(mockEntityManager.find(Customer.class, expectedId2)).thenReturn(expectedCustomer2);// WhenOptional<Customer> actualCustomer1 = dao.findById(expectedId1);Optional<Customer> actualCustomer2 = dao.findById(expectedId2);// ThenassertEquals(expectedName1, actualCustomer1.get().getName());assertEquals(expectedName2, actualCustomer2.get().getName());}

您甚至可以鏈接返回，以使模擬在每次調用時執行不同的操作。 請注意，如果您調用模擬程序的次數超過了您的存根行為，那么它將永遠永遠根據最后一個存根行為。

@Testpublic void invoking_mock_with_chained_stubs_returns_different_customers() throws Exception {// Givenlong expectedId1 = 10L;String expectedName1 = "John Doe";String expectedAddress1 = "21 Main Street";Customer expectedCustomer1 = new Customer(expectedId1, expectedName1, expectedAddress1);long expectedId2 = 20L;String expectedName2 = "Jane Deer";String expectedAddress2 = "46 High Street";Customer expectedCustomer2 = new Customer(expectedId2, expectedName2, expectedAddress2);when(mockEntityManager.find(Customer.class, expectedId1)).thenReturn(expectedCustomer1).thenReturn(expectedCustomer2);// WhenOptional<Customer> actualCustomer1 = dao.findById(expectedId1);Optional<Customer> actualCustomer2 = dao.findById(expectedId1);// ThenassertEquals(expectedName1, actualCustomer1.get().getName());assertEquals(expectedName2, actualCustomer2.get().getName());}

請注意，我們輸入了相同的ID到兩個電話，不同的行為是由第二goverened theReturn()方法，這只能是因為when()存根的一部分明確預期和輸入expectedId1 ，如果我們通過expectedId2我們由于它不是存根中的期望值，因此可能會從模擬中獲得空響應。

現在讓我們測試客戶丟失的情況。

@Testpublic void finding_missing_customer_should_return_null() throws Exception {// Givenlong expectedId = 10L;when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(null);// WhenOptional<Customer> actualCustomer = dao.findById(expectedId);// ThenassertFalse(actualCustomer.isPresent());}

在這里我們可以看到我們使用相同的語法，但是這次使用它來返回null。

允許的Mockito您使用的可變參數thenReturn存根連續調用，所以如果我們想我們可以在前面的兩個測試搟成一個如下：

@Testpublic void finding_customer_should_respond_appropriately() throws Exception {// Givenlong expectedId = 10L;String expectedName = "John Doe";String expectedAddress = "21 Main Street";Customer expectedCustomer1 = new Customer(expectedId, expectedName, expectedAddress);Customer expectedCustomer2 = null;when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(expectedCustomer1, expectedCustomer2);// WhenOptional<Customer> actualCustomer1 = dao.findById(expectedId);Optional<Customer> actualCustomer2 = dao.findById(expectedId);// ThenassertTrue(actualCustomer1.isPresent());assertFalse(actualCustomer2.isPresent());}

如果我們的find方法由于某些持久性問題而引發異常怎么辦？ 讓我們測試一下！

@Test(expected=IllegalArgumentException.class)public void finding_customer_should_throw_exception_up_the_stack() throws Exception {// Givenlong expectedId = 10L;when(mockEntityManager.find(Customer.class, expectedId)).thenThrow(new IllegalArgumentException());// Whendao.findById(expectedId);// Thenfail("Exception should be thrown.");}

我們使用了thenThrow()方法引發異常。 在對無效方法進行存根時，將此語法與我們對doThrow()使用進行doThrow() 。 這是兩個相似但不同的方法– thenThrow()將不適用于void方法。

使用答案

我們在上面看到，我們創建了具有某些期望值的客戶。 如果我們想創建一些已知的測試用戶并以id為基礎返回他們，則可以使用Answer ，可以從when()調用中返回。 Answer是Mockito提供的通用類型，用于提供“罐頭響應”。 它的answer()方法采用一個InvocationOnMock對象，該對象包含有關當前模擬方法調用的某些信息。

讓我們創建3個客戶和一個Answer，根據輸入的ID選擇要返回的客戶。

首先，將3位客戶添加為測試類的私有成員。

private Customer homerSimpson, bruceWayne, tyrionLannister;

然后添加一個專用的setupCustomers方法以對其進行初始化，然后從@Before方法進行調用。

@Beforepublic void setUp() throws Exception {dao = new CustomerDAO(mockEntityManager);setupCustomers();}private void setupCustomers() {homerSimpson = new Customer(1, "Homer Simpson", "Springfield");bruceWayne = new Customer(2, "Bruce Wayne", "Gotham City");tyrionLannister = new Customer(2, "Tyrion Lannister", "Kings Landing");}

現在，我們可以基于運行時傳遞給傳遞給模擬EntityManager的find()方法的ID創建一個Answer來返回適當的Customer。

private Answer<Customer> withCustomerById = new Answer<Customer>() {@Overridepublic Customer answer(InvocationOnMock invocation) throws Throwable {Object[] args = invocation.getArguments();int id = ((Long)args[1]).intValue(); // Cast to int for switch.switch (id) {case 1 : return homerSimpson;case 2 : return bruceWayne;case 3 : return tyrionLannister;default : return null;}}};

我們可以看到我們使用InvocationOnMock提取了傳遞到Mock方法調用中的參數。 我們知道第二個參數是ID，因此我們可以讀取該參數并確定要返回的適當客戶。 稍后，帶有withCustomerById的答案的名稱將適合我們的模擬語法。

現在，讓我們編寫一個測試來證明此答案的實際效果。

@Testpublic void finding_customer_by_id_returns_appropriate_customer() throws Exception {// Givenlong[] expectedId = {1, 2, 3};when(mockEntityManager.find(eq(Customer.class), anyLong())).thenAnswer(withCustomerById);// WhenOptional<Customer> actualCustomer0 = dao.findById(expectedId[0]);Optional<Customer> actualCustomer1 = dao.findById(expectedId[1]);Optional<Customer> actualCustomer2 = dao.findById(expectedId[2]);// ThenassertEquals("Homer Simpson", actualCustomer0.get().getName());assertEquals("Bruce Wayne", actualCustomer1.get().getName());assertEquals("Tyrion Lannister", actualCustomer2.get().getName());}

讓我們詳細看一下存根線。

when(mockEntityManager.find(eq(Customer.class), anyLong())).thenAnswer(withCustomerById);

在這里，我們看到了一些新事物。 第一件事是，我們不執行when().thenReturn()而是執行when().thenAnswer()并提供withCustomerById Answer作為要給出的答案。 第二件事是我們不對傳遞給mockEntityManager.find()的ID使用真實值，而是使用靜態org.mockito.Matchers.anyLong() 。 這是一個Matcher ，用于使Mockito發出Answer，而無需檢查是否已傳遞特定的Long值。Matchers讓我們忽略模擬調用的參數，而只專注于返回值。

我們還用eq() Matcher裝飾了Customer.class –這是由于您不能在Mock方法調用中混合使用實值和Matchers，您要么必須將所有參數都用作Matchers，要么必須將所有參數都用作實值。 eq()提供了一個Matcher，僅當運行時參數等于存根中的指定參數時才匹配。 讓我們繼續僅在輸入類類型為Customer.class類型時不指定特定ID的情況下才返回Answer。

什么這一切意味著，三個調用mockEntityManager.find()用不同的ID是所有產生相同的答案報錯，并且我們已經編碼的答案與不同的ID相應的客戶對象響應是我們已經成功地嘲笑一個EntityManager能力模仿現實行為。

有關行為驅動開發測試約定的說明

您可能已經注意到，我們在單元測試中采用了約定，將測試分為三部分– //給定，//時間和//然后。 該約定稱為行為驅動開發，是設計單元測試的非常合乎邏輯的方法。

• // 給定的是設置階段，在該階段我們初始化數據和存根模擬類。 它與陳述“給定以下初始條件”相同。
• //什么時候是執行階段，在該階段我們執行被測方法并捕獲所有返回的對象。
• //然后是驗證階段，在此階段我們放置斷言邏輯，該邏輯將檢查該方法是否表現出預期的行為。

Mockito在org.mockito.BDDMockito類中開箱即用地支持BDD。 它用BDD doppelgangers given() willReturn() ， willThrow() ， willAnswer() ， willAnswer()替換了常規的存根方法– when() ， thenReturn() ， thenThrow() ， thenAnswer()等。 這樣可以避免在// //給定部分中使用when() ，因為這可能會造成混淆。

因為我們在測試中使用BDD約定，所以我們還將使用BDDMockito提供的方法。

讓我們使用BDDMockito語法重寫finding_existing_customer_should_return_customer() 。

import static org.mockito.BDDMockito.*;@Testpublic void finding_existing_customer_should_return_customer_bdd() throws Exception {// Givenlong expectedId = 10L;String expectedName = "John Doe";String expectedAddress = "21 Main Street";Customer expectedCustomer = new Customer(expectedId, expectedName, expectedAddress);given(mockEntityManager.find(Customer.class, expectedId)).willReturn(expectedCustomer);// WhenOptional<Customer> actualCustomer = dao.findById(expectedId);// ThenassertTrue(actualCustomer.isPresent());assertEquals(expectedId, actualCustomer.get().getId());assertEquals(expectedName, actualCustomer.get().getName());assertEquals(expectedAddress, actualCustomer.get().getAddress());}

測試的邏輯沒有改變，只是以BDD格式可讀。

在Eclipse中使用Mockito靜態方法的提示

如果要避免導入org.mockito.Mockito.*等，為各種Mockito靜態方法手動添加靜態導入可能會很痛苦org.mockito.Mockito.*為了在Eclipse中為這些方法啟用內容輔助，您只需要啟動org.mockito.Mockito.* > Preferences并轉到左側導航欄中的Java / Editor / Content Assist / Favorites。 然后，按照圖1添加以下內容作為“ New Type…”。

• org.mockito.Mockito
• org.mockito.Matchers
• org.mockito.BDDMockito

這會將Mockito靜態方法添加到Eclipse Content Assist中，使您可以在使用它們時自動完成并導入它們。

圖1 – Content Assist收藏夾

使用多個模擬

現在，我們將結合在一起使用多個模擬。 讓我們向DAO中添加一個方法以返回所有可用客戶的列表。

public List<Customer> findAll() throws Exception {TypedQuery<Customer> query = em.createQuery("select * from CUSTOMER", Customer.class);return query.getResultList();}

在這里，我們看到EntityManager的createQuery()方法返回一個通用類型TypedQuery 。 它接受一個SQL String和一個作為返回類型的類作為參數。 TypedQuery本身公開了幾種方法，包括List getResultList() ，這些方法可用于執行返回多個值的查詢，例如上面的select * from CUSTOMER查詢中的select * from CUSTOMER 。

為了對此方法編寫測試，我們將要創建一個TypedQuery的Mock。

@Mock private TypedQuery<Customer> mockQuery;

現在，我們可以對這個模擬查詢進行存根以返回已知客戶的列表。 讓我們創建一個答案來做到這一點，并重用我們先前創建的已知客戶。 您可能已經注意到Answer是一個功能接口，只有一種方法。 我們正在使用Java 8，因此我們可以創建一個lambda表達式來內聯地表示我們的Answer，而不是像前面的Answer示例中那樣創建一個匿名內部類。

given(mockQuery.getResultList()).willAnswer(i -> Arrays.asList(homerSimpson, bruceWayne, tyrionLannister));

當然我們也可以將上面的存根編碼為

given(mockQuery.getResultList()).willReturn(Arrays.asList(homerSimpson, bruceWayne, tyrionLannister));given

這展示了Mockito的靈活性–總是有幾種不同的方式來做相同的事情。

現在我們已經對模擬TypedQuery的行為進行了存根，我們可以對模擬EntityManager進行存根以在請求時返回它。 與其將SQL引入我們的測試用例中， anyString()僅使用anyString()匹配器來觸發模擬createQuery() ，當然，我們還將用eq()匹配器包圍該類參數。

完整的測試如下所示：

@Testpublic void finding_all_customers_should_return_all_customers() throws Exception {// Givengiven(mockQuery.getResultList()).willAnswer(i -> Arrays.asList(homerSimpson, bruceWayne, tyrionLannister));given(mockEntityManager.createQuery(anyString(), eq(Customer.class))).willReturn(mockQuery);// WhenList<Customer> actualCustomers = dao.findAll();// ThenassertEquals(actualCustomers.size(), 3);}

測試更新！

讓我們添加Update() DAO方法：

public Customer update(Customer customer) throws Exception {return em.merge(customer);}

現在查看是否可以為其創建測試。 本教程隨附的示例代碼項目中已編寫了可能的解決方案。 記住，在Mockito中有很多方法可以做相同的事情，看看是否能想到其中的幾種！

5.參數匹配器

Mocktio的自然行為是使用對象的equals()方法作為參數傳入，以查看是否存在特定的存根行為。 但是，如果對于我們來說不重要的是那些值，那么在存根時可以避免使用實際的對象和變量。 我們通過使用Mockito參數匹配器來實現

我們已經看到了一些運行中的Mockito參數匹配器： anyLong() ， anyString()和eq 。 當我們不特別在意Mock的輸入時，我們會使用這些匹配器，我們只對編碼它的返回行為感興趣，并且我們希望它在所有條件下的行為都相同。

如前所述，但需要特別注意的是，當使用參數匹配器時，所有參數都必須是參數匹配器，您不能將實值與參數匹配器混合和匹配，否則會從Mockito中獲取運行時錯誤。

參數匹配器都擴展了org.mockito.ArgumentMatcher ，Mockito包括一個現成的參數匹配器庫，可以通過org.mockito.Matchers的靜態方法進行org.mockito.Matchers ，要使用它們只需導入org.mockito.Matchers.* ;

您可以查看org.mockito.Matchers的javadoc，以查看Mockito提供的所有Matchers，而以下測試類演示了其中一些用法：

package com.javacodegeeks.hughwphamill.mockito.stubbing;import static org.junit.Assert.*; import static org.mockito.Matchers.*; import static org.mockito.Mockito.*;import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Set;import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.runners.MockitoJUnitRunner;@RunWith(MockitoJUnitRunner.class) public class MatchersTest {public interface TestForMock {public boolean usesPrimitives(int i, float f, double d, byte b, boolean bool);public boolean usesObjects(String s, Object o, Integer i);public boolean usesCollections(List<String> list, Map<Integer, String> map, Set<Object> set);public boolean usesString(String s);public boolean usesVarargs(String... s);public boolean usesObject(Object o);}@MockTestForMock test;@Testpublic void test() {// default behaviour is to return falseassertFalse(test.usesString("Hello"));when(test.usesObjects(any(), any(), any())).thenReturn(true);assertTrue(test.usesObjects("Hello", new Thread(), 17));Mockito.reset(test);when(test.usesObjects(anyString(), anyObject(), anyInt())).thenReturn(true);assertTrue(test.usesObjects("Hi there", new Float(18), 42));Mockito.reset(test);when(test.usesPrimitives(anyInt(), anyFloat(), anyDouble(), anyByte(), anyBoolean())).thenReturn(true);assertTrue(test.usesPrimitives(1, 43.4f, 3.141592654d, (byte)2, false));Mockito.reset(test);// Gives unchecked type conversion warningwhen(test.usesCollections(anyList(), anyMap(), anySet())).thenReturn(true);assertTrue(test.usesCollections(Arrays.asList("Hello", "World"), Collections.EMPTY_MAP, Collections.EMPTY_SET));Mockito.reset(test);// Gives no warningwhen(test.usesCollections(anyListOf(String.class), anyMapOf(Integer.class, String.class), anySetOf(Object.class))).thenReturn(true);assertTrue(test.usesCollections(Collections.emptyList(), Collections.emptyMap(), Collections.emptySet()));Mockito.reset(test);// eq() must match exactlywhen(test.usesObjects(eq("Hello World"), any(Object.class),anyInt())).thenReturn(true);assertFalse(test.usesObjects("Hi World", new Object(), 360));assertTrue(test.usesObjects("Hello World", new Object(), 360));Mockito.reset(test);when(test.usesString(startsWith("Hello"))).thenReturn(true);assertTrue(test.usesString("Hello there"));Mockito.reset(test);when(test.usesString(endsWith("something"))).thenReturn(true);assertTrue(test.usesString("isn't that something"));Mockito.reset(test);when(test.usesString(contains("second"))).thenReturn(true);assertTrue(test.usesString("first, second, third."));Mockito.reset(test);// Regular Expressionwhen(test.usesString(matches("^\\\\w+$"))).thenReturn(true);assertTrue(test.usesString("Weak_Password1"));assertFalse(test.usesString("@Str0nG!pa$$woR>%42"));Mockito.reset(test);when(test.usesString((String)isNull())).thenReturn(true);assertTrue(test.usesString(null));Mockito.reset(test);when(test.usesString((String)isNotNull())).thenReturn(true);assertTrue(test.usesString("Anything"));Mockito.reset(test);// Object ReferenceString string1 = new String("hello");String string2 = new String("hello");when(test.usesString(same(string1))).thenReturn(true);assertTrue(test.usesString(string1));assertFalse(test.usesString(string2));Mockito.reset(test);// Compare to eq()when(test.usesString(eq(string1))).thenReturn(true);assertTrue(test.usesString(string1));assertTrue(test.usesString(string2));Mockito.reset(test);when(test.usesVarargs(anyVararg())).thenReturn(true);assertTrue(test.usesVarargs("A","B","C","D","E"));assertTrue(test.usesVarargs("ABC", "123"));assertTrue(test.usesVarargs("Hello!"));Mockito.reset(test);when(test.usesObject(isA(String.class))).thenReturn(true);assertTrue(test.usesObject("A String Object"));assertFalse(test.usesObject(new Integer(7)));Mockito.reset(test);// Field equality using reflectionwhen(test.usesObject(refEq(new SomeBeanWithoutEquals("abc", 123)))).thenReturn(true);assertTrue(test.usesObject(new SomeBeanWithoutEquals("abc", 123)));Mockito.reset(test);// Compare to eq()when(test.usesObject(eq(new SomeBeanWithoutEquals("abc", 123)))).thenReturn(true);assertFalse(test.usesObject(new SomeBeanWithoutEquals("abc", 123)));Mockito.reset(test);when(test.usesObject(eq(new SomeBeanWithEquals("abc", 123)))).thenReturn(true);assertTrue(test.usesObject(new SomeBeanWithEquals("abc", 123)));Mockito.reset(test);}public class SomeBeanWithoutEquals {private String string;private int number;public SomeBeanWithoutEquals(String string, int number) {this.string = string;this.number = number;}}public class SomeBeanWithEquals {private String string;private int number;public SomeBeanWithEquals(String string, int number) {this.string = string;this.number = number;}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + getOuterType().hashCode();result = prime * result + number;result = prime * result+ ((string == null) ? 0 : string.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;SomeBeanWithEquals other = (SomeBeanWithEquals) obj;if (!getOuterType().equals(other.getOuterType()))return false;if (number != other.number)return false;if (string == null) {if (other.string != null)return false;} else if (!string.equals(other.string))return false;return true;}private MatchersTest getOuterType() {return MatchersTest.this;}} }

還可以通過擴展org.mockito.ArgumentMatcher來創建自己的org.mockito.ArgumentMatcher 。 讓我們創建一個匹配器，如果List包含特定元素，該匹配器將觸發。 我們還將創建用于創建Matcher的靜態便利方法，該方法使用argThat將Matcher轉換為List，以便在存根調用中使用。 我們將實現matches()方法來調用List的contains方法來進行實際的contains檢查。

public class ListContainsMatcher<T> extends ArgumentMatcher<List<T>> {private T element;public ListContainsMatcher(T element) {this.element = element;}@Overridepublic boolean matches(Object argument) {@SuppressWarnings("unchecked")List<T> list = (List<T>) argument;return list.contains(element);}public static <T> List<T> contains(T element) {return argThat(new ListContainsMatcher<>(element));} }

現在進行測試，以演示我們的新Matcher的運行！

@RunWith(MockitoJUnitRunner.class) public class ListContainsMatcherTest {public interface TestClass {public boolean usesStrings(List<String> list);public boolean usesIntegers(List<Integer> list);}private List<String> stringList = Arrays.asList("Hello", "Java", "Code", "Geek");private List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);@MockTestClass test;@Testpublic void test() throws Exception {when(test.usesStrings(contains("Java"))).thenReturn(true);when(test.usesIntegers(contains(5))).thenReturn(true);assertTrue(test.usesIntegers(integerList));assertTrue(test.usesStrings(stringList));Mockito.reset(test);when(test.usesStrings(contains("Something Else"))).thenReturn(true);when(test.usesIntegers(contains(42))).thenReturn(true);assertFalse(test.usesStrings(stringList));assertFalse(test.usesIntegers(integerList));Mockito.reset(test);} }

作為練習，嘗試編寫自己的Matcher，如果Map包含特定的鍵/值對，該Matcher將匹配。

6.間諜和部分存根

如前所述，可以使用@Spy批注對類進行部分存根。 部分存根允許我們在測試中使用真實的類，而僅存根與我們有關的特定行為。 Mockito準則告訴我們，在處理遺留代碼時，通常應謹慎偶爾使用間諜。 最佳實踐不是使用Spy部分模擬被測類，而是部分模擬依賴項。 被測類應始終是真實對象。

假設我們正在處理一個在java.awt.BufferedImage上工作的圖像處理類。 此類將BufferedImage放入其構造函數中，并公開一個方法，該方法使用隨機彩色的垂直條紋填充圖像，并根據輸入的縮略圖高度返回圖像的縮略圖。

public class ImageProcessor {private BufferedImage image;public ImageProcessor(BufferedImage image) {this.image = image;}public Image overwriteImageWithStripesAndReturnThumbnail(int thumbHeight) {debugOutputColorSpace();Random random = new Random();Color color = new Color(random.nextInt(255), random.nextInt(255), random.nextInt(255));for (int x = 0; x < image.getWidth(); x++) {if (x % 20 == 0) {color = new Color(random.nextInt(255), random.nextInt(255), random.nextInt(255));for (int y = 0; y < image.getHeight(); y++) {image.setRGB(x, y, color.getRGB());}}}Image thumbnail = image.getScaledInstance(-1, thumbHeight, Image.SCALE_FAST);Image microScale = image.getScaledInstance(-1, 5, Image.SCALE_DEFAULT);debugOutput(microScale);return thumbnail;}private void debugOutput(Image microScale) {System.out.println("Runtime type of microScale Image is " + microScale.getClass());}private void debugOutputColorSpace() {for (int i=0; i< image.getColorModel().getColorSpace().getNumComponents(); i++) {String componentName = image.getColorModel().getColorSpace().getName(i);System.out.println(String.format("Colorspace Component[%d]: %s", i, componentName));}} }

overwriteImageWithStripesAndReturnThumbnail()方法中發生了很多事情。 它要做的第一件事是輸出一些有關圖像色彩空間的調試信息。 然后，它會使用圖像的寬度和高度方法生成一些隨機顏色，并將其繪制為整個圖像中的水平條紋。 然后，它執行縮放操作以返回代表縮略圖的圖像。 然后，它進行第二次縮放操作以生成一個小的診斷微映像，并輸出此微映像的運行時類類型作為調試信息。

我們看到了與BufferedImage的許多交互，其中大多數是完全內部的或隨機的。 最終，當我們要驗證方法的行為時，對我們而言重要的是對getScaledInstance()的首次調用-如果方法的返回值是從getScaledInstance（）返回的對象，則我們的類起作用。 這是BufferedImage的行為，它對我們來說很重要。 我們面臨的問題是對BufferedImages方法還有許多其他調用。 從測試的角度來看，我們實際上并不在乎這些方法的返回值，但是如果我們不對它們的行為進行編碼，則它們將以某種方式導致NullPointerException并可能導致其他不良行為。

為了解決這個問題，我們將為BufferedImage創建一個Spy，并且僅對我們感興趣的getScaledInstance()方法進行存根處理。

讓我們創建一個空的測試類，其中包含正在測試和創建Spy的類，以及用于返回縮略圖的Mock。

@RunWith(MockitoJUnitRunner.class) public class ImageProcessorTest {private ImageProcessor processor;@Spyprivate BufferedImage imageSpy = new BufferedImage(800, 600, BufferedImage.TYPE_INT_ARGB);@MockImage mockThumbnail;@Beforepublic void setup() {processor = new ImageProcessor(imageSpy);} }

請注意，BufferedImage沒有默認構造函數，因此我們必須使用它的參數化構造函數自己實例化它，如果它具有默認構造函數，我們可以讓Mockito為我們實例化它。

現在，讓我們首先嘗試暫存我們感興趣的行為。忽略輸入高度，寬度和模式并繼續對所有三個參數使用Argument Matchers是有意義的。 我們最終得到如下內容：

given(imageSpy.getScaledInstance(anyInt(), anyInt(), anyInt())).willReturn(mockThumbnail);

通常，這是對Spy進行存根的最好方法，但是，在這種情況下會出現問題– imageSpy是一個實際的BufferedImage，并且傳遞given() Given given()的存根調用是在存根操作執行時實際執行的真實方法調用由JVM運行。 getScaledInstance要求寬度和高度不為零，因此此調用將導致引發IllegalArgumentException 。

一種可能的解決方案是在存根調用中使用實參

@Testpublic void scale_should_return_internal_image_scaled() throws Exception {// Givengiven(imageSpy.getScaledInstance(-1, 100, Image.SCALE_FAST)).willReturn(mockThumbnail);// WhenImage actualImage = processor.overwriteImageWithStripesAndReturnThumbnail(100);// ThenassertEquals(actualImage, mockThumbnail);}

該測試成功運行，并在控制臺上產生以下輸出

Colorspace Component[0]: Red Colorspace Component[1]: Green Colorspace Component[2]: Blue Runtime type of microScale Image is class sun.awt.image.ToolkitImage

使用實值的副作用是對getScaledInstance()的第二次調用getScaledInstance()用于創建用于調試的微圖像）無法匹配，并且此時執行了BufferedImage中的real方法，而不是我們的存根行為–這就是為什么我們看到真實值輸出的微圖像的運行時類型，而不是Mockito模擬實現，我們將查看是否將嘲笑縮略圖傳遞給了調試輸出方法。

但是，如果我們想繼續使用參數匹配器怎么辦？ 可以使用doReturn()方法（如果您記得，通常用于void方法）對getScaledInstance()方法進行存根，而無需在存根時實際調用它。

@Testpublic void scale_should_return_internal_image_scaled_doReturn() throws Exception {// GivendoReturn(mockThumbnail).when(imageSpy).getScaledInstance(anyInt(), anyInt(), anyInt());// WhenImage actualImage = processor.overwriteImageWithStripesAndReturnThumbnail(100);// ThenassertEquals(actualImage, mockThumbnail);}

這給出以下輸出：

Colorspace Component[0]: Red Colorspace Component[1]: Green Colorspace Component[2]: Blue Runtime type of microScale Image is class $java.awt.Image$$EnhancerByMockitoWithCGLIB$$72355119

您可以看到微映像的運行時類型現在是Mockito創建的Mock實現。 之所以如此，是因為兩個對getScaledInstance調用getScaledInstance與存根參數匹配，因此兩個調用都返回了Mock縮略圖。

有一種方法可以確保在第二個實例中調用Spy的真實方法，方法是使用doCallRealMethod()方法。 像往常一樣，Mockito讓您將存根方法鏈接在一起，以便為與存根參數匹配的存根方法的連續調用編寫不同的行為。

@Testpublic void scale_should_return_internal_image_scaled_doReturn_doCallRealMethod() throws Exception {// GivendoReturn(mockThumbnail).doCallRealMethod().when(imageSpy).getScaledInstance(anyInt(), anyInt(), anyInt());// WhenImage actualImage = processor.overwriteImageWithStripesAndReturnThumbnail(100);// ThenassertEquals(actualImage, mockThumbnail);}

給出以下輸出

Colorspace Component[0]: Red Colorspace Component[1]: Green Colorspace Component[2]: Blue Runtime type of microScale Image is class sun.awt.image.ToolkitImage

7.結論

我們已經研究了許多針對嘲笑和間諜的舉止行為的方法，并且暗示存在一種幾乎無限的舉止行為的方法。

Mockito的javadoc是有關Stubbing方法（特別是Mockito開箱即用）的ArgumentMatchers的良好信息來源。

我們已經詳細介紹了存根行為，在下一個教程中，我們將研究使用Mockito驗證框架來驗證Mocks的行為。

8.下載源代碼

這是關于Mockito Stubbing的課程。 您可以在此處下載源代碼： mockito2-stubbing

翻譯自: https://www.javacodegeeks.com/2015/11/mocks-spies-partial-mocks-and-stubbing.html

總結

以上是生活随笔為你收集整理的cks子，间谍，局部Mo子和短管的全部內容，希望文章能夠幫你解決所遇到的問題。

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