Immer die Anzahl der Aufrufe einer mock

Nehme ich testen will code wie folgt:

class ClassToTest
  //UsedClass1 contains a method UsedClass2 thisMethod() {}
  UsedClass1 foo;
  void aMethod()
  {
    int max = new Random().nextInt(100);
    for(i = 0; i < max; i++)
    {
      foo.thisMethod().thatMethod();
    }
  }
}

Wenn ich einen test wie diesen:

ClassToTest test;
UsedClass1 uc1;
UsedClass2 uc2;
@Test
public void thingToTest() {
  test = new ClassToTest();
  uc1 = mock(UsedClass1.class);
  uc2 = mock(UsedClass2.class);
  when(uc1.thisMethod()).thenReturn(uc2);
  when(uc2.thatMethod()).thenReturn(true);

  test.aMethod();

  //I would like to do this
  verifyEquals(callsTo(uc1.thisMethod()), callsTo(uc2.thatMethod()));
}

Wie bekomme ich die Anzahl der Aufrufe uc1.thisMethod() und uc2.thatMethod() so kann ich überprüfen, wurden Sie beide als die gleiche Anzahl von Zeiten?

  • Der einzige Weg, ich kann mir (jetzt) ist ein wrapper um jede Methode, die erhöht es den eigenen Zähler jedes mal, wenn es aufgerufen wird. AFAIK die jvm nicht verfolgen die Anzahl der Male jede Methode/Klasse/instanziert.
InformationsquelleAutor Ken Y-N | 2014-08-28
  1. 2

    Können Sie eine benutzerdefinierte VerificationMode zählen die Aufrufe, hier gehen Sie:

    public class InvocationCounter {

    public static <T> T countInvocations(T mock, AtomicInteger count) {
        return Mockito.verify(mock, new Counter(count));
    }

    private InvocationCounter(){}

    private static class Counter implements VerificationInOrderMode, VerificationMode {
        private final AtomicInteger count;

        private Counter(AtomicInteger count) {
            this.count = count;
        }

        public void verify(VerificationData data) {
            count.set(data.getAllInvocations().size());
        }

        public void verifyInOrder(VerificationDataInOrder data) {
            count.set(data.getAllInvocations().size());
        }

        @Override
        public VerificationMode description(String description) {
            return VerificationModeFactory.description(this, description);
        }

    }

}

    Und dann verwenden Sie es wie diese (es funktioniert auch mit void-Rückgabe-Typen):

    @Mock
private Function<String, Integer> callable;

AtomicInteger count= new AtomicInteger(); //here is the actual invocation count stored

countInvocations(callable,count).apply( anyString());

assertThat(count.get(),is(2));
    • Leider, aus irgendeinem Grund ist dieser Ansatz für mich nicht funktioniert. Es war nicht nur die Aktualisierung der Zähler. So, ich habe den Ansatz erwähnt in der Antwort von @antoniob - mit doAnswer(...) - und es funktionierte.
    InformationsquelleAutor Chriss
  2. 17

    Können Sie etwas wie das hier tun:

    YourService serviceMock = Mockito.mock(YourService.class);

//code using YourService

//details of all invocations including methods and arguments
Collection<Invocation> invocations = Mockito.mockingDetails(serviceMock).getInvocations();
//just a number of calls of any mock's methods
int numberOfCalls = invocations.size();

    Wenn Sie möchten, dass nur die Aufrufe von bestimmten Methode/param-Kombination, können Sie dies mit

    int specificMethodCall = Mockito.mockingDetails(serviceMock.myMethod(myParam)).getInvocations()
    • Das ist großartig. Aber mit ein wenig defekt ist, dass Alle Aufrufe von mock sind, zählen hier.
    • wissen Sie, wie Sie machen Mockito.mockingDetails(serviceMock.myMethod(myParam)).getInvocations() arbeiten, wenn serviceMock.myMethod(myParam) nichts zurückgibt(void)?
    • haben Sie versucht, Sie anzurufen mockingDetails(serviceMock).getInvocations() und dann filtern Sie die Ergebnisliste für Ihre Methode Namen?
    InformationsquelleAutor Jakub Kubrynski
  3. 7

    Könnten Sie stub Ihre Methoden, und Inkrementieren einen Zähler, wie das ist:

    final AtomicInteger countCall1 = new AtomicInteger();

Mockito.doAnswer(new Answer<UsedClass2>() {
    @Override
    public UsedClass2 answer(InvocationOnMock invocation) throws Throwable {
        countCall1.incrementAndGet();
        return uc2;
    }
}).when(uc1).thisMethod();
    • Aus Interesse, warum die AtomicInteger?
    • Die Methode thread-safe. Wenn thisMethod genannt wird, von verschiedenen threads, die AtomicInteger erlaubt das Inkrementieren der Zähler sicher.
    • Ok, ich nahm an, dass war der Grund, aber dachte, ich würde check (vor allem seit der Beispiel-code nicht mehrere threads).
    InformationsquelleAutor antoniob
  4. 3

    Wenn Sie wissen, die Anzahl der Zeiten, die eine Methode ist suppoed aufgerufen werden, können Sie die times() Methode Mockito

    //for example if had to be called 3 times
verify(uc1, times(3)).thisMethod();
verify(uc2, times(3)).thatMethod();

    Aber ich sehe jetzt, dass Sie die Methode aufrufen, eine zufällige Anzahl von Zeiten, so dass dies wahrscheinlich nicht die beste Antwort, es sei denn, Sie stub die Zufallszahlen-generator, um immer wieder einen erwarteten Wert.

    • Die Zufallszahl war nur ein Beispiel - da haben wir schon die Anzahl der Anrufe verfügbar indirekt über die times() Methode, es scheint seltsam, dass es keine Möglichkeit gibt, den Zugriff, die Anzahl direkt.
    InformationsquelleAutor dkatzel
Schreibe einen Kommentar