Cómo verificar varias llamadas a métodos con diferentes parametros

Question

tengo el siguiente método que deseo para verificar el comportamiento de

public void methodToTest(Exception e, ActionErrors errors) { 

    ... 
     errors.add("exception.message", 
        ActionMessageFactory.createErrorMessage(e.toString())); 

     errors.add("exception.detail", 
        ActionMessageFactory.createErrorMessage(e.getStackTrace()[0].toString())); 

    ... 
} 

En mi clase @test Tenía la esperanza de hacer algo como esto para verificar que se llama errors.add() con "Exception.Message" y de nuevo con "exception.detail"

verify(errors).add(eq("exception.message"), any(ActionError.class)); 
verify(errors).add(eq("exception.detail"), any(ActionError.class)); 

embargo Mockito se queja de la siguiente manera

Argument(s) are different! Wanted: 
actionErrors.add(
    "exception.message", 
    <any> 
); 

Actual invocation has different arguments: 
actionErrors.add(
    "exception.detail", 
    org.apache.struts.action.ActionError@38063806 
); 

¿Cómo puedo decirle a Mockito que verifique ambos valores?

Answer 1

Otras lecturas me ha llevado a tratar de usar ArgumentCaptors y las siguientes obras, aunque mucho más detallado de lo que me gustaría.

ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class); 

verify(errors, atLeastOnce()).add(argument.capture(), any(ActionMessage.class)); 

List<String> values = argument.getAllValues(); 

assertTrue(values.contains("exception.message")); 
assertTrue(values.contains("exception.detail")); 

Answer 2

intentar algo como esto:

verify(errors, times(2)) 
    .add(AdditionalMatchers.or(eq("exception.message"), eq("exception.detail")), 
      any(ActionError.class)); 

Answer 3

es probable que tenga un problema en el código. Porque, como cuestión de hecho en realidad se escribe este código:

Map<Character, String> map = mock(Map.class); 

map.put('a', "a"); 
map.put('b', "b"); 
map.put('c', "c"); 

verify(map).put(eq('c'), anyString()); 
verify(map).put(eq('a'), anyString()); 
verify(map).put(eq('b'), anyString()); 

Nota el primer verificar ni siquiera está en orden en lo que se refiere a las invocaciones reales.

Además, le recomendaría que no se burle de los tipos que no le pertenecen, por ejemplo, el tipo de puntales.

[EDIT @Brad]

Después de ejecutar código de Brice (arriba) en mi IDE puedo ver que he utilizado en lugar de ActionError ActionMessage, así que por eso mi verificar() no se pongan en venta. El mensaje de error que inicialmente publiqué me indujo a error al pensar que era el primer argumento que no coincidía. Resulta que fue el segundo argumento.

Así que la respuesta a mi pregunta es

/** 
* note that ActionMessageFactory.createErrorMessage() returns ActionMessage 
* and ActionError extends ActionMessage 
*/ 
verify(errors).add(eq("exception.message"), any(ActionMessage.class)); 
verify(errors).add(eq("exception.detail"), any(ActionMessage.class)); 

Answer 4

Si el orden de los dos add() llamadas es relevante, puede utilizar InOrder:

InOrder inOrder = inOrder(errors, errors); 
inOrder.verify(errors).add(eq("exception.message"), any(ActionError.class)); 
inOrder.verify(errors).add(eq("exception.detail"), any(ActionError.class)); 

Answer 5

Usted puede utilizar Mockito.atLeastOnce() que permite Mockito para pasar la prueba, incluso si eso mockObject será llamado muchas veces.

Mockito.verify(mockObject, Mockito.atLeastOnce()).testMethod(Mockito.eq(1)); 

Mockito.verify(mockObject, Mockito.atLeastOnce()).testMethod(Mockito.eq(2));