使用Mockito对带有相同参数的相同方法进行多次调用

Question

是否有办法让存根方法在后续调用时返回不同的对象?我想这样做是为了测试来自ExecutorCompletionService的不确定响应。即测试无论方法的返回顺序如何，结果保持不变。

我要测试的代码看起来像这样:

// 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

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

你可以在thenReturn的括号中放入任意多的参数，只要它们都是正确的类型。第一个值将在第一次调用该方法时返回，然后是第二个答案，依此类推。最后一个值将在所有其他值用完后重复返回。

Answer 2

您可以使用thenAnswer方法(当与when链接时):

when(someMock.someMethod()).thenAnswer(new Answer() {
    private int count = 0;
    public Object answer(InvocationOnMock invocation) {
        if (count++ == 1)
            return 1;
        return 2;
    }
});

或者使用等效的静态doAnswer方法:

doAnswer(new Answer() {
    private int count = 0;
    public Object answer(InvocationOnMock invocation) {
        if (count++ == 1)
            return 1;
        return 2;
    }
}).when(someMock).someMethod();

Answer 3

正如前面指出的，几乎所有的调用都是可链接的。

你可以调用

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

更多信息见Mockito的文档

Answer 4

几乎所有的调用都是可链接的:

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

Answer 5

BDD style:

import static org.mockito.BDDMockito.given;
        ...
        given(yourMock.yourMethod()).willReturn(1, 2, 3);

<标题>经典风格:

import static org.mockito.Mockito.when;
        ...
        when(yourMock.yourMethod()).thenReturn(1, 2, 3);

<标题>显式风格:

        ...
        when(yourMock.yourMethod())
            .thenReturn(1)
            .thenReturn(2)
            .thenReturn(3);

取决于参数

选项# 1

假设我们有两个参数，并检查第二个(列表)参数的大小:

        ...
        when(yourMock.yourMethod(any(), anyList()))
             .thenAnswer(args -> ((List) args.getArgument(1)).size() < 2
                                 ? 1
                                 : 3);

args是对象，因此必须将arg强制转换为我们的类型。我将^^^转换为(List)。

选项#2 (BDD)

        ...
        given(yourMock.yourMethod(any(), anyList()))
             .willAnswer(args -> ((List) args.getArgument(1)).size() < 2
                                 ? 1
                                 : 3);

Answer 6

我已经实现了一个MultipleAnswer类，它可以帮助我在每次调用中存根不同的答案。下面这段代码:

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

Answer 7

doReturn(value1, value2, value3)。当(method-call)

Answer 8

与@[Igor Nikolaev] 8年前的回答有关，使用Answer可以使用Java 8中可用的lambda表达式来简化。

when(someMock.someMethod()).thenAnswer(invocation -> {
    doStuff();
    return;
});

或更简单:

when(someMock.someMethod()).thenAnswer(invocation -> doStuff());

Answer 9

这与问题没有直接关系。但我想把这个放在同一条链上。

如果尝试用多个参数验证相同的方法调用，您可以使用Mockito的以下时间特性。如果您不验证，则不需要它。

5。验证((n)方法,倍).methoscall ();

这里的'n'是mock被调用的次数

Answer 10

如果你有一个动态的值列表，你可以使用AdditionalAnswers.returnsElementsOf:

import org.mockito.AdditionalAnswers;
when(mock.method()).thenAnswer(AdditionalAnswers.returnsElementsOf(myListOfValues));

Answer 11

Following可以作为一个通用方法，在不同的方法调用时返回不同的参数。我们唯一需要做的就是传递一个顺序数组，其中的对象应该在每次调用中检索。

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

交货。getAnswerForSubsequentCalls(mock1, mock3, mock2);将在第一次调用时返回mock1对象，第二次调用时返回mock3对象，第三次调用时返回mock2对象。应该像when(something()).doAnswer(getAnswerForSubsequentCalls(mock1, mock3, mock2));一样使用吗这几乎类似于when(something()).thenReturn(mock1, mock3, mock2);

Answer 12

您可以使用LinkedList和Answer。如

MyService mock = mock(MyService.class);
LinkedList<String> results = new LinkedList<>(List.of("A", "B", "C"));
when(mock.doSomething(any())).thenAnswer(invocation -> results.removeFirst());

Answer 13

这可能是基本的/明显的，但如果像我一样，您试图模拟对一个方法的多次调用，每次调用要测试的方法调用次数未知，例如:

public String method(String testArg) {
    //...
    while(condition) {
        someValue = someBean.nestedMethod(); // This is called unknown number of times
        //...
    }
    //...
}

你可以这样做:

@Test
public void testMethod() {
    mockNestedMethodForValue("value1");
    assertEquals(method("arg"), "expected1");
    mockNestedMethodForValue("value2");
    assertEquals(method("arg"), "expected2");
    mockNestedMethodForValue("value3");
    assertEquals(method("arg"), "expected3");
}
private void mockNestedMethodForValue(String value) {
    doReturn(value).when(someBeanMock).nestedMethod();
}

Answer 14

这是BDD样式的工作示例，非常简单明了

given(carRepository.findByName(any(String.class))).willReturn(Optional.empty()).willReturn(Optional.of(MockData.createCarEntity()));