JUnit es uno de los frameworks más populares para realizar pruebas unitarias en Java. Con la evolución de la metodología de desarrollo ágil y las prácticas de integración continua, las pruebas unitarias se han convertido en un pilar fundamental para garantizar la calidad y robustez del software. En este artículo, exploraremos JUnit y sus principales aserciones, como assertEquals, assertTrue, assertFalse, entre otras.

---

¿Qué es JUnit?

JUnit es un framework de código abierto que proporciona un conjunto de anotaciones y métodos para estructurar y automatizar pruebas en Java. Ofrece:

• Simplicidad: Las anotaciones y métodos son sencillos de usar.
• Integración: Se integra con la mayoría de los IDE (Eclipse, IntelliJ, NetBeans, etc.) y herramientas de construcción (Maven, Gradle).
• Claridad: Permite crear casos de prueba organizados y fáciles de leer.

Versiones de JUnit

• JUnit 4: Presenta anotaciones como @Test, @Before, @After, @BeforeClass, @AfterClass.
• JUnit 5: Aporta mejoras en la separación de los módulos, anotaciones más potentes y un modelo extendible. Utiliza anotaciones como @Test, @BeforeEach, @AfterEach, @BeforeAll, @AfterAll.

En este artículo, utilizaremos la terminología y anotaciones más comunes; la mayoría de los conceptos funcionan de forma muy similar en ambas versiones.

---

Estructura básica de una prueba unitaria

Para comenzar, crearemos una clase de prueba. Generalmente, se sigue una convención en la que los tests se ubican en el directorio src/test/java, y el nombre de la clase de prueba termina con la palabra Test. Por ejemplo:

La idea principal es:

1. Configurar el entorno o valores de entrada (Arrange).
2. Ejecutar el método o bloque de código que queremos probar (Act).
3. Verificar el comportamiento usando aserciones (Assert).

Esta estructura se suele resumir en el patrón de diseño AAA (Arrange, Act, Assert).

---

Principales aserciones en JUnit

Las aserciones son la base de las pruebas en JUnit, pues permiten verificar si el resultado real coincide con el resultado esperado. A continuación, se muestran las más utilizadas.

1. assertEquals(expected, actual)

Verifica que dos valores son iguales. Por ejemplo, si se espera que la suma de 2 + 2 sea 4:

@Test
public void pruebaSuma() {
    int resultado = Calculadora.sumar(2, 2);
    // Verificar
    org.junit.Assert.assertEquals(4, resultado); // JUnit4

    // O en JUnit5 (import estático)
    // Assertions.assertEquals(4, resultado);
}

Si los valores no coinciden, la prueba falla e indica qué valor se obtuvo y cuál era el esperado.

• Importante: Para JUnit4, el orden de los parámetros en assertEquals es assertEquals(<expected>, <actual>).
• En JUnit5, se mantiene la misma convención.

2. assertTrue(condition)

Comprueba que una expresión booleana sea verdadera. Por ejemplo, si un método esPar(int numero) retorna un booleano indicando si un número es par:

@Test
public void pruebaEsPar() {
    boolean resultado = Calculadora.esPar(4);
    org.junit.Assert.assertTrue(resultado); // JUnit4
    // Assertions.assertTrue(resultado); // JUnit5
}

Si resultado es falso, la prueba marcará un error.

3. assertFalse(condition)

Similar a assertTrue, pero espera que la condición sea falsa:

@Test
public void pruebaNoEsPar() {
    boolean resultado = Calculadora.esPar(5);
    org.junit.Assert.assertFalse(resultado); // JUnit4
    // Assertions.assertFalse(resultado); // JUnit5
}

Si resultado es verdadero, la prueba fallará.

4. assertNull(object), assertNotNull(object)

• assertNull(object) verifica que el objeto sea null.
• assertNotNull(object) verifica que el objeto no sea null.

Ejemplo:

@Test
public void pruebaObjetoNulo() {
    Object objeto = null;
    org.junit.Assert.assertNull(objeto);
    // Assertions.assertNull(objeto); // JUnit5
}

5. assertSame(expected, actual) y assertNotSame(expected, actual)

assertSame verifica que dos referencias apunten al mismo objeto, mientras que assertNotSame verifica que sean diferentes. A veces es útil cuando se quiere comprobar la misma instancia:

@Test
public void pruebaMismaInstancia() {
    Calculadora calc1 = Calculadora.getInstancia();
    Calculadora calc2 = Calculadora.getInstancia();
    
    org.junit.Assert.assertSame(calc1, calc2); 
    // Assertions.assertSame(calc1, calc2); // JUnit5
}

---

Ejemplo práctico

Supongamos que tenemos una clase Calculadora con métodos sencillos: sumar(), restar(), multiplicar(), dividir(), y un método esPar(). Veamos cómo podrían lucir algunos tests:

Notas importantes:

• En assertEquals para valores de tipo double, se suele incluir un parámetro delta para indicar el margen de error aceptable.
• En JUnit4 se puede usar la propiedad expected en @Test para indicar que se espera una excepción (expected = ArithmeticException.class). En JUnit5 se utiliza Assertions.assertThrows(ArithmeticException.class, () -> {...}).

---

Buenas prácticas al escribir pruebas con JUnit

1. Nombre descriptivo de los métodos de prueba: Utiliza nombres de prueba que describan la funcionalidad o el escenario, por ejemplo, deberiaSumarDosNumeros() o lanzarExcepcionSiDivisorEsCero().
2. Único propósito por test: Cada prueba debe enfocarse en un solo caso o escenario. Esto facilita la lectura, el mantenimiento y la depuración cuando algo falla.
3. Uso de @Before/@BeforeEach y @After/@AfterEach: Son métodos de configuración previa y limpieza posterior para cada prueba. Si necesitas crear objetos o establecer un estado repetitivo, lo haces en @Before o @BeforeEach. Para liberar recursos o limpiar datos, @After o @AfterEach.
4. No dependas del orden de ejecución: Las pruebas deben ser independientes. No asumas que una prueba se ejecuta antes que otra.
5. Mantén tus pruebas rápidas: Si una prueba tarda mucho en ejecutarse, romperá la fluidez del proceso de desarrollo y la integración continua. Asegúrate de que tus pruebas unitarias sean veloces y concisas.

---

Conclusión

Las pruebas unitarias en JUnit ofrecen una forma estructurada y eficiente de verificar la lógica de tu aplicación Java. Usar aserciones como assertEquals, assertTrue o assertFalse es esencial para corroborar que tus métodos funcionen según lo esperado. Con la adopción de buenas prácticas y la integración de JUnit en tu flujo de desarrollo, podrás detectar errores tempranamente y mantener un código más robusto y fácil de mantener.

¿Listo para empezar? Prueba a crear tus clases de prueba en un proyecto Java, escribe algunos métodos de test y ejecuta tu suite de pruebas. Verás cómo identificar problemas y corregirlos resulta mucho más sencillo si cuentas con esta base sólida de pruebas unitarias.

---

Referencias útiles:

• Sitio oficial de JUnit
• Documentación JUnit 5

¡Espero que este artículo te ayude a entender mejor cómo funcionan las pruebas en JUnit y cómo utilizarlas para asegurar la calidad de tu proyecto Java!