TOC

Introduction à Jukito

Introduction à Jukito

1. Vue d'ensemble

Jukito est la puissance combinée deJUnit,Guice etMockito - utilisée 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 àMaven Central.

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

Pour commencer à comprendre la puissance de Jukito, nous allons définir une simple interfaceCalculator avec une méthodeAdd: 

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

Et nous allons mettre en œuvre 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 unJukitoModule, 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 lesJukitoModule et exécute le testwith all the different implementations injected at runtime.

Si nous exécutons des tests, nous pouvons constater qu’en réalité 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éthodeAdd: 

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 tout d'abord, nous devons ajouter des liaisons supplémentaires dans notre méthodeconfigureTest: 

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

Maintenantthe @All annotation is going to produce the Cartesian product of the different combinations between the different implementations of the Calculator interface and the AdditionTest instances.

Nous pouvons regarder le nombre accru de tests qu'il produit maintenant: 

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 deviendra 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 aboutira à 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 entière à notre méthodeconfigureTest, pour montrer ce qui peut être fait avec ces groupes.

Ajoutons maintenant d'autres tests: 

@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 «même 2», «même 4», «même 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 didacticiel, nous avons examiné comment Jukito permet l'utilisation d'une suite de tests complète en fournissant juste assez de combinaisons de scénarios de tests.

L'exemple complet peut être trouvéover on GitHub.

Related