JUnit & Mockito: Integración paso a paso para pruebas unitarias

Las pruebas unitarias son una parte esencial del desarrollo de software. Permiten verificar el correcto funcionamiento de cada módulo de código de forma independiente, detectando errores tempranamente y mejorando la calidad general del software. En este contexto, JUnit y Mockito se convierten en herramientas fundamentales para realizar pruebas unitarias de manera eficiente y efectiva. JUnit proporciona un framework robusto para la ejecución de pruebas, mientras que Mockito permite crear objetos simulados (mocks) que simulan el comportamiento de otras clases, facilitando el aislamiento y la prueba de los componentes individuales.

Este tutorial detalla cómo integrar JUnit y Mockito para realizar pruebas unitarias de forma práctica. A través de la creación de una aplicación matemática sencilla, ilustraremos los pasos necesarios para utilizar estas herramientas y comprender su funcionamiento.

Creando la Interfaz: El punto de partida

Comenzaremos por definir la interfaz CalculatorService que encapsula las operaciones matemáticas de nuestra aplicación. Esta interfaz servirá como punto de partida para la creación de los mocks con Mockito.

java
public interface CalculatorService {
int add(int num1, int num2);
int subtract(int num1, int num2);
int multiply(int num1, int num2);
int divide(int num1, int num2);
}


Esta interfaz define cuatro métodos: add, subtract, multiply y divide. Estos métodos representarán las operaciones matemáticas básicas que nuestra aplicación debe realizar.

La clase de la aplicación: El corazón de la lógica

A continuación, creamos la clase MathApplication que utiliza el servicio de cálculo definido en la interfaz CalculatorService. Esta clase será la que vamos a probar utilizando JUnit y Mockito.

«`java
public class MathApplication {
private CalculatorService calculatorService;

public MathApplication(CalculatorService calculatorService) {
    this.calculatorService = calculatorService;
}

public int add(int num1, int num2) {
    return calculatorService.add(num1, num2);
}

public int subtract(int num1, int num2) {
    return calculatorService.subtract(num1, num2);
}

public int multiply(int num1, int num2) {
    return calculatorService.multiply(num1, num2);
}

public int divide(int num1, int num2) {
    return calculatorService.divide(num1, num2);
}

}
«`

La clase MathApplication recibe una instancia de CalculatorService en su constructor. Los métodos de MathApplication simplemente delegan la lógica de cálculo a los métodos correspondientes de CalculatorService.

Pruebas unitarias: Verificando el comportamiento

Para probar la clase MathApplication, crearemos la clase de prueba MathApplicationTester. Esta clase utilizará JUnit para ejecutar los casos de prueba y Mockito para crear un objeto simulado de CalculatorService.

«`java
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.junit.jupiter.api.Assertions.*;

public class MathApplicationTester {
@Test
public void testAdd() {
CalculatorService calculatorService = Mockito.mock(CalculatorService.class);
Mockito.when(calculatorService.add(1, 2)).thenReturn(3);
MathApplication mathApplication = new MathApplication(calculatorService);
int result = mathApplication.add(1, 2);
assertEquals(3, result);
}

// Similar tests for subtract, multiply, and divide

}
«`

En este ejemplo de prueba, se crea un mock de CalculatorService utilizando Mockito.mock. Se define el comportamiento del mock utilizando Mockito.when y se establece que la suma de 1 y 2 debe devolver 3. Se crea una instancia de MathApplication con el mock de CalculatorService y se llama al método add. Finalmente, se utiliza assertEquals para verificar que el resultado de la operación es el esperado.

Ejecución de las pruebas: Automatización del proceso

Para ejecutar los casos de prueba, se crea la clase TestRunner que se encargará de ejecutar todas las pruebas unitarias definidas en el proyecto.

«`java
import org.junit.platform.launcher.Launcher;
import org.junit.platform.launcher.LauncherDiscoveryRequest;
import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
import org.junit.platform.launcher.core.LauncherFactory;
import org.junit.platform.launcher.core.TestExecutionListener;
import org.junit.platform.launcher.core.TestExecutionSummary;

public class TestRunner {
public static void main(String[] args) {
LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
.selectors(LauncherDiscoveryRequestBuilder.selectPackage(«com.example»))
.build();
Launcher launcher = LauncherFactory.create();
launcher.execute(request, new TestExecutionListener() {
@Override
public void executionFinished(TestExecutionSummary testExecutionSummary) {
System.out.println(testExecutionSummary.getSummary());
}
});
}
}
«`

Esta clase utiliza la API de JUnit para descubrir y ejecutar los casos de prueba. Se especifica el paquete que contiene las pruebas y se configura un listener para imprimir el resumen de la ejecución de las pruebas.

Verificación de los resultados: Validando el éxito

Para verificar los resultados de la ejecución de las pruebas, compilamos el código y ejecutamos la clase TestRunner. Si todas las pruebas se ejecutan correctamente, se mostrará un resumen con el estado de cada prueba y la información relevante sobre su ejecución.

JUnit & Mockito: Una combinación poderosa

La integración de JUnit y Mockito ofrece una herramienta poderosa para el desarrollo de software. JUnit proporciona un framework robusto para la ejecución de pruebas, mientras que Mockito permite crear objetos simulados (mocks) que facilitan el aislamiento y la prueba de los componentes individuales. Utilizando esta combinación, los desarrolladores pueden escribir pruebas unitarias de forma eficiente y efectiva, mejorando la calidad del código y detectando errores tempranamente en el ciclo de desarrollo.