El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este módulo, aprenderás cómo escribir tests efectivos que no solo aseguren la calidad de tu código, sino que también sean fáciles de mantener y entender. Un test efectivo es aquel que es claro, conciso y cubre los casos necesarios para garantizar que el código funcione correctamente.

Principios de un Test Efectivo

1.1. Claridad y Simplicidad

Nombres Descriptivos: Usa nombres de métodos de test que describan claramente lo que están verificando.
Un Solo Caso por Test: Cada test debe verificar un solo caso o comportamiento. Esto facilita la identificación de fallos específicos.

1.2. Independencia

Aislamiento: Los tests deben ser independientes entre sí. Un test no debe depender del resultado de otro.
Estado Inicial Consistente: Asegúrate de que cada test comience con un estado conocido y consistente.

1.3. Repetibilidad

Determinismo: Los tests deben producir los mismos resultados cada vez que se ejecutan, sin importar el entorno o el orden de ejecución.

1.4. Rapidez

Ejecución Rápida: Los tests deben ejecutarse rápidamente para no ralentizar el ciclo de desarrollo.

Estructura de un Test

Un test efectivo generalmente sigue la estructura AAA (Arrange, Act, Assert):

Arrange: Configura el entorno y los datos necesarios para el test.
Act: Ejecuta el código que se está probando.
Assert: Verifica que el resultado es el esperado.

Ejemplo de Estructura AAA

@Test
public void shouldReturnTrueWhenInputIsPositive() {
    // Arrange
    int input = 5;
    MyClass myClass = new MyClass();

    // Act
    boolean result = myClass.isPositive(input);

    // Assert
    assertTrue(result);
}

Buenas Prácticas

3.1. Uso de Aserciones Claras

Aserciones Específicas: Usa aserciones que sean específicas y claras. Por ejemplo, assertEquals(expected, actual) es más claro que assertTrue(expected == actual).

3.2. Configuración y Limpieza

@Before y @After: Usa las anotaciones @Before y @After para configurar y limpiar el entorno de test.

@Before
public void setUp() {
    // Código para configurar el entorno antes de cada test
}

@After
public void tearDown() {
    // Código para limpiar el entorno después de cada test
}

3.3. Tests Parametrizados

Reutilización de Código: Usa tests parametrizados para probar múltiples casos con el mismo código de test.

@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 4, 5})
public void shouldReturnTrueForPositiveNumbers(int number) {
    MyClass myClass = new MyClass();
    assertTrue(myClass.isPositive(number));
}

Ejercicios Prácticos

Ejercicio 1: Test de un Método Sencillo

Descripción: Escribe un test para un método que verifica si un número es par.

Código del Método:

public class NumberUtils {
    public boolean isEven(int number) {
        return number % 2 == 0;
    }
}

Test:

@Test
public void shouldReturnTrueForEvenNumbers() {
    // Arrange
    int input = 4;
    NumberUtils numberUtils = new NumberUtils();

    // Act
    boolean result = numberUtils.isEven(input);

    // Assert
    assertTrue(result);
}

Ejercicio 2: Test con @Before y @After

Descripción: Escribe tests para un método que suma dos números, utilizando @Before para la configuración.

Código del Método:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

Test:

public class CalculatorTest {
    private Calculator calculator;

    @Before
    public void setUp() {
        calculator = new Calculator();
    }

    @Test
    public void shouldReturnSumOfTwoNumbers() {
        // Act
        int result = calculator.add(2, 3);

        // Assert
        assertEquals(5, result);
    }

    @After
    public void tearDown() {
        calculator = null;
    }
}

Conclusión

Escribir tests efectivos es crucial para mantener la calidad del código y facilitar el mantenimiento a largo plazo. Recuerda seguir los principios de claridad, independencia, repetibilidad y rapidez. Utiliza la estructura AAA para organizar tus tests y sigue las buenas prácticas para asegurar que tus tests sean robustos y fáciles de entender.

En el próximo tema, aprenderás sobre cómo organizar el código de tests para mantener un proyecto limpio y manejable.

Escribiendo Tests Efectivos

Principios de un Test Efectivo

1.1. Claridad y Simplicidad

1.2. Independencia

1.3. Repetibilidad

1.4. Rapidez

Estructura de un Test

Ejemplo de Estructura AAA

Buenas Prácticas

3.1. Uso de Aserciones Claras

3.2. Configuración y Limpieza

3.3. Tests Parametrizados

Ejercicios Prácticos

Ejercicio 1: Test de un Método Sencillo

Ejercicio 2: Test con @Before y @After

Conclusión

Curso de JUnit

Módulo 1: Introducción a JUnit

Módulo 2: Anotaciones Básicas de JUnit

Módulo 3: Aserciones en JUnit

Módulo 4: Tests Parametrizados

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

Módulo 9: Nuevas Características de JUnit 5