Comment vérifier qu'une méthode spécifique n'a pas été appelée à l'aide de Mockito?

Comment vérifier qu'une méthode n'est pas appelée sur la dépendance d'un objet?

Par exemple:

public interface Dependency {
    void someMethod();
}

public class Foo {
    public bar(final Dependency d) {
        ...
    }
}

Avec le test Foo:

public class FooTest {
    @Test
    public void dependencyIsNotCalled() {
        final Foo foo = new Foo(...);
        final Dependency dependency = mock(Dependency.class);
        foo.bar(dependency);
        **// verify here that someMethod was not called??**
    }
}

Encore plus significatif:

import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;

// ...

verify(dependency, never()).someMethod();

La documentation de cette fonctionnalité est là §4 "Vérification du nombre exact d'appels / au moins x / jamais" , et le neverjavadoc est ici .

utilisez le deuxième argument de la Mockito.verifyméthode, comme dans:

verify(dependency, Mockito.times(0)).someMethod()

Comme modèle plus général à suivre, j'ai tendance à utiliser un @Afterbloc dans le test:

@After
public void after() {
    verifyNoMoreInteractions(<your mock1>, <your mock2>...);
}

Ensuite, le test est libre de vérifier uniquement ce qui doit être appelé.

De plus, j'ai constaté que j'oubliais souvent de vérifier s'il n'y avait pas d'interactions, pour découvrir plus tard que des choses étaient appelées qui n'auraient pas dû l'être.

Je trouve donc ce modèle utile pour intercepter tous les appels inattendus qui n'ont pas été spécifiquement vérifiés.

Tout d'abord: vous devez toujours importer mockito static, de cette façon le code sera beaucoup plus lisible (et intuitif):

import static org.mockito.Mockito.*;

Il existe en fait de nombreuses façons d'y parvenir, mais il est (sans doute) plus propre d'utiliser le

verify(yourMock, times(0)).someMethod();

partout dans vos tests, lorsque sur d'autres tests vous l'utilisez pour affirmer un certain nombre d'exécutions comme ceci:

verify(yourMock, times(5)).someMethod();

Les alternatives sont:

verify(yourMock, never()).someMethod();

Alternativement - lorsque vous voulez vraiment vous assurer qu'un certain objet simulé n'est PAS appelé du tout - vous pouvez utiliser:

verifyZeroInteractions(yourMock)

Les méthodes verifyNoMoreInteractions()et verifyZeroInteractions()ont en interne la même implémentation que:

public static transient void verifyNoMoreInteractions(Object mocks[])
{
    MOCKITO_CORE.verifyNoMoreInteractions(mocks);
}

public static transient void verifyZeroInteractions(Object mocks[])
{
    MOCKITO_CORE.verifyNoMoreInteractions(mocks);
}

nous pouvons donc utiliser n'importe lequel d'entre eux sur un objet fictif ou un tableau d'objets fictifs pour vérifier qu'aucune méthode n'a été appelée à l'aide d'objets fictifs.