El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Testing de Excepciones

Siguiente ►
►

En este módulo, aprenderemos cómo manejar y probar excepciones en JUnit. Las pruebas de excepciones son cruciales para asegurarnos de que nuestro código maneje adecuadamente las situaciones de error.

Conceptos Clave

  1. Excepciones: Son eventos que ocurren durante la ejecución de un programa y que interrumpen el flujo normal de las instrucciones.
  2. Testing de Excepciones: Proceso de verificar que el código lanza las excepciones esperadas bajo condiciones específicas.

Métodos para Probar Excepciones en JUnit

  1. Usando @Test(expected = Exception.class)

Esta es una forma sencilla de probar si un método lanza una excepción específica.

import org.junit.Test;

public class ExceptionTest {

    @Test(expected = IllegalArgumentException.class)
    public void testExceptionIsThrown() {
        MyClass myClass = new MyClass();
        myClass.methodThatThrowsException();
    }
}

Explicación:

  • @Test(expected = IllegalArgumentException.class): Indica que se espera que el método methodThatThrowsException lance una IllegalArgumentException.

  1. Usando try-catch y fail()

Este método proporciona más control y permite verificar el mensaje de la excepción.

import org.junit.Test;
import static org.junit.Assert.fail;

public class ExceptionTest {

    @Test
    public void testExceptionMessage() {
        MyClass myClass = new MyClass();
        try {
            myClass.methodThatThrowsException();
            fail("Expected IllegalArgumentException to be thrown");
        } catch (IllegalArgumentException e) {
            assertEquals("Invalid argument", e.getMessage());
        }
    }
}

Explicación:

  • try-catch: Intenta ejecutar el método y captura la excepción.
  • fail("Expected IllegalArgumentException to be thrown"): Falla la prueba si no se lanza la excepción.
  • assertEquals("Invalid argument", e.getMessage()): Verifica que el mensaje de la excepción sea el esperado.

  1. Usando assertThrows

Introducido en JUnit 5, assertThrows es una forma más moderna y limpia de probar excepciones.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertThrows;

public class ExceptionTest {

    @Test
    public void testExceptionIsThrown() {
        MyClass myClass = new MyClass();
        IllegalArgumentException thrown = assertThrows(
            IllegalArgumentException.class,
            () -> myClass.methodThatThrowsException(),
            "Expected methodThatThrowsException() to throw, but it didn't"
        );

        assertEquals("Invalid argument", thrown.getMessage());
    }
}

Explicación:

  • assertThrows(IllegalArgumentException.class, () -> myClass.methodThatThrowsException()): Verifica que se lance una IllegalArgumentException.
  • assertEquals("Invalid argument", thrown.getMessage()): Verifica el mensaje de la excepción.

Ejercicio Práctico

Ejercicio 1: Probar Excepciones con @Test(expected)

  1. Crea una clase Calculator con un método divide(int a, int b) que lance una ArithmeticException si b es 0.
  2. Escribe una prueba que verifique que se lanza una ArithmeticException cuando b es 0.
public class Calculator {
    public int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return a / b;
    }
}
import org.junit.Test;

public class CalculatorTest {

    @Test(expected = ArithmeticException.class)
    public void testDivideByZero() {
        Calculator calculator = new Calculator();
        calculator.divide(10, 0);
    }
}

Ejercicio 2: Probar Excepciones con assertThrows

  1. Modifica la prueba anterior para usar assertThrows.
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertThrows;

public class CalculatorTest {

    @Test
    public void testDivideByZero() {
        Calculator calculator = new Calculator();
        ArithmeticException thrown = assertThrows(
            ArithmeticException.class,
            () -> calculator.divide(10, 0),
            "Expected divide(10, 0) to throw, but it didn't"
        );

        assertEquals("Cannot divide by zero", thrown.getMessage());
    }
}

Resumen

En esta sección, hemos aprendido cómo probar excepciones en JUnit utilizando diferentes métodos:

  • @Test(expected = Exception.class)
  • try-catch y fail()
  • assertThrows

Cada método tiene sus ventajas y desventajas, y la elección del método depende de la situación específica y de las necesidades del test. Con estos conocimientos, estarás mejor preparado para manejar y probar excepciones en tus proyectos de Java.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados