Introduzione a Jukito

1. Panoramica

Jukito è la potenza combinata di JUnit, Guice e Mockito, utilizzata per semplificare i test di più implementazioni della stessa interfaccia.

In questo articolo vedremo come gli autori sono riusciti a combinare queste tre librerie per aiutarci a ridurre molto codice standard, rendendo i nostri test flessibili e facili.

2. Configurazione

Innanzitutto, aggiungeremo la seguente dipendenza al nostro progetto:

 org.jukito jukito 1.5 test 

Possiamo trovare l'ultima versione su Maven Central.

3. Diverse implementazioni di un'interfaccia

Per iniziare a comprendere la potenza di Jukito, definiremo una semplice interfaccia di Calcolatrice con un metodo Add :

public interface Calculator { public double add(double a, double b); }

E implementeremo la seguente interfaccia:

public class SimpleCalculator implements Calculator { @Override public double add(double a, double b) { return a + b; } }

Abbiamo anche bisogno di un'altra implementazione:

public class ScientificCalculator extends SimpleCalculator { }

Ora, usiamo Jukito per testare entrambe le nostre implementazioni:

@RunWith(JukitoRunner.class) public class CalculatorTest { public static class Module extends JukitoModule { @Override protected void configureTest() { bindMany(Calculator.class, SimpleCalculator.class, ScientificCalculator.class); } } @Test public void givenTwoNumbers_WhenAdd_ThenSumBoth(@All Calculator calc) { double result = calc.add(1, 1); assertEquals(2, result, .1); } }

In questo esempio, possiamo vedere un JukitoModule , che si collega a tutte le implementazioni specificate.

L' annotazione @All accetta tutti i collegamenti della stessa interfaccia creati da JukitoModule ed esegue il test con tutte le diverse implementazioni iniettate in fase di esecuzione .

Se eseguiamo test, possiamo vedere che in effetti vengono eseguiti due test invece di uno:

Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

4. Il prodotto cartesiano

Aggiungiamo ora una semplice classe annidata per diverse combinazioni di test per il nostro metodo Add :

public static class AdditionTest { int a; int b; int expected; // standard constructors/getters }

Questo amplierà il numero di test che possiamo eseguire, ma prima dobbiamo aggiungere ulteriori bind nel nostro metodo configureTest :

bindManyInstances(AdditionTest.class, new AdditionTest(1, 1, 2), new AdditionTest(10, 10, 20), new AdditionTest(18, 24, 42));

E infine aggiungiamo un altro test alla nostra suite:

@Test public void givenTwoNumbers_WhenAdd_ThenSumBoth( @All Calculator calc, @All AdditionTest addTest) { double result = calc.add(addTest.a, addTest.b); assertEquals(addTest.expected, result, .1); }

Ora l' annotazione @All produrrà il prodotto cartesiano delle diverse combinazioni tra le diverse implementazioni dell'interfaccia di Calculator e le istanze di AdditionTest .

Possiamo dare un'occhiata all'aumento del numero di test che ora produce:

Tests run: 8, Failures: 0, Errors: 0, Skipped: 0

Dobbiamo ricordare che il numero di esecuzioni di test aumenta drasticamente per i prodotti cartesiani.

Il tempo di esecuzione di tutti i test crescerà in modo lineare con il numero di esecuzioni. i: e .: un metodo di test con tre parametri con un'annotazione @All e quattro associazioni per parametro verrà eseguito 4 x 4 x 4 = 64 volte.

Avere cinque associazioni per lo stesso metodo di test porterà a 5 x 5 x 5 = 125 esecuzioni.

5. Raggruppamento per nomi

L'ultima caratteristica di cui parleremo è il raggruppamento per nome:

bindManyNamedInstances(Integer.class, "even", 2, 4, 6); bindManyNamedInstances(Integer.class, "odd", 1, 3, 5);

Qui, abbiamo aggiunto alcune istanze denominate della classe integer al nostro metodo configureTest , per mostrare cosa si può fare con questi gruppi.

Ora aggiungiamo altri test:

@Test public void givenEvenNumbers_whenPrint_thenOutput(@All("even") Integer i) { System.out.println("even " + i); } @Test public void givenOddNumbers_whenPrint_thenOutput(@All("odd") Integer i) { System.out.println("odd " + i); }

L'esempio precedente stamperà le sei stringhe "pari 2", "pari 4", "pari 6", "dispari 1", "dispari 3", "dispari 5".

Tieni presente che l'ordine di questi non è garantito in fase di esecuzione.

6. Conclusione

In questo breve tutorial, abbiamo dato un'occhiata a come Jukito consente l'uso di un'intera suite di test, fornendo un numero sufficiente di combinazioni di casi di test.

L'esempio completo può essere trovato su GitHub.