Mockito - Aperçu

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 des méthodes 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 chapitre First 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.