Parametrización en JUnit 5

Al escribir pruebas automatizadas, a menudo utilizamos la parametrización, lo que significa ejecutar la misma prueba con diferentes entradas. Descubramos qué problemas puede resolver la parametrización y cómo usarla con Allure Report.

1. Preparación

Requisitos

Asegúrate de cumplir con los siguientes requisitos:

• Java instalado.
• Gradle instalado.
• Allure instalado.

Lista de dependencias

Esta guía utiliza los siguientes paquetes:

• org.junit:junit-bom:5.10.2
• io.qameta.allure:allure-bom:2.28.0

Ejemplo de código

El código fuente completo utilizado en esta guía está disponible en https://github.com/allure-examples/guide-junit5-parametrization.

Configuración

Para ejecutar los ejemplos de esta guía, necesitas tener Java y Allure Report instalados.

A continuación, descarga un proyecto nuevo con JUnit desde Allure Start.

2. Por qué usar parametrización

Comenzaremos con un ejemplo sencillo: sumar dos números.

  @Test
	public void testSum() {
      assertEquals(1 + 2, 3);
  }

¿Cómo ejecutamos esta prueba con múltiples conjuntos de datos?

La primera solución que viene a la mente es simplemente crear un bucle dentro de la prueba. Algo como esto:

@Test
public void testSum() {
    final int[][] data = new int[][]{
            {1, 2, 3},
            {-1, 1, 0},
            {0, 0, 0}
    };
    for (int[] datum : data) {
        assertEquals(datum[0] + datum[1], datum[2]);
    }
}

Este enfoque tiene muchas desventajas:

1. Si la prueba falla en un conjunto de datos, nunca llegará a los demás.
2. Los datos se acceden a través de una matriz y no hay variables nombradas, lo que afecta la legibilidad. Esta desventaja no es muy evidente aquí, pero si la prueba estuviera mejor estructurada, definitivamente destacaría.
3. Un informe de prueba solo muestra el nombre de la prueba, no el ciclo particular del bucle. En esta configuración, no hay forma de hacerlo más legible.

Entonces, ¿cuál sería una mejor manera de hacerlo? JUnit5 ya tiene una respuesta: parametrización. Reescribamos la prueba anterior:

private static Stream<Arguments> dataProvider() {
    return Stream.of(
            Arguments.of(1, 2, 3),
            Arguments.of(-1, 1, 0),
            Arguments.of(0, 0, 0)
    );
}

@ParameterizedTest
@MethodSource("dataProvider")
public void testSum(int x, int y, int sum) {
    assertEquals(x + y, sum);
}

Este enfoque nos permite resolver los problemas de los que hablamos antes:

1. La prueba se ejecuta varias veces, y aunque una de las ejecuciones falle, aún recibirás retroalimentación de todas las demás.
2. Los datos se acceden con variables (x, y y sum), lo que es mucho más conveniente.
3. En un informe, múltiples ejecuciones de la prueba parametrizada se muestran como ejecuciones de prueba separadas:

3. Parametrización en Allure

Allure Report se integra con JUnit5 y admite pruebas automatizadas parametrizadas. Pero antes de usarlas, veamos cómo funcionan en Allure.

Si simplemente activas la integración de Allure, las pruebas parametrizadas, lamentablemente, se verán como pruebas normales, solo mostradas varias veces en el informe:

¿Por qué ocurre esto? Porque Allure necesita que se le informe sobre los parámetros. Para entender qué ve Allure, ejecuta una prueba parametrizada y luego revisa la carpeta allure-results. Allí, abre cualquier archivo {uid}-result.json y encuentra la sección parameters:

{
  "testCaseName": "testSum(int, int, int)",
  "parameters": [
    {
      "name": "UniqueId",
      "value": "[engine:junit-jupiter]/[class:org.example.junit_parameterization.SumTest]/[test-template:testSumParameterized(int, int, int)]/[test-template-invocation:#1]",
      "mode": "hidden"
    }
  ],
  "start": 1717700137076,
  "stop": 1717700137101
}

Como puedes ver, esta sección no menciona x, y ni sum, por lo que no hay una sección para parámetros; simplemente están escritos como parte del nombre del método.

¿Cómo resolvemos este problema?

Si deseas una solución detallada, puedes consultarla en la documentación, pero por ahora, simplemente reescribamos nuestra prueba parametrizada de esta manera:

@ParameterizedTest
@MethodSource("dataProvider")
public void testSum(int x, int y, int sum) {
    Allure.parameter("x", x);
    Allure.parameter("y", y);
    Allure.parameter("sum", sum);

    assertEquals(x + y, sum);
}

Ahora, si volvemos a ejecutar nuestro ejemplo, la sección parámetros del archivo de resultados de la prueba tendrá el siguiente aspecto:

{
  "testCaseName": "testSum(int, int, int)",
  "parameters": [
    {
      "name": "UniqueId",
      "value": "[engine:junit-jupiter]/[class:org.example.junit_parameterization.SumTest]/[test-template:testSumAllurified(int, int, int)]/[test-template-invocation:#2]",
      "mode": "hidden"
    },
    {
      "name": "x",
      "value": "-1"
    },
    {
      "name": "y",
      "value": "1"
    },
    {
      "name": "sum",
      "value": "0"
    }
  ]
}

Como puedes ver, finalmente los parámetros han aparecido en los resultados de la prueba, lo que significa que el informe ahora debería verse así:

4. Conclusión

La parametrización es una técnica de prueba muy útil que permite ejecutar la misma prueba en múltiples conjuntos de datos sin duplicar la prueba ni complicarla con bucles. Esto aumenta la legibilidad y facilita el mantenimiento de las pruebas.

La parametrización es completamente compatible con la integración Allure-JUnit5. Las integraciones de Allure se mejoran constantemente, y en versiones futuras, es posible que puedas lograr el mismo resultado sin escribir explícitamente los parámetros. Sin embargo, el enfoque actual proporciona la funcionalidad requerida y te permite verificar todo antes de generar el informe.