Lección 7 de 8: pruebas. Una aplicación sin pruebas automáticas se rompe en silencio cada vez que alguien cambia algo. Aquí vas a escribir los tres tipos de prueba de Spring Boot: unitarias sin Spring, de una sola capa con @WebMvcTest y @DataJpaTest, y de la aplicación completa con RestTestClient, y a leer lo que dice Maven cuando una falla.
Por qué probar, y qué probar
Una prueba automática es un programa que usa tu código y revisa que el resultado sea el esperado. Tarda segundos en correr y la puedes repetir cada vez que cambies algo: es la forma de saber que tu arreglo de hoy no rompió lo que funcionaba ayer. En Spring Boot hay tres tamaños, y conviene usar cada uno para lo suyo:
El starter de pruebas que trae cada proyecto (spring-boot-starter-webmvc-test, spring-boot-starter-data-jpa-test…) incluye todo: JUnit 6 para escribir y correr las pruebas, AssertJ para las comprobaciones, Mockito para los objetos falsos y las herramientas de Spring. Las pruebas van en src/test/java, con el mismo paquete que la clase que prueban, y se corren con:
./mvnw test
Vamos a probar un catálogo pequeño: una entidad Producto, su repositorio, un controlador con GET /productos/{id} y POST /productos con validación, y una calculadora de precios.
1. Pruebas unitarias: sin Spring
La lógica pura, la que no habla con la base ni con la red, se prueba como cualquier clase de Java. No hace falta arrancar Spring, y por eso estas pruebas tardan milisegundos. Esta calculadora aplica un descuento y luego el IVA:
package com.ejemplo.catalogo;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class CalculadoraPrecio {
private static final BigDecimal IVA = new BigDecimal("0.16");
/** Aplica el descuento (por ejemplo, 10 para 10 %) y después el IVA. */
public BigDecimal total(BigDecimal precio, int descuento) {
BigDecimal conDescuento = precio.subtract(precio.multiply(BigDecimal.valueOf(descuento)).movePointLeft(2));
return conDescuento.add(conDescuento.multiply(IVA)).setScale(2, RoundingMode.HALF_UP);
}
}package com.ejemplo.catalogo;
import static org.assertj.core.api.Assertions.assertThat;
import java.math.BigDecimal;
import org.junit.jupiter.api.Test;
class CalculadoraPrecioTest {
private final CalculadoraPrecio calc = new CalculadoraPrecio();
@Test
void sinDescuentoSoloSumaElIva() {
assertThat(calc.total(new BigDecimal("100"), 0)).isEqualByComparingTo("116.00");
}
@Test
void aplicaElDescuentoAntesDelIva() {
// 1,000 con 10 % de descuento = 900; más IVA = 1,044
assertThat(calc.total(new BigDecimal("1000"), 10)).isEqualByComparingTo("1044.00");
}
}Cada método con @Test es una prueba. assertThat(...) de AssertJ se lee casi en español: «comprueba que el total sea igual a 116.00». Con BigDecimal usa isEqualByComparingTo, que compara el valor sin fijarse en los decimales (116 y 116.00 son iguales para ella, pero no para equals). Si la lógica está en clases sin Spring, como esta, la puedes probar a fondo con muchos casos sin pagar el tiempo de arranque.
2. Probar el controlador: @WebMvcTest
Para un controlador interesa saber si responde el código y el JSON correctos, si la validación funciona y si las rutas están bien. @WebMvcTest arranca solo la capa web (el controlador indicado, Jackson, la validación, los manejadores de errores), sin base de datos ni servidor real. Como el controlador necesita el repositorio, se le da uno falso con @MockitoBean:
package com.ejemplo.catalogo;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import java.math.BigDecimal;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.web.servlet.assertj.MockMvcTester;
@WebMvcTest(ProductoController.class)
class ProductoControllerTest {
@Autowired
MockMvcTester mvc;
@MockitoBean
ProductoRepository repo;
@Test
void devuelveElProductoEnJson() {
given(repo.findById(1L)).willReturn(Optional.of(new Producto("Teclado mecánico", new BigDecimal("1299.00"))));
assertThat(mvc.get().uri("/productos/1"))
.hasStatusOk()
.bodyJson().extractingPath("$.nombre").isEqualTo("Teclado mecánico");
}
@Test
void respondeNotFoundSiNoExiste() {
given(repo.findById(99L)).willReturn(Optional.empty());
assertThat(mvc.get().uri("/productos/99")).hasStatus(HttpStatus.NOT_FOUND);
}
@Test
void rechazaUnPrecioNegativo() {
assertThat(mvc.post().uri("/productos")
.contentType(MediaType.APPLICATION_JSON)
.content("""
{"nombre": "Mouse", "precio": -5}
"""))
.hasStatus(HttpStatus.BAD_REQUEST);
}
}Tres piezas nuevas:
@MockitoBeanpone en el contenedor un mock de Mockito en lugar del repositorio real: un objeto que no hace nada hasta que le dices qué responder.given(repo.findById(1L)).willReturn(...)programa esa respuesta.MockMvcTestersimula peticiones HTTP sin red y deja revisar la respuesta con AssertJ: el código, las cabeceras y el JSON, con rutas como$.nombre.- La tercera prueba no programa el mock: la validación rechaza el precio negativo antes de llegar al repositorio.
Piénsalo así
Un mock es un doble de acción. Para filmar la escena del controlador no necesitas al actor principal (la base de datos): basta alguien que diga sus líneas cuando le toca. Así pruebas la escena rápido y sin riesgos.
3. Probar el repositorio: @DataJpaTest
@DataJpaTest arranca solo la capa de datos: JPA, Hibernate, tus repositorios y una base H2 en memoria. Cada prueba corre dentro de una transacción que se deshace al terminar, así que una prueba no le deja basura a la siguiente:
package com.ejemplo.catalogo;
import static org.assertj.core.api.Assertions.assertThat;
import java.math.BigDecimal;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.data.jpa.test.autoconfigure.DataJpaTest;
@DataJpaTest
class ProductoRepositoryTest {
@Autowired
ProductoRepository repo;
@Test
void buscaSinImportarMayusculas() {
repo.save(new Producto("Mouse inalámbrico", new BigDecimal("349.50")));
repo.save(new Producto("Teclado mecánico", new BigDecimal("1299.00")));
assertThat(repo.findByNombreContainingIgnoreCase("MOUSE"))
.extracting(Producto::getNombre)
.containsExactly("Mouse inalámbrico");
}
}Vale la pena probar sobre todo las consultas derivadas y las de @Query: un error de dedo en el nombre, como el de la lección 5, aquí se descubre al momento.
4. La aplicación completa: @SpringBootTest y RestTestClient
Unas pocas pruebas deben arrancar todo junto, de verdad, para comprobar que las piezas encajan. Con webEnvironment = RANDOM_PORT, Spring Boot levanta el servidor en un puerto libre al azar. RestTestClient, nuevo en Spring Framework 7, hace peticiones HTTP reales a ese servidor; en Spring Boot 4.2 reemplaza a TestRestTemplate, que quedó obsoleto. Se inyecta con @AutoConfigureRestTestClient:
package com.ejemplo.catalogo;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.client.RestTestClient;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureRestTestClient
class CatalogoApplicationTests {
@Autowired
RestTestClient cliente;
@Test
void creaYLeeUnProducto() {
cliente.post().uri("/productos")
.contentType(MediaType.APPLICATION_JSON)
.body("""
{"nombre": "Audífonos", "precio": 899.90}
""")
.exchange()
.expectStatus().isCreated()
.expectHeader().location("/productos/1");
cliente.get().uri("/productos/1")
.exchange()
.expectStatus().isOk()
.expectBody().jsonPath("$.nombre").isEqualTo("Audífonos");
}
}Esta prueba crea un producto, revisa el 201 y la cabecera Location, y después lo lee. Pasa por el controlador, la validación, Jackson, Hibernate y H2: si algo no encaja entre capas, aquí falla.
Correr las pruebas
mvn test[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 6.636 s -- in com.ejemplo.catalogo.CatalogoApplicationTests [INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.657 s -- in com.ejemplo.catalogo.ProductoRepositoryTest [INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.006 s -- in com.ejemplo.catalogo.CalculadoraPrecioTest [INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.529 s -- in com.ejemplo.catalogo.ProductoControllerTest [INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0 [INFO] BUILD SUCCESS
Maven corre cada clase y avisa cuántas pruebas pasaron y cuánto tardó. Fíjate en los tiempos: la calculadora tarda casi nada; las otras pagan el arranque de su parte de Spring. Spring guarda en caché los contextos que ya arrancó y los reutiliza entre clases de prueba con la misma configuración, así que una suite grande no arranca Spring cien veces.
El aviso de Mockito. Al correr las pruebas, verás en la consola un aviso de Mockito: «Mockito is currently self-attaching to enable the inline-mock-maker. This will no longer work in future releases of the JDK». No es un error, las pruebas pasan; dice que las versiones futuras de Java ya no permitirán que Mockito se cargue solo. Mockito recomienda cargarlo como agente desde Maven, con dos plugins en el pom.xml:
<!-- (en <build><plugins>) -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>properties</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<argLine>-javaagent:${org.mockito:mockito-core:jar}</argLine>
</configuration>
</plugin>Lo probamos: con esos plugins, ./mvnw test pasa igual y el aviso ya no sale.
El error que te ahorra: una prueba que atrapa un error de lógica
Para eso existen: alguien «simplificó» la calculadora y ahora aplica el IVA primero y resta el descuento después, sobre el precio sin IVA. Parece lo mismo, pero no lo es. Al correr las pruebas:
mvn test[ERROR] Tests run: 2, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.147 s <<< FAILURE! -- in com.ejemplo.catalogo.CalculadoraPrecioTest [ERROR] com.ejemplo.catalogo.CalculadoraPrecioTest.aplicaElDescuentoAntesDelIva -- Time elapsed: 0.097 s <<< FAILURE! expected: 1044.00 but was: 1060.00
La prueba dice qué esperaba, qué obtuvo y en qué método. Con 10 % de descuento sobre $1,000 debía cobrar $1,044 y cobraba $1,060. Sin la prueba, ese error de $16 por venta habría llegado a producción.
Si olvidas el mock. En una prueba con @WebMvcTest, el repositorio no existe, porque esa prueba no arranca la capa de datos. Si quitas el @MockitoBean, el contexto no arranca y todas las pruebas de la clase fallan con un mensaje como este:
mvn test (fragmento de la causa)Unsatisfied dependency expressed through constructor parameter 0: No qualifying bean of type 'com.ejemplo.catalogo.ProductoRepository' available: expected at least 1 bean which qualifies as autowire candidate.
La solución es darle al controlador todo lo que pide: un @MockitoBean por cada dependencia.
Retos
Reto 1. Escribe una prueba con @DataJpaTest que compruebe que buscar «silla» en un catálogo vacío devuelve una lista vacía, no null.
Ver la solución
package com.ejemplo.catalogo;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.data.jpa.test.autoconfigure.DataJpaTest;
@DataJpaTest
class BusquedaVaciaTest {
@Autowired
ProductoRepository repo;
@Test
void sinCoincidenciasDevuelveListaVacia() {
assertThat(repo.findByNombreContainingIgnoreCase("silla")).isEmpty();
}
}mvn test[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 5.340 s -- in com.ejemplo.catalogo.BusquedaVaciaTest [INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 [INFO] BUILD SUCCESS
isEmpty() de AssertJ falla con un mensaje claro tanto si la lista tiene elementos como si es null.
Reto 2. Sin ejecutarlo: en ProductoControllerTest, si no programas el mock en devuelveElProductoEnJson (quitas el given), ¿qué responde GET /productos/1?
Ver la solución
Un 404. Un mock de Mockito sin programar devuelve valores «vacíos»: null, cero, listas vacías y, para un Optional, un Optional vacío. ResponseEntity.of lo convierte en 404, y la prueba falla porque esperaba 200. Es una pista frecuente: si una prueba con mocks da resultados vacíos inesperados, revisa qué le programaste.
Reto 3. ¿Por qué no hacer todas las pruebas con @SpringBootTest, si así se prueba «todo de verdad»?
Ver la solución
Por tiempo y por claridad. Cada @SpringBootTest arranca la aplicación completa; con cientos de pruebas, la suite pasaría de segundos a minutos, y la gente deja de correrla. Además, cuando falla una prueba grande, el problema puede estar en cualquier capa. Las pruebas pequeñas fallan cerca del error y dicen exactamente dónde está. Unas cuantas pruebas completas para revisar que todo encaje, y muchas pequeñas para la lógica, es la combinación que mejor funciona.
Cada proyecto de esta lección se compiló con Spring Boot 4.2.0, Java 25 (Temurin 25.0.5.1) y Maven 3.10.1 en un contenedor limpio y sin acceso a la red, se arrancó y se le hicieron las peticiones que ves con curl antes de publicar la lección; los registros, las respuestas y los errores están copiados de esa ejecución. Las horas de los registros son de la Ciudad de México.
