Mockito: Methode der Rückgabewert hängt davon ab, eine andere Methode aufgerufen

In meinem unit-test-ich müssen zu verspotten, eine Schnittstelle, die zwischen verschiedenen Methoden hat nextItem() und isEmpty() Methoden:

public interface MyQueue {
    Item nextItem();
    boolean isEmpty();
    //other methods
    ...
}

Meine Forderung für die mock ist, dass isEmpty() zunächst sollte false zurückgeben, aber nach nextItem() genannt wurde isEmpty() sollte true zurückgeben. Also ich bin mocking eine Warteschlange mit einem Element.

  1. Was ist die einfachste Möglichkeit zum implementieren dieser Art von mock mit mockito?
  2. Kann ich implementieren, zusätzliche Anforderung: Aufruf nextItem() zweite, Dritte mal, und so wird Ergebnis in eine bestimmte Art von exception?

P. S. ich will nicht die komplette Umsetzung meines Schnittstelle für den test, weil Sie andere Methoden, wodurch Sie schwer zu verstehen und ausführlichen code.

  • Sie können eine boolean-variable, die können Sie Umschalten auf true, wenn Sie geben Sie nextItem()
  • können Sie vorschlagen, die Umsetzung, die nicht verbose?
InformationsquelleAutor pavel_kazlou | 2012-09-29
  1. 9

    Können Sie erreichen, dass mit thenAnswer(), eine Funktion, die Mockito-Dokumentation sieht, wie umstritten:

    Doch eine weitere umstrittene Eigenschaft, die nicht im Mockito ursprünglich. Wir empfehlen die Verwendung von einfach stubbing mit toReturn() oder toThrow() nur. Diese beiden sollte gerade genug, um test - /Probefahrt jeder clean & simple-code.

    Hier thenAnswer:

    private boolean called = false;

when(mock.nextItem()).thenAnswer(new Answer() {
 Object answer(InvocationOnMock invocation) {   
     called = true;       
     return item;
 }
when(mock.isEmpty()).thenAnswer(new Answer() {
 Object answer(InvocationOnMock invocation) {          
     return called;
 }
});
    • Wow!!! Danke, so weit es ist die beste Lösung für mein problem - kurzen und leicht zu lesenden code. Ich muss feststellen, dass in meiner Umsetzung Ihrer Idee, die Antworten, die bestimmte Typen (Element, und Boolean statt Objekt). Ein kleines Problem mit dieser Vorgehensweise haben wir zur Einführung test der Klasse Spielfeld called, die nur in einer test-Methode. Wir können nicht nur die Erklärung der called innen test-Methode, weil es muss dann endgültig.
    InformationsquelleAutor Assen Kolov
  2. 6

    Hier ist ein einfaches Beispiel:

    //given
MyQueue mock = mock(MyQueue.class);

given(mock.isEmpty()).willReturn(false, true);
given(mock.nextItem()).willReturn(someItem);

//when
mock.isEmpty();   //yields false
mock.nextItem();  //yields someItem
mock.isEmpty();   //yields true

//then
InOrder inOrder = inOrder(mock);
inOrder.verify(mock).isEmpty();
inOrder.verify(mock).nextItem();
inOrder.verify(mock).isEmpty();

    willReturn(false, true) bedeutet: zurück false auf den ersten Aufruf und die true auf den zweiten. InOrder - Objekt wird verwendet, um zu überprüfen, Aufruf-Reihenfolge. Ändern Sie die Reihenfolge oder entfernen nextItem() Anruf, und der test schlägt fehl.

    Alternativ können Sie diese syntax verwenden:

    given(mock.isEmpty()).
        willReturn(false).
        willReturn(true).
        willThrow(SpecialException.class);

    Wenn Sie noch stärker Spott Semantik, die Sie sich vorstellen können, die schwere Artillerie - benutzerdefinierte Antwort-Rückruf:

    given(mock.isEmpty()).willAnswer(new Answer<Boolean>() {
    private int counter = 0;
    @Override
    public Boolean answer(InvocationOnMock invocation) throws Throwable {
        switch(++counter) {
            case 1: return false;
            case 2: return true;
            default: throw new SpecialException();
        }
    }
});

    Aber dies kann leicht dazu führen, dass wartbaren test-code, mit Vorsicht zu verwenden.

    Schließlich können Sie spy Ihre realen Objekt durch Spott nur ausgewählten Methoden.

    • Danke, schöne Erklärung. Aber deine Lösung bringt mehrere strenge Anforderungen an die mock: Sie verlangen, dass isEmpty() wird nicht mehr als einmal aufgerufen werden, bevor nextItem() genannt wird.
    • leider, sogar die schwere Artillerie nicht zwingen, die Interaktion zwischen Methoden - Anforderungen werden separat auf jede Methode und nur auf eine Anzahl von Anrufungen...
    • siehe meine Lösung unter, aber die schwere Artillerie durchsetzen können, diese Art der Sache, wenn Sie verwenden, eine Antwort, die von einem anderen abhängt Antwort. Es können dann Entscheidungen über andere Dinge, die kann oder kann nicht aufgerufen worden sein, bevor es.
    • gut, können Sie verwenden die gleiche Antwort-Objekt für beide Methoden. Sie können auch zu beantworten haben, Objekte zu teilen globalen Zustand. Aber dies wird zu hässlich, um hier einfügen...
    • Beachten Sie, dass wenn Sie lieber nicht verwenden, um die BDDMockito Methoden, Sie können schreiben so when(mock.isEmpty()).thenReturn(false, true);. Beachten Sie auch, dass die Dritte und alle nachfolgenden Aufrufe von isEmpty() auch zurück true - wenn Sie mehrere Werte zurückgeben, nachdem thenReturn oder willReturn, den letzten Wert, den Sie der Liste zurückgegeben werden können wiederholt.
    InformationsquelleAutor Tomasz Nurkiewicz
  3. 2

    Können Sie einige benutzerdefinierte Antwort-Implementierungen, von denen eine bedingt das andere:

    public class NextItemAnswer implements Answer<Item> {
   private int invocationCount = 0;
   private Item item;
   public NextItemAnswer(Item item) {
       this.item = item;
   }

   public Item answer(InvocationOnMock invocation) throws Throwable {
       invocationCount++;
       return item;
   }

   public int getInvocationCount() {
       return invocationCount;
   }
}

public class IsEmptyAnswer implements Answer<Boolean> {
   private NextItemAnswer nextItemAnswer;
   public IsEmptyAnswer(NextItemAnswer nextItemAnswer) {
       this.nextItemAnswer = nextItemAnswer;
   }
   public Boolean answer(InvocationOnMock invocation) throws Throwable {
       return nextItemAnswer.getInvocationCount() >= 0;
   }
}

    und dann:

    NextItemAnswer nextItemAnswer = new NextItemAnswer(item);
IsEmptyAnswer isEmptyAnswer = new IsEmptyAnswer(nextItemAnswer);

when(mock.isEmpty()).thenAnswer(isEmptyAnswer);
when(mock.nextItem()).thenAnswer(nextItemAnswer);

    Könnten Sie zu zwicken, als ich noch nicht getestet, code, aber der Ansatz sollte sein, was Sie brauchen.

    • Vielen Dank, jetzt kann ich sehen, kann dies tatsächlich zu tun mit Antworten, die in einem klassischen java-Stil. So traurig es ist ausführlich, verstecken meine ursprüngliche Idee, die hinter vielen Zeilen code.
    • Sie können machen es etwas weniger ausführlich durch die Verwendung von anonymen Klassen statt erklärt, aber die Idee ist immer noch die gleiche.
    InformationsquelleAutor Matt
  4. 2

    Mir ist klar, dass Sie explizit geschrieben, dass Sie nicht wollen, um eine vollständige Umsetzung der MyQueue, aber, um ehrlich zu sein, das wäre das erste, was, das ich tun würde.

    In der Tat habe ich regelmäßig 'mock' - Implementierungen von einigermaßen komplexen interfaces/Objekte für den Zweck der tests einfacher zu testen. Ich bin nicht der einzige, zu denken, dass: das Spring-Framework bietet viele verspottet Versionen von komplexen Objekten (MockHttpServletRequest, MockHttpServletResponse, etc.), zum Beispiel.

    In diesem Fall, würde ich nicht zu überfrachten meine test-und diese Klasse entweder in einem separaten Paket oder auch in der Produktion von code.

    Einen MockQueue würde Ihren tests viel besser lesbar als die andere (aber richtige) Antworten hier suggerieren.

    • In der Tat, dies ist die beste Antwort. Die anderen sind nicht falsch, aber Sie konnte nicht erkennen, dass das, was der Benutzer braucht, ist nur eine partielle Implementierung der Schnittstelle, mit trivialen Logik. In JMockit, es gibt eine API, geeignet für solche Fälle: MyQueue mock = new MockUp<MyQueue>() { boolean nextItemCalled; @Mock boolean isEmpty() { return nextItemCalled; } @Mock Item nextItem() { nextItemCalled = true; return someItem; } }.getMockInstance();
    • Was ist, wenn die Umsetzung muss noch geändert werden für verschiedene tests? Sie haben dann stellen Sie einige OO-design mit Vererbung oder Komposition für die Implementierungen. Ich denke, Ansatz mit Spott nur die Methoden, die ich brauche für jeden test hält unit-tests einfach und leicht zu verstehen. Ich begründe der Vertrag, in dem meine getestete Klasse entsprechen sollte, den code, der nicht in Zusammenhang sollten vermieden werden. Übrigens, vielen Dank für diese Art von Antwort, die beinhaltet die Diskussion des Konzepts, ich bin wirklich daran interessiert, Ihren Vorschlag, aber derzeit nicht verstehen kann, die Vorteile.
    • Naja, würde Sie verspotten die Collection - Schnittstelle? Ich habe gesehen, einige Leute tun es, aber das klingt nicht wie eine gute Idee für mich. Eine Schnittstelle namens Queue gibt einige grundlegende Annahmen zu den Kunden von die-Schnittstelle. Auch wenn sich die Implementierungen unterscheiden, das Allgemeine Verhalten sollte mehr oder weniger das gleiche von dem Punkt der Sicht der client-Klassen. Sie haben ein mehr konkretes Beispiel für eine situation, wo das nicht funktionieren würde?
    • mocking Sammlung ist nicht eine gute Idee, denn es gibt viele bewährte - Implementierungen für ihn, das kann ich zuverlässig verwenden, um die form der Anforderungen. Die umgekehrte situation ist, wenn ich mit eigene Klasse/interface als Abhängigkeit für die getestete Klasse. Wenn ich meine eigenen Implementierungen im test, gut, dass bedeutet, dass ich nicht die Prüfung Ziel-Klasse in der Isolierung, sondern zusammen mit der Queue-Abhängigkeit. Dies bedeutet, dass ein erfolgreicher test gebrochen werden kann oder (was schlimmer ist) nicht testen kann behoben werden, indem Sie ändern den code nicht getestet, Klasse aber in seiner Abhängigkeit.
    • Wenn Sie Ihre eigenen Implementierungen, haben Sie zwei Möglichkeiten: entweder Sie bieten eine "zu einfache" brechen " Umsetzung nur für Ihre tests (das ist im Grunde MockQueue), und zum testen sollte es eigentlich nicht notwendig sein. Oder, Sie einfach wiederverwenden eine aktuelle, gültige & getestet, Umsetzung. Ich habe eigentlich genau die Art von Objekten, die in meinem aktuellen Projekt. Ein DataHistory Klasse, ziemlich Komplex und damit gründlich getestet, die ich wiederverwenden in meinen anderen tests. Ich denke, es funktioniert, weil sein Verhalten ist relativ einfach zu verstehen (die Dinge hinzufügen, geben Sie Sie in einer bestimmten Reihenfolge), ähnlich wie eine Sammlung, wirklich.
    • Ok, ich denke ich verstehe deinen Punkt und die Beispiele, die Sie erwähnt. Ich war zunächst auf der Suche für ein mock-framework-Ansatz, weil die Anwesenheit von anderen tests in der test-Klasse, das waren nicht dass eine Aktivität aus der Warteschlange Abhängigkeit. So landete ich mit einfachen mocks geliefert. Und wenn es Zeit war für einige das Verhalten auf der Warteschlangen-Seite, habe ich beschlossen, mock verwenden, um die Konsistenz unter den tests. Ich halte diese Lösung für jetzt, aber ich Stimme mit Ihnen überein, dass die einfache Implementierung des offensichtlichen-Schnittstelle ist besser als komplexe mock-Konstruktionen.

    InformationsquelleAutor Eric
  5. 1

    Können Sie sagen, mockito zu beantworten, anders auf aufeinander folgende Aufrufe an die gleiche verspottet-Verfahren unter Verwendung der beschriebenen Techniken in die docs mockito.

    when(mock.isEmpty())
  .thenReturn(false)
  .thenReturn(true);

    wird die isEmpty() Aufruf true zurück, nur auf den ersten Anruf, und

    when(mock.nextItem())
  .thenReturn(item)
  .thenThrow(new NextOnEmptyQueueException())

    machen nextItem() Gegenzug etwas auf den ersten Anruf, und eine Ausnahme werfen, auf die Sie später Anrufe.

    Ich weiß nicht, dass es möglich ist, das Ergebnis einer dieser Methoden hängt von der Sequenzierung der Anrufe zu den anderen, obwohl. Wenn es wirklich möglich ist, ich bin sicher, es ist viel komplexer.

    • Vielen Dank (vor allem für schöne Verkettung Lösung für meine zweite Frage). Aber das gleiche Problem wie mit Tomasz Lösung bleibt - Ihre Lösung bedeutet, dass isEmpty() nur einmal aufgerufen werden, bevor nextItem() genannt wird.
    • Ja, tut es, aber wie bereits in der Antwort, die ich bin nicht sicher, es ist möglich besser zu machen.
    InformationsquelleAutor Don Roby
  6. 1

    Können Sie eine utility-Methode und verwenden Sie es, wo immer Sie wollen.

    public static boolean mockHasInvocation(Object mock, String methodName, Object... args) {
    return mockingDetails(mock).getInvocations().stream()
            .anyMatch(o -> o.getMethod().getName().equals(methodName) && Arrays.equals(o.getArguments(), args));
}

    Einfache Nutzung:

    if(mockHasInvocation(mockObject, "methodName", "argument1", "argument2")){doSomething();}

    In diesem Fall müssen Sie keine zusätzliche Variablen und es ist mehr "Mockito Stil".

    InformationsquelleAutor dvelopp
Schreibe einen Kommentar