Java

Tutorial Java: Introducción a JUnit 5

Aprende a configurar JUnit 5 en Maven y domina los métodos básicos de assertions para pruebas unitarias en Java con ejemplos prácticos.

Aprende Java y certifícate

Agregar JUnit 5 en Maven

Para comenzar a utilizar JUnit 5 en nuestros proyectos Java, necesitamos incorporar las dependencias necesarias. Maven nos facilita enormemente esta tarea mediante su sistema de gestión de dependencias.

JUnit 5 está compuesto por varios módulos que podemos agregar según nuestras necesidades. Para un uso básico, necesitaremos al menos el módulo jupiter-api, que contiene las anotaciones y clases principales para escribir tests.

Configuración básica en el pom.xml

Para agregar JUnit 5 a un proyecto Maven, debemos modificar el archivo pom.xml incluyendo las dependencias necesarias dentro de la sección <dependencies>:

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.9.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Observa que hemos establecido el <scope> como test, lo que significa que estas dependencias solo estarán disponibles durante la fase de pruebas y no se incluirán en el paquete final de la aplicación.

Configuración del plugin de Surefire

Para asegurarnos de que Maven ejecute correctamente los tests de JUnit 5, también necesitamos configurar el plugin de Surefire. Este plugin es el responsable de ejecutar los tests durante el ciclo de vida de Maven:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.0.0</version>
        </plugin>
    </plugins>
</build>

Dependencias individuales

Si prefieres un control más granular sobre las dependencias, puedes agregar los módulos específicos de JUnit 5 que necesites:

<dependencies>
    <!-- API de JUnit Jupiter - contiene anotaciones como @Test -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.9.2</version>
        <scope>test</scope>
    </dependency>
    
    <!-- Motor de ejecución de JUnit Jupiter -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.9.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Estructura de directorios

Una vez configuradas las dependencias, Maven espera que los tests se ubiquen en una estructura de directorios específica:

src/
├── main/
│   └── java/           # Código fuente principal
└── test/
    └── java/           # Código de pruebas

Por ejemplo, si tienes una clase Calculator en src/main/java/com/example/Calculator.java, su test correspondiente debería estar en src/test/java/com/example/CalculatorTest.java.

Verificación de la configuración

Para verificar que JUnit 5 se ha configurado correctamente, podemos crear un test simple:

package com.example;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class SimpleTest {
    
    @Test
    void simpleAssertion() {
        assertEquals(2, 1 + 1, "1 + 1 debe ser igual a 2");
    }
}

Luego, ejecutamos los tests con el comando Maven:

mvn test

Si la configuración es correcta, Maven ejecutará el test y mostrará un resultado exitoso.

Dependencias adicionales útiles

Dependiendo de tus necesidades, podrías querer agregar módulos adicionales de JUnit 5:

<!-- Para tests parametrizados -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-params</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>

<!-- Para compatibilidad con JUnit 4 -->
<dependency>
    <groupId>org.junit.vintage</groupId>
    <artifactId>junit-vintage-engine</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>

Con esta configuración básica, ya estamos listos para comenzar a escribir tests unitarios con JUnit 5 en nuestro proyecto Java gestionado con Maven.

La anotación @Test

La anotación @Test es el elemento fundamental para crear pruebas unitarias en JUnit 5. Esta anotación marca un método como un método de prueba que será ejecutado por el framework de testing.

Para utilizar la anotación @Test, primero debemos importarla del paquete correspondiente:

import org.junit.jupiter.api.Test;

Un método de prueba básico tiene esta estructura:

@Test
void nombreDelTest() {
    // Código de la prueba
}

Observa que los métodos de prueba:

  • No necesitan ser public (a diferencia de JUnit 4)
  • Normalmente tienen un tipo de retorno void
  • Pueden tener cualquier nombre descriptivo

Creando tu primera prueba

Veamos un ejemplo sencillo de cómo crear una prueba para una clase Calculadora:

// Clase que queremos probar (src/main/java/com/example/Calculadora.java)
package com.example;

public class Calculadora {
    public int sumar(int a, int b) {
        return a + b;
    }
}
// Clase de prueba (src/test/java/com/example/CalculadoraTest.java)
package com.example;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class CalculadoraTest {
    
    @Test
    void sumarDosNumeros() {
        // 1. Preparación (Arrange)
        Calculadora calc = new Calculadora();
        
        // 2. Acción (Act)
        int resultado = calc.sumar(3, 5);
        
        // 3. Verificación (Assert)
        assertEquals(8, resultado, "3 + 5 debe ser igual a 8");
    }
}

Este ejemplo sigue el patrón AAA (Arrange-Act-Assert):

  1. Arrange: Preparamos el escenario creando una instancia de Calculadora
  2. Act: Ejecutamos la operación que queremos probar
  3. Assert: Verificamos que el resultado sea el esperado

Ciclo de vida de un test

Cuando JUnit 5 ejecuta un método anotado con @Test:

  1. Crea una nueva instancia de la clase de prueba
  2. Ejecuta el método de prueba
  3. Si el método completa su ejecución sin lanzar excepciones, la prueba se considera exitosa
  4. Si el método lanza una excepción o falla una aserción, la prueba se considera fallida

Comportamientos especiales

La anotación @Test puede combinarse con otras anotaciones para modificar su comportamiento:

@Test
@DisplayName("Prueba de suma de números positivos")
void testConNombrePersonalizado() {
    // Esta prueba tendrá un nombre personalizado en los informes
}

@Test
@Disabled("Esta prueba está temporalmente deshabilitada")
void testDeshabilitado() {
    // Este test no se ejecutará
}

@Test
@Timeout(5) // Tiempo máximo en segundos
void testConLímiteDeTiempo() {
    // Esta prueba fallará si tarda más de 5 segundos
}

Pruebas esperadas para excepciones

JUnit 5 permite verificar que un código lance excepciones específicas:

@Test
void divisionPorCeroDebeArrojarExcepcion() {
    Calculadora calc = new Calculadora();
    
    // Verificamos que se lance ArithmeticException
    assertThrows(ArithmeticException.class, () -> {
        calc.dividir(10, 0);
    });
}

Ejecutando pruebas desde el IDE

La mayoría de los entornos de desarrollo modernos como IntelliJ IDEA, Eclipse o NetBeans tienen integración con JUnit 5, permitiéndote ejecutar pruebas con un simple clic:

  • Ejecutar una prueba individual: haz clic derecho en el método y selecciona "Run"
  • Ejecutar todas las pruebas de una clase: haz clic derecho en la clase y selecciona "Run"
  • Ejecutar todas las pruebas del proyecto: ejecuta la configuración de prueba del proyecto

Convenciones de nomenclatura

Aunque JUnit 5 no impone reglas estrictas para nombrar tus pruebas, estas convenciones son comunes:

  • Nombres de clases de prueba: [NombreClase]Test
  • Nombres de métodos de prueba: descriptivos de lo que se está probando
  • Estructura: [escenario]_[comportamiento]_[resultadoEsperado]

Por ejemplo:

@Test
void sumaDeNumerosNegativos_DebeRetornarSumaCorrecta() {
    // Código de la prueba
}

La anotación @Test es solo el comienzo de lo que JUnit 5 ofrece, pero dominarla es el primer paso para crear pruebas efectivas que garanticen la calidad de tu código Java.

Métodos básicos de la API Assertions

La clase Assertions es el corazón de la verificación en JUnit 5, proporcionando métodos estáticos que nos permiten validar si nuestro código funciona como esperamos. Estos métodos nos ayudan a comprobar resultados, comparar valores y verificar comportamientos.

Para utilizar los métodos de aserciones en nuestros tests, debemos importarlos:

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

El uso de la importación estática nos permite llamar a los métodos directamente, mejorando la legibilidad del código.

Aserciones básicas

Los métodos más comunes y fundamentales son:

  • assertEquals: Compara si dos valores son iguales
@Test
void testSuma() {
    int resultado = 2 + 2;
    assertEquals(4, resultado);
}
  • assertTrue/assertFalse: Verifica si una condición es verdadera o falsa
@Test
void testCondicion() {
    String texto = "Hola Mundo";
    assertTrue(texto.startsWith("Hola"));
    assertFalse(texto.isEmpty());
}
  • assertNull/assertNotNull: Comprueba si un objeto es null o no
@Test
void testNulos() {
    String textoVacio = "";
    String textoNulo = null;
    
    assertNull(textoNulo);
    assertNotNull(textoVacio);
}

Mensajes personalizados

Todos los métodos de aserción aceptan un mensaje personalizado como último parámetro, que se mostrará si la prueba falla:

@Test
void testConMensaje() {
    int resultado = sumar(3, 2);
    assertEquals(5, resultado, "La suma de 3 + 2 debería ser 5");
}

También podemos usar Supplier para crear mensajes de forma perezosa, lo que mejora el rendimiento ya que el mensaje solo se construye si la prueba falla:

@Test
void testConMensajePerezoso() {
    String nombre = "Juan";
    assertEquals("Juan", nombre, () -> "El nombre debería ser 'Juan' pero fue '" + nombre + "'");
}

Comparación de arrays

JUnit 5 proporciona métodos específicos para comparar arrays:

@Test
void testArrays() {
    int[] esperado = {1, 2, 3};
    int[] actual = {1, 2, 3};
    
    assertArrayEquals(esperado, actual);
}

Verificación de excepciones

Para verificar que un código lanza una excepción específica:

@Test
void testExcepcion() {
    Exception exception = assertThrows(ArithmeticException.class, () -> {
        int resultado = 10 / 0;
    });
    
    assertEquals("/ by zero", exception.getMessage());
}

Agrupación de aserciones

El método assertAll permite agrupar varias aserciones para que se ejecuten todas, incluso si alguna falla:

@Test
void testMultiplesAserciones() {
    String texto = "JUnit 5";
    
    assertAll("texto",
        () -> assertEquals(7, texto.length()),
        () -> assertTrue(texto.contains("JUnit")),
        () -> assertTrue(texto.endsWith("5"))
    );
}

Esto es especialmente útil cuando queremos verificar múltiples propiedades de un objeto y necesitamos ver todos los fallos a la vez, no solo el primero.

Verificación de tiempo de ejecución

Para verificar que un código se ejecuta dentro de un tiempo límite:

@Test
void testTiempoEjecucion() {
    assertTimeout(Duration.ofMillis(100), () -> {
        // Código que debería ejecutarse en menos de 100ms
        Thread.sleep(50);
    });
}

Ejemplo práctico

Veamos un ejemplo completo utilizando varios métodos de aserción para probar una clase Producto:

class Producto {
    private String nombre;
    private double precio;
    
    public Producto(String nombre, double precio) {
        this.nombre = nombre;
        this.precio = precio;
    }
    
    public String getNombre() { return nombre; }
    public double getPrecio() { return precio; }
    public double getPrecioConIVA() { return precio * 1.21; }
}

Y su test correspondiente:

@Test
void testProducto() {
    Producto p = new Producto("Teclado", 50.0);
    
    assertAll("propiedades del producto",
        () -> assertEquals("Teclado", p.getNombre()),
        () -> assertEquals(50.0, p.getPrecio()),
        () -> assertEquals(60.5, p.getPrecioConIVA(), 0.01),
        () -> assertTrue(p.getPrecio() > 0)
    );
}

Aserciones para colecciones

Para verificar elementos en colecciones:

@Test
void testLista() {
    List<String> frutas = Arrays.asList("Manzana", "Pera", "Naranja");
    
    assertEquals(3, frutas.size());
    assertTrue(frutas.contains("Pera"));
    assertEquals("Manzana", frutas.get(0));
}

Aserciones para objetos

Para comparar objetos completos, JUnit utiliza el método equals():

@Test
void testObjetos() {
    Punto p1 = new Punto(1, 2);
    Punto p2 = new Punto(1, 2);
    Punto p3 = new Punto(5, 6);
    
    assertEquals(p1, p2); // Pasa si p1.equals(p2) es true
    assertNotEquals(p1, p3);
}

Los métodos de aserción de JUnit 5 son herramientas fundamentales para validar el comportamiento de nuestro código. Dominarlos nos permitirá crear pruebas robustas que verifiquen correctamente la funcionalidad de nuestras aplicaciones Java.

CONSTRUYE TU CARRERA EN IA Y PROGRAMACIÓN SOFTWARE

Accede a +1000 lecciones y cursos con certificado. Mejora tu portfolio con certificados de superación para tu CV.

30 % DE DESCUENTO

Plan mensual

19.00 /mes

13.30 € /mes

Precio normal mensual: 19 €
63 % DE DESCUENTO

Plan anual

10.00 /mes

7.00 € /mes

Ahorras 144 € al año
Precio normal anual: 120 €
Aprende Java online

Ejercicios de esta lección Introducción a JUnit 5

Evalúa tus conocimientos de esta lección Introducción a JUnit 5 con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.

Streams: match

Test

Gestión de errores y excepciones

Código

CRUD en Java de modelo Customer sobre un ArrayList

Proyecto

Clases abstractas

Test

Listas

Código

Métodos de la clase String

Código

Streams: reduce()

Test

API java.nio 2

Puzzle

Polimorfismo

Código

Pattern Matching

Código

Streams: flatMap()

Test

Llamada y sobrecarga de funciones

Puzzle

Métodos referenciados

Test

Métodos de la clase String

Código

Representación de Fecha

Puzzle

Operadores lógicos

Test

Inferencia de tipos con var

Código

Tipos de datos

Código

Estructuras de iteración

Puzzle

Streams: forEach()

Test

Objetos

Puzzle

Funciones lambda

Test

Uso de Scanner

Puzzle

Tipos de variables

Puzzle

Streams: collect()

Puzzle

Operadores aritméticos

Puzzle

Arrays y matrices

Código

Clases y objetos

Código

Interfaz funcional Consumer

Test

CRUD en Java de modelo Customer sobre un HashMap

Proyecto

Interfaces

Código

Enumeraciones Enums

Código

API Optional

Test

Interfaz funcional Function

Test

Encapsulación

Test

Interfaces

Código

Uso de API Optional

Puzzle

Representación de Hora

Test

Herencia básica

Test

Clases y objetos

Código

Interfaz funcional Supplier

Puzzle

HashMap

Puzzle

Sobrecarga de métodos

Test

Polimorfismo de tiempo de ejecución

Puzzle

OOP en Java

Proyecto

Sobrecarga de métodos

Código

CRUD de productos en Java

Proyecto

Clases sealed

Código

Creación de Streams

Test

Records

Código

Encapsulación

Código

Streams: min max

Puzzle

Herencia

Código

Métodos avanzados de la clase String

Puzzle

Funciones

Código

Polimorfismo de tiempo de compilación

Test

Reto sintaxis Java

Proyecto

Conjuntos

Código

Estructuras de control

Código

Recursión

Código

Excepciones

Puzzle

Herencia avanzada

Puzzle

Estructuras de selección

Test

Uso de interfaces

Test

Operadores

Código

Variables

Código

HashSet

Test

Objeto Scanner

Test

Streams: filter()

Puzzle

Operaciones de Streams

Puzzle

Interfaz funcional Predicate

Puzzle

Streams: sorted()

Test

Configuración de entorno

Test

Uso de variables

Test

Clases

Test

Streams: distinct()

Puzzle

Streams: count()

Test

ArrayList

Test

Mapas

Código

Datos de referencia

Test

Interfaces funcionales

Puzzle

Métodos básicos de la clase String

Test

Tipos de datos

Código

Clases abstractas

Código

Instalación

Test

Funciones

Código

Excepciones

Código

Estructuras de control

Código

Herencia de clases

Código

La clase Scanner

Código

Generics

Código

Streams: map()

Puzzle

Funciones y encapsulamiento

Test

Todas las lecciones de Java

Accede a todas las lecciones de Java y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.

Instalación De Java

Introducción Y Entorno

Configuración De Entorno Java

Introducción Y Entorno

Tipos De Datos

Sintaxis

Variables

Sintaxis

Operadores

Sintaxis

Estructuras De Control

Sintaxis

Funciones

Sintaxis

Recursión

Sintaxis

Arrays Y Matrices

Sintaxis

Excepciones

Programación Orientada A Objetos

Clases Y Objetos

Programación Orientada A Objetos

Encapsulación

Programación Orientada A Objetos

Herencia

Programación Orientada A Objetos

Clases Abstractas

Programación Orientada A Objetos

Interfaces

Programación Orientada A Objetos

Sobrecarga De Métodos

Programación Orientada A Objetos

Polimorfismo

Programación Orientada A Objetos

La Clase Scanner

Programación Orientada A Objetos

Métodos De La Clase String

Programación Orientada A Objetos

Excepciones

Programación Orientada A Objetos

Records

Programación Orientada A Objetos

Pattern Matching

Programación Orientada A Objetos

Inferencia De Tipos Con Var

Programación Orientada A Objetos

Enumeraciones Enums

Programación Orientada A Objetos

Generics

Programación Orientada A Objetos

Clases Sealed

Programación Orientada A Objetos

Listas

Framework Collections

Conjuntos

Framework Collections

Mapas

Framework Collections

Funciones Lambda

Programación Funcional

Interfaz Funcional Consumer

Programación Funcional

Interfaz Funcional Predicate

Programación Funcional

Interfaz Funcional Supplier

Programación Funcional

Interfaz Funcional Function

Programación Funcional

Métodos Referenciados

Programación Funcional

Creación De Streams

Programación Funcional

Operaciones Intermedias Con Streams: Map()

Programación Funcional

Operaciones Intermedias Con Streams: Filter()

Programación Funcional

Operaciones Intermedias Con Streams: Distinct()

Programación Funcional

Operaciones Finales Con Streams: Collect()

Programación Funcional

Operaciones Finales Con Streams: Min Max

Programación Funcional

Operaciones Intermedias Con Streams: Flatmap()

Programación Funcional

Operaciones Intermedias Con Streams: Sorted()

Programación Funcional

Operaciones Finales Con Streams: Reduce()

Programación Funcional

Operaciones Finales Con Streams: Foreach()

Programación Funcional

Operaciones Finales Con Streams: Count()

Programación Funcional

Operaciones Finales Con Streams: Match

Programación Funcional

Api Optional

Programación Funcional

Transformación

Programación Funcional

Reducción Y Acumulación

Programación Funcional

Mapeo

Programación Funcional

Streams Paralelos

Programación Funcional

Agrupación Y Partición

Programación Funcional

Filtrado Y Búsqueda

Programación Funcional

Api Java.nio 2

Entrada Y Salida Io

Fundamentos De Io

Entrada Y Salida Io

Leer Y Escribir Archivos

Entrada Y Salida Io

Httpclient Moderno

Entrada Y Salida Io

Clases De Nio2

Entrada Y Salida Io

Api Java.time

Api Java.time

Localtime

Api Java.time

Localdatetime

Api Java.time

Localdate

Api Java.time

Executorservice

Concurrencia

Virtual Threads (Project Loom)

Concurrencia

Future Y Completablefuture

Concurrencia

Spring Framework

Frameworks Para Java

Micronaut

Frameworks Para Java

Maven

Frameworks Para Java

Gradle

Frameworks Para Java

Lombok Para Java

Frameworks Para Java

Quarkus

Frameworks Para Java

Ecosistema Jakarta Ee De Java

Frameworks Para Java

Introducción A Junit 5

Testing

Accede GRATIS a Java y certifícate

Certificados de superación de Java

Supera todos los ejercicios de programación del curso de Java y obtén certificados de superación para mejorar tu currículum y tu empleabilidad.

En esta lección

Objetivos de aprendizaje de esta lección

  • Configurar JUnit 5 en un proyecto Maven incluyendo dependencias y plugins necesarios.
  • Entender y utilizar la anotación @Test para definir métodos de prueba.
  • Aplicar los métodos básicos de la API Assertions para validar resultados en pruebas.
  • Conocer la estructura de directorios recomendada para pruebas en Maven.
  • Ejecutar y verificar pruebas unitarias desde el IDE y línea de comandos.