Wie kann ich überprüfen, ob eine bestimmte Methode nicht mit Mockito aufgerufen wurde?

Wie kann ich überprüfen, ob eine Methode nicht von der Abhängigkeit eines Objekts aufgerufen wird?

Zum Beispiel:

public interface Dependency {
    void someMethod();
}

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

Mit dem Foo-Test:

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??**
    }
}

Noch aussagekräftiger:

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

// ...

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

Die Dokumentation dieser Funktion finden Sie in §4 "Überprüfen der genauen Anzahl der Aufrufe / mindestens x / nie" , und der neverJavadoc ist hier .

Verwenden Sie das zweite Argument für die Mockito.verifyMethode wie folgt:

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

Als allgemeineres Muster tendiere ich dazu, @Afterim Test einen Block zu verwenden :

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

Dann ist der Test nur frei , um zu überprüfen , was sollte aufgerufen werden.

Außerdem stellte ich fest, dass ich oft vergessen hatte, nach "keine Interaktionen" zu suchen, um später festzustellen, dass Dinge aufgerufen wurden, die nicht hätten sein sollen.

Daher finde ich dieses Muster nützlich, um alle unerwarteten Anrufe abzufangen, die nicht speziell überprüft wurden.

Zuallererst: Sie sollten immer mockito static importieren, damit der Code viel besser lesbar (und intuitiver) ist:

import static org.mockito.Mockito.*;

Es gibt tatsächlich viele Möglichkeiten, dies zu erreichen, aber es ist (wohl) sauberer, das zu verwenden

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

Methode für alle Tests, wenn Sie sie bei anderen Tests verwenden, um eine bestimmte Anzahl von Ausführungen wie folgt zu bestätigen:

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

Alternativen sind:

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

Alternativ - wenn Sie wirklich sicherstellen möchten, dass ein bestimmtes verspottetes Objekt überhaupt NICHT aufgerufen wird - können Sie Folgendes verwenden:

verifyZeroInteractions(yourMock)

Sowohl die verifyNoMoreInteractions()als auch die verifyZeroInteractions()Methode haben intern dieselbe Implementierung wie:

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

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

Daher können wir eines davon für ein Scheinobjekt oder ein Array von Scheinobjekten verwenden, um zu überprüfen, ob keine Methoden mit Scheinobjekten aufgerufen wurden.