IA Cheatsheets

🧪 JUnit Cheatsheet Completo 🧪

JUnit es un framework de código abierto para escribir y ejecutar pruebas unitarias en Java. Permite a los desarrolladores asegurar la calidad de su código, detectar errores temprano y facilitar el refactoring. JUnit 5 (conocido como JUnit Jupiter) es la versión moderna y modular.

1. 🌟 Conceptos Clave

2. 🛠️ Configuración Inicial (Maven)

Para usar JUnit 5 (Jupiter), necesitas las siguientes dependencias en tu pom.xml:

<dependencies>
    &lt;!-- Módulo de API de JUnit Jupiter (para escribir pruebas) -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.10.0</version> &lt;!-- Usar la versión más reciente -->
        <scope>test</scope>
    </dependency>
    &lt;!-- Módulo de Engine de JUnit Jupiter (para ejecutar pruebas) -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.10.0</version>
        <scope>test</scope>
    </dependency>
    &lt;!-- Para ejecutar pruebas JUnit 4 en la plataforma JUnit 5 (opcional) -->
    <dependency>
        <groupId>org.junit.vintage</groupId>
        <artifactId>junit-vintage-engine</artifactId>
        <version>5.10.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <plugins>
        &lt;!-- Plugin para configurar el compilador -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <source>17</source> &lt;!-- Versión de Java -->
                <target>17</target>
            </configuration>
        </plugin>
        &lt;!-- Plugin para ejecutar pruebas JUnit 5 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.1.2</version>
            <configuration>
                <argLine>
                    --enable-preview
                </argLine>
            </configuration>
        </plugin>
    </plugins>
</build>

3. 📝 Estructura Básica de una Prueba

// src/main/java/com/example/myapp/Calculadora.java
package com.example.myapp;

public class Calculadora {
    public int sumar(int a, int b) {
        return a + b;
    }

    public int dividir(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("No se puede dividir por cero");
        }
        return a / b;
    }
}
// src/test/java/com/example/myapp/CalculadoraTest.java
package com.example.myapp;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*; // Importa todas las aserciones estáticas

class CalculadoraTest {

    @Test // Anotación que marca el método como un método de prueba
    @DisplayName("Prueba de suma básica: 5 + 3 debería ser 8") // Nombre legible en reportes
    void testSumarNumerosPositivos() {
        // Arrange (Preparación): Instanciar objetos, preparar datos
        Calculadora calculadora = new Calculadora();
        int a = 5;
        int b = 3;

        // Act (Ejecución): Llamar al método a probar
        int resultado = calculadora.sumar(a, b);

        // Assert (Verificación): Comprobar el resultado
        assertEquals(8, resultado, "5 + 3 debería ser 8"); // Esperado, Actual, Mensaje opcional
        assertTrue(resultado > 0, "El resultado debería ser positivo");
    }

    @Test
    @DisplayName("Prueba de división por cero: debería lanzar IllegalArgumentException")
    void testDividirPorCero() {
        Calculadora calculadora = new Calculadora();

        // Verificar que una excepción específica es lanzada
        assertThrows(IllegalArgumentException.class, () -&gt; {
            calculadora.dividir(10, 0);
        }, "Dividir por cero debería lanzar IllegalArgumentException");
    }
}

4. 🧮 Anotaciones Comunes de JUnit Jupiter

5. ✅ Aserciones (clase org.junit.jupiter.api.Assertions)

Métodos estáticos para verificar condiciones.

6. 🔄 Pruebas Parametrizadas (@ParameterizedTest)

Ejecuta el mismo método de prueba con diferentes conjuntos de datos.

7. ⚖️ Asunciones (Assumptions)

Permiten “saltar” una prueba si una condición no se cumple. A diferencia de assert, no hacen que la prueba falle, sino que la “abortan” o la “ignoran”.

import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;

class AssumptionTest {
    @Test
    void testSoloEnDesarrollo() {
        Assumptions.assumeTrue(System.getenv("ENV") != null && System.getenv("ENV").equals("DEV"));
        // El resto de la prueba solo se ejecuta si la variable de entorno ENV es "DEV"
        System.out.println("Ejecutando prueba de desarrollo...");
    }

    @Test
    void testConRecursoOpcional() {
        boolean recursoDisponible = false; // Simula si un recurso externo está disponible
        Assumptions.assumingThat(recursoDisponible, () -&gt; {
            // Esta lambda solo se ejecuta si recursoDisponible es true
            System.out.println("Ejecutando prueba que depende de un recurso.");
            assertTrue(true);
        });
        // La prueba principal siempre continuará desde aquí
        System.out.println("Prueba principal continúa.");
    }
}

8. 📦 Extensiones (@ExtendWith)

El mecanismo de extensión de JUnit 5. Permite integrar funcionalidades de terceros (ej. Mockito, Spring, etc.) o crear tus propias extensiones.

// Ejemplo con Mockito (requiere dependencia mockito-junit-jupiter)
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class) // Habilita la extensión de Mockito
class UserServiceTest {
    @Mock // Mockea la dependencia
    private UserRepository userRepository;

    @Test
    void testGetUserById() {
        // Configura el mock
        when(userRepository.findById(1L)).thenReturn("John Doe");

        // ... usa userRepository en tu servicio
        // UserService userService = new UserService(userRepository);
        // assertEquals("John Doe", userService.getUserById(1L));
    }
}

9. 💡 Buenas Prácticas y Consejos

Este cheatsheet te proporciona una referencia completa de JUnit 5, cubriendo sus conceptos esenciales, cómo estructurar pruebas, las anotaciones clave, las aserciones, las pruebas parametrizadas y las mejores prácticas para escribir pruebas unitarias de Java efectivas y robustas.