Mockito - Guía rápida

¿Qué es burlarse?

Burlarse es una forma de probar la funcionalidad de una clase de forma aislada. La simulación no requiere una conexión a la base de datos o la lectura del archivo de propiedades o la lectura del servidor de archivos para probar una funcionalidad. Los objetos simulados hacen la burla del verdadero servicio. Un objeto simulado devuelve datos ficticios correspondientes a alguna entrada ficticia que se le ha pasado.

Mockito

Mockito facilita la creación de objetos simulados sin problemas. Utiliza Java Reflection para crear objetos simulados para una interfaz determinada. Los objetos simulados no son más que un proxy de implementaciones reales.

Considere un caso de Stock Service que devuelve los detalles del precio de una acción. Durante el desarrollo, el servicio de stock real no se puede utilizar para obtener datos en tiempo real. Por tanto, necesitamos una implementación ficticia del servicio de stock. Mockito puede hacer lo mismo con mucha facilidad, como sugiere su nombre.

Beneficios de Mockito

  • No Handwriting - No es necesario escribir objetos simulados por su cuenta.

  • Refactoring Safe - Renombrar los nombres de los métodos de la interfaz o reordenar los parámetros no romperá el código de prueba, ya que se crean Mocks en tiempo de ejecución.

  • Return value support - Soporta valores de retorno.

  • Exception support - Admite excepciones.

  • Order check support - Admite la verificación del orden de las llamadas a métodos.

  • Annotation support - Admite la creación de simulacros mediante anotaciones.

Considere el siguiente fragmento de código.

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

Entendamos los conceptos importantes del programa anterior. El código completo está disponible en el capítuloFirst Application.

  • Portfolio - Un objeto para llevar una lista de existencias y obtener el valor de mercado calculado utilizando los precios de las acciones y la cantidad de existencias.

  • Stock - Un objeto para llevar los detalles de un stock como su id, nombre, cantidad, etc.

  • StockService - Un servicio de acciones devuelve el precio actual de una acción.

  • mock(...) - Mockito creó un simulacro de servicio de stock.

  • when(...).thenReturn(...)- Implementación simulada del método getPrice de la interfaz stockService. Para googleStock, devuelve 50,00 como precio.

  • portfolio.setStocks(...) - La cartera ahora contiene una lista de dos acciones.

  • portfolio.setStockService(...) - Asigna el objeto stockService Mock a la cartera.

  • portfolio.getMarketValue() - La cartera devuelve el valor de mercado en función de sus acciones utilizando el servicio de acciones simuladas.

Mockito es un marco para Java, por lo que el primer requisito es tener JDK instalado en su máquina.

Requisitos del sistema

JDK 1,5 o superior.
Memoria ningún requisito mínimo.
Espacio del disco ningún requisito mínimo.
Sistema operativo ningún requisito mínimo.

Step 1 − Verify Java Installation on Your Machine

Abra la consola y ejecute lo siguiente java mando.

SO Tarea Mando
Ventanas Abrir consola de comandos c: \> java -version
Linux Terminal de comando abierto $ java -version
Mac Terminal abierta máquina:> joseph $ java -version

Verifiquemos la salida para todos los sistemas operativos:

SO Salida
Ventanas

versión de Java "1.6.0_21"

Entorno de ejecución Java (TM) SE (compilación 1.6.0_21-b07)

VM de cliente Java HotSpot (TM) (compilación 17.0-b17, modo mixto, uso compartido)
Linux

versión de Java "1.6.0_21"

Entorno de ejecución Java (TM) SE (compilación 1.6.0_21-b07)

VM de cliente Java HotSpot (TM) (compilación 17.0-b17, modo mixto, uso compartido)
Mac

versión de Java "1.6.0_21"

Entorno de ejecución Java (TM) SE (compilación 1.6.0_21-b07)

Servidor VM Java HotSpot (TM) de 64 bits (compilación 17.0-b17, modo mixto, uso compartido)

Si no tiene Java instalado, haga clic aquí para instalar el kit de desarrollo de software (SDK) de Java .

Suponemos que tiene Java 1.6.0_21 instalado en su sistema para este tutorial.

Step 2 − Set JAVA Environment

Selecciona el JAVA_HOMEvariable de entorno para apuntar a la ubicación del directorio base donde está instalado Java en su máquina. Por ejemplo,

SO Salida
Ventanas Establezca la variable de entorno JAVA_HOME en C: \ Archivos de programa \ Java \ jdk1.6.0_21
Linux exportar JAVA_HOME = / usr / local / java-current
Mac exportar JAVA_HOME = / Library / Java / Home

Agrega la ubicación del compilador de Java a la ruta del sistema.

SO Salida
Ventanas Agregue la cadena; C: \ Archivos de programa \ Java \ jdk1.6.0_21 \ bin al final de la variable del sistema, Ruta.
Linux export PATH = $ PATH: $ JAVA_HOME / bin /
Mac no requerido

Verifique la instalación de Java usando el comando java -version como se explicó anteriormente.

Step 3 − Download Mockito-All Archive

Para descargar la última versión de Mockito desde Maven Repository, haga clic aquí.

Guarde el archivo jar en su unidad C, digamos, C: \> Mockito.

SO Nombre de archivo
Ventanas 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

Selecciona el Mockito_HOMEvariable de entorno para apuntar a la ubicación del directorio base donde se almacenan Mockito y los archivos jar de dependencia en su máquina. La siguiente tabla muestra cómo configurar la variable de entorno en diferentes sistemas operativos, asumiendo que hemos extraído mockito-all-2.0.2-beta.jar en C: \> carpeta Mockito.

SO Salida
Ventanas Establezca la variable de entorno Mockito_HOME en C: \ Mockito
Linux exportar Mockito_HOME = / usr / local / Mockito
Mac exportar Mockito_HOME = / Library / Mockito

Step 5 − Set CLASSPATH Variable

Selecciona el CLASSPATHvariable de entorno para apuntar a la ubicación donde se almacena Mockito jar. La siguiente tabla muestra cómo configurar la variable CLASSPATH en diferentes sistemas operativos.

SO Salida
Ventanas Establezca la variable de entorno CLASSPATH en% CLASSPATH%;% Mockito_HOME% \ mockito-all-2.0.2-beta.jar;.;
Linux exportar CLASSPATH = $ CLASSPATH: $ Mockito_HOME / mockito-all-2.0.2-beta.jar :.
Mac exportar CLASSPATH = $ CLASSPATH: $ Mockito_HOME / mockito-all-2.0.2-beta.jar :.

Step 6 − Download JUnit Archive

Descargue la última versión del archivo jar JUnit de Github . Guarde la carpeta en la ubicación C: \> Junit.

SO Nombre de archivo
Ventanas 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

Selecciona el JUNIT_HOMEvariable de entorno para apuntar a la ubicación del directorio base donde se almacenan los archivos jar JUnit en su máquina. La siguiente tabla muestra cómo configurar esta variable de entorno en diferentes sistemas operativos, asumiendo que hemos almacenado junit4.11.jar y hamcrest-core-1.2.1.jar en C: \> Junit.

SO Salida
Ventanas Establezca la variable de entorno JUNIT_HOME en C: \ JUNIT
Linux exportar JUNIT_HOME = / usr / local / JUNIT
Mac exportar JUNIT_HOME = / Library / JUNIT

Step 8 − Set CLASSPATH Variable

Establezca la variable de entorno CLASSPATH para que apunte a la ubicación del jar de JUNIT. La siguiente tabla muestra cómo se hace en diferentes sistemas operativos.

SO Salida
Ventanas Establezca la variable de entorno CLASSPATH en% CLASSPATH%;% JUNIT_HOME% \ junit4.11.jar;% JUNIT_HOME% \ hamcrest-core-1.2.1.jar;.;
Linux export CLASSPATH = $ CLASSPATH: $ JUNIT_HOME / junit4.11.jar: $ JUNIT_HOME / hamcrest-core-1.2.1.jar :.
Mac export CLASSPATH = $ CLASSPATH: $ JUNIT_HOME / junit4.11.jar: $ JUNIT_HOME / hamcrest-core-1.2.1.jar :.

Antes de entrar en los detalles de Mockito Framework, veamos una aplicación en acción. En este ejemplo, creamos una simulación de Stock Service para obtener el precio ficticio de algunas acciones y probamos por unidad una clase java denominada Portfolio.

El proceso se discute a continuación paso a paso.

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

Probemos la clase Portfolio, inyectándole una simulación de stockservice. Mock será creado por 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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute el PortfolioTester para ver el resultado:

C:\Mockito_WORKSPACE>java PortfolioTester

Verificar la salida

pass

En este capítulo, aprenderemos cómo integrar JUnit y Mockito juntos. Aquí crearemos una aplicación matemática que usa CalculatorService para realizar operaciones matemáticas básicas como suma, resta, multiplicación y división.

Usaremos Mockito para simular la implementación ficticia de CalculatorService. Además, hemos hecho un uso extensivo de las anotaciones para mostrar su compatibilidad con JUnit y Mockito.

El proceso se discute a continuación paso a paso.

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true

Para obtener más información sobre JUnit, consulte el Tutorial de JUnit en Tutorials Point.

Mockito agrega una funcionalidad a un objeto simulado usando los métodos when(). Eche un vistazo al siguiente fragmento de código.

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

Aquí le hemos indicado a Mockito que dé un comportamiento de sumar 10 y 20 a la add método de calcService y como resultado, devolver el valor de 30,00.

En este momento, Mock registró el comportamiento y es un objeto simulado funcional.

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

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C:\>Mockito_WORKSPACE para ejecutar los casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true

Mockito puede asegurar si se llama a un método simulado con argumentos reequilibrados o no. Se hace usando elverify()método. Eche un vistazo al siguiente fragmento de código.

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

Ejemplo: verify () con los mismos argumentos

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true

Ejemplo: verify () con diferentes argumentos

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

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 proporciona una verificación especial sobre la cantidad de llamadas que se pueden realizar con un método en particular. Suponga que MathApplication debería llamar al método CalculatorService.serviceUsed () solo una vez, entonces no debería poder llamar a CalculatorService.serviceUsed () más de una vez.

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

Cree la interfaz CalculatorService de la siguiente manera.

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

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true

Mockito proporciona los siguientes métodos adicionales para variar los recuentos de llamadas esperados.

  • atLeast (int min) - espera llamadas mínimas.

  • atLeastOnce () - espera al menos una llamada.

  • atMost (int max) - espera llamadas máximas.

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar caso (s) de prueba

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true

Mockito proporciona la capacidad a un simulacro de lanzar excepciones, por lo que se puede probar el manejo de excepciones. Eche un vistazo al siguiente fragmento de código.

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

Aquí hemos agregado una cláusula de excepción a un objeto simulado. MathApplication hace uso de calcService usando su método add y el simulacro lanza una RuntimeException cada vez que se invoca el método calcService.add ().

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

testAdd(MathApplicationTester): Add operation not implemented
false

Hasta ahora, hemos utilizado anotaciones para crear simulaciones. Mockito proporciona varios métodos para crear objetos simulados. mock () crea simulacros sin preocuparse por el orden de las llamadas al método que el simulacro va a realizar a su debido tiempo.

Sintaxis

calcService = mock(CalculatorService.class);

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por Mockito.

Aquí hemos agregado dos llamadas al método simulado, add () y restar (), al objeto simulado a través de when (). Sin embargo, durante las pruebas, llamamos a subtract () antes de llamar a add (). Cuando creamos un objeto simulado usando create (), el orden de ejecución del método no importa.

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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true

Mockito proporciona la clase Inorder que se encarga del orden de las llamadas al método que el simulacro va a realizar a su debido tiempo.

Sintaxis

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

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por Mockito.

Aquí hemos agregado dos llamadas al método simulado, add () y restar (), al objeto simulado a través de when (). Sin embargo, durante las pruebas, llamamos a subtract () antes de llamar a add (). Cuando creamos un objeto simulado usando Mockito, el orden de ejecución del método no importa. Usando la clase InOrder, podemos asegurar el orden de las llamadas.

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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

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 proporciona una interfaz de respuesta que permite apuntar con una interfaz genérica.

Sintaxis

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

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por Mockito.

Aquí hemos agregado una llamada al método simulado, add () al objeto simulado a través de when (). Sin embargo, durante las pruebas, llamamos a subtract () antes de llamar a add (). Cuando creamos un objeto simulado usando Mockito.createStrictMock (), el orden de ejecución del método sí importa.

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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true

Mockito ofrece la opción de crear espías en objetos reales. Cuando se llama a spy, se llama al método real del objeto real.

Sintaxis

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

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por Mockito.

Aquí hemos agregado una llamada al método simulado, add () al objeto simulado a través de when (). Sin embargo, durante las pruebas, llamamos a subtract () antes de llamar a add (). Cuando creamos un objeto simulado usando Mockito.createStrictMock (), el orden de ejecución del método sí importa.

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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true

Mockito proporciona la capacidad de restablecer un simulacro para que pueda reutilizarse más tarde. Eche un vistazo al siguiente fragmento de código.

//reset mock
reset(calcService);

Aquí hemos restablecido el objeto simulado. MathApplication hace uso de calcService y, después de restablecer el simulacro, el uso del método simulado fallará la prueba.

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

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

El desarrollo impulsado por el comportamiento es un estilo de escritura que utiliza given, when y thenformato como métodos de prueba. Mockito proporciona métodos especiales para hacerlo. Eche un vistazo al siguiente fragmento de código.

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

Aquí estamos usando given método de la clase BDDMockito en lugar de when método de .

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true

Mockito proporciona una opción especial de tiempo de espera para probar si se llama a un método dentro del marco de tiempo estipulado.

Sintaxis

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

Ejemplo

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

Probemos la clase MathApplication, inyectando en ella una simulación de calculatorService. Mock será creado por 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

Cree un archivo de clase java llamado TestRunner en C:\> Mockito_WORKSPACE para ejecutar casos de prueba.

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

Compila las clases usando javac compilador de la siguiente manera:

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

Ahora ejecute Test Runner para ver el resultado:

C:\Mockito_WORKSPACE>java TestRunner

Verifique la salida.

true