@RepeatedTest

JUnit Jupiter ofrece la capacidad de repetir una prueba un número especificado de veces mediante la anotación @RepeatedTest y especificando el número total de repeticiones deseadas. Cada invocación de una prueba repetida se comporta como la ejecución de un método @Test regular, con total soporte para los mismos callbacks del ciclo de vida y extensiones.

El siguiente ejemplo demuestra cómo declarar una prueba llamada repeatedTest() que se repetirá automáticamente 10 veces.

@RepeatedTest(10)
void repeatedTest() {
    // ...
}

Desde JUnit Jupiter 5.10, la anotación @RepeatedTest se puede configurar con un umbral de fallos, lo que significa el número de fallos después del cual las repeticiones restantes serán automáticamente omitidas. Debes establecer el atributo failureThreshold a un número positivo menor que el total de repeticiones para omitir las invocaciones de las repeticiones restantes después de que se haya encontrado el número especificado de fallos.

Por ejemplo, si estás utilizando @RepeatedTest para invocar repetidamente una prueba que sospechas que es inestable (flaky), un solo fallo es suficiente para demostrar que la prueba es inestable, y no es necesario invocar las repeticiones restantes. Para admitir este caso específico, configura failureThreshold = 1. También puedes configurar el umbral a un número mayor que 1 dependiendo de tu caso de uso.

Por defecto, el atributo failureThreshold se establece en Integer.MAX_VALUE, lo que indica que no se aplicará un umbral de fallos. Esto significa que el número especificado de repeticiones se invocará sin importar si alguna de las repeticiones falla.

❗❗Si las repeticiones de un método @RepeatedTest se ejecutan en paralelo, no se pueden hacer garantías con respecto al umbral de fallos. Por lo tanto, se recomienda que un método @RepeatedTest sea anotado con @Execution(SAME_THREAD) cuando se configure la ejecución paralela. Consulta la sección de Ejecución Paralela para más detalles.

Además de especificar el número de repeticiones y el umbral de fallos, se puede configurar un nombre de visualización personalizado para cada repetición a través del atributo name de la anotación @RepeatedTest. Además, el nombre de visualización puede ser un patrón compuesto por una combinación de texto estático y marcadores de posición dinámicos. Los siguientes marcadores de posición son actualmente compatibles:

• {displayName}: nombre de visualización del método @RepeatedTest.
• {currentRepetition}: el número de repetición actual.
• {totalRepetitions}: el número total de repeticiones.

El nombre de visualización por defecto para una repetición determinada se genera con el siguiente patrón: “repetición {currentRepetition} de {totalRepetitions}”. Así, los nombres de visualización para las repeticiones individuales del ejemplo anterior de repeatedTest() serían: repetición 1 de 10, repetición 2 de 10, etc.

Si deseas incluir el nombre de la prueba @RepeatedTest en el nombre de cada repetición, puedes definir tu propio patrón personalizado o usar el patrón predefinido RepeatedTest.LONG_DISPLAY_NAME. Este último es igual a "{displayName} :: repetition {currentRepetition} of {totalRepetitions}", lo que da como resultado nombres de visualización para las repeticiones individuales como:

• repeatedTest() :: repetition 1 of 10
• repeatedTest() :: repetition 2 of 10, etc.

Para recuperar información sobre la repetición actual, el número total de repeticiones, el número de repeticiones que han fallado y el umbral de fallos, un desarrollador puede optar por inyectar una instancia de RepetitionInfo en un método anotado con @RepeatedTest, @BeforeEach o @AfterEach.

El objeto RepetitionInfo proporciona los siguientes métodos útiles:

• getCurrentRepetition(): Obtiene el número de repetición actual.
• getTotalRepetitions(): Obtiene el número total de repeticiones.
• getFailureCount(): Obtiene el número de repeticiones que han fallado hasta el momento.
• getFailureThreshold(): Obtiene el umbral de fallos configurado para la prueba.

Esto permite acceder a información detallada sobre el estado de las repeticiones dentro de las pruebas, lo que puede ser útil para la personalización del comportamiento de los métodos de prueba o para el seguimiento del progreso de las repeticiones.

import org.junit.jupiter.api.*;

import static org.junit.jupiter.api.Assertions.*;

public class RepeatedTestExample {

    @BeforeEach
    public void setup(RepetitionInfo repetitionInfo) {
        // Obtener el número total de repeticiones
        System.out.println("Total de repeticiones: " + repetitionInfo.getTotalRepetitions());
        // Obtener la repetición actual
        System.out.println("Iniciando la repetición: " + repetitionInfo.getCurrentRepetition());
    }

    @RepeatedTest(5)  // Repetir la prueba 5 veces
    void repeatedTest(RepetitionInfo repetitionInfo) {
        System.out.println("Repetición " + repetitionInfo.getCurrentRepetition() + " de " + repetitionInfo.getTotalRepetitions());

        // Simular una prueba que falle en la repetición 3
        if (repetitionInfo.getCurrentRepetition() == 3) {
            fail("Fallo intencional en la repetición 3");
        }

        // Asegurar que estamos ejecutando una prueba válida
        assertTrue(repetitionInfo.getCurrentRepetition() <= repetitionInfo.getTotalRepetitions());
    }

    @AfterEach
    public void teardown(RepetitionInfo repetitionInfo) {
        // Obtener el número de fallos hasta ahora
        System.out.println("Repeticiones fallidas hasta ahora: " + repetitionInfo.getFailureCount());
    }
}

Más ejemplos en Repeated Test Examples