Utilizzo di Mockito con più chiamate allo stesso metodo con gli stessi argomenti

Question

C'è un modo per avere un metodo stub restituito oggetti diversi nelle chiamate successive? Mi piacerebbe farlo per testare risposte non determinabili da un ExecutorCompletionService. per testare che indipendentemente dall'ordine di restituzione dei metodi, il risultato rimane costante.

Il codice che sto cercando di testare assomiglia a questo.

// Create an completion service so we can group these tasks together 
ExecutorCompletionService<T> completionService = 
     new ExecutorCompletionService<T>(service); 

// Add all these tasks to the completion service 
for (Callable<T> t : ts) 
    completionService.submit(request); 

// As an when each call finished, add it to the response set. 
for (int i = 0; i < calls.size(); i ++) { 
    try { 
     T t = completionService.take().get(); 
     // do some stuff that I want to test 
    } catch (...) { }   
} 

Answer 1

Potete farlo utilizzando il metodo thenAnswer (quando il concatenamento con when):

when(someMock.someMethod()).thenAnswer(new Answer() { 
    private int count = 0; 

    public Object answer(InvocationOnMock invocation) { 
     if (count++ == 1) 
      return 1; 

     return 2; 
    } 
}); 

o utilizzando l'equivalente, statica doAnswer metodo:

doAnswer(new Answer() { 
    private int count = 0; 

    public Object answer(InvocationOnMock invocation) { 
     if (count++ == 1) 
      return 1; 

     return 2; 
    } 
}).when(someMock).someMethod(); 

Answer 2

Come su

when(method-call).thenReturn(value1, value2, value3); 

Puoi mettere tutti gli argomenti che vuoi nelle parentesi di thenReturn, sempre che siano del tipo corretto. Il primo valore verrà restituito la prima volta che viene chiamato il metodo, quindi la seconda risposta e così via. L'ultimo valore verrà restituito ripetutamente una volta esauriti tutti gli altri valori.

Answer 3

si può anche catena doReturn() chiamate di metodi come questo

doReturn(null).doReturn(anotherInstance).when(mock).method(); 

carino non è vero :)

Answer 4

Come previously pointed out quasi tutte le chiamate sono chainable.

Così si potrebbe chiamare

when(mock.method()).thenReturn(foo).thenReturn(bar).thenThrow(new Exception("test")); 

//OR if you're mocking a void method and/or using spy instead of mock 

doReturn(foo).doReturn(bar).doThrow(new Exception("Test").when(mock).method(); 

More info in Mockito's Documenation.

Answer 5

Di seguito è possibile utilizzare come metodo comune per restituire argomenti diversi su chiamate di metodo differenti. L'unica cosa che dobbiamo fare è passare un array con l'ordine in cui gli oggetti devono essere recuperati in ogni chiamata.

@SafeVarargs 
public static <Mock> Answer<Mock> getAnswerForSubsequentCalls(final Mock... mockArr) { 
    return new Answer<Mock>() { 
     private int count=0, size=mockArr.length; 
     public Mock answer(InvocationOnMock invocation) throws throwable { 
      Mock mock = null; 
      for(; count<size && mock==null; count++){ 
       mock = mockArr[count]; 
      } 

      return mock;  
     } 
    } 
} 

Es. getAnswerForSubsequentCalls(mock1, mock3, mock2); restituirà l'oggetto mock1 alla prima chiamata, l'oggetto mock3 alla seconda chiamata e l'oggetto mock2 alla terza chiamata. Dovrebbe essere utilizzato come when(something()).doAnswer(getAnswerForSubsequentCalls(mock1, mock3, mock2)); Questo è quasi simile a when(something()).thenReturn(mock1, mock3, mock2);

Answer 6

Ho implementato una classe MultipleAnswer che mi aiuta a stub risposte diverse a ogni chiamata. Qui il pezzo di codice:

private final class MultipleAnswer<T> implements Answer<T> { 

    private final ArrayList<Answer<T>> mAnswers; 

    MultipleAnswer(Answer<T>... answer) { 
     mAnswers = new ArrayList<>(); 
     mAnswers.addAll(Arrays.asList(answer)); 
    } 

    @Override 
    public T answer(InvocationOnMock invocation) throws Throwable { 
     return mAnswers.remove(0).answer(invocation); 
    } 
}