Mockito - Guida rapida
Cos'è il Mocking?
Il mocking è un modo per testare la funzionalità di una classe in isolamento. Il mocking non richiede una connessione al database o la lettura del file delle proprietà o della lettura del file server per testare una funzionalità. Gli oggetti fittizi prendono in giro il vero servizio. Un oggetto fittizio restituisce un dato fittizio corrispondente a un input fittizio passato ad esso.
Mockito
Mockito facilita la creazione di oggetti fittizi senza interruzioni. Utilizza Java Reflection per creare oggetti fittizi per una determinata interfaccia. Gli oggetti fittizi non sono altro che proxy per le implementazioni effettive.
Si consideri un caso di Stock Service che restituisce i dettagli del prezzo di un'azione. Durante lo sviluppo, il servizio di magazzino effettivo non può essere utilizzato per ottenere dati in tempo reale. Quindi abbiamo bisogno di un'implementazione fittizia del servizio di magazzino. Mockito può fare lo stesso molto facilmente, come suggerisce il nome.
Vantaggi di Mockito
No Handwriting - Non è necessario scrivere oggetti fittizi da soli.
Refactoring Safe - La ridenominazione dei nomi dei metodi di interfaccia o il riordino dei parametri non interromperà il codice di test poiché i mock vengono creati in fase di esecuzione.
Return value support - Supporta i valori di ritorno.
Exception support - Supporta le eccezioni.
Order check support - Supporta il controllo dell'ordine delle chiamate ai metodi.
Annotation support - Supporta la creazione di mock utilizzando l'annotazione.
Considera il seguente frammento di codice.
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);
}
}
Comprendiamo i concetti importanti del programma sopra. Il codice completo è disponibile nel capitoloFirst Application.
Portfolio - Un oggetto per trasportare un elenco di azioni e per ottenere il valore di mercato calcolato utilizzando i prezzi delle azioni e la quantità di azioni.
Stock - Un oggetto per contenere i dettagli di uno stock come il suo ID, nome, quantità, ecc.
StockService - Un servizio di stock restituisce il prezzo corrente di un'azione.
mock(...) - Mockito ha creato una simulazione di stock service.
when(...).thenReturn(...)- Simulazione dell'implementazione del metodo getPrice dell'interfaccia stockService. Per googleStock, restituisci 50.00 come prezzo.
portfolio.setStocks(...) - Il portafoglio ora contiene un elenco di due azioni.
portfolio.setStockService(...) - Assegna l'oggetto stockService Mock al portfolio.
portfolio.getMarketValue() - Il portafoglio restituisce il valore di mercato in base alle sue azioni utilizzando il servizio di azioni fittizie.
Mockito è un framework per Java, quindi il primo requisito è avere JDK installato sulla tua macchina.
Requisito del sistema
JDK | 1.5 o superiore. |
---|---|
Memoria | nessun requisito minimo. |
Spazio sul disco | nessun requisito minimo. |
Sistema operativo | nessun requisito minimo. |
Step 1 − Verify Java Installation on Your Machine
Apri la console ed esegui quanto segue java comando.
OS | Compito | Comando |
---|---|---|
finestre | Apri la Console di comando | c: \> java -version |
Linux | Apri Terminale di comando | $ java -version |
Mac | Apri Terminale | macchina:> joseph $ java -version |
Verifichiamo l'output per tutti i sistemi operativi -
OS | Produzione |
---|---|
finestre | versione java "1.6.0_21" Java (TM) SE Runtime Environment (build 1.6.0_21-b07) VM client Java HotSpot (TM) (build 17.0-b17, modalità mista, condivisione) |
Linux | versione java "1.6.0_21" Java (TM) SE Runtime Environment (build 1.6.0_21-b07) VM client Java HotSpot (TM) (build 17.0-b17, modalità mista, condivisione) |
Mac | versione java "1.6.0_21" Java (TM) SE Runtime Environment (build 1.6.0_21-b07) VM server Java HotSpot (TM) a 64 bit (build 17.0-b17, modalità mista, condivisione) |
Se non hai Java installato, per installare il Java Software Development Kit (SDK) fai clic qui.
Supponiamo che tu abbia Java 1.6.0_21 installato sul tuo sistema per questo tutorial.
Step 2 − Set JAVA Environment
Impostare il JAVA_HOMEvariabile di ambiente in modo che punti alla posizione della directory di base in cui Java è installato sulla macchina. Per esempio,
OS | Produzione |
---|---|
finestre | Imposta la variabile d'ambiente JAVA_HOME su C: \ Program Files \ Java \ jdk1.6.0_21 |
Linux | export JAVA_HOME = / usr / local / java-current |
Mac | export JAVA_HOME = / Library / Java / Home |
Aggiungi la posizione del compilatore Java al tuo percorso di sistema.
OS | Produzione |
---|---|
finestre | Aggiungi la stringa; C: \ Program Files \ Java \ jdk1.6.0_21 \ bin alla fine della variabile di sistema, Path. |
Linux | export PATH = $ PATH: $ JAVA_HOME / bin / |
Mac | non richiesto |
Verificare l'installazione di Java utilizzando il comando java -version come spiegato sopra.
Step 3 − Download Mockito-All Archive
Per scaricare l'ultima versione di Mockito da Maven Repository fare clic qui.
Salva il file jar sul tuo disco C, diciamo, C: \> Mockito.
OS | Nome dell'archivio |
---|---|
finestre | 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
Impostare il Mockito_HOMEvariabile di ambiente in modo che punti alla posizione della directory di base in cui Mockito e i jar delle dipendenze sono archiviati sulla macchina. La tabella seguente mostra come impostare la variabile di ambiente su diversi sistemi operativi, assumendo che abbiamo estratto mockito-all-2.0.2-beta.jar nella cartella C: \> Mockito.
OS | Produzione |
---|---|
finestre | Imposta la variabile d'ambiente Mockito_HOME su C: \ Mockito |
Linux | esporta Mockito_HOME = / usr / local / Mockito |
Mac | export Mockito_HOME = / Library / Mockito |
Step 5 − Set CLASSPATH Variable
Impostare il CLASSPATHvariabile di ambiente per puntare alla posizione in cui è archiviato il vaso Mockito. La tabella seguente mostra come impostare la variabile CLASSPATH su diversi sistemi operativi.
OS | Produzione |
---|---|
finestre | Imposta la variabile d'ambiente CLASSPATH su% 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
Scarica l'ultima versione del file jar JUnit da Github . Salvare la cartella nella posizione C: \> Junit.
OS | Nome dell'archivio |
---|---|
finestre | 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
Impostare il JUNIT_HOMEvariabile di ambiente in modo che punti alla posizione della directory di base in cui i jar JUnit sono archiviati sulla macchina. La tabella seguente mostra come impostare questa variabile di ambiente su diversi sistemi operativi, assumendo che abbiamo memorizzato junit4.11.jar e hamcrest-core-1.2.1.jar in C: \> Junit.
OS | Produzione |
---|---|
finestre | Imposta la variabile d'ambiente JUNIT_HOME su C: \ JUNIT |
Linux | esportare JUNIT_HOME = / usr / local / JUNIT |
Mac | export JUNIT_HOME = / Library / JUNIT |
Step 8 − Set CLASSPATH Variable
Imposta la variabile d'ambiente CLASSPATH in modo che punti alla posizione del jar JUNIT. La tabella seguente mostra come viene eseguita su diversi sistemi operativi.
OS | Produzione |
---|---|
finestre | Imposta la variabile d'ambiente CLASSPATH su% 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 :. |
Prima di entrare nei dettagli del Mockito Framework, vediamo un'applicazione in azione. In questo esempio, abbiamo creato una simulazione di Stock Service per ottenere il prezzo fittizio di alcune azioni e l'unità ha testato una classe java denominata Portfolio.
Il processo è discusso di seguito in modo graduale.
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
Testiamo la classe Portfolio, inserendovi una simulazione di stockservice. Mock sarà creato da 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 le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac Stock.java StockService.java Portfolio.java PortfolioTester.java
Ora esegui PortfolioTester per vedere il risultato -
C:\Mockito_WORKSPACE>java PortfolioTester
Verifica l'output
pass
In questo capitolo impareremo come integrare JUnit e Mockito insieme. Qui creeremo un'applicazione matematica che utilizza CalculatorService per eseguire operazioni matematiche di base come addizione, sottrazione, moltiplicazione e divisione.
Useremo Mockito per simulare l'implementazione fittizia di CalculatorService. Inoltre, abbiamo fatto un ampio uso di annotazioni per mostrare la loro compatibilità con JUnit e Mockito.
Il processo è discusso di seguito in modo graduale.
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true
Per saperne di più su JUnit, fare riferimento al Tutorial JUnit al punto Tutorials.
Mockito aggiunge una funzionalità a un oggetto fittizio utilizzando i metodi when(). Dai un'occhiata al seguente frammento di codice.
//add the behavior of calc service to add two numbers
when(calcService.add(10.0,20.0)).thenReturn(30.00);
Qui abbiamo incaricato Mockito di dare un comportamento di aggiungere 10 e 20 al add metodo di calcService e di conseguenza, per restituire il valore di 30,00.
A questo punto, Mock ha registrato il comportamento ed è un oggetto fittizio funzionante.
//add the behavior of calc service to add two numbers
when(calcService.add(10.0,20.0)).thenReturn(30.00);
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C:\>Mockito_WORKSPACE per eseguire il / i test case.
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 le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true
Mockito può garantire se un metodo fittizio viene chiamato con gli argomenti richiesti o meno. È fatto usando ilverify()metodo. Dai un'occhiata al seguente frammento di codice.
//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);
Esempio: verifica () con gli stessi argomenti
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true
Esempio: verifica () con argomenti diversi
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
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 fornisce un controllo speciale sul numero di chiamate che possono essere effettuate su un particolare metodo. Supponiamo che MathApplication debba chiamare il metodo CalculatorService.serviceUsed () solo una volta, quindi non dovrebbe essere in grado di chiamare CalculatorService.serviceUsed () più di una volta.
//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);
Creare l'interfaccia CalculatorService come segue.
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);
}
Esempio
Step 1 − Create an interface called CalculatorService to provide mathematical functionsFile: 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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true
Mockito fornisce i seguenti metodi aggiuntivi per variare i conteggi delle chiamate previste.
atLeast (int min) - prevede chiamate minime.
atLeastOnce () - attende almeno una chiamata.
atMost (int max) - si aspetta un numero massimo di chiamate.
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true
Mockito fornisce la possibilità a un mock di generare eccezioni, quindi la gestione delle eccezioni può essere testata. Dai un'occhiata al seguente frammento di codice.
//add the behavior to throw exception
doThrow(new Runtime Exception("divide operation not implemented"))
.when(calcService).add(10.0,20.0);
Qui abbiamo aggiunto una clausola di eccezione a un oggetto fittizio. MathApplication fa uso di calcService utilizzando il suo metodo add e il mock lancia una RuntimeException ogni volta che viene richiamato il metodo calcService.add ().
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
testAdd(MathApplicationTester): Add operation not implemented
false
Finora, abbiamo utilizzato le annotazioni per creare mock. Mockito fornisce vari metodi per creare oggetti fittizi. mock () crea mock senza preoccuparsi dell'ordine delle chiamate di metodo che il mock farà a tempo debito della sua azione.
Sintassi
calcService = mock(CalculatorService.class);
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da Mockito.
Qui abbiamo aggiunto due chiamate al metodo mock, add () e subtract (), all'oggetto mock tramite when (). Tuttavia, durante i test, abbiamo chiamato subtract () prima di chiamare add (). Quando creiamo un oggetto fittizio usando create (), l'ordine di esecuzione del metodo non ha importanza.
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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true
Mockito fornisce la classe Inorder che si prende cura dell'ordine delle chiamate di metodo che il mock farà a tempo debito della sua azione.
Sintassi
//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);
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da Mockito.
Qui abbiamo aggiunto due chiamate al metodo mock, add () e subtract (), all'oggetto mock tramite when (). Tuttavia, durante i test, abbiamo chiamato subtract () prima di chiamare add (). Quando creiamo un oggetto fittizio utilizzando Mockito, l'ordine di esecuzione del metodo non ha importanza. Utilizzando la classe InOrder, possiamo garantire l'ordine delle chiamate.
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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
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 fornisce un'interfaccia di risposta che consente lo stubbing con un'interfaccia generica.
Sintassi
//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;
}
});
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da Mockito.
Qui abbiamo aggiunto una chiamata al metodo mock, add () all'oggetto mock tramite when (). Tuttavia, durante i test, abbiamo chiamato subtract () prima di chiamare add (). Quando creiamo un oggetto fittizio utilizzando Mockito.createStrictMock (), l'ordine di esecuzione del metodo è importante.
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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true
Mockito fornisce l'opzione per creare spia su oggetti reali. Quando viene chiamata la spia, viene chiamato il metodo effettivo dell'oggetto reale.
Sintassi
//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);
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da Mockito.
Qui abbiamo aggiunto una chiamata al metodo mock, add () all'oggetto mock tramite when (). Tuttavia, durante i test, abbiamo chiamato subtract () prima di chiamare add (). Quando creiamo un oggetto fittizio utilizzando Mockito.createStrictMock (), l'ordine di esecuzione del metodo è importante.
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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true
Mockito offre la possibilità di ripristinare un mock in modo che possa essere riutilizzato in seguito. Dai un'occhiata al seguente frammento di codice.
//reset mock
reset(calcService);
Qui abbiamo ripristinato l'oggetto fittizio. MathApplication fa uso di calcService e dopo aver reimpostato il mock, l'utilizzo del metodo mocked fallirà il test.
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
testAddAndSubtract(MathApplicationTester): expected:<0.0> but was:<30.0>
false
Lo sviluppo guidato dal comportamento è uno stile di scrittura utilizzato dai test given, when e thenformato come metodi di prova. Mockito fornisce metodi speciali per farlo. Dai un'occhiata al seguente frammento di codice.
//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);
Qui stiamo usando given metodo della classe BDDMockito invece di when metodo di .
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true
Mockito fornisce un'opzione speciale di timeout per verificare se un metodo viene chiamato entro l'intervallo di tempo stabilito.
Sintassi
//passes when add() is called within 100 ms.
verify(calcService,timeout(100)).add(20.0,10.0);
Esempio
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
Testiamo la classe MathApplication, inserendovi una simulazione di calculatorService. Mock sarà creato da 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
Crea un file di classe java denominato TestRunner in C:\> Mockito_WORKSPACE per eseguire uno o più casi di 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
Compila le classi usando javac compilatore come segue -
C:\Mockito_WORKSPACE>javac CalculatorService.java MathApplication.
java MathApplicationTester.java TestRunner.java
Ora esegui il Test Runner per vedere il risultato:
C:\Mockito_WORKSPACE>java TestRunner
Verifica l'output.
true