Introduction à Jukito

1. Vue d'ensemble

Jukito est la puissance combinée de JUnit, Guice et Mockito - utilisé pour simplifier les tests de plusieurs implémentations de la même interface.

Dans cet article, nous allons voir comment les auteurs ont réussi à combiner ces trois bibliothèques pour nous aider à réduire beaucoup de code standard, ce qui rend nos tests flexibles et faciles.

2. Configuration

Tout d'abord, nous allons ajouter la dépendance suivante à notre projet:

 org.jukito jukito 1.5 test 

Nous pouvons trouver la dernière version sur Maven Central.

3. Différentes implémentations d'une interface

Pour commencer à comprendre la puissance de Jukito, nous allons définir une interface de calculatrice simple avec une méthode Add :

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

Et nous allons implémenter l'interface suivante:

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

Nous avons également besoin d'une autre implémentation:

public class ScientificCalculator extends SimpleCalculator { }

Maintenant, utilisons Jukito pour tester nos deux implémentations:

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

Dans cet exemple, nous pouvons voir un JukitoModule , qui se connecte dans toutes les implémentations spécifiées.

L' annotation @All prend toutes les liaisons de la même interface effectuées par le JukitoModule et exécute le test avec toutes les différentes implémentations injectées lors de l'exécution .

Si nous exécutons des tests, nous pouvons voir qu'en effet deux tests sont exécutés au lieu d'un:

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

4. Le produit cartésien

Ajoutons maintenant une classe imbriquée simple pour différentes combinaisons de tests pour notre méthode Add :

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

Cela augmentera le nombre de tests que nous pouvons exécuter, mais d'abord, nous devons ajouter des liaisons supplémentaires dans notre méthode configureTest :

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

Et enfin nous ajoutons un autre test à notre 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); }

Désormais, l' annotation @All va produire le produit cartésien des différentes combinaisons entre les différentes implémentations de l' interface Calculator et les instances AdditionTest .

Nous pouvons voir l'augmentation du nombre de tests qu'elle produit désormais:

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

Nous devons nous rappeler que le nombre d'exécutions de tests augmente considérablement pour les produits cartésiens.

Le temps d'exécution de tous les tests augmentera de manière linéaire avec le nombre d'exécutions. i: e .: une méthode de test avec trois paramètres avec une annotation @All et quatre liaisons par paramètre sera exécutée 4 x 4 x 4 = 64 fois.

Avoir cinq liaisons pour la même méthode de test conduira à 5 x 5 x 5 = 125 exécutions.

5. Regroupement par noms

La dernière caractéristique dont nous parlerons est le regroupement par nom:

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

Ici, nous avons ajouté quelques instances nommées de la classe integer à notre méthode configureTest , pour montrer ce qui peut être fait avec ces groupes.

Ajoutons maintenant quelques tests supplémentaires:

@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'exemple ci-dessus imprimera les six chaînes «pair 2», «pair 4», «pair 6», «impair 1», «impair 3», «impair 5».

Gardez à l'esprit que l'ordre de ceux-ci n'est pas garanti au moment de l'exécution.

6. Conclusion

Dans ce rapide tutoriel, nous avons examiné comment Jukito permet l'utilisation de toute une suite de tests, en fournissant juste assez de combinaisons de cas de test.

L'exemple complet peut être trouvé sur GitHub.