Mockito - Guide rapide

Qu'est-ce que se moquer?

La moquerie est un moyen de tester la fonctionnalité d'une classe de manière isolée. La simulation ne nécessite pas de connexion à la base de données ou de lecture de fichier de propriétés ou de lecture de serveur de fichiers pour tester une fonctionnalité. Les objets simulés se moquent du service réel. Un objet factice renvoie une donnée factice correspondant à une entrée factice qui lui est passée.

Mockito

Mockito facilite la création d'objets fictifs de manière transparente. Il utilise Java Reflection afin de créer des objets simulés pour une interface donnée. Les objets simulés ne sont que des proxy pour les implémentations réelles.

Prenons un cas de Stock Service qui renvoie les détails de prix d'un stock. Pendant le développement, le service de stock réel ne peut pas être utilisé pour obtenir des données en temps réel. Nous avons donc besoin d'une implémentation factice du service de stock. Mockito peut faire la même chose très facilement, comme son nom l'indique.

Avantages de Mockito

  • No Handwriting - Pas besoin d'écrire des objets simulés par vous-même.

  • Refactoring Safe - Renommer les noms de méthode d'interface ou réorganiser les paramètres ne cassera pas le code de test car les Mocks sont créés au moment de l'exécution.

  • Return value support - Prend en charge les valeurs de retour.

  • Exception support - Prend en charge les exceptions.

  • Order check support - Prend en charge la vérification de l'ordre des appels de méthode.

  • Annotation support - Prend en charge la création de simulations en utilisant l'annotation.

Considérez l'extrait de code suivant.

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

Comprenons les concepts importants du programme ci-dessus. Le code complet est disponible dans le chapitreFirst Application.

  • Portfolio - Un objet pour porter une liste de stocks et pour obtenir la valeur marchande calculée en utilisant les prix des actions et la quantité de stock.

  • Stock - Un objet pour porter les détails d'un stock tels que son identifiant, son nom, sa quantité, etc.

  • StockService - Un service de stock renvoie le prix actuel d'une action.

  • mock(...) - Mockito a créé une maquette de service de stock.

  • when(...).thenReturn(...)- Implémentation simulée de la méthode getPrice de l'interface stockService. Pour googleStock, renvoyez 50.00 comme prix.

  • portfolio.setStocks(...) - Le portefeuille contient désormais une liste de deux actions.

  • portfolio.setStockService(...) - Affecte l'objet stockService Mock au portefeuille.

  • portfolio.getMarketValue() - Le portefeuille renvoie la valeur marchande en fonction de ses actions en utilisant le service de simulation de stock.

Mockito est un framework pour Java, donc la toute première exigence est d'avoir JDK installé sur votre machine.

Exigence du système

JDK 1.5 ou supérieur.
Mémoire aucune exigence minimale.
Espace disque aucune exigence minimale.
Système opérateur aucune exigence minimale.

Step 1 − Verify Java Installation on Your Machine

Ouvrez la console et exécutez ce qui suit java commander.

OS Tâche Commander
les fenêtres Ouvrez la console de commande c: \> java -version
Linux Ouvrir le terminal de commande $ java -version
Mac Terminal ouvert machine:> joseph $ java -version

Vérifions la sortie pour tous les systèmes d'exploitation -

OS Production
les fenêtres

version java "1.6.0_21"

Environnement d'exécution Java (TM) SE (build 1.6.0_21-b07)

VM client Java HotSpot (TM) (build 17.0-b17, mode mixte, partage)
Linux

version java "1.6.0_21"

Environnement d'exécution Java (TM) SE (build 1.6.0_21-b07)

VM client Java HotSpot (TM) (build 17.0-b17, mode mixte, partage)
Mac

version java "1.6.0_21"

Environnement d'exécution Java (TM) SE (build 1.6.0_21-b07)

VM serveur 64 bits Java HotSpot (TM) (build 17.0-b17, mode mixte, partage)

Si vous n'avez pas installé Java, pour installer le kit de développement logiciel Java (SDK), cliquez ici.

Nous supposons que Java 1.6.0_21 est installé sur votre système pour ce didacticiel.

Step 2 − Set JAVA Environment

Met le JAVA_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base où Java est installé sur votre machine. Par exemple,

OS Production
les fenêtres Définissez la variable d'environnement JAVA_HOME sur C: \ Program Files \ Java \ jdk1.6.0_21
Linux export JAVA_HOME = / usr / local / java-current
Mac export JAVA_HOME = / Bibliothèque / Java / Accueil

Ajoutez l'emplacement du compilateur Java à votre chemin système.

OS Production
les fenêtres Ajoutez la chaîne; C: \ Program Files \ Java \ jdk1.6.0_21 \ bin à la fin de la variable système, Path.
Linux export PATH = $ PATH: $ JAVA_HOME / bin /
Mac non requis

Vérifiez l'installation de Java à l'aide de la commande java -version comme expliqué ci-dessus.

Step 3 − Download Mockito-All Archive

Pour télécharger la dernière version de Mockito à partir du référentiel Maven, cliquez ici.

Enregistrez le fichier jar sur votre lecteur C, disons, C: \> Mockito.

OS Nom de l'archive
les fenêtres 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

Met le Mockito_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base où Mockito et les fichiers JAR de dépendance sont stockés sur votre machine. Le tableau suivant montre comment définir la variable d'environnement sur différents systèmes d'exploitation, en supposant que nous avons extrait mockito-all-2.0.2-beta.jar dans le dossier C: \> Mockito.

OS Production
les fenêtres Définissez la variable d'environnement Mockito_HOME sur C: \ Mockito
Linux export Mockito_HOME = / usr / local / Mockito
Mac export Mockito_HOME = / Bibliothèque / Mockito

Step 5 − Set CLASSPATH Variable

Met le CLASSPATHvariable d'environnement pour pointer vers l'emplacement où le pot Mockito est stocké. Le tableau suivant montre comment définir la variable CLASSPATH sur différents systèmes d'exploitation.

OS Production
les fenêtres Définissez la variable d'environnement CLASSPATH sur% CLASSPATH%;% Mockito_HOME% \ mockito-all-2.0.2-beta.jar;.;
Linux export CLASSPATH = $ CLASSPATH: $ Mockito_HOME / mockito-all-2.0.2-beta.jar :.
Mac export CLASSPATH = $ CLASSPATH: $ Mockito_HOME / mockito-all-2.0.2-beta.jar :.

Step 6 − Download JUnit Archive

Téléchargez la dernière version du fichier jar JUnit depuis Github . Enregistrez le dossier à l'emplacement C: \> Junit.

OS Nom de l'archive
les fenêtres 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

Met le JUNIT_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base où les fichiers JUnit sont stockés sur votre machine. Le tableau suivant montre comment définir cette variable d'environnement sur différents systèmes d'exploitation, en supposant que nous ayons stocké junit4.11.jar et hamcrest-core-1.2.1.jar sur C: \> Junit.

OS Production
les fenêtres Définissez la variable d'environnement JUNIT_HOME sur C: \ JUNIT
Linux export JUNIT_HOME = / usr / local / JUNIT
Mac export JUNIT_HOME = / Bibliothèque / JUNIT

Step 8 − Set CLASSPATH Variable

Définissez la variable d'environnement CLASSPATH pour qu'elle pointe vers l'emplacement du fichier JUNIT. Le tableau suivant montre comment cela se fait sur différents systèmes d'exploitation.

OS Production
les fenêtres Définissez la variable d'environnement CLASSPATH sur% 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 :.

Avant d'entrer dans les détails du Mockito Framework, voyons une application en action. Dans cet exemple, nous avons créé une maquette de Stock Service pour obtenir le prix factice de certaines actions et testé à l'unité une classe Java nommée Portfolio.

Le processus est discuté ci-dessous d'une manière étape par étape.

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

Testons la classe Portfolio, en y injectant une simulation de stockervice. Mock sera créé par 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

Compilez les classes en utilisant javac compilateur comme suit -

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

Exécutez maintenant le PortfolioTester pour voir le résultat -

C:\Mockito_WORKSPACE>java PortfolioTester

Vérifiez la sortie

pass

Dans ce chapitre, nous allons apprendre à intégrer JUnit et Mockito ensemble. Ici, nous allons créer une application mathématique qui utilise CalculatorService pour effectuer des opérations mathématiques de base telles que l'addition, la soustraction, la multiplication et la division.

Nous utiliserons Mockito pour simuler l'implémentation factice de CalculatorService. De plus, nous avons largement utilisé les annotations pour montrer leur compatibilité avec JUnit et Mockito.

Le processus est discuté ci-dessous d'une manière étape par étape.

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Pour en savoir plus sur JUnit, veuillez consulter le didacticiel JUnit à Tutorials Point.

Mockito ajoute une fonctionnalité à un objet simulé en utilisant les méthodes when(). Jetez un œil à l'extrait de code suivant.

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

Ici, nous avons demandé à Mockito de donner un comportement d'ajout de 10 et 20 au add méthode de calcService et par conséquent, pour renvoyer la valeur de 30,00.

À ce stade, Mock a enregistré le comportement et est un objet factice de travail.

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

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C:\>Mockito_WORKSPACE pour exécuter le ou les cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Mockito peut garantir si une méthode fictive est appelée avec les arguments requis ou non. Cela se fait en utilisant leverify()méthode. Jetez un œil à l'extrait de code suivant.

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

Exemple - verify () avec les mêmes arguments

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Exécutez maintenant le Test Runner pour voir le résultat

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Exemple - verify () avec différents arguments

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

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 fournit un contrôle spécial sur le nombre d'appels qui peuvent être effectués sur une méthode particulière. Supposons que MathApplication n'appelle la méthode CalculatorService.serviceUsed () qu'une seule fois, alors il ne devrait pas pouvoir appeler CalculatorService.serviceUsed () plus d'une fois.

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

Créez l'interface CalculatorService comme suit.

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

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Mockito fournit les méthodes supplémentaires suivantes pour faire varier le nombre d'appels attendu.

  • atLeast (int min) - s'attend à des appels min.

  • atLeastOnce () - attend au moins un appel.

  • atMost (int max) - s'attend à un maximum d'appels.

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Mockito offre la possibilité à une maquette de lancer des exceptions, de sorte que la gestion des exceptions peut être testée. Jetez un œil à l'extrait de code suivant.

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

Ici, nous avons ajouté une clause d'exception à un objet fictif. MathApplication utilise calcService à l'aide de sa méthode add et la simulation lève une exception RuntimeException chaque fois que la méthode calcService.add () est appelée.

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

testAdd(MathApplicationTester): Add operation not implemented
false

Jusqu'à présent, nous avons utilisé des annotations pour créer des simulations. Mockito propose diverses méthodes pour créer des objets simulés. mock () crée des mocks sans se soucier de l'ordre des appels de méthode que le mock va faire en temps voulu.

Syntaxe

calcService = mock(CalculatorService.class);

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par Mockito.

Ici, nous avons ajouté deux appels de méthode fictive, add () et soustract (), à l'objet fictif via when (). Cependant, lors des tests, nous avons appelé soustract () avant d'appeler add (). Lorsque nous créons un objet fictif à l'aide de create (), l'ordre d'exécution de la méthode n'a pas d'importance.

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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Mockito fournit la classe Inorder qui s'occupe de l'ordre des appels de méthode que le simulacre va faire au cours de son action.

Syntaxe

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

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par Mockito.

Ici, nous avons ajouté deux appels de méthode fictive, add () et soustract (), à l'objet fictif via when (). Cependant, lors des tests, nous avons appelé soustract () avant d'appeler add (). Lorsque nous créons un objet fictif à l'aide de Mockito, l'ordre d'exécution de la méthode n'a pas d'importance. En utilisant la classe InOrder, nous pouvons garantir l'ordre des appels.

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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

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 fournit une interface de réponse qui permet le stubbing avec une interface générique.

Syntaxe

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

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par Mockito.

Ici, nous avons ajouté un appel de méthode fictive, add () à l'objet fictif via when (). Cependant, lors des tests, nous avons appelé soustract () avant d'appeler add (). Lorsque nous créons un objet fictif à l'aide de Mockito.createStrictMock (), l'ordre d'exécution de la méthode importe.

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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Mockito offre une option pour créer des espions sur des objets réels. Lorsque l'espion est appelé, la méthode réelle de l'objet réel est appelée.

Syntaxe

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

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par Mockito.

Ici, nous avons ajouté un appel de méthode fictive, add () à l'objet fictif via when (). Cependant, lors des tests, nous avons appelé soustract () avant d'appeler add (). Lorsque nous créons un objet fictif à l'aide de Mockito.createStrictMock (), l'ordre d'exécution de la méthode importe.

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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Mockito offre la possibilité de réinitialiser une maquette afin qu'elle puisse être réutilisée plus tard. Jetez un œil à l'extrait de code suivant.

//reset mock
reset(calcService);

Ici, nous avons réinitialisé l'objet simulé. MathApplication utilise calcService et après avoir réinitialisé le simulacre, l'utilisation d'une méthode simulée échouera le test.

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

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

Le développement piloté par le comportement est un style d'écriture de tests utilise given, when et thenformat comme méthodes de test. Mockito fournit des méthodes spéciales pour ce faire. Jetez un œil à l'extrait de code suivant.

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

Ici nous utilisons given méthode de la classe BDDMockito au lieu de when méthode de .

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Mockito fournit une option spéciale de délai d'expiration pour tester si une méthode est appelée dans le délai imparti.

Syntaxe

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

Exemple

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

Testons la classe MathApplication, en y injectant un simulacre de calculatorService. Mock sera créé par 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

Créez un fichier de classe Java nommé TestRunner dans C:\> Mockito_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, lancez le Test Runner pour voir le résultat -

C:\Mockito_WORKSPACE>java TestRunner

Vérifiez la sortie.

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