Las pruebas unitarias son un componente fundamental cuando estamos escribiendo el código para un programa, ya que nos aseguran que el código se comporte como esperamos que lo haga. Cuando se trata de ejecutar un mismo test varias veces con diferentes entradas, los JUnit parameterized test o, dicho de otro modo, las pruebas parametrizadas, son una gran herramienta que podemos usar. Si trabajas con JUnit 5, este artículo te será de gran ayuda, ya que te enseñaremos qué son las JUnit parameterized test y cómo podemos usarlas en nuestros proyectos.

¿Qué encontrarás en este post?

¿Qué es un JUnit Parameterized Test?

Un JUnit parameterized test es un método de prueba en el que se reciben diferentes conjuntos de datos en forma de parámetros. En vez de repetir el mismo código para probar distintos escenarios, lo que puedes hacer es reutilizar el método con diferentes valores de entrada, lo cual hace que mejoremos la cobertura de nuestras pruebas y nos ahorra tiempo.

Existen muchas ventajas al usar JUnit parameterized test, nombremos 3 de esas:

Reutilización de código: Evitas la duplicación de métodos de prueba que solo varían en los datos.
Cobertura de casos extremos: Puedes incluir tantos casos de prueba como desees sin complicar la estructura del código.
Mayor legibilidad: Separas la lógica de la prueba de los datos, esto a su vez facilita el mantenimiento del código.

Configuración de JUnit Parameterized Test

Para empezar a realizar tus JUnit parameterized test, debes estar completamente seguro de que has configurado tu proyecto de la manera ideal, si no, este no va a funcionar. Si usas Maven o Gradle, verifica que hayas incluido las dependencias necesarias:

Dependencia en Maven:

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

Desglosemos, para entender mejor lo que hemos escrito:

<dependency>: Esto define una nueva dependencia dentro del proyecto Maven. Todo el bloque dentro de esta etiqueta corresponde a una biblioteca específica que tu proyecto necesita.
<groupId>: Indica el grupo o organización que mantiene esta biblioteca. En este caso, org.junit.jupiter hace referencia al módulo de JUnit 5, que es la plataforma de pruebas más utilizada en Java.
<artifactId>: Es el identificador único de la biblioteca dentro del grupo. Aquí, el junit-jupiter-params es el módulo específico de JUnit que permite usar parameterized tests.
<version>: Especifica la versión de la biblioteca que quieres incluir en tu proyecto. En este caso, la versión es 5.11.0-M2, que es una versión de desarrollo del módulo de parámetros de JUnit 5.
<scope>: Define el alcance de la dependencia, que controla en qué fases del ciclo de vida de Maven estará disponible la biblioteca. Aquí el valor es test, lo que significa que esta dependencia solo se utilizará durante la fase de pruebas. No se incluirá en la fase de construcción del proyecto final o en la ejecución del código en producción.

Dependencia en Gradle:

testImplementation("org.junit.jupiter:junit-jupiter-params:5.11.0")

De modo que:

"org.junit.jupiter:junit-jupiter-params": es la biblioteca específica que necesitas. Al igual que en Maven, org.junit.jupiter es el grupo que mantiene JUnit 5, y junit-jupiter-params es el módulo que proporciona la funcionalidad de JUnit parameterized test.

"5.11.0": Es la versión de la biblioteca que estás incluyendo en el proyecto. En este caso, la versión 5.11.0 es del módulo de parámetros de JUnit 5.

Primer ejemplo de un Parameterized Test

Aquí tenemos un método que determina si un número es impar:

public class Numbers {
    public static boolean isOdd(int number) {
        return number % 2 != 0;
    }
}

Ahora, queremos probar este método con diferentes entradas. En lugar de escribir múltiples métodos de prueba, utilizamos un JUnit parameterized test:

@ParameterizedTest
@ValueSource(ints = {1, 3, 5, -3, 15, Integer.MAX_VALUE}) 
void isOdd_ShouldReturnTrueForOddNumbers(int number) {
    assertTrue(Numbers.isOdd(number));
}

En este caso, JUnit ejecutará la prueba varias veces, una por cada valor en el array @ValueSource. De esta forma podemos verificar si el método isOdd funciona correctamente para cada número impar.

Fuentes de parámetros en JUnit 5

En JUnit podemos usar varias formas para pasar parámetros a un test. Algunas de las más conocidas son:

@ValueSource

Esta es la fuente más simple y común para pasar valores. Funciona para tipos básicos como int, String, long, entre otros:

@ParameterizedTest
@ValueSource(strings = {"", "  "})
void isBlank_ShouldReturnTrueForBlankStrings(String input) {
    assertTrue(Strings.isBlank(input));
}

@EnumSource

Permite pasar valores desde un enum. Si necesitas probar un método con todos los valores posibles de una enumeración, puedes usarlo:

@ParameterizedTest
@EnumSource(Month.class)
void allMonths_AreValid(Month month) {
    assertNotNull(month);
}

@CsvSource

Ideal cuando necesitas pasar varios valores para un solo test. Funciona como una lista de valores separados por comas:

@ParameterizedTest
@CsvSource({"test,TEST", "java,JAVA"})
void toUpperCase_ShouldConvertToUpperCase(String input, String expected) {
    assertEquals(expected, input.toUpperCase());
}

@MethodSource

Permite definir un método en tu clase que actúe como fuente de parámetros. Este método puede devolver un Stream, List u otras colecciones de datos:

@ParameterizedTest
@MethodSource("provideStringsForIsBlank")
void isBlank_ShouldReturnTrueForNullAndBlankStrings(String input) {
    assertTrue(Strings.isBlank(input));
}

private static Stream<String> provideStringsForIsBlank() {
    return Stream.of(null, "", " ");
}

Límite de valores nulos y vacíos

Con @NullSource y @EmptySource, puedes manejar valores nulos o vacíos sin necesidad de escribir código adicional:

@ParameterizedTest
@NullSource
void isBlank_ShouldReturnTrueForNullInputs(String input) {
    assertTrue(Strings.isBlank(input));
}

Además, si deseas probar tanto valores nulos como vacíos, puedes usar @NullAndEmptySource:

@ParameterizedTest
@NullAndEmptySource
void isBlank_ShouldReturnTrueForNullAndEmptyStrings(String input) {
    assertTrue(Strings.isBlank(input));
}

Si te interesa aprender más sobre estas temáticas y quieres convertirte en un experto en Java y sus múltiples herramientas de gestión, no puedes perderte nuestro bootcamp en java, un curso completo que te ayudará en tu proceso de formación para convertirte en un gran programador. ¡Anímate e inscríbete ahora!