En el post de excepciones en Java acabamos con una calculadora de IVA que pide un precio, acepta la coma española y no se cae si escribes abc. Para comprobar que funcionaba la ejecutaste y fuiste tecleando abc, -3 y 12,50. Perfecto la primera vez. El problema llega cuando cambias una línea del redondeo dos semanas después: tienes que acordarte de volver a teclear los tres casos, y casi nadie lo hace.
Así es como los errores de cálculo llegan a una factura. No porque el código fuera difícil, sino porque probarlo a mano da pereza y se salta. Hoy vamos a convertir esas tres pruebas (y alguna más) en un código que se ejecuta solo en dos segundos y te dice si has roto algo.
Al terminar tendrás un proyecto Java con Maven y diez comprobaciones automáticas sobre la calculadora, y habrás visto fallar un test a propósito, que es la parte que más enseña.
Probar a mano no escala
Piensa en cuando sales de casa y dudas si has cerrado la puerta. Vuelves, compruebas, y la próxima vez dudas igual, porque no hay ningún registro de que lo comprobaste. Con el código pasa lo mismo: ejecutarlo y mirar la pantalla te da una certeza que dura hasta el siguiente cambio.
La alternativa es escribir las comprobaciones como código: "con 100 euros de base, el IVA tiene que ser 21,00". Si esa frase está escrita, se puede ejecutar mil veces sin que nadie teclee nada. A cada una de esas comprobaciones se le llama test (prueba automática), y a las que miran una sola pieza pequeña del programa, test unitario. La herramienta que Java usa para escribirlos y ejecutarlos se llama JUnit.
Comprobé las versiones el 3 de noviembre de 2026 en las fuentes oficiales. La última estable de JUnit es la 6.1.3, publicada el 7 de agosto de 2026, y pide Java 17 o superior. Yo uso Java 21 en el post; la LTS más reciente es Java 25, y cualquiera de las dos te sirve. Si en un tutorial antiguo ves JUnit 5, los imports y las anotaciones que usaremos hoy son los mismos.
Primero hay que poder probar el cálculo
Mira la calculadora de aquella vez: toda la lógica vive dentro de main, mezclada con el Scanner que espera que alguien escriba en el teclado. Un test no puede teclear. Y tampoco puedes llamar a "la parte que calcula el IVA" porque no existe como pieza aparte: está pegada a las demás.
Esto es lo que pasa casi siempre al empezar con tests: el primer obstáculo no es JUnit, es que el código no está pensado para probarse. La solución es separar. Por un lado, una clase que solo calcula y valida. Por otro, el main que habla con el usuario.
package es.studycodepro.tienda;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class CalculadoraIva {
private static final BigDecimal IVA = new BigDecimal("0.21");
public static BigDecimal parsearPrecio(String texto) {
BigDecimal base = new BigDecimal(texto.trim().replace(',', '.'));
if (base.signum() < 0) {
throw new IllegalArgumentException("El precio no puede ser negativo");
}
return base;
}
public static BigDecimal calcularIva(BigDecimal base) {
return base.multiply(IVA).setScale(2, RoundingMode.HALF_UP);
}
public static BigDecimal calcularTotal(BigDecimal base) {
return base.add(calcularIva(base));
}
}
Son las mismas reglas del post anterior (coma española, nada de negativos, IVA al 21 % redondeado hacia arriba), pero ahora cada una es un método que recibe algo y devuelve algo. No imprime nada y no pregunta nada. Eso es justo lo que lo hace fácil de probar. Los métodos son static para no complicar el ejemplo: así los llamas con CalculadoraIva.calcularIva(...) sin crear ningún objeto.
Y el programa que habla con el usuario se queda en su propia clase, bastante más corto que antes:
package es.studycodepro.tienda;
import java.math.BigDecimal;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
BigDecimal base = null;
while (base == null) {
System.out.print("Precio sin IVA en euros: ");
try {
base = CalculadoraIva.parsearPrecio(teclado.nextLine());
} catch (NumberFormatException e) {
System.out.println("Eso no es un número. Prueba con 12,50");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
}
}
System.out.println("IVA (21%): " + CalculadoraIva.calcularIva(base) + " €");
System.out.println("Total: " + CalculadoraIva.calcularTotal(base) + " €");
}
}
Fíjate en que ya no hace falta el base = null dentro del segundo catch: si parsearPrecio lanza una excepción, la asignación no llega a ocurrir y base sigue valiendo null. Escribe abc, -3 y 12,50 como la otra vez y verás la misma salida (IVA 2.63 y total 15.13). Esa es la prueba de que el cambio no ha roto nada, y es la última vez que lo compruebas a mano.
El proyecto con Maven
JUnit no viene con Java, hay que descargarlo. Para eso se usa una herramienta de construcción, y la más habitual en empresas es Maven: tú describes en un archivo pom.xml qué librerías necesitas y él las descarga, compila y lanza los tests. Si ya has visto el post de Spring Boot, el esquema te sonará. Crea esta estructura de carpetas, que Maven espera exactamente así:
calculadora-iva/
pom.xml
src/
main/java/es/studycodepro/tienda/
CalculadoraIva.java
Main.java
test/java/es/studycodepro/tienda/
CalculadoraIvaTest.java
El código de la aplicación va en src/main/java y los tests en src/test/java, con la misma estructura de paquetes. Y este es el pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>es.studycodepro</groupId>
<artifactId>calculadora-iva</artifactId>
<version>1.0.0</version>
<properties>
<maven.compiler.release>21</maven.compiler.release>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>6.1.3</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.6.0</version>
</plugin>
</plugins>
</build>
</project>
Lo importante está en tres sitios. maven.compiler.release es la versión de Java con la que compila. La dependencia junit-jupiter trae todo lo que necesitamos de JUnit, y el scope en test significa que solo se usa al probar y no viaja con tu programa final. Y el plugin surefire es el que, al ejecutar mvn test, busca tus clases de test y las lanza. Si algún día Maven te avisa de que hay una versión más nueva del plugin, súbela sin miedo; la que pongo aquí es una que funciona, no necesariamente la última.
Tu primer test
Crea CalculadoraIvaTest.java en src/test/java/es/studycodepro/tienda/. Empezamos con dos comprobaciones: un precio redondo y el caso del redondeo que ya conoces del otro post, 12,50 € por 0,21, que da 2,625 y tiene que quedar en 2,63.
package es.studycodepro.tienda;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.math.BigDecimal;
import org.junit.jupiter.api.Test;
class CalculadoraIvaTest {
@Test
void calculaElIvaDeUnPrecioRedondo() {
BigDecimal iva = CalculadoraIva.calcularIva(new BigDecimal("100"));
assertEquals(new BigDecimal("21.00"), iva);
}
@Test
void redondeaHaciaArribaLaMitad() {
BigDecimal iva = CalculadoraIva.calcularIva(new BigDecimal("12.50"));
assertEquals(new BigDecimal("2.63"), iva);
}
}
Cada test es un método con la anotación @Test, que es la marca que le dice a JUnit "esto hay que ejecutarlo". Dentro hay tres pasos que se repiten siempre: preparas el dato, llamas al código que quieres probar y comparas el resultado con lo que esperabas. Esa comparación es assertEquals, que significa "afirma que estos dos valores son iguales". Si lo son, el test pasa; si no, falla y te dice por qué.
Los nombres largos son a propósito. Cuando un test falle, lo primero que verás es su nombre, y redondeaHaciaArribaLaMitad te cuenta qué se rompió sin abrir el archivo. Ahora ejecútalo desde la carpeta del proyecto:
mvn test
La primera vez tarda, porque Maven descarga JUnit. Al final tienes que ver algo parecido a esto:
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS
Error típico: el test que nunca se ejecuta
Si en lugar de org.junit.jupiter.api.Test importas org.junit.Test (de JUnit 4, muy frecuente en tutoriales antiguos y en lo que sugiere el editor), o si te olvidas de la anotación @Test, Maven no se queja: ese método simplemente no se ejecuta. Por eso hay un hábito que te ahorra sustos: mira siempre el número de Tests run y comprueba que coincide con los tests que has escrito. Dos tests escritos y Tests run: 1 significa que uno no cuenta.
Error típico: la clase de test no se encuentra
Si Maven dice No tests to run, revisa tres cosas: que el archivo está en src/test/java y no en src/main/java, que el paquete coincide con el de la clase que pruebas, y que el nombre de la clase termina en Test (CalculadoraIvaTest sí, PruebasCalculadora no). Surefire busca esos nombres por convención.
Verlo fallar a propósito
Un test que has visto pasar no te dice mucho, porque podría estar mal escrito y pasar siempre. Lo que de verdad demuestra que funciona es verlo fallar cuando el código está mal. Así que vamos a romper la calculadora adrede. En calcularIva, cambia RoundingMode.HALF_UP por RoundingMode.DOWN, que corta los decimales en lugar de redondear, y vuelve a lanzar mvn test.
[ERROR] Failures:
[ERROR] CalculadoraIvaTest.redondeaHaciaArribaLaMitad:20 expected: <2.63> but was: <2.62>
[ERROR] Tests run: 2, Failures: 1, Errors: 0, Skipped: 0
[INFO] BUILD FAILURE
Mira qué ha pasado: el test del precio redondo sigue pasando (100 por 0,21 es 21 exacto, sin nada que redondear), pero el del 12,50 ha saltado. El mensaje te da el nombre del test, la línea, lo que esperabas y lo que ha salido. Con un solo vistazo sabes que el redondeo está mal. Eso es lo que hace un test: te avisa justo en el momento en que cambias algo, y no semanas después cuando un cliente protesta. Devuelve el HALF_UP y comprueba que vuelve a pasar.
Error típico: poner los valores al revés
El orden de assertEquals es primero lo esperado y después lo que ha calculado tu código. Si los intercambias, el test falla igual, pero el mensaje se da la vuelta y te dice expected: <2.62> but was: <2.63>, justo al contrario de la realidad. Es confuso y te hace buscar el error en el sitio equivocado.
El fallo de BigDecimal que te va a pasar
Cambia el primer test para que espere new BigDecimal("21.0") en lugar de "21.00". Parece lo mismo, y para un humano lo es. Ejecuta:
CalculadoraIvaTest.calculaElIvaDeUnPrecioRedondo:15 expected: <21.0> but was: <21.00>
Falla, y el mensaje parece absurdo: 21.0 y 21.00 valen lo mismo. La razón es que el equals de BigDecimal también compara la escala, es decir, cuántos decimales tiene el número. Para él, 21.0 y 21.00 son números distintos. Esto me costó pillarlo la primera vez, porque miraba los valores y no los decimales.
Tienes dos salidas. La que usamos en el post es fijar la escala en el código (setScale(2, ...), que ya hace calcularIva) y escribir en el test el número con sus dos decimales. La otra es comparar con compareTo, que ignora la escala: assertEquals(0, esperado.compareTo(obtenido)) pasa con 21.0 y con 21.00. Para dinero, la primera es mejor, porque te obliga a decidir que todo importe lleva exactamente dos decimales. Vuelve a poner "21.00" en el test.
Probar lo que debe fallar: assertThrows
Hasta ahora hemos comprobado que el código calcula bien. Falta lo contrario: que se queja cuando debe. Una calculadora que acepta un precio negativo sin avisar es tan mala como una que calcula mal. Para eso JUnit tiene assertThrows, que afirma que cierto código lanza una excepción concreta.
@Test
void aceptaLaComaEspanola() {
assertEquals(new BigDecimal("12.50"), CalculadoraIva.parsearPrecio("12,50"));
}
@Test
void rechazaUnPrecioNegativo() {
IllegalArgumentException error = assertThrows(
IllegalArgumentException.class,
() -> CalculadoraIva.parsearPrecio("-3"));
assertEquals("El precio no puede ser negativo", error.getMessage());
}
@Test
void rechazaTextoQueNoEsUnNumero() {
assertThrows(NumberFormatException.class,
() -> CalculadoraIva.parsearPrecio("abc"));
}
@Test
void rechazaUnPrecioVacio() {
assertThrows(NumberFormatException.class,
() -> CalculadoraIva.parsearPrecio(""));
}
Añade también import static org.junit.jupiter.api.Assertions.assertThrows; arriba, junto al de assertEquals. Lo nuevo es el () ->: es una lambda (si no la recuerdas, está explicada en el post de Streams y lambdas) que envuelve la llamada. JUnit necesita ejecutarla él mismo, dentro de su propio try, para poder comprobar que salta la excepción. Si llamaras al método fuera de la lambda, la excepción saltaría antes de que JUnit pudiera atraparla y el test acabaría en error.
Además, assertThrows devuelve la excepción que ha capturado, y por eso en el segundo test podemos comprobar también el mensaje. Es el mismo texto que ve el usuario en Main, así que si alguien lo cambia por descuido, un test lo notará.
Error típico: probar excepciones con try y catch
Es tentador escribir try { parsearPrecio("-3"); } catch (IllegalArgumentException e) { } dentro del test. El problema es que si el código no lanza la excepción, el test pasa igualmente, porque no hay nada que haga fallar el try. Un test que no puede fallar no prueba nada. assertThrows sí falla si la excepción no aparece.
Muchos casos, un solo test
Para el total con IVA queremos probar varios importes: uno redondo, uno con redondeo, cero y un céntimo. Copiar y pegar cuatro tests casi idénticos funciona, pero es aburrido y cuesta mantenerlo. JUnit tiene los tests parametrizados: escribes el test una vez y le das una tabla de casos.
@ParameterizedTest
@CsvSource({
"100, 121.00",
"12.50, 15.13",
"0, 0.00",
"0.01, 0.01"
})
void calculaElTotalConIva(String base, String esperado) {
BigDecimal total = CalculadoraIva.calcularTotal(new BigDecimal(base));
assertEquals(new BigDecimal(esperado), total);
}
Cada línea del @CsvSource es un caso: el primer valor entra en base y el segundo en esperado. Necesitas dos imports más: org.junit.jupiter.params.ParameterizedTest y org.junit.jupiter.params.provider.CsvSource. JUnit ejecuta el método cuatro veces y cuenta cada una como un test aparte, así que si falla el caso del céntimo, sabes que ese y no otro.
Los casos que he elegido no son casualidad. El cero y el céntimo son límites, los sitios donde los programas suelen romperse: el IVA de un céntimo es 0,0021, que redondea a 0,00, y el total se queda en 0,01. Cuando no sepas qué probar, empieza por ahí, por el valor más pequeño, el cero y lo que no debería existir.
Con todo lo anterior, mvn test debería decirte algo parecido a Tests run: 10, Failures: 0: dos del principio, cuatro de coma y excepciones, y los cuatro casos del parametrizado. Si te sale un número distinto, vuelve al aviso de los tests que no se ejecutan.
Ejercicio: el IVA reducido, empezando por el test
En España no todo lleva el 21 %: hay un tipo reducido del 10 % y uno superreducido del 4 % para ciertos productos. Tu calculadora todavía no lo sabe. Haz esto en orden, porque el orden es el ejercicio:
Primero escribe un test que espere calcularIva(new BigDecimal("100"), new BigDecimal("0.10")) igual a 10.00. No compilará, porque ese método con dos parámetros no existe. Eso es correcto: es tu primer test rojo. Después crea el método (puedes dejar el de un parámetro llamando al nuevo con 0,21) hasta que el test pase. Por último, añade un caso del 4 % con un precio que obligue a redondear, como 12,50, y comprueba que los diez tests anteriores siguen en verde.
Escribir primero el test te obliga a decidir cómo quieres usar el método antes de preocuparte de cómo está hecho por dentro. Y la parte del final, que lo anterior sigue pasando, es el motivo por el que existen los tests.
Qué toca ahora
Con esto ya puedes cambiar el cálculo de una calculadora y saber en dos segundos si has roto algo, sin teclear un solo número. Es la misma red de seguridad que se usa en cualquier proyecto Java de empresa, solo que con un ejemplo pequeño.
Para seguir, coge la última clase que hayas escrito en el blog, por ejemplo la del informe de pedidos de Streams y lambdas, sepárala de su main como hicimos hoy y escríbele cuatro tests: un caso normal, la lista vacía, un solo elemento y algo que no debería existir. Cuando un test falle y no entiendas el mensaje, pégaselo a una IA y pídele que te explique qué significa, sin que te dé el arreglo; después léelo y decide tú si tiene sentido.
Y si quieres ver los tests dentro de un proyecto real, el siguiente paso natural es la aplicación del post de Spring Boot: añade un test a uno de sus métodos y comprueba que mvn test lo ejecuta.