usar - mockito when java

Mockito verifica después de la excepción Junit 4.10

Question

Estoy probando un método con una excepción esperada. También necesito verificar que se haya llamado a un código de limpieza (en un objeto simulado) después de lanzar la excepción, pero parece que se está ignorando la verificación. Aquí está el código. Estoy usando la Rule ExpectedException Exception de Junit para verificar la excepción esperada.

@Rule
public ExpectedException expectedEx = ExpectedException.none();

@Test
public void testExpectedException()
{
   MockedObject mockObj = mock(MockedObj.class);
   MySubject subject = new MySubject(mockedObj);
   expectedEx.expect(MyException.class);
   expectedEx.expectMessage("My exception message.");
   subject.someMethodThrowingException();
   verify(mockObj).
       someCleanup(eq(...));
}

Parece que la verify se ignora por completo. No importa qué método puse en la verify , mi prueba está pasando, que no es lo que quiero.

¿Alguna idea de por qué pasa eso?

Answer 1

No he intentado esto todavía, pero además de la excelente respuesta de Jeff Bowman, es posible que tenga la opción de usar la Regla de ExpectedException con un intento ... finalmente construya, colocando su declaración de verificación en el bloque finally.

Answer 2

Una solución más elegante con catch-exception

@Test
public void testExpectedException()
{
    MockedObject mockObj = mock(MockedObject.class);
    MySubject subject = new MySubject(mockObj);

    when(subject).someMethodThrowingException();

    then(caughtException())
            .isInstanceOf(MyException.class)
            .hasMessage("My exception message.");

    verify(mockObj).someCleanup(eq(...));
}

Answer 3

ExpectedException funciona envolviendo todo su método de prueba en un bloque try-catch a través de JUnit @Rule . Cuando su código arroja una excepción, sube la pila al try / catch más cercano, que sucede en la instancia ExpectedException (que verifica que sea la excepción que está esperando).

En Java, si se produce una excepción no detectada en un método, el control nunca regresará a las declaraciones posteriores en ese método. Las mismas reglas se aplican aquí: el control nunca regresa a las declaraciones en su prueba después de la excepción.

Técnicamente, podrías poner las verificaciones en un bloque final, pero eso tiende a ser un mal hábito . En cualquier caso, es probable que trague el útil mensaje ExpectedException , ya que se ejecutaría antes de que la regla ExpectedException pueda interceptarlo.

Si realmente necesita verificar el estado después de la excepción, por método, siempre puede volver a este modismo:

@Test
public void testExpectedException()
{
  MockedObject mockObj = mock(MockedObj.class);
  MySubject subject = new MySubject(mockedObj);
  try {
    subject.someMethodThrowingException();
    fail("Expected MyException.");
  } catch (MyException expected) {
    assertEquals("My exception message.", expected.getMessage());
  }
  verify(mockObj).someCleanup(eq(...));
}

Actualización: con las expresiones lambda de Java 8, puede envolver una llamada de interfaz funcional en un bloque de prueba de manera concisa para que sea útil . Me imagino que el soporte para esta sintaxis encontrará su camino en muchas bibliotecas de prueba estándar.

assertThrows(MyException.class,
    () -> systemUnderTest.throwingMethod());