TOC

Introdução ao Jukito

Introdução ao Jukito

1. Visão geral

Jukito é a potência combinada deJUnit,Guice eMockito - usado para simplificar o teste de várias implementações da mesma interface.

Neste artigo, veremos como os autores conseguiram combinar essas três bibliotecas para nos ajudar a reduzir muito código clichê, tornando nossos testes flexíveis e fáceis.

2. Configurando

Primeiro, vamos adicionar a seguinte dependência ao nosso projeto: 


    org.jukito
    jukito
    1.5
    test

Podemos encontrar a versão mais recente emMaven Central.

3. Diferentes implementações de uma interface

Para começar a entender o poder do Jukito, vamos definir uma interfaceCalculator simples com um métodoAdd: 

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

E vamos implementar a seguinte interface: 

public class SimpleCalculator implements Calculator {

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

Também precisamos de outra implementação: 

public class ScientificCalculator extends SimpleCalculator {
}

Agora, vamos usar o Jukito para testar nossas implementações: 

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

Neste exemplo, podemos ver umJukitoModule, que conecta em todas as implementações especificadas.

A anotação@All pega todas as ligações da mesma interface feitas porJukitoModulee executa o testewith all the different implementations injected at runtime.

Se executarmos testes, podemos ver que de fato dois testes são executados em vez de um: 

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

4. O produto cartesiano

Vamos agora adicionar uma classe aninhada simples para diferentes combinações de testes para nosso métodoAdd: 

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

    // standard constructors/getters
}

Isso irá expandir o número de testes que podemos executar, mas primeiro, precisamos adicionar ligações adicionais em nosso métodoconfigureTest: 

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

E, finalmente, adicionamos outro teste à nossa suíte: 

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

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

Podemos dar uma olhada no aumento do número de testes que agora produz: 

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

Precisamos lembrar que o número de execuções de teste aumenta drasticamente para produtos cartesianos.

O tempo de execução de todos os testes será linear com o número de execuções. i: e .: um método de teste com três parâmetros com uma anotação@All e quatro ligações por parâmetro será executado 4 x 4 x 4 = 64 vezes.

Ter cinco ligações para o mesmo método de teste levará a 5 x 5 x 5 = 125 execuções.

5. Agrupamento por nomes

O recurso final que discutiremos é o agrupamento por nome: 

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

Aqui, adicionamos algumas instâncias nomeadas da classe inteira ao nosso métodoconfigureTest, para mostrar o que pode ser feito com esses grupos.

Agora vamos adicionar mais alguns testes: 

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

O exemplo acima imprimirá as seis strings "par 2", "par 4", "par 6", "ímpar 1", "ímpar 3", "ímpar 5".

Lembre-se de que a ordem destes não é garantida no tempo de execução.

6. Conclusão

Neste tutorial rápido, vimos como o Jukito permite o uso de todo um conjunto de testes, fornecendo combinações suficientes de casos de teste.

O exemplo completo pode ser encontradoover on GitHub.

Related