Pruebas unitarias con JUnit

JUnit es un conjunto de bibliotecas que nos permiten escribir y ejecutar pruebas unitarias para Java.

Las pruebas unitarias nos sirven para comprobar el funcionamiento de nuestro código. Éstas nos permiten asegurar la robustez del código, preever futuros errores, corregir errores en caso de haberlos. Pueden ser manuales o automatizadas en el despliegue.

Estas pruebas se ejecutan en el tiempo de compilación y se aseguran de que los componentes individuales de la aplicación funcionen correctamente.

También existen alternativas para crear pruebas unitarias y son:

1. Pruebas integración con Arquillian: Arquillian es un marco de pruebas de integración que permite realizar pruebas integradas de la aplicación en un entorno de ejecución en vivo. Esto permite verificar la integración de los componentes de la aplicación y asegurarse de que funcionen correctamente juntos.

2. Pruebas de rendimiento con Gatling: Gatling es una herramienta de pruebas de rendimiento que permite medir el rendimiento de la aplicación en diferentes escenarios de carga. Esto ayuda a identificar cuellos de botella y a mejorar la escalabilidad de la aplicación.

3. Pruebas de aceptación con Cucumber: Cucumber es un marco de pruebas de aceptación que permite escribir pruebas de aceptación en un lenguaje fácil de entender y ejecutarlas automáticamente. Esto ayuda a asegurarse de que la aplicación cumpla con los requisitos funcionales especificados.

JUnit se compone de:

1. JUnit Platform (el núcleo): el que ejecuta las pruebas unitarias.
2. JUnit Jupiter: donde escribimos nuestras pruebas unitarias  
3. JUnit Vintage:como JUnit Jupiter, pero ya obsoleto.

Se puede integrar con otros frameworks de pruebas(como Mockito).

Algunas anotaciones de JUnit Jupiter:

• @Test. 
• @DisplayName. 
• @Tag. 
• @BeforeEach. 
• @AfterEach. 
• @BeforeAll. 
• @AfterAll. 
• @Disable. 
• @Nested. 
• @ExtendWith.

Generamos un proyecto Maven con este comando y seguimos el modo interactivo. Para después ubicarnos en el directorio del proyecto creado

$ mvn archetype:generate
$ cd proyecto-maven

Supongamos que tenemos una clase como esta:

Main.java

package com.inforhomex.app;

public class Main{
  public static int sumaInt(int a, int b){
      return a + b;
  }
}

En esta clase tenemos un método estático que suma dos números enteros. Para poder probar nuestro código usando JUnit debemos tener estas dependencias en nuestro proyecto (estamos usando Maven):

pom.xml

 <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <scope>test</scope>
    </dependency>
    
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-params</artifactId>
      <scope>test</scope>
    </dependency>

Ahora nos ubicamos en la carpeta de tests. Veremos una clase ``MainTest.java`` (puedes renombrar las clases como te parezca). Esta clase nos servirá para probar el método estático de suma de la clase principal del programa. Importamos la clase y creamos un test que falle (rojo en TDD).

package com.inforhomex.app;

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

import org.junit.jupiter.api.Test;
import com.inforhomex.app.Main;

public class MainTest {

    @Test
    public void testSumaIntFail() {
        int a = 43;
        int b = 56;
        int suma = Main.sumaInt(a, b);
        assertTrue(suma == 990);
    }
}

La anotación @Test nos permite crear una prueba. El método assertTrue evalua que una expresión o valor booleano que puede devolver falso o verdadero. En este test queremos que falle. Por lo que al ejecutar la prueba veremos el error.

Probemos el test:

$ mvn clean test

Si todo fue "correcto", la prueba fallará. Pues el resultado de la suma no concuerda el valor que evaluamos. Ahora escribimos un método que pase la prueba (verde en TDD).

MainTest.java

package com.inforhomex.app;

import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import com.inforhomex.app.Main;

public class MainTest {

    @Test
    public void testSumaInt() {
        int a = 43;
        int b = 56;
        int suma = Main.sumaInt(a, b);
        assertTrue(suma == 99);
    }
}

Al ejecutar la prueba dará como válido el resultado. Pues el valor de la suma (99) es igual al valor que colocamos en la expresión (99).

Probemos con un método estático para "formatear" una fecha de la forma YYYY-mm-dd a este otra forma YYYY/mm/dd.

Main.java

package com.inforhomex.app;

import java.time.LocalDate;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hola, mundo");
    }

    public static String formatDate(String fecha){
        String fechaFormato = null;
        LocalDate hoy = LocalDate.now();
        fechaFormato = hoy.toString().replaceAll("-","/");
        return fechaFormato;
    }
}

Ahora la clase tipo Test donde escribimos dos test, uno que falle y el otro que pase. Ocuparemos el método assertEquals para evaluar si dos objetos son iguales o no.

MainTest.java

package com.inforhomex.app;

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
import com.inforhomex.app.Main;

public class MainTest {

 
    @Test 
    public void testFormatDate(){
        String fecha = "2025-10-04";
        String nuevaFecha = Main.formatDate(fecha);
        assertEquals(nuevaFecha, "2025/10/04");
    }


     @Test 
    public void testFormatDateFail(){
        String fecha = "2025-10-04";
        String nuevaFecha = Main.formatDate(fecha);
        assertEquals(nuevaFecha, "2025-10-04");
    }

   
}

Ejecutamos el test:

$ mvn clean test

Nos dará como resultado un test exitoso y uno fallido.

¡Hemos hecho nuestras pruebas unitarias con JUnit!

Más sobre este tema en próximas entregas.

Enlaces:

https://junit.org/
https://code.visualstudio.com/docs/java/java-testing
https://medium.com/@sharmapraveen91/deep-dive-into-junit-5-and-mockito-annotations-and-use-cases-3b170698f1b2