Ottenere numero di chiamate ad un mock

Question

Si supponga che voglio testare il codice come questo:

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(); 
    } 
    } 
} 

Se ho un test come questo:

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())); 
} 

Come posso ottenere il numero di chiamate al uc1.thisMethod() e uc2.thatMethod() così posso verificare che entrambi sono stati chiamati lo stesso numero di volte?

Answer 1

È possibile utilizzare un VerificationMode personalizzato per contare le invocazioni, qui si va:

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); 
     } 

    } 

} 

E poi usare in questo modo (funziona anche con tipi di ritorno void):

@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)); 

Answer 2

Si potrebbe stub i vostri metodi, e incrementare un contatore, come questo:

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(); 

Answer 3

Se si conosce il numero di volte in cui un metodo viene suppoed essere chiamato è possibile utilizzare il metodo times() di Mockito

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

Tuttavia, ora vedo che si chiama il metodo un numero casuale di volte, quindi questa probabilmente non è la risposta migliore a meno che non si estenda il generatore di numeri casuali per restituire sempre un valore previsto.

Answer 4

Puoi fare qualcosa del genere:

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();