Ist dies eine angemessene Anwendung der Reset-Methode von Mockito?

Ich habe eine private Methode in meiner Testklasse, die ein häufig verwendetes BarObjekt erstellt. Der BarKonstruktor ruft die someMethod()Methode in meinem verspotteten Objekt auf:

private @Mock Foo mockedObject; // My mocked object
...

private Bar getBar() {
  Bar result = new Bar(mockedObject); // this calls mockedObject.someMethod()
}

In einigen meiner Testmethoden, die ich überprüfen möchte, someMethodwurde auch von diesem bestimmten Test aufgerufen. So etwas wie das folgende:

@Test
public void someTest() {
  Bar bar = getBar();

  // do some things

  verify(mockedObject).someMethod(); // <--- will fail
}

Dies schlägt fehl, da das verspottete Objekt someMethodzweimal aufgerufen wurde. Ich möchte nicht, dass sich meine Testmethoden um die Nebenwirkungen meiner getBar()Methode kümmern. Wäre es also sinnvoll, mein Scheinobjekt am Ende von zurückzusetzen getBar()?

private Bar getBar() {
  Bar result = new Bar(mockedObject); // this calls mockedObject.someMethod()
  reset(mockedObject); // <-- is this OK?
}

Ich frage, weil die Dokumentation vorschlägt , dass das Zurücksetzen von Scheinobjekten im Allgemeinen auf schlechte Tests hindeutet. Dies fühlt sich für mich jedoch in Ordnung an.

Alternative

Die alternative Wahl scheint zu sein:

verify(mockedObject, times(2)).someMethod();

was meiner meinung nach jeden test zwingt, über die erwartungen von zu wissen getBar(), ohne gewinn.

Ich glaube, dies ist einer der Fälle, in denen die Verwendung reset()in Ordnung ist. Der Test, den Sie schreiben, testet, dass "einige Dinge" einen einzelnen Anruf auslösen someMethod(). Das Schreiben der verify()Anweisung mit einer anderen Anzahl von Aufrufen kann zu Verwirrung führen.

• atLeastOnce() Dies ist eine schlechte Sache, da Sie möchten, dass Ihre Tests immer korrekt sind.
• times(2)verhindert das falsche Positiv, lässt es jedoch so erscheinen, als würden Sie zwei Aufrufe erwarten, anstatt zu sagen, dass "ich weiß, dass der Konstruktor einen hinzufügt". Wenn sich im Konstruktor etwas ändert, um einen zusätzlichen Aufruf hinzuzufügen, hat der Test jetzt die Möglichkeit, ein falsches positives Ergebnis zu erzielen. Und das Entfernen des Anrufs würde dazu führen, dass der Test fehlschlägt, da der Test jetzt falsch ist, anstatt dass das, was gerade getestet wird, falsch ist.

Durch die Verwendung reset()in der Hilfsmethode vermeiden Sie diese beiden Probleme. Sie müssen jedoch darauf achten, dass auch die von Ihnen vorgenommenen Stubs zurückgesetzt werden. Seien Sie also gewarnt. Der Hauptgrund, von dem reset()abgeraten wird, ist zu verhindern

bar = mock(Bar.class);
//do stuff
verify(bar).someMethod();
reset(bar);
//do other stuff
verify(bar).someMethod2();

Dies ist nicht das, was das OP versucht. Ich nehme an, das OP verfügt über einen Test, der den Aufruf im Konstruktor überprüft. Für diesen Test ermöglicht das Zurücksetzen, diese einzelne Aktion und ihre Wirkung zu isolieren. Dies ist einer der wenigen Fälle, bei reset()denen hilfreich sein kann. Die anderen Optionen, die nicht alle verwenden, haben Nachteile. Die Tatsache, dass das OP diesen Beitrag verfasst hat, zeigt, dass er über die Situation nachdenkt und die Rücksetzmethode nicht nur blind anwendet.

Smart Mockito-Benutzer verwenden die Rücksetzfunktion kaum, da sie wissen, dass dies ein Zeichen für schlechte Tests sein kann. Normalerweise müssen Sie Ihre Mocks nicht zurücksetzen, sondern erstellen für jede Testmethode neue Mocks.

Anstatt reset()zu überlegen, ob Sie einfache, kleine und fokussierte Testmethoden über lange, zu spezifizierte Tests schreiben möchten. Der erste mögliche Codegeruch befindet sich reset()in der Mitte der Testmethode.

Extrahiert aus den Mockito-Dokumenten .

Mein Rat ist, dass Sie versuchen, die Verwendung zu vermeiden reset(). Meiner Meinung nach sollte ein zweimaliger Aufruf von someMethod getestet werden (möglicherweise handelt es sich um einen Datenbankzugriff oder einen anderen langen Prozess, um den Sie sich kümmern möchten).

Wenn Ihnen das wirklich egal ist, können Sie Folgendes verwenden:

verify(mockedObject, atLeastOnce()).someMethod();

Beachten Sie, dass dies zu einem falschen Ergebnis führen kann, wenn Sie someMethod von getBar und nicht danach aufrufen (dies ist ein falsches Verhalten, aber der Test schlägt nicht fehl).

Absolut nicht. Wie so oft ist die Schwierigkeit, einen sauberen Test zu schreiben, eine große rote Fahne für das Design Ihres Produktionscodes. In diesem Fall ist die beste Lösung, den Code so umzugestalten, dass der Konstruktor von Bar keine Methoden aufruft.

Konstruktoren sollten konstruieren, keine Logik ausführen. Nehmen Sie den Rückgabewert der Methode und übergeben Sie ihn als Konstruktorparameter.

new Bar(mockedObject);

wird:

new Bar(mockedObject.someMethod());

Wenn dies dazu führen würde, dass diese Logik an vielen Stellen dupliziert wird, sollten Sie eine Factory-Methode erstellen, die unabhängig von Ihrem Bar-Objekt getestet werden kann:

public Bar createBar(MockedObject mockedObject) {
    Object dependency = mockedObject.someMethod();
    // ...more logic that used to be in Bar constructor
    return new Bar(dependency);
}

Wenn dieses Refactoring zu schwierig ist, ist die Verwendung von reset () eine gute Lösung. Aber lassen Sie uns klar sein - es zeigt an, dass Ihr Code schlecht gestaltet ist.