TOC

Einführung in Jukito

Einführung in Jukito

1. Überblick

Jukito ist die kombinierte Leistung vonJUnit,Guice undMockito - wird verwendet, um das Testen mehrerer Implementierungen derselben Schnittstelle zu vereinfachen.

In diesem Artikel werden wir sehen, wie Autoren es geschafft haben, diese drei Bibliotheken zu kombinieren, um viel Code auf dem Boilerplate zu reduzieren und unsere Tests flexibel und einfach zu gestalten.

2. Einrichten

Zunächst fügen wir unserem Projekt die folgende Abhängigkeit hinzu: 


    org.jukito
    jukito
    1.5
    test

Wir finden die neueste Version unterMaven Central.

3. Verschiedene Implementierungen einer Schnittstelle

Um die Leistungsfähigkeit von Jukito zu verstehen, definieren wir eine einfacheCalculator-Schnittstelle mit einerAdd-Methode: 

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

Und wir werden die folgende Schnittstelle implementieren: 

public class SimpleCalculator implements Calculator {

    @Override
    public double add(double a, double b) {
        return a + b;
    }
}

Wir brauchen auch eine andere Implementierung: 

public class ScientificCalculator extends SimpleCalculator {
}

Verwenden wir jetzt Jukito, um unsere beiden Implementierungen zu testen: 

@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 diesem Beispiel sehen wir einJukitoModule, das in allen angegebenen Implementierungen verdrahtet ist.

Die Annotation@All nimmt alle Bindungen derselben Schnittstelle, die vonJukitoModule erstellt wurden, und führt den Testwith all the different implementations injected at runtime aus.

Wenn wir Tests ausführen, können wir sehen, dass tatsächlich zwei Tests anstelle von einem ausgeführt werden: 

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

4. Das kartesische Produkt

Fügen wir nun eine einfache verschachtelte Klasse für verschiedene Testkombinationen für unsereAdd-Methode hinzu: 

public static class AdditionTest {
    int a;
    int b;
    int expected;

    // standard constructors/getters
}

Dies erhöht die Anzahl der Tests, die wir ausführen können. Zuerst müssen wir jedoch zusätzliche Bindungen in unsereconfigureTest-Methode einfügen: 

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

Zum Schluss erweitern wir unsere Suite um einen weiteren Test: 

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

Jetztthe @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.

Wir können uns die erhöhte Anzahl von Tests ansehen, die es jetzt produziert: 

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

Wir müssen uns daran erinnern, dass die Anzahl der Testausführungen für kartesische Produkte drastisch zunimmt.

Die Ausführungszeit aller Tests wächst linear mit der Anzahl der Ausführungen. i: e.: Eine Testmethode mit drei Parametern mit einer@All-Annotation und vier Bindungen pro Parameter wird 4 x 4 x 4 = 64 Mal ausgeführt.

Mit fünf Bindungen für dieselbe Testmethode werden 5 x 5 x 5 = 125 Ausführungen ausgeführt.

5. Gruppierung nach Namen

Das letzte Feature, das wir diskutieren werden, ist die Gruppierung nach Namen: 

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

Hier haben wir unsererconfigureTest-Methode einige benannte Instanzen der Integer-Klasse hinzugefügt, um zu zeigen, was mit diesen Gruppen getan werden kann.

Fügen wir nun einige weitere Tests hinzu: 

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

Im obigen Beispiel werden die sechs Zeichenfolgen "gerade 2", "gerade 4", "gerade 6", "ungerade 1", "ungerade 3", "ungerade 5" gedruckt.

Beachten Sie, dass die Reihenfolge dieser zur Laufzeit nicht garantiert ist.

6. Fazit

In diesem kurzen Tutorial haben wir uns angesehen, wie Jukito die Verwendung einer ganzen Testsuite ermöglicht, indem gerade genug Kombinationen von Testfällen bereitgestellt werden.

Das vollständige Beispiel finden Sie inover on GitHub.

Related