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ícateAgregar 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):
- Arrange: Preparamos el escenario creando una instancia de
Calculadora
- Act: Ejecutamos la operación que queremos probar
- Assert: Verificamos que el resultado sea el esperado
Ciclo de vida de un test
Cuando JUnit 5 ejecuta un método anotado con @Test
:
- Crea una nueva instancia de la clase de prueba
- Ejecuta el método de prueba
- Si el método completa su ejecución sin lanzar excepciones, la prueba se considera exitosa
- 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.
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
Gestión de errores y excepciones
CRUD en Java de modelo Customer sobre un ArrayList
Clases abstractas
Listas
Métodos de la clase String
Streams: reduce()
API java.nio 2
Polimorfismo
Pattern Matching
Streams: flatMap()
Llamada y sobrecarga de funciones
Métodos referenciados
Métodos de la clase String
Representación de Fecha
Operadores lógicos
Inferencia de tipos con var
Tipos de datos
Estructuras de iteración
Streams: forEach()
Objetos
Funciones lambda
Uso de Scanner
Tipos de variables
Streams: collect()
Operadores aritméticos
Arrays y matrices
Clases y objetos
Interfaz funcional Consumer
CRUD en Java de modelo Customer sobre un HashMap
Interfaces
Enumeraciones Enums
API Optional
Interfaz funcional Function
Encapsulación
Interfaces
Uso de API Optional
Representación de Hora
Herencia básica
Clases y objetos
Interfaz funcional Supplier
HashMap
Sobrecarga de métodos
Polimorfismo de tiempo de ejecución
OOP en Java
Sobrecarga de métodos
CRUD de productos en Java
Clases sealed
Creación de Streams
Records
Encapsulación
Streams: min max
Herencia
Métodos avanzados de la clase String
Funciones
Polimorfismo de tiempo de compilación
Reto sintaxis Java
Conjuntos
Estructuras de control
Recursión
Excepciones
Herencia avanzada
Estructuras de selección
Uso de interfaces
Operadores
Variables
HashSet
Objeto Scanner
Streams: filter()
Operaciones de Streams
Interfaz funcional Predicate
Streams: sorted()
Configuración de entorno
Uso de variables
Clases
Streams: distinct()
Streams: count()
ArrayList
Mapas
Datos de referencia
Interfaces funcionales
Métodos básicos de la clase String
Tipos de datos
Clases abstractas
Instalación
Funciones
Excepciones
Estructuras de control
Herencia de clases
La clase Scanner
Generics
Streams: map()
Funciones y encapsulamiento
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
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.