Testes parametrizados em Junit

5.1 Anotação @ParameterizedTest

Às vezes, você só quer chamar o teste várias vezes com parâmetros diferentes: valores diferentes, parâmetros de entrada diferentes, nomes de usuários diferentes. O JUnit visa facilitar sua vida, então para este caso ele possui testes parametrizados.

Para usar testes parametrizados, você precisa adicionar mais uma dependência ao seu pom.xml:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-params</artifactId>
    <version>5.8.2</version>
    <scope>test</scope>
</dependency>

Então podemos considerar um exemplo:

@ParameterizedTest
@ValueSource(ints = { 1, 2, 3 })
void testMethod(int argument) {
    //test code
}

@ParameterizedTest
@ValueSource(ints = { 1, 2, 3 })
void testMethodWithAutoboxing(Integer argument) {
    //test code
}

Cada método de teste será chamado 3 vezes e cada vez que for chamado, outro parâmetro será passado para ele. Os valores são definidos usando outra anotação - @ValueSource . Mas é preciso dizer mais sobre isso.

5.2 Anotação @ValueSource

A anotação @ValueSource é ótima para trabalhar com primitivos e literais. Basta listar os valores dos parâmetros separados por vírgulas e o teste será chamado uma vez para cada valor.

@ParameterizedTest
@ValueSource(ints = { 1, 2, 3 })
void testMethodWithAutoboxing(Integer argument) {
    //test code
}

Mas também há um sinal de menos - esta anotação não suporta null, então você precisará usar uma muleta especial para ela - @NullSource . Se parece com isso:

@ParameterizedTest
@NullSource
void testMethodNullSource(Integer argument) {
    assertTrue(argument == null);
}

5.3 Anotação @EnumSource

Existe também uma anotação especial @EnumSource , que passa todos os valores de um Enum específico para o método. Sua aplicação é assim:

enum Direction {
    EAST, WEST, NORTH, SOUTH
}

@ParameterizedTest
@EnumSource(Direction.class)
void testWithEnumSource(Direction d) {
    assertNotNull(d);
}

5.4 Anotação @MethodSource

Mas como passar objetos como parâmetros? Especialmente se eles tiverem um algoritmo de construção complexo. Para fazer isso, você pode simplesmente especificar um método auxiliar especial que retornará uma lista (Stream) de tais valores.

Exemplo:

@ParameterizedTest
@MethodSource("argsProviderFactory")
void testWithMethodSource(String argument) {
    assertNotNull(argument);
}

static Stream<String> argsProviderFactory() {
    return Stream.of("one", "two",  "three");
}

Testes Parametrizados com Múltiplos Argumentos

Claro, você já se perguntou o que fazer se quiser passar vários parâmetros para o método. Existe uma anotação muito legal @CSVSource para isso . Ele permite listar os valores dos parâmetros do método simplesmente separados por vírgulas.

Exemplo:

@ParameterizedTest
@CsvSource({
    "alex, 30, Programmer, Working",
    "brian, 35, Tester, Working",
	"charles, 40, manager, kicks"
})
void testWithCsvSource(String name, int age, String occupation, String status) {
	//method code
}