Wie lässt sich überprüfen, dass eine bestimmte Methode nicht mit Mockito aufgerufen wurde?

Question

Wie kann man überprüfen, ob eine Methode pas in 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??**
    }
}

Answer 1

Noch sinnvoller:

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

// ...

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

Die Dokumentation zu dieser Funktion finden Sie hier §4 "Überprüfung der genauen Anzahl von Aufrufen / mindestens x / nie" und die never javadoc ist ici .

Answer 2

Verwenden Sie das zweite Argument auf der Registerkarte Mockito.verify Methode, wie in:

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

Answer 3

Zunächst einmal: Sie sollten mockito immer statisch importieren, so wird der Code viel lesbarer (und intuitiver):

import static org.mockito.Mockito.*;

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

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

Methode überall in Ihren Tests, wenn Sie sie in anderen Tests verwenden, um eine bestimmte Anzahl von Ausführungen wie diese zu bestätigen:

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

Alternativen sind:

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

Alternativ - wenn Sie wirklich sicherstellen wollen, dass ein bestimmtes Mocked Object tatsächlich NICHT aufgerufen wird - können Sie verwenden:

verifyZeroInteractions(yourMock)

Bitte beachten: verifyZeroInteractions(Object... mocks) ist veraltet. Seit Version 3.0.1. Die jetzt empfohlene Methode ist:

verifyNoInteractions(yourMock)

Answer 4

Als allgemeines Muster verwende ich in der Regel eine @After Block im Test:

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

Dann steht es dem Test frei, nur zu überprüfen, was sollte genannt werden.

Außerdem stellte ich fest, dass ich oft vergaß, auf "keine Interaktionen" zu achten, um dann später festzustellen, dass Dinge aufgerufen wurden, die nicht hätten aufgerufen werden dürfen.

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

Answer 5

Sowohl die verifyNoMoreInteractions() y verifyZeroInteractions() Methode haben intern die gleiche Implementierung wie:

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

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

so können wir jede von ihnen auf Mock-Objekt oder Array von Mock-Objekte verwenden, um zu überprüfen, dass keine Methoden mit Mock-Objekte aufgerufen wurden.