java - uso - test unitarios junit mockito

Use Mockito para verificar que no se llame nada después de un método

Question

Estoy usando Mockito para escribir una prueba unitaria en Java, y me gustaría verificar que un determinado método sea el último invocado en un objeto.

Estoy haciendo algo como esto en el código bajo prueba:

row.setSomething(value);
row.setSomethingElse(anotherValue);
row.editABunchMoreStuff();
row.saveToDatabase();

En mi simulacro, no me importa el orden en que edite todo en la fila, pero es muy importante que no intente hacer nada más después de que lo haya guardado. ¿Existe una forma correcta de hacer esto?

Tenga en cuenta que no estoy buscando verifyNoMoreInteractions: no confirma que saveToDatabase sea el último llamado, y también falla si llamo a algo en la fila que no verifico explícitamente. Me gustaría poder decir algo como:

verify(row).setSomething(value);
verify(row).setSomethingElse(anotherValue);
verifyTheLastThingCalledOn(row).saveToDatabase();

Si ayuda, voy a cambiar a Mockito de una prueba de JMock que hizo esto:

row.expects(once()).method("saveToDatabase").id("save");
row.expects(never()).method(ANYTHING).after("save");

Answer 1

No estoy al 100% en el tema pero solo buscaba encontrar lo opuesto a verificar, y este fue el único resultado relevante, termina buscando Mockito.verifyZeroInteractions (simulacro);

Solo en caso de que alguien más termine aquí buscando esto ...

Answer 2

Esta pregunta me llevó a realizar algunas mejoras en la API de Verificaciones en JMockit (disponible en la próxima versión 0.983).

La solución que surgió te permite escribir (en un método de prueba):

    new VerificationsInOrder() {{
        unverifiedInvocations();
        row.saveToDababase();
    }};

... si solo quiere verificar que se llame a un determinado método después de todo lo demás. Para verificar que ocurra antes de todas las demás invocaciones, simplemente mueva la llamada a la parte superior. Esto en realidad se aplica a cualquier secuencia de invocaciones consecutivas.

Si además de la verificación anterior, también desea verificar que se invoquen otros métodos en cualquier orden, se puede agregar un segundo bloque de verificaciones a la prueba (antes o después del otro bloque, no importa):

    new Verifications() {{
        row.setSomething(value);
        row.setSomethingElse(anotherValue);
    }};

Aunque es un poco largo debido al uso de clases internas anónimas, esta sintaxis es simple y flexible; observe cómo agrega estructura a la prueba y evita la repetición de llamadas a métodos (como verify(...) ). Hay más que lo que describí aquí (emparejamientos de Hamcrest, recuentos de invocación, etc.), y no está limitado a la verificación de los métodos de instancia (los métodos estáticos y los constructores pueden ser burlados y verificados de la misma manera).

Answer 3

Creo que requiere más trabajo personalizado.

verify(row, new LastCall()).saveToDatabase();

y entonces

public class LastCall implements VerificationMode {
    public void verify(VerificationData data) {
        List<Invocation> invocations = data.getAllInvocations();
        InvocationMatcher matcher = data.getWanted();
        Invocation invocation = invocations.get(invocations.size() - 1);
        if (!matcher.matches(invocation)) throw new MockitoException("...");
    }
}

Respuesta anterior:

Tienes razón. verifyNoMoreInteractions es lo que necesita.

verify(row).setSomething(value);
verify(row).setSomethingElse(anotherValue);
verify(row).editABunchMoreStuff();
verify(row).saveToDatabase();
verifyNoMoreInteractions(row);