Utilisez Mockito pour vérifier que rien n'est appelé après une méthode

Question

J'utilise Mockito d'écrire un test unitaire en Java, et je voudrais vérifier qu'une certaine méthode est la dernier appelé sur un objet.

Je fais quelque chose comme cela dans le code sous test:

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

Dans ma maquette, je ne me soucie pas de l'ordre dans lequel je modifie tout sur la ligne, mais il est très important que je pas essayer de faire quoi que ce soit plus à elle après que je l'ai sauvé il. Y at-il un bon moyen de le faire?

Notez que je ne cherche pas verifyNoMoreInteractions: il ne confirme pas que SaveToDatabase est la dernière chose appelée, et elle échoue aussi si je l'appelle quoi que ce soit sur la ligne que je ne vérifie pas explicitement. Je voudrais pouvoir dire quelque chose comme:

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

Si elle aide, je passe à Mockito d'un test de JMock qui a fait ceci:

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

Answer 1

Je pense qu'il nécessite plus de travail personnalisé.

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

et

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("...");
    }
}

précédente Réponse:

Vous avez raison. verifyNoMoreInteractions est ce que vous avez besoin.

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

Answer 2

Pas à 100% sur le sujet, mais je cherchais juste de trouver le contraire de vérifier, et ce fut le seul résultat pertinent, il finit que je cherchais Mockito.verifyZeroInteractions (maquette);

Juste Incase quelqu'un d'autre se termine à chercher ici pour cette ...

Answer 3

Cette question m'a amené à faire quelques améliorations à la Verifications API JMockit (disponible dans la prochaine version 0,983).

La solution que je suis venu avec vous permet d'écrire (dans une méthode d'essai):

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

... si vous voulez seulement vérifier qu'une certaine méthode est appelée après tout le reste. Pour vérifier cela arrive avant tous les autres invocations, il suffit de déplacer l'appel vers le haut. Cela vaut en fait une séquence d'invocations consécutives.

Si, en plus de la vérification ci-dessus, vous voulez également vérifier que d'autres méthodes sont appelées dans l'ordre, une seconde vérifications bloc peut être ajouté à l'épreuve (avant ou après l'autre bloc , il n'a pas d'importance):

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

Bien qu'un peu long à cause de l'utilisation des classes internes anonymes, cette syntaxe est à la fois simple et flexible; remarquez comment il ajoute de la structure à l'épreuve et évite la répétition des appels de méthode (comme verify(...)). Il y a plus à ce que je l'ai décrit ici (Hamcrest Matchers, le nombre d'invocations, etc.), et il ne se limite pas à la vérification des méthodes d'instance (méthodes statiques et les constructeurs peuvent être moquaient et vérifiés de la même manière).