Las pruebas unitarias son una práctica fundamental en el desarrollo de software que garantiza la confiabilidad y corrección de su código. En este artículo, exploraremos los conceptos clave de las pruebas unitarias de Java, incluidos ejemplos de código simples, parametrización, pruebas de excepciones, anotaciones como , , y , así como el uso de simulacros y apéndices. . @Before @BeforeEach @After @AfterEach También presentaremos la popular biblioteca Mockito para burlarnos y brindaremos orientación sobre cómo medir la cobertura del código utilizando complementos de Maven. La importancia de las pruebas unitarias Las pruebas unitarias son la práctica de probar componentes individuales o unidades de código de forma aislada para verificar su corrección. El objetivo principal es detectar y corregir errores en las primeras etapas del proceso de desarrollo, garantizando que cada unidad de código se comporte como se espera. Comencemos creando una clase de calculadora simple que podamos usar para nuestros ejemplos. La clase contiene operaciones aritméticas básicas: Calculator public class Calculator { public int add(int a, int b) { return a + b; } public int subtract(int a, int b) { return a - b; } public int multiply(int a, int b) { return a * b; } public int divide(int a, int b) { return a / b; } } Escribir una prueba unitaria simple Para crear una prueba unitaria para nuestra clase , puede utilizar el marco JUnit, un marco de prueba popular para Java. Escribamos una prueba unitaria simple para el método : Calculator add import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; public class CalculatorTest { @Test public void testAdd() { Calculator calculator = new Calculator(); int result = calculator.add(2, 3); assertEquals(5, result); } } En esta prueba, importamos las clases JUnit necesarias y anotamos el método de prueba con . Luego creamos una instancia de la clase y afirmamos que el resultado del método es igual al valor esperado (5). @Test Calculator add Pruebas parametrizadas Las pruebas parametrizadas le permiten ejecutar la misma lógica de prueba con múltiples conjuntos de datos de entrada. Esto es útil para probar un método con varios valores de entrada. Para hacer esto en JUnit, puede usar la anotación y proporcionar los valores de entrada y los resultados esperados como parámetros. He aquí un ejemplo: @ParameterizedTest import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; import static org.junit.jupiter.api.Assertions.assertEquals; public class CalculatorTest { @ParameterizedTest @CsvSource({"2, 3, 5", "4, 7, 11", "0, 0, 0"}) public void testAdd(int a, int b, int expected) { Calculator calculator = new Calculator(); int result = calculator.add(a, b); assertEquals(expected, result); } } En este ejemplo, la anotación nos permite proporcionar múltiples conjuntos de valores de entrada y resultados esperados en formato CSV. El método de prueba se ejecuta para cada combinación, lo que garantiza la corrección del método . @ParameterizedTest add Pruebas de excepción Probar las excepciones es fundamental para garantizar que su código maneje los errores de manera adecuada. Para probar casos de excepción, puede utilizar la anotación junto con el método proporcionado por JUnit. @Test assertThrows He aquí un ejemplo: javaCopy codeimport org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertThrows; public class CalculatorTest { @Test public void testDivideByZero() { Calculator calculator = new Calculator(); assertThrows(ArithmeticException.class, () -> calculator.divide(5, 0)); } } En esta prueba, verificamos que dividir un número entre cero en la clase arroja una . Calculator ArithmeticException Uso de anotaciones: @Before, @BeforeEach, @After y @AfterEach Anotaciones como , , y se utilizan para configurar y desmantelar el entorno de prueba. Estas anotaciones ayudan a gestionar las tareas comunes de inicialización y limpieza de pruebas. @Before @BeforeEach @After @AfterEach y se ejecutan una vez antes y después de todos los métodos de prueba en la clase de prueba, respectivamente. @Before @After y se ejecutan antes y después de cada método de prueba. @BeforeEach @AfterEach He aquí un ejemplo: import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; public class CalculatorTest { private Calculator calculator; @BeforeEach public void setUp() { calculator = new Calculator(); } @AfterEach public void tearDown() { calculator = null; } @Test public void testAdd() { int result = calculator.add(2, 3); assertEquals(5, result); } @Test public void testSubtract() { int result = calculator.subtract(5, 3); assertEquals(2, result); } } En este ejemplo, el método está anotado con e inicializa el objeto antes de cada prueba. El método , anotado con , limpia los recursos después de cada prueba. setUp @BeforeEach Calculator tearDown @AfterEach Simulacros y talones Los simulacros y los resguardos son esenciales en las pruebas unitarias cuando se desea aislar el código que se está probando de dependencias externas, como bases de datos o servicios web. Le permiten simular el comportamiento de estas dependencias. Un simulacro es un objeto que imita el comportamiento de un objeto real pero que está bajo tu control. Registra interacciones y le permite verificar que se llaman métodos específicos. Mock: un stub proporciona respuestas predeterminadas a llamadas a métodos. Devuelve datos predefinidos y se utiliza para simular ciertos comportamientos de un sistema externo. Stub: Ampliemos la clase para incluir un método que involucre una dependencia externa y luego creemos un código auxiliar para simular esa dependencia. Calculator public class Calculator { private ExternalService externalService; public Calculator(ExternalService externalService) { this.externalService = externalService; } public int performComplexCalculation(int a, int b) { int result = externalService.multiply(a, b); return result + externalService.getConstant(); } } En esta clase actualizada, se basa en un para multiplicar y obtener un valor constante. Calculator performComplexCalculation ExternalService A continuación se explica cómo puede crear un código auxiliar para probar la clase sin depender del real. Calculator ExternalService import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.*; public class CalculatorTest { @Test public void testPerformComplexCalculation() { // Create a stub for ExternalService ExternalService externalServiceStub = new ExternalService() { @Override public int multiply(int a, int b) { return a * b; } @Override public int getConstant() { return 5; // Stubbed constant value } }; // Create the Calculator with the stubbed ExternalService Calculator calculator = new Calculator(externalServiceStub); // Test the performComplexCalculation method int result = calculator.performComplexCalculation(2, 3); assertEquals(11, result); // 2*3 + 5 (constant) = 11 } } En esta prueba, se incluye dentro del método de prueba mediante la creación de una clase anónima que anula los métodos necesarios. De esta manera, el método de prueba se ejecuta sin depender de la implementación real de . ExternalService Calculator ExternalService Los stubs son útiles para simular el comportamiento de sistemas externos o dependencias para aislar y probar la funcionalidad específica de una clase o método. Esto le permite controlar el comportamiento del stub y centrarse en la unidad bajo prueba sin la necesidad de servicios externos reales. Presentamos Mockito para burlarse Mockito es una biblioteca Java popular para crear y administrar objetos simulados. Digamos que tenemos una clase que interactúa con una pasarela de pago externa. Podemos usar Mockito para crear un simulacro de la pasarela de pago: PaymentService import org.junit.jupiter.api.Test; import static org.mockito.Mockito.*; public class PaymentServiceTest { @Test public void testProcessPayment() { PaymentGateway paymentGateway = mock(PaymentGateway.class); PaymentService paymentService = new PaymentService(paymentGateway); when(paymentGateway.charge(100.0)).thenReturn(true); boolean result = paymentService.processPayment(100.0); assertTrue(result); verify(paymentGateway, times(1)).charge(100.0); } } En este ejemplo, creamos un simulado y usamos el método para definir su comportamiento. Luego llamamos al método en la clase y verificamos que el método se llamó con los parámetros esperados. PaymentGateway when processPayment PaymentService charge Cobertura de código y complemento Maven La cobertura de código mide el porcentaje de líneas de código, ramas o declaraciones que ejecutan sus pruebas unitarias. Le ayuda a identificar código no probado y áreas que pueden requerir pruebas adicionales. Maven es una herramienta de compilación popular para proyectos Java y puede integrar el análisis de cobertura de código en su proyecto Maven utilizando complementos como JaCoCo. Aquí le mostramos cómo agregar JaCoCo a su proyecto: Abra el archivo de su proyecto. pom.xml Agregue la configuración del complemento JaCoCo Maven: <build> <plugins> <plugin> <groupId>org.jacoco</groupId> <artifactId>jacoco-maven-plugin</artifactId> <version>0.8.7</version> <executions> <execution> <goals> <goal>prepare-agent</goal> </goals> </execution> <execution> <id>report</id> <phase>test</phase> <goals> <goal>report</goal> </goals> </execution> </executions> </plugin> </plugins> </build> Ejecute su compilación Maven con el siguiente comando: mvn clean verify Después de ejecutar la compilación, puede encontrar el informe de cobertura del código en el archivo . Este informe proporciona información detallada sobre la cobertura de su código por sus pruebas unitarias. target/site/jacoco/index.html Conclusión Las pruebas unitarias de Java son una práctica esencial para garantizar la confiabilidad y corrección de su código. Con herramientas como JUnit y Mockito, puede escribir pruebas unitarias y simulacros efectivos para sus componentes. Al integrar el análisis de cobertura de código con Maven y JaCoCo, puede asegurarse de que sus pruebas cubran una parte importante de su código base. Probar y mantener pruebas unitarias periódicamente le ayudará a producir aplicaciones Java robustas y de alta calidad. En la siguiente parte de esta serie, exploraremos las pruebas de integración, un aspecto crítico de las pruebas de software que implica probar las interacciones entre diferentes componentes y servicios para garantizar que el sistema general funcione correctamente. ¡Estén atentos a la segunda parte, donde nos sumergiremos en el apasionante mundo de las pruebas de integración!
![featured image - Pruebas en Java: los conceptos clave [Parte 1: Pruebas unitarias]](https://hackernoon.imgix.net/images/m1niFilZlGUYAN3blcOrJ7nMPqh2-mx83xyp.jpeg?auto=format&fit=max&w=3840)
