Mockito - 快速指南

---

---

Mockito - 概述

什麼是 Mock？

Mock 是一種以隔離的方式測試類功能的方法。Mock 不需要資料庫連線或屬性檔案讀取或檔案伺服器讀取來測試功能。Mock 物件模擬真實的服務。Mock 物件返回與傳遞給它的某些虛擬輸入相對應虛擬資料。

Mockito

Mockito 方便無縫建立 Mock 物件。它使用 Java 反射來為給定的介面建立 Mock 物件。Mock 物件只不過是實際實現的代理。

考慮一個返回股票價格詳細資訊的股票服務案例。在開發過程中，無法使用實際的股票服務來獲取即時資料。因此，我們需要股票服務的虛擬實現。Mockito 可以非常輕鬆地做到這一點，正如其名稱所示。

Mockito 的優勢

• 無需手動編寫 - 無需自己編寫 Mock 物件。

• 重構安全 - 重新命名介面方法名稱或重新排序引數不會破壞測試程式碼，因為 Mock 是在執行時建立的。

• 返回值支援 - 支援返回值。

• 異常支援 - 支援異常。

• 順序檢查支援 - 支援檢查方法呼叫的順序。

• 註解支援 - 支援使用註解建立 Mock。

考慮以下程式碼片段。

package com.tutorialspoint.mock;

import java.util.ArrayList;
import java.util.List;

import static org.mockito.Mockito.*;

public class PortfolioTester {
   public static void main(String[] args){

      //Create a portfolio object which is to be tested		
      Portfolio portfolio = new Portfolio();

      //Creates a list of stocks to be added to the portfolio
      List<Stock> stocks = new ArrayList<Stock>();
      Stock googleStock = new Stock("1","Google", 10);
      Stock microsoftStock = new Stock("2","Microsoft",100);

      stocks.add(googleStock);
      stocks.add(microsoftStock);		

      //Create the mock object of stock service
      StockService stockServiceMock = mock(StockService.class);

      // mock the behavior of stock service to return the value of various stocks
      when(stockServiceMock.getPrice(googleStock)).thenReturn(50.00);
      when(stockServiceMock.getPrice(microsoftStock)).thenReturn(1000.00);

      //add stocks to the portfolio
      portfolio.setStocks(stocks);

      //set the stockService to the portfolio
      portfolio.setStockService(stockServiceMock);

      double marketValue = portfolio.getMarketValue();

      //verify the market value to be 
      //10*50.00 + 100* 1000.00 = 500.00 + 100000.00 = 100500
      System.out.println("Market value of the portfolio: "+ marketValue);
   }
}

讓我們瞭解上述程式的重要概念。完整程式碼在第一個應用章節中提供。

• 投資組合 - 一個物件，用於承載股票列表並獲取使用股票價格和股票數量計算的市場價值。

• 股票 - 一個物件，用於承載股票的詳細資訊，例如其 ID、名稱、數量等。

• 股票服務 - 股票服務返回股票的當前價格。

• mock(...) - Mockito 建立了股票服務的 Mock。

• when(...).thenReturn(...) - StockService 介面的 getPrice 方法的 Mock 實現。對於 googleStock，返回 50.00 作為價格。

• portfolio.setStocks(...) - 投資組合現在包含兩個股票的列表。

• portfolio.setStockService(...) - 將 stockService Mock 物件分配給投資組合。

• portfolio.getMarketValue() - 投資組合根據其股票使用 Mock 股票服務返回市場價值。

Mockito - 環境設定

Mockito 是一個 Java 框架，因此首要要求是在您的機器上安裝 JDK。

系統要求

步驟 1 - 驗證您的機器上是否安裝了 Java

開啟控制檯並執行以下java命令。

讓我們驗證所有作業系統的輸出 -

如果您未安裝 Java，要安裝 Java 軟體開發工具包 (SDK)，點選此處。

在本教程中，我們假設您的系統上安裝了 Java 1.6.0_21。

步驟 2 - 設定 JAVA 環境

設定JAVA_HOME環境變數以指向 Java 安裝在您的機器上的基本目錄位置。例如，

將 Java 編譯器的路徑新增到系統路徑中。

如上所述，使用命令java -version驗證 Java 安裝。

步驟 3 - 下載 Mockito-All 歸檔檔案

要從 Maven 儲存庫下載 Mockito 的最新版本，點選此處。

將 jar 檔案儲存到您的 C 盤，例如，C:\>Mockito。

步驟 4 - 設定 Mockito 環境

設定Mockito_HOME環境變數以指向 Mockito 和依賴項 jar 儲存在您的機器上的基本目錄位置。下表顯示瞭如何在不同的作業系統上設定環境變數，假設我們已將 mockito-all-2.0.2-beta.jar 解壓縮到 C:\>Mockito 資料夾中。

步驟 5 - 設定 CLASSPATH 變數

設定CLASSPATH環境變數以指向 Mockito jar 儲存的位置。下表顯示瞭如何在不同的作業系統上設定 CLASSPATH 變數。

步驟 6 - 下載 JUnit 歸檔檔案

從Github下載 JUnit jar 檔案的最新版本。將資料夾儲存到 C:\>Junit 位置。

步驟 7 - 設定 JUnit 環境

設定JUNIT_HOME環境變數以指向 JUnit jar 儲存在您的機器上的基本目錄位置。下表顯示瞭如何在不同的作業系統上設定此環境變數，假設我們已將 junit4.11.jar 和 hamcrest-core-1.2.1.jar 儲存在 C:\>Junit 中。

步驟 8 - 設定 CLASSPATH 變數

設定 CLASSPATH 環境變數以指向 JUNIT jar 的位置。下表顯示瞭如何在不同的作業系統上執行此操作。

Mockito - 第一個應用

在深入瞭解 Mockito 框架的細節之前，讓我們先看看一個應用的實際操作。在此示例中，我們建立了一個股票服務的 Mock，以獲取某些股票的虛擬價格，並對名為 Portfolio 的 Java 類進行了單元測試。

該過程將在下面分步驟討論。

步驟 1 - 建立一個 JAVA 類來表示股票

檔案：Stock.java

public class Stock {
   private String stockId;
   private String name;	
   private int quantity;

   public Stock(String stockId, String name, int quantity){
      this.stockId = stockId;
      this.name = name;		
      this.quantity = quantity;		
   }

   public String getStockId() {
      return stockId;
   }

   public void setStockId(String stockId) {
      this.stockId = stockId;
   }

   public int getQuantity() {
      return quantity;
   }

   public String getTicker() {
      return name;
   }
}

步驟 2 - 建立一個介面 StockService 來獲取股票的價格

檔案：StockService.java

public interface StockService {
   public double getPrice(Stock stock);
}

步驟 3 - 建立一個類 Portfolio 來表示任何客戶的投資組合

檔案：Portfolio.java

import java.util.List;

public class Portfolio {
   private StockService stockService;
   private List<Stock> stocks;

   public StockService getStockService() {
      return stockService;
   }
   
   public void setStockService(StockService stockService) {
      this.stockService = stockService;
   }

   public List<Stock> getStocks() {
      return stocks;
   }

   public void setStocks(List<Stock> stocks) {
      this.stocks = stocks;
   }

   public double getMarketValue(){
      double marketValue = 0.0;
      
      for(Stock stock:stocks){
         marketValue += stockService.getPrice(stock) * stock.getQuantity();
      }
      return marketValue;
   }
}

步驟 4 - 測試 Portfolio 類

讓我們透過向其中注入 stockservice 的 Mock 來測試 Portfolio 類。Mock 將由 Mockito 建立。

檔案：PortfolioTester.java

package com.tutorialspoint.mock;

import java.util.ArrayList;
import java.util.List;

import static org.mockito.Mockito.*;

public class PortfolioTester {
	
   Portfolio portfolio;	
   StockService stockService;
	   
   
   public static void main(String[] args){
      PortfolioTester tester = new PortfolioTester();
      tester.setUp();
      System.out.println(tester.testMarketValue()?"pass":"fail");
   }
   
   public void setUp(){
      //Create a portfolio object which is to be tested		
      portfolio = new Portfolio();		
  
      //Create the mock object of stock service
      stockService = mock(StockService.class);		

      //set the stockService to the portfolio
      portfolio.setStockService(stockService);
   }
   
   public boolean testMarketValue(){
    	   
      //Creates a list of stocks to be added to the portfolio
      List<Stock> stocks = new ArrayList<Stock>();
      Stock googleStock = new Stock("1","Google", 10);
      Stock microsoftStock = new Stock("2","Microsoft",100);	
 
      stocks.add(googleStock);
      stocks.add(microsoftStock);

      //add stocks to the portfolio
      portfolio.setStocks(stocks);

      //mock the behavior of stock service to return the value of various stocks
      when(stockService.getPrice(googleStock)).thenReturn(50.00);
      when(stockService.getPrice(microsoftStock)).thenReturn(1000.00);		

      double marketValue = portfolio.getMarketValue();		
      return marketValue == 100500.0;
   }
}

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac Stock.java StockService.java Portfolio.java PortfolioTester.java

現在執行 PortfolioTester 以檢視結果 -

C:\Mockito_WORKSPACE>java PortfolioTester

驗證輸出

pass

Mockito - JUnit 整合

在本節中，我們將學習如何將 JUnit 和 Mockito 整合在一起。在這裡，我們將建立一個使用 CalculatorService 執行基本數學運算（如加法、減法、乘法和除法）的數學應用。

我們將使用 Mockito 模擬 CalculatorService 的虛擬實現。此外，我們廣泛使用了註解來展示它們與 JUnit 和 Mockito 的相容性。

該過程將在下面分步驟討論。

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   //@InjectMocks annotation is used to create and inject the mock object
   @InjectMocks 
   MathApplication mathApplication = new MathApplication();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   public void testAdd(){
      //add the behavior of calc service to add two numbers
      when(calcService.add(10.0,20.0)).thenReturn(30.00);
		
      //test the add functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
   }
}

步驟 4 - 建立一個類來執行測試用例

在C> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true

要了解有關 JUnit 的更多資訊，請參閱 Tutorials Point 上的 JUnit 教程。

Mockito - 新增行為

Mockito 使用when()方法向 Mock 物件新增功能。請檢視以下程式碼片段。

//add the behavior of calc service to add two numbers
when(calcService.add(10.0,20.0)).thenReturn(30.00);

在這裡，我們指示 Mockito 為calcService的add方法新增 10 和 20 的行為，並因此返回 30.00 的值。

此時，Mock 記錄了行為，並且是一個正在工作的 Mock 物件。

//add the behavior of calc service to add two numbers
when(calcService.add(10.0,20.0)).thenReturn(30.00);

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   //@InjectMocks annotation is used to create and inject the mock object
   @InjectMocks 
   MathApplication mathApplication = new MathApplication();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   public void testAdd(){
      //add the behavior of calc service to add two numbers
      when(calcService.add(10.0,20.0)).thenReturn(30.00);
		
      //test the add functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
   }
}

步驟 4 - 執行測試用例

在C:\>Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true

Mockito - 驗證行為

Mockito 可以確保是否正在使用所需的引數呼叫 Mock 方法。這是使用verify()方法完成的。請檢視以下程式碼片段。

//test the add functionality
Assert.assertEquals(calcService.add(10.0, 20.0),30.0,0);


//verify call to calcService is made or not with same arguments.
verify(calcService).add(10.0, 20.0);

示例 - 使用相同引數的 verify()

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      //return calcService.add(input1, input2);
      return input1 + input2;
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   //@InjectMocks annotation is used to create and inject the mock object
   @InjectMocks 
   MathApplication mathApplication = new MathApplication();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   public void testAdd(){
      //add the behavior of calc service to add two numbers
      when(calcService.add(10.0,20.0)).thenReturn(30.00);
		
      //test the add functionality
      Assert.assertEquals(calcService.add(10.0, 20.0),30.0,0);

       
      //verify the behavior
      verify(calcService).add(10.0, 20.0);
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true

示例 - 使用不同引數的 verify()

步驟 1 - 建立一個介面 CalculatorService 以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      //return calcService.add(input1, input2);
      return input1 + input2;
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   //@InjectMocks annotation is used to create and inject the mock object
   @InjectMocks 
   MathApplication mathApplication = new MathApplication();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   public void testAdd(){
      //add the behavior of calc service to add two numbers
      when(calcService.add(10.0,20.0)).thenReturn(30.00);
		
      //test the add functionality
      Assert.assertEquals(calcService.add(10.0, 20.0),30.0,0);

       
      //verify the behavior
      verify(calcService).add(20.0, 30.0);
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

testAdd(MathApplicationTester): 
Argument(s) are different! Wanted:
calcService.add(20.0, 30.0);
-> at MathApplicationTester.testAdd(MathApplicationTester.java:32)
Actual invocation has different arguments:
calcService.add(10.0, 20.0);
-> at MathApplication.add(MathApplication.java:10)

false

Mockito - 期望呼叫

Mockito 對可以對特定方法進行的呼叫次數進行特殊檢查。假設 MathApplication 應該只調用 CalculatorService.serviceUsed() 方法一次，那麼它不應該能夠呼叫 CalculatorService.serviceUsed() 超過一次。

//add the behavior of calc service to add two numbers
when(calcService.add(10.0,20.0)).thenReturn(30.00);

//limit the method call to 1, no less and no more calls are allowed
verify(calcService, times(1)).add(10.0, 20.0);

如下建立 CalculatorService 介面。

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){		      
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.never;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   //@InjectMocks annotation is used to create and inject the mock object
   @InjectMocks 
   MathApplication mathApplication = new MathApplication();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   public void testAdd(){
      //add the behavior of calc service to add two numbers
      when(calcService.add(10.0,20.0)).thenReturn(30.00);
		
      //add the behavior of calc service to subtract two numbers
      when(calcService.subtract(20.0,10.0)).thenReturn(10.00);
      
      //test the add functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
      
      //test the subtract functionality
      Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0.0);
      
      //default call count is 1 
      verify(calcService).subtract(20.0, 10.0);
      
      //check if add function is called three times
      verify(calcService, times(3)).add(10.0, 20.0);
      
      //verify that method was never called on a mock
      verify(calcService, never()).multiply(10.0,20.0);
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true

Mockito - 變化呼叫

Mockito 提供以下其他方法來改變預期的呼叫次數。

• atLeast (int min) - 期望至少 min 次呼叫。

• atLeastOnce () - 期望至少一次呼叫。

• atMost (int max) - 期望最多 max 次呼叫。

示例

步驟 1 - 建立一個介面 CalculatorService 以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.atMost;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   //@InjectMocks annotation is used to create and inject the mock object
   @InjectMocks 
   MathApplication mathApplication = new MathApplication();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   public void testAdd(){
      //add the behavior of calc service to add two numbers
      when(calcService.add(10.0,20.0)).thenReturn(30.00);
		
      //add the behavior of calc service to subtract two numbers
      when(calcService.subtract(20.0,10.0)).thenReturn(10.00);
      
      //test the add functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
      
      //test the subtract functionality
      Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0.0);
      
      //check a minimum 1 call count
      verify(calcService, atLeastOnce()).subtract(20.0, 10.0);
      
      //check if add function is called minimum 2 times
      verify(calcService, atLeast(2)).add(10.0, 20.0);
      
      //check if add function is called maximum 3 times
      verify(calcService, atMost(3)).add(10.0,20.0);     
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true

Mockito - 異常處理

Mockito 使 Mock 能夠丟擲異常，以便可以測試異常處理。請檢視以下程式碼片段。

//add the behavior to throw exception
doThrow(new Runtime Exception("divide operation not implemented"))
   .when(calcService).add(10.0,20.0);

在這裡，我們向 Mock 物件添加了一個異常子句。MathApplication 使用其 add 方法使用 calcService，並且只要呼叫 calcService.add() 方法，Mock 就會丟擲 RuntimeException。

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.doThrow;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoRunner.class)
public class MathApplicationTester {
	
   // @TestSubject annotation is used to identify class 
      which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test(expected = RuntimeException.class)
   public void testAdd(){
      //add the behavior to throw exception
      doThrow(new RuntimeException("Add operation not implemented"))
         .when(calcService).add(10.0,20.0);

      //test the add functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0); 
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

testAdd(MathApplicationTester): Add operation not implemented
false

Mockito - 建立 Mock

到目前為止，我們一直使用註解來建立 Mock。Mockito 提供了各種方法來建立 Mock 物件。mock() 建立 Mock，而不必擔心 Mock 在其操作過程中將要進行的方法呼叫的順序。

語法

calcService = mock(CalculatorService.class);

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

在這裡，我們透過 when() 向 Mock 物件添加了兩個 Mock 方法呼叫，add() 和 subtract()。但是，在測試期間，我們在呼叫 add() 之前呼叫了 subtract()。當我們使用 create() 建立 Mock 物件時，方法的執行順序無關緊要。

檔案：MathApplicationTester.java

package com.tutorialspoint.mock;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   private MathApplication mathApplication;
   private CalculatorService calcService;

   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      calcService = mock(CalculatorService.class);
      mathApplication.setCalculatorService(calcService);
   }

   @Test
   public void testAddAndSubtract(){

      //add the behavior to add numbers
      when(calcService.add(20.0,10.0)).thenReturn(30.0);

      //subtract the behavior to subtract numbers
      when(calcService.subtract(20.0,10.0)).thenReturn(10.0);

      //test the subtract functionality
      Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);

      //test the add functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);

      //verify call to calcService is made or not
      verify(calcService).add(20.0,10.0);
      verify(calcService).subtract(20.0,10.0);
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true

Mockito - 有序驗證

Mockito 提供了 Inorder 類，用於處理模擬物件在執行過程中方法呼叫的順序。

語法

//create an inOrder verifier for a single mock
InOrder inOrder = inOrder(calcService);

//following will make sure that add is first called then subtract is called.
inOrder.verify(calcService).add(20.0,10.0);
inOrder.verify(calcService).subtract(20.0,10.0);

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

這裡我們在模擬物件上透過 when() 添加了兩個模擬方法呼叫，add() 和 subtract()。但是，在測試過程中，我們在呼叫 add() 之前呼叫了 subtract()。當我們使用 Mockito 建立模擬物件時，方法的執行順序並不重要。使用 InOrder 類，我們可以確保呼叫順序。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.inOrder;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   private MathApplication mathApplication;
   private CalculatorService calcService;

   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      calcService = mock(CalculatorService.class);
      mathApplication.setCalculatorService(calcService);
   }

   @Test
   public void testAddAndSubtract(){

      //add the behavior to add numbers
      when(calcService.add(20.0,10.0)).thenReturn(30.0);

      //subtract the behavior to subtract numbers
      when(calcService.subtract(20.0,10.0)).thenReturn(10.0);

      //test the add functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);

      //test the subtract functionality
      Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);

      //create an inOrder verifier for a single mock
      InOrder inOrder = inOrder(calcService);

      //following will make sure that add is first called then subtract is called.
      inOrder.verify(calcService).subtract(20.0,10.0);
      inOrder.verify(calcService).add(20.0,10.0);
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

testAddAndSubtract(MathApplicationTester): 
Verification in order failure
Wanted but not invoked:
calculatorService.add(20.0, 10.0);
-> at MathApplicationTester.testAddAndSubtract(MathApplicationTester.java:48)
Wanted anywhere AFTER following interaction:
calculatorService.subtract(20.0, 10.0);
-> at MathApplication.subtract(MathApplication.java:13)
false

Mockito - 回撥

Mockito 提供了一個 Answer 介面，允許使用泛型介面進行存根。

語法

//add the behavior to add numbers
when(calcService.add(20.0,10.0)).thenAnswer(new Answer<Double>() {
   @Override
   public Double answer(InvocationOnMock invocation) throws Throwable {
      //get the arguments passed to mock
      Object[] args = invocation.getArguments();
      //get the mock 
      Object mock = invocation.getMock();	
      //return the result
      return 30.0;
   }
});

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

這裡我們在模擬物件上透過 when() 添加了一個模擬方法呼叫，add()。但是，在測試過程中，我們在呼叫 add() 之前呼叫了 subtract()。當我們使用 Mockito.createStrictMock() 建立模擬物件時，方法的執行順序很重要。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.inOrder;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   private MathApplication mathApplication;
   private CalculatorService calcService;

   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      calcService = mock(CalculatorService.class);
      mathApplication.setCalculatorService(calcService);
   }

   @Test
   public void testAdd(){

      //add the behavior to add numbers
      when(calcService.add(20.0,10.0)).thenAnswer(new Answer<Double>() {

         @Override
         public Double answer(InvocationOnMock invocation) throws Throwable {
            //get the arguments passed to mock
            Object[] args = invocation.getArguments();
				
            //get the mock 
            Object mock = invocation.getMock();	
				
            //return the result
            return 30.0;
         }
      });

      //test the add functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true

Mockito - 監控

Mockito 提供了在真實物件上建立 spy 的選項。當呼叫 spy 時，會呼叫真實物件的方法。

語法

//create a spy on actual object
calcService = spy(calculator);

//perform operation on real object
//test the add functionality
Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

這裡我們在模擬物件上透過 when() 添加了一個模擬方法呼叫，add()。但是，在測試過程中，我們在呼叫 add() 之前呼叫了 subtract()。當我們使用 Mockito.createStrictMock() 建立模擬物件時，方法的執行順序很重要。

檔案：MathApplicationTester.java

import static org.mockito.Mockito.spy;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   private MathApplication mathApplication;
   private CalculatorService calcService;

   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      Calculator calculator = new Calculator();
      calcService = spy(calculator);
      mathApplication.setCalculatorService(calcService);	     
   }

   @Test
   public void testAdd(){

      //perform operation on real object
      //test the add functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
   }

   class Calculator implements CalculatorService {
      @Override
      public double add(double input1, double input2) {
         return input1 + input2;
      }

      @Override
      public double subtract(double input1, double input2) {
         throw new UnsupportedOperationException("Method not implemented yet!");
      }

      @Override
      public double multiply(double input1, double input2) {
         throw new UnsupportedOperationException("Method not implemented yet!");
      }

      @Override
      public double divide(double input1, double input2) {
         throw new UnsupportedOperationException("Method not implemented yet!");
      }
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true

Mockito - 重置 Mock

Mockito 提供了重置模擬物件的功能，以便以後可以重複使用。請檢視以下程式碼片段。

//reset mock
reset(calcService);

這裡我們重置了模擬物件。MathApplication 使用了 calcService，並且在重置模擬物件後，使用模擬方法將導致測試失敗。

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

package com.tutorialspoint.mock;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.reset;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   private MathApplication mathApplication;
   private CalculatorService calcService;

   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      calcService = mock(CalculatorService.class);
      mathApplication.setCalculatorService(calcService);
   }

   @Test
   public void testAddAndSubtract(){

      //add the behavior to add numbers
      when(calcService.add(20.0,10.0)).thenReturn(30.0);
  
      //test the add functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);

      //reset the mock	  
      reset(calcService);

      //test the add functionality after resetting the mock
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);   
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

testAddAndSubtract(MathApplicationTester): expected:<0.0> but was:<30.0>
false

Mockito - 行為驅動開發

行為驅動開發是一種編寫測試的風格，使用 **given**、**when** 和 **then** 格式作為測試方法。Mockito 提供了專門的方法來做到這一點。請檢視以下程式碼片段。

//Given
given(calcService.add(20.0,10.0)).willReturn(30.0);

//when
double result = calcService.add(20.0,10.0);

//then
Assert.assertEquals(result,30.0,0);	     

這裡我們使用 BDDMockito 類的 **given** 方法代替了 . 的 **when** 方法。

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

package com.tutorialspoint.mock;

import static org.mockito.BDDMockito.*;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   private MathApplication mathApplication;
   private CalculatorService calcService;

   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      calcService = mock(CalculatorService.class);
      mathApplication.setCalculatorService(calcService);
   }

   @Test
   public void testAdd(){

      //Given
      given(calcService.add(20.0,10.0)).willReturn(30.0);

      //when
      double result = calcService.add(20.0,10.0);

      //then
      Assert.assertEquals(result,30.0,0);   
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true

Mockito - 超時

Mockito 提供了一個特殊的 Timeout 選項來測試方法是否在規定的時間範圍內被呼叫。

語法

//passes when add() is called within 100 ms.
verify(calcService,timeout(100)).add(20.0,10.0);

示例

步驟 1 - 建立一個名為 CalculatorService 的介面以提供數學函式

檔案：CalculatorService.java

public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);
}

步驟 2 - 建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;

   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   
   public double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);
   }
}

步驟 3 - 測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的 Mock 來測試 MathApplication 類。Mock 將由 Mockito 建立。

檔案：MathApplicationTester.java

package com.tutorialspoint.mock;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
@RunWith(MockitoJUnitRunner.class)
public class MathApplicationTester {
	
   private MathApplication mathApplication;
   private CalculatorService calcService;

   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      calcService = mock(CalculatorService.class);
      mathApplication.setCalculatorService(calcService);
   }

   @Test
   public void testAddAndSubtract(){

      //add the behavior to add numbers
      when(calcService.add(20.0,10.0)).thenReturn(30.0);

      //subtract the behavior to subtract numbers
      when(calcService.subtract(20.0,10.0)).thenReturn(10.0);

      //test the subtract functionality
      Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);

      //test the add functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);

      //verify call to add method to be completed within 100 ms
      verify(calcService, timeout(100)).add(20.0,10.0);
	  
      //invocation count can be added to ensure multiplication invocations
      //can be checked within given timeframe
      verify(calcService, timeout(100).times(1)).subtract(20.0,10.0);
   }
}

步驟 4 - 執行測試用例

在C:\> Mockito_WORKSPACE中建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      
      System.out.println(result.wasSuccessful());
   }
}  	

步驟 5 - 驗證結果

使用javac編譯器編譯類，如下所示 -

C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
   java MathApplicationTester.java TestRunner.java

現在執行 Test Runner 以檢視結果 -

C:\Mockito_WORKSPACE>java TestRunner

驗證輸出。

true