Anotaciones básicas y ciclo de vida

JUnit proporciona diversas anotaciones y funcionalidades que permiten a los desarrolladores escribir pruebas de manera estructurada y fácil de entender.

Anotaciones básicas en JUnit

@Test

La anotación @Test se utiliza para marcar un método como prueba unitaria. Este será un método void que no retorna ningún valor y generalmente se utiliza para realizar aserciones que comprueban el comportamiento esperado del código. @Test es la piedra angular sobre la cual se construyen las pruebas unitarias en JUnit.

@Test
void ejemploTest() {
    assertEquals(2, 1 + 1, "1 + 1 debe ser igual a 2");
}

@BeforeEach

La anotación @BeforeEach se utiliza para especificar un método que se ejecuta antes de cada prueba. Es útil para preparar el entorno de prueba, como inicializar variables o configurar conexiones a bases de datos. Se ejecuta una vez por cada método @Test.

@BeforeEach
void setUp() {
    // código de configuración inicial
}

@AfterEach

La anotación @AfterEach indica un método que se ejecuta después de cada prueba. Se utiliza para realizar tareas de limpieza, como cerrar conexiones a bases de datos o restablecer estados. Se ejecuta una vez por cada método @Test.

@AfterEach
void tearDown() {
    // código de limpieza
}

@BeforeAll

La anotación @BeforeAll se aplica a un método estático que se ejecuta una sola vez antes de todas las pruebas en la clase actual. Es útil para configurar recursos costosos, como conexiones de red o bases de datos. Se ejecuta una única vez independientemente del número de métodos @Test que contenga la clase.

@BeforeAll
static void initAll() {
    // configuración que se ejecuta una vez antes de todas las pruebas
}

@AfterAll

La anotación @AfterAll se usa en un método estático que se ejecuta después de que todas las pruebas en la clase han sido ejecutadas. Sirve para liberar recursos utilizados durante las pruebas. Se ejecuta una única vez independientemente del número de métodos @Test que contenga la clase.

@AfterAll
static void cleanUpAll() {
    // limpieza final que se ejecuta después de todas las pruebas
}

@DisplayName

La anotación @DisplayName permite asignar un nombre más descriptivo y legible a los tests, que se mostrará en los informes de los resultados de las pruebas en lugar del nombre del método de test. Esto es especialmente útil para clarificar qué se está probando, especialmente cuando los nombres de los métodos no pueden capturar completamente el propósito del test.

@Test
@DisplayName("Verificar suma con entradas positivas")
void testSuma() {
    assertEquals(2, 1 + 1);
}

En este caso, el método testSuma muestra el nombre “Verificar suma con entradas positivas” en los resultados de las pruebas, proporcionando un contexto claro sobre lo que verifica el test.

@Order y @TestMethodOrder

La anotación @Order se utiliza para definir el orden en el que se deben ejecutar los métodos de test dentro de una clase de prueba. Los tests se ejecutarán en orden ascendente según el número proporcionado en la anotación. Esta característica es útil cuando el orden de ejecución es importante para el resultado de las pruebas.

La anotación @TestMethodOrder(MethodOrderer.OrderAnnotation.class) se coloca a nivel de la clase de test y define la estrategia que JUnit debe usar para ordenar los métodos de test. Al especificar MethodOrderer.OrderAnnotation.class, se le indica a JUnit que organice los métodos de test de acuerdo con los valores proporcionados en las anotaciones @Order de cada método.

import org.junit.jupiter.api.*;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class EjemploOrdenadoTest {

    @Test
    @Order(1)
    void primero() {
        assertTrue(true);
    }

    @Test
    @Order(2)
    void segundo() {
        assertTrue(true);
    }
}

Aquí, los métodos primero y segundo se ejecutan en el orden indicado por sus anotaciones @Order, asegurando que primero siempre se ejecute antes de segundo. Esto es crucial cuando el estado establecido en primero afecta el comportamiento de segundo.

Ciclo de vida de las pruebas en JUnit

El ciclo de vida de las pruebas describe el proceso y orden en que se ejecutan las anotaciones y los métodos de prueba dentro de una clase de pruebas. Este ciclo está diseñado para proporcionar un entorno de prueba controlado y repetible que asegura que cada prueba se ejecute en un estado conocido y predecible, sin influencias externas de otras pruebas. Esto facilita la escritura de pruebas más limpias, fiables y mantenibles.

El orden típico de ejecución es:

1. @BeforeAll: Se ejecuta primero y sólo una vez antes de todas las pruebas de la clase.
2. @BeforeEach: Se ejecuta antes de cada prueba individual.
3. @Test: Se ejecuta el método de prueba propiamente dicho.
4. @AfterEach: Se ejecuta después de cada prueba individual.
5. @AfterAll: Se ejecuta una vez después de todas las pruebas de la clase.

Este flujo asegura que el entorno de cada prueba sea correcto y que los recursos sean gestionados de manera eficiente, evitando interferencias entre pruebas y garantizando que cada prueba sea independiente.

Por ejemplo, si se tiene una clase como:

import org.junit.jupiter.api.*;

class PruebasDeEjemplo {

    @BeforeAll
    static void initAll() {
        System.out.println("@BeforeAll - Configuración inicial para todas las pruebas");
    }

    @BeforeEach
    void setUp() {
        System.out.println("@BeforeEach - Configuración para cada prueba");
    }

    @Test
    void pruebaUno() {
        System.out.println("@Test - Ejecutando pruebaUno");
        assertEquals(1, 1 * 1);
    }

    @Test
    void pruebaDos() {
        System.out.println("@Test - Ejecutando pruebaDos");
        assertEquals(4, 2 * 2);
    }

    @Test
    void pruebaTres() {
        System.out.println("@Test - Ejecutando pruebaTres");
        assertEquals(9, 3 * 3);
    }

    @AfterEach
    void tearDown() {
        System.out.println("@AfterEach - Limpieza después de cada prueba");
    }

    @AfterAll
    static void cleanUpAll() {
        System.out.println("@AfterAll - Limpieza después de todas las pruebas");
    }
}

Si se ejecuta la clase, la salida por consola sería:

@BeforeAll - Configuración inicial para todas las pruebas
@BeforeEach - Configuración para cada prueba
@Test - Ejecutando pruebaUno
@AfterEach - Limpieza después de cada prueba
@BeforeEach - Configuración para cada prueba
@Test - Ejecutando pruebaDos
@AfterEach - Limpieza después de cada prueba
@BeforeEach - Configuración para cada prueba
@Test - Ejecutando pruebaTres
@AfterEach - Limpieza después de cada prueba
@AfterAll - Limpieza después de todas las pruebas

Process finished with exit code 0