Pruebas en JUnit para verificar que la excepción sea capturada en el nivel de jerarquía correcto.

Answer

1. 

   davy.ai

   July 29, 2023 at 12:29 pm

   Para probar que la excepción fue capturada en el nivel correcto, puedes utilizar el mecanismo de prueba de excepciones de JUnit.

   1. Primero, anota el método de prueba con @Test(expected = <excepción>), donde <excepción> es el tipo de excepción que se espera que se lance.

   2. Luego, escribe el código de prueba que desencadene la excepción llamando al método apropiado.

   3. Por último, agrega código adicional para verificar que la excepción no fue capturada por ningún otro método antes de llegar al nivel esperado. Por ejemplo, puedes añadir un bloque try-catch después de llamar al método que debería desencadenar la excepción, y asegurarte de que la excepción capturada no sea la excepción esperada.

   Aquí tienes un ejemplo de clase de prueba que demuestra este enfoque:

   import org.junit.Test;
   import static org.junit.Assert.*;
   
   public class PruebaPropagacionExcepciones {
   
       @Test(expected = Exception.class)
       public void pruebaPropagacionExcepcion() throws Exception {
           C c = new C();
           c.llamarB();
       }
   
       @Test
       public void pruebaExcepcionNoCapturadaPorB() throws Exception {
           B b = new B();
           try {
               b.llamarA();
               fail("Excepción esperada no lanzada");
           } catch (Exception e) {
               assertNotEquals("Excepción capturada en el nivel incorrecto", ClaseExcepcionCapturadaIncorrecta.class, e.getClass());
           }   
       }
   }
   
   class A {
       public void lanzarExcepcion() throws Exception {
           throw new Exception();
       }
   }
   
   class B {
       private A a = new A();
   
       public void llamarA() throws Exception {
           a.lanzarExcepcion();
       }
   
       public void lanzarExcepcion() throws Exception {
           throw new ExcepcionDiferente();
       }
   }
   
   class C {
       private B b = new B();
   
       public void llamarB() throws Exception {
           try {
               b.llamarA();
               fail("Excepción no propagada");
           } catch (ExcepcionDiferente e) {
               // ignorar
           }
       }
   }
   

   En este ejemplo, tenemos tres clases A, B y C que se llaman entre sí y propagan una excepción. La clase A lanza la excepción, la clase B la captura y lanza una excepción diferente, y la clase C captura la excepción lanzada por la clase B.

   El primer método de prueba pruebaPropagacionExcepcion verifica que la excepción se propague al nivel correcto llamando al método llamarB de la clase C, lo cual debería desencadenar la excepción lanzada por la clase A.

   El segundo método de prueba pruebaExcepcionNoCapturadaPorB verifica que la excepción no sea capturada en el nivel incorrecto llamando al método llamarA de la clase B, lo cual debería desencadenar la excepción lanzada por la clase A. El bloque try-catch captura cualquier excepción lanzada por la clase B, y el método assertNotEquals verifica que la excepción capturada no sea de la clase ClaseExcepcionCapturadaIncorrecta esperada.</excepción></excepción>

Comments are closed.