En este módulo, profundizaremos en las aserciones avanzadas de JUnit. Las aserciones son fundamentales para verificar que el código se comporte como se espera. JUnit proporciona una variedad de aserciones avanzadas que permiten realizar verificaciones más complejas y detalladas.
Contenido
Aserciones de Arrays
Las aserciones de arrays permiten verificar que dos arrays sean iguales. Esto es útil cuando se trabaja con datos en forma de arrays y se necesita comparar su contenido.
Ejemplo
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
public class ArrayAssertionsTest {
@Test
public void testArrayEquals() {
int[] expected = {1, 2, 3, 4, 5};
int[] actual = {1, 2, 3, 4, 5};
assertArrayEquals(expected, actual, "Los arrays no son iguales");
}
}Explicación
assertArrayEquals(expected, actual, "Los arrays no son iguales"): Verifica que los arraysexpectedyactualsean iguales. Si no lo son, se muestra el mensaje "Los arrays no son iguales".
Aserciones de Colecciones
JUnit también permite verificar colecciones como listas y conjuntos. Esto es útil cuando se trabaja con estructuras de datos más complejas.
Ejemplo
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Arrays;
public class CollectionAssertionsTest {
@Test
public void testIterableEquals() {
List<String> expected = Arrays.asList("uno", "dos", "tres");
List<String> actual = Arrays.asList("uno", "dos", "tres");
assertIterableEquals(expected, actual, "Las colecciones no son iguales");
}
}Explicación
assertIterableEquals(expected, actual, "Las colecciones no son iguales"): Verifica que las coleccionesexpectedyactualsean iguales. Si no lo son, se muestra el mensaje "Las colecciones no son iguales".
Aserciones de Excepciones
Las aserciones de excepciones permiten verificar que un bloque de código lanza una excepción específica. Esto es útil para probar el manejo de errores en el código.
Ejemplo
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
public class ExceptionAssertionsTest {
@Test
public void testException() {
Exception exception = assertThrows(IllegalArgumentException.class, () -> {
throw new IllegalArgumentException("Mensaje de error");
});
assertEquals("Mensaje de error", exception.getMessage());
}
}Explicación
assertThrows(IllegalArgumentException.class, () -> { throw new IllegalArgumentException("Mensaje de error"); }): Verifica que el bloque de código lanza unaIllegalArgumentException.assertEquals("Mensaje de error", exception.getMessage()): Verifica que el mensaje de la excepción sea "Mensaje de error".
Aserciones de Tiempo
Las aserciones de tiempo permiten verificar que un bloque de código se ejecuta dentro de un tiempo específico. Esto es útil para probar el rendimiento del código.
Ejemplo
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
public class TimeoutAssertionsTest {
@Test
public void testTimeout() {
assertTimeout(Duration.ofSeconds(1), () -> {
// Simula una tarea que toma tiempo
Thread.sleep(500);
});
}
}Explicación
assertTimeout(Duration.ofSeconds(1), () -> { Thread.sleep(500); }): Verifica que el bloque de código se ejecuta en menos de 1 segundo.
Aserciones Compuestas
Las aserciones compuestas permiten agrupar varias aserciones en una sola prueba. Esto es útil para verificar múltiples condiciones en un solo test.
Ejemplo
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
public class CompositeAssertionsTest {
@Test
public void testAll() {
assertAll("group of assertions",
() -> assertEquals(2, 1 + 1),
() -> assertTrue("hello".startsWith("h")),
() -> assertFalse("world".isEmpty())
);
}
}Explicación
assertAll("group of assertions", ...): Agrupa varias aserciones. Si alguna falla, se muestra el mensaje "group of assertions".
Ejercicios Prácticos
Ejercicio 1
Escribe un test que verifique que dos arrays de cadenas de texto son iguales.
Solución
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
public class ArrayStringAssertionsTest {
@Test
public void testStringArrayEquals() {
String[] expected = {"a", "b", "c"};
String[] actual = {"a", "b", "c"};
assertArrayEquals(expected, actual, "Los arrays de cadenas no son iguales");
}
}Ejercicio 2
Escribe un test que verifique que una lista de enteros contiene los elementos esperados.
Solución
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Arrays;
public class IntegerListAssertionsTest {
@Test
public void testIntegerListEquals() {
List<Integer> expected = Arrays.asList(1, 2, 3);
List<Integer> actual = Arrays.asList(1, 2, 3);
assertIterableEquals(expected, actual, "Las listas de enteros no son iguales");
}
}Ejercicio 3
Escribe un test que verifique que un método lanza una NullPointerException.
Solución
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
public class NullPointerExceptionTest {
@Test
public void testNullPointerException() {
Exception exception = assertThrows(NullPointerException.class, () -> {
String str = null;
str.length();
});
assertEquals(null, exception.getMessage());
}
}Conclusión
En este módulo, hemos explorado las aserciones avanzadas de JUnit, incluyendo aserciones de arrays, colecciones, excepciones, tiempo y aserciones compuestas. Estas herramientas permiten realizar verificaciones más detalladas y complejas en nuestros tests, mejorando la calidad y robustez del código. En el próximo módulo, aprenderemos sobre los tests parametrizados, una técnica poderosa para ejecutar el mismo test con diferentes datos.
Curso de JUnit
Módulo 1: Introducción a JUnit
Módulo 2: Anotaciones Básicas de JUnit
- Entendiendo @Test
- Usando @Before y @After
- Usando @BeforeClass y @AfterClass
- Ignorando Tests con @Ignore
Módulo 3: Aserciones en JUnit
Módulo 4: Tests Parametrizados
- Introducción a los Tests Parametrizados
- Creando Tests Parametrizados
- Usando @ParameterizedTest
- Tests Parametrizados Personalizados
Módulo 5: Suites de Tests
Módulo 6: Mocking con JUnit
Módulo 7: Características Avanzadas de JUnit
Módulo 8: Mejores Prácticas y Consejos
- Escribiendo Tests Efectivos
- Organizando el Código de Tests
- Desarrollo Guiado por Tests (TDD)
- Integración Continua con JUnit