Mockito - Hướng dẫn nhanh

Chế giễu là gì?

Chế nhạo là một cách để kiểm tra chức năng của một lớp một cách riêng biệt. Chế độ giả không yêu cầu kết nối cơ sở dữ liệu hoặc đọc tệp thuộc tính hoặc đọc máy chủ tệp để kiểm tra chức năng. Các đối tượng giả mạo thực hiện việc chế nhạo dịch vụ thực. Một đối tượng giả trả về một dữ liệu giả tương ứng với một số đầu vào giả được chuyển cho nó.

Mockito

Mockito tạo điều kiện cho việc tạo các đối tượng giả một cách liền mạch. Nó sử dụng Java Reflection để tạo các đối tượng giả cho một giao diện nhất định. Đối tượng giả mạo không là gì ngoài proxy cho các triển khai thực tế.

Hãy xem xét một trường hợp của Dịch vụ Chứng khoán trả về chi tiết giá của một cổ phiếu. Trong quá trình phát triển, không thể sử dụng dịch vụ chứng khoán thực tế để lấy dữ liệu thời gian thực. Vì vậy, chúng tôi cần một triển khai giả của dịch vụ chứng khoán. Mockito có thể làm điều tương tự rất dễ dàng, như tên gọi của nó.

Lợi ích của Mockito

  • No Handwriting - Không cần phải viết các đối tượng giả của riêng bạn.

  • Refactoring Safe - Đổi tên tên phương thức giao diện hoặc sắp xếp lại các tham số sẽ không phá vỡ mã kiểm tra vì Mocks được tạo trong thời gian chạy.

  • Return value support - Hỗ trợ giá trị trả về.

  • Exception support - Hỗ trợ các trường hợp ngoại lệ.

  • Order check support - Hỗ trợ kiểm tra thứ tự của các cuộc gọi phương thức.

  • Annotation support - Hỗ trợ tạo chế độ giả bằng chú thích.

Hãy xem xét đoạn mã sau.

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);
   }
}

Chúng ta hãy hiểu các khái niệm quan trọng của chương trình trên. Mã hoàn chỉnh có sẵn trong chươngFirst Application.

  • Portfolio - Đối tượng để ghi danh sách cổ phiếu và tính giá trị thị trường bằng cách sử dụng giá cổ phiếu và số lượng cổ phiếu.

  • Stock - Một đối tượng để mang các thông tin chi tiết của cổ phiếu như id, tên, số lượng, v.v.

  • StockService - Một dịch vụ cổ phiếu trả về giá hiện tại của một cổ phiếu.

  • mock(...) - Mockito đã tạo ra một bản mô phỏng dịch vụ chứng khoán.

  • when(...).thenReturn(...)- Mô phỏng thực hiện phương thức getPrice của giao diện stockService. Đối với googleStock, trả lại 50,00 như giá.

  • portfolio.setStocks(...) - Danh mục đầu tư hiện có danh sách hai cổ phiếu.

  • portfolio.setStockService(...) - Gán đối tượng stockService Mock vào danh mục đầu tư.

  • portfolio.getMarketValue() - Danh mục đầu tư trả lại giá trị thị trường dựa trên cổ phiếu của nó bằng cách sử dụng dịch vụ chứng khoán giả.

Mockito là một khuôn khổ cho Java, vì vậy yêu cầu đầu tiên là phải cài đặt JDK trong máy của bạn.

Yêu cầu hệ thống

JDK 1,5 trở lên.
Ký ức không có yêu cầu tối thiểu.
Dung lượng đĩa không có yêu cầu tối thiểu.
Hệ điều hành không có yêu cầu tối thiểu.

Step 1 − Verify Java Installation on Your Machine

Mở bảng điều khiển và thực hiện các thao tác sau java chỉ huy.

Hệ điều hành Bài tập Chỉ huy
các cửa sổ Mở bảng điều khiển lệnh c: \> java -version
Linux Mở Command Terminal $ java -version
Mac Mở thiết bị đầu cuối machine:> joseph $ java -version

Hãy xác minh kết quả đầu ra cho tất cả các hệ điều hành -

Hệ điều hành Đầu ra
các cửa sổ

phiên bản java "1.6.0_21"

Môi trường thời gian chạy Java (TM) SE (bản dựng 1.6.0_21-b07)

Máy khách Java HotSpot (TM) (xây dựng 17.0-b17, chế độ hỗn hợp, chia sẻ)
Linux

phiên bản java "1.6.0_21"

Môi trường thời gian chạy Java (TM) SE (bản dựng 1.6.0_21-b07)

Máy khách Java HotSpot (TM) (xây dựng 17.0-b17, chế độ hỗn hợp, chia sẻ)
Mac

phiên bản java "1.6.0_21"

Môi trường thời gian chạy Java (TM) SE (bản dựng 1.6.0_21-b07)

Máy chủ ảo Java HotSpot (TM) 64-Bit (bản dựng 17.0-b17, chế độ hỗn hợp, chia sẻ)

Nếu bạn chưa cài đặt Java, Để cài đặt Bộ phát triển phần mềm Java (SDK), hãy nhấp vào đây.

Chúng tôi giả sử bạn đã cài đặt Java 1.6.0_21 trên hệ thống của mình cho hướng dẫn này.

Step 2 − Set JAVA Environment

Đặt JAVA_HOMEbiến môi trường để trỏ đến vị trí thư mục cơ sở nơi Java được cài đặt trên máy của bạn. Ví dụ,

Hệ điều hành Đầu ra
các cửa sổ Đặt biến môi trường JAVA_HOME thành C: \ Program Files \ Java \ jdk1.6.0_21
Linux xuất JAVA_HOME = / usr / local / java-current
Mac export JAVA_HOME = / Library / Java / Home

Nối vị trí của trình biên dịch Java vào Đường dẫn hệ thống của bạn.

Hệ điều hành Đầu ra
các cửa sổ Nối chuỗi; C: \ Program Files \ Java \ jdk1.6.0_21 \ bin vào cuối biến hệ thống, Đường dẫn.
Linux xuất PATH = $ PATH: $ JAVA_HOME / bin /
Mac không yêu cầu

Xác minh cài đặt Java bằng lệnh java -version Như đã giải thích ở trên.

Step 3 − Download Mockito-All Archive

Để tải xuống phiên bản Mockito mới nhất từ ​​Maven Repository, hãy nhấp vào đây.

Lưu tệp jar trên ổ C của bạn, giả sử C: \> Mockito.

Hệ điều hành Tên lưu trữ
các cửa sổ mockito-all-2.0.2-beta.jar
Linux mockito-all-2.0.2-beta.jar
Mac mockito-all-2.0.2-beta.jar

Step 4 − Set Mockito Environment

Đặt Mockito_HOMEbiến môi trường để trỏ đến vị trí thư mục cơ sở nơi Mockito và các lọ phụ thuộc được lưu trữ trên máy của bạn. Bảng sau đây cho thấy cách đặt biến môi trường trên các hệ điều hành khác nhau, giả sử chúng ta đã giải nén mockito-all-2.0.2-beta.jar vào thư mục C: \> Mockito.

Hệ điều hành Đầu ra
các cửa sổ Đặt biến môi trường Mockito_HOME thành C: \ Mockito
Linux xuất Mockito_HOME = / usr / local / Mockito
Mac xuất Mockito_HOME = / Library / Mockito

Step 5 − Set CLASSPATH Variable

Đặt CLASSPATHbiến môi trường để trỏ đến vị trí lưu trữ bình Mockito. Bảng sau đây cho thấy cách đặt biến CLASSPATH trên các hệ điều hành khác nhau.

Hệ điều hành Đầu ra
các cửa sổ Đặt biến môi trường CLASSPATH thành% CLASSPATH%;% Mockito_HOME% \ mockito-all-2.0.2-beta.jar;.;
Linux xuất CLASSPATH = $ CLASSPATH: $ Mockito_HOME / mockito-all-2.0.2-beta.jar:.
Mac xuất CLASSPATH = $ CLASSPATH: $ Mockito_HOME / mockito-all-2.0.2-beta.jar:.

Step 6 − Download JUnit Archive

Tải xuống phiên bản mới nhất của tệp jar JUnit từ Github . Lưu thư mục tại vị trí C: \> Junit.

Hệ điều hành Tên lưu trữ
các cửa sổ junit4.11.jar, hamcrest-core-1.2.1.jar
Linux junit4.11.jar, hamcrest-core-1.2.1.jar
Mac junit4.11.jar, hamcrest-core-1.2.1.jar

Step 7 − Set JUnit Environment

Đặt JUNIT_HOMEbiến môi trường để trỏ đến vị trí thư mục cơ sở nơi lưu trữ các lọ JUnit trên máy của bạn. Bảng sau đây cho thấy cách đặt biến môi trường này trên các hệ điều hành khác nhau, giả sử chúng ta đã lưu trữ junit4.11.jar và hamcrest-core-1.2.1.jar tại C: \> Junit.

Hệ điều hành Đầu ra
các cửa sổ Đặt biến môi trường JUNIT_HOME thành C: \ JUNIT
Linux xuất JUNIT_HOME = / usr / local / JUNIT
Mac xuất JUNIT_HOME = / Library / JUNIT

Step 8 − Set CLASSPATH Variable

Đặt biến môi trường CLASSPATH trỏ đến vị trí jar JUNIT. Bảng sau đây cho thấy cách nó được thực hiện trên các hệ điều hành khác nhau.

Hệ điều hành Đầu ra
các cửa sổ Đặt biến môi trường CLASSPATH thành% CLASSPATH%;% JUNIT_HOME% \ junit4.11.jar;% JUNIT_HOME% \ hamcrest-core-1.2.1.jar;.;
Linux xuất CLASSPATH = $ CLASSPATH: $ JUNIT_HOME / junit4.11.jar: $ JUNIT_HOME / hamcrest-core-1.2.1.jar:.
Mac xuất CLASSPATH = $ CLASSPATH: $ JUNIT_HOME / junit4.11.jar: $ JUNIT_HOME / hamcrest-core-1.2.1.jar:.

Trước khi đi vào chi tiết của Mockito Framework, chúng ta hãy xem một ứng dụng đang hoạt động. Trong ví dụ này, chúng tôi đã tạo một mô hình Dịch vụ chứng khoán để lấy giá giả của một số cổ phiếu và đơn vị đã thử nghiệm một lớp java có tên là Danh mục đầu tư.

Quy trình được thảo luận dưới đây theo cách thức từng bước.

Step 1 − Create a JAVA class to represent the Stock

File: 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;
   }
}

Step 2 − Create an interface StockService to get the price of a stock

File: StockService.java

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

Step 3 − Create a class Portfolio to represent the portfolio of any client

File: 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;
   }
}

Step 4 − Test the Portfolio class

Hãy kiểm tra lớp Danh mục đầu tư, bằng cách đưa vào đó một mô hình dịch vụ chứng khoán. Mock sẽ được tạo bởi Mockito.

File: 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;
   }
}

Step 5 − Verify the result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy PortfolioTester để xem kết quả -

C:\Mockito_WORKSPACE>java PortfolioTester

Xác minh đầu ra

pass

Trong chương này, chúng ta sẽ tìm hiểu cách tích hợp JUnit và Mockito với nhau. Ở đây chúng ta sẽ tạo một Ứng dụng Toán học sử dụng CalculatorService để thực hiện các phép toán cơ bản như cộng, trừ, nhân và chia.

Chúng tôi sẽ sử dụng Mockito để mô phỏng việc triển khai giả của CalculatorService. Ngoài ra, chúng tôi đã sử dụng rộng rãi các chú thích để giới thiệu khả năng tương thích của chúng với cả JUnit và Mockito.

Quy trình được thảo luận dưới đây theo cách thức từng bước.

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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);
   }
}

Step 4 − Create a class to execute to test cases

Tạo tệp lớp java có tên TestRunner trong C> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true

Để tìm hiểu thêm về JUnit, vui lòng tham khảo Hướng dẫn JUnit tại Tutorials Point.

Mockito thêm một chức năng vào một đối tượng giả sử dụng các phương thức when(). Hãy xem đoạn mã sau.

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

Ở đây, chúng tôi đã hướng dẫn Mockito đưa ra hành vi thêm 10 và 20 vào add phương pháp của calcService và kết quả là trả về giá trị 30,00.

Tại thời điểm này, Mock đã ghi lại hành vi và là đối tượng giả đang hoạt động.

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

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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);
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\>Mockito_WORKSPACE để thực thi (các) trường hợp thử nghiệm.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true

Mockito có thể đảm bảo liệu một phương thức giả có đang được gọi với các đối số được yêu cầu hay không. Nó được thực hiện bằng cách sử dụngverify()phương pháp. Hãy xem đoạn mã sau.

//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);

Ví dụ - verify () với các đối số giống nhau

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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);
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true

Ví dụ - verify () với các đối số khác nhau

Step 1 − Create an interface CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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);
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

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 cung cấp một kiểm tra đặc biệt về số lượng cuộc gọi có thể được thực hiện trên một phương thức cụ thể. Giả sử MathApplication chỉ nên gọi phương thức CalculatorService.serviceUsed () một lần, thì nó sẽ không thể gọi CalculatorService.serviceUsed () nhiều hơn một lần.

//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);

Tạo giao diện CalculatorService như sau.

File: 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);
}

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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);
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true

Mockito cung cấp các phương pháp bổ sung sau để thay đổi số lượng cuộc gọi dự kiến.

  • atLeast (int min) - mong đợi cuộc gọi tối thiểu.

  • atLeastOnce () - mong đợi ít nhất một cuộc gọi.

  • atMost (int max) - mong đợi cuộc gọi tối đa.

Thí dụ

Step 1 − Create an interface CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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);     
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp kiểm tra

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true

Mockito cung cấp khả năng giả lập để ném các ngoại lệ, vì vậy việc xử lý ngoại lệ có thể được kiểm tra. Hãy xem đoạn mã sau.

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

Ở đây chúng tôi đã thêm một mệnh đề ngoại lệ vào một đối tượng giả. MathApplication sử dụng calcService bằng cách sử dụng phương thức thêm của nó và mô hình ném một RuntimeException bất cứ khi nào phương thức calcService.add () được gọi.

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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); 
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

testAdd(MathApplicationTester): Add operation not implemented
false

Cho đến nay, chúng tôi đã sử dụng các chú thích để tạo ra các mô phỏng. Mockito cung cấp nhiều phương pháp khác nhau để tạo các đối tượng giả. mock () tạo mocks mà không cần bận tâm về thứ tự của các lệnh gọi phương thức mà mock sẽ thực hiện trong quá trình hoạt động của nó.

Cú pháp

calcService = mock(CalculatorService.class);

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

Ở đây chúng tôi đã thêm hai cuộc gọi phương thức giả, add () và subtract (), vào đối tượng giả thông qua when (). Tuy nhiên, trong quá trình thử nghiệm, chúng tôi đã gọi là subtract () trước khi gọi add (). Khi chúng ta tạo một đối tượng giả sử dụng create (), thứ tự thực thi của phương thức không quan trọng.

File: 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);
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true

Mockito cung cấp lớp Inorder quản lý thứ tự của các lệnh gọi phương thức mà mô hình sẽ thực hiện trong quá trình hoạt động của nó.

Cú pháp

//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);

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

Ở đây chúng tôi đã thêm hai cuộc gọi phương thức giả, add () và subtract (), vào đối tượng giả thông qua when (). Tuy nhiên, trong quá trình thử nghiệm, chúng tôi đã gọi là subtract () trước khi gọi add (). Khi chúng ta tạo một đối tượng giả bằng Mockito, thứ tự thực thi của phương thức không quan trọng. Sử dụng lớp InOrder, chúng ta có thể đảm bảo thứ tự cuộc gọi.

File: 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);
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

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 cung cấp một giao diện Trả lời cho phép khai thác với giao diện chung.

Cú pháp

//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;
   }
});

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

Ở đây chúng tôi đã thêm một cuộc gọi phương thức giả, thêm () vào đối tượng giả thông qua when (). Tuy nhiên, trong quá trình thử nghiệm, chúng tôi đã gọi là subtract () trước khi gọi add (). Khi chúng ta tạo một đối tượng giả sử dụng Mockito.createStrictMock (), thứ tự thực thi của phương thức rất quan trọng.

File: 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);
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true

Mockito cung cấp tùy chọn để tạo gián điệp trên các đối tượng thực. Khi gián điệp được gọi, thì phương thức thực tế của đối tượng thực được gọi.

Cú pháp

//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);

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

Ở đây chúng tôi đã thêm một cuộc gọi phương thức giả, thêm () vào đối tượng giả thông qua when (). Tuy nhiên, trong quá trình thử nghiệm, chúng tôi đã gọi là subtract () trước khi gọi add (). Khi chúng ta tạo một đối tượng giả sử dụng Mockito.createStrictMock (), thứ tự thực thi của phương thức rất quan trọng.

File: 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!");
      }
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true

Mockito cung cấp khả năng thiết lập lại mô hình để có thể sử dụng lại sau này. Hãy xem đoạn mã sau.

//reset mock
reset(calcService);

Ở đây chúng tôi đã đặt lại đối tượng giả. MathApplication sử dụng calcService và sau khi thiết lập lại mô hình, sử dụng phương pháp mô phỏng sẽ không đạt được bài kiểm tra.

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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);   
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

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

Phát triển theo hướng hành vi là một phong cách sử dụng các bài kiểm tra viết given, when và thenđịnh dạng như các phương pháp thử nghiệm. Mockito cung cấp các phương pháp đặc biệt để làm như vậy. Hãy xem đoạn mã sau.

//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);

Ở đây chúng tôi đang sử dụng given phương thức của lớp BDDMockito thay vì when phương pháp của.

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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);   
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true

Mockito cung cấp tùy chọn Thời gian chờ đặc biệt để kiểm tra xem một phương thức có được gọi trong khung thời gian quy định hay không.

Cú pháp

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

Thí dụ

Step 1 − Create an interface called CalculatorService to provide mathematical functions

File: 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);
}

Step 2 − Create a JAVA class to represent MathApplication

File: 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);
   }
}

Step 3 − Test the MathApplication class

Hãy kiểm tra lớp MathApplication, bằng cách đưa vào nó một mô hình của CalculatorService. Mock sẽ được tạo bởi Mockito.

File: 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);
   }
}

Step 4 − Execute test cases

Tạo tệp lớp java có tên TestRunner trong C:\> Mockito_WORKSPACE để thực thi (các) trường hợp Kiểm thử.

File: 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());
   }
}

Step 5 − Verify the Result

Biên dịch các lớp bằng cách sử dụng javac trình biên dịch như sau -

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

Bây giờ hãy chạy Trình chạy thử nghiệm để xem kết quả -

C:\Mockito_WORKSPACE>java TestRunner

Xác minh kết quả đầu ra.

true
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved