Menggunakan Mockito dengan beberapa panggilan ke metode yang sama dengan argumen yang sama

Apakah ada cara agar metode stubbed mengembalikan objek yang berbeda pada pemanggilan berikutnya? Saya ingin melakukan ini untuk menguji tanggapan yang tidak ditentukan dari ExecutorCompletionService. yaitu untuk menguji bahwa terlepas dari urutan pengembalian metode, hasilnya tetap konstan.

Kode yang ingin saya uji terlihat seperti ini.

// 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 (...) { }        
}

Anda dapat melakukannya menggunakan thenAnswermetode (saat merantai dengan when):

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

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

        return 2;
    }
});

Atau menggunakan doAnswermetode statis yang setara :

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

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

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

Bagaimana tentang

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

Anda dapat menempatkan argumen sebanyak yang Anda suka di kurung thenReturn, asalkan semuanya adalah tipe yang benar. Nilai pertama akan dikembalikan saat metode pertama dipanggil, lalu jawaban kedua, dan seterusnya. Nilai terakhir akan dikembalikan berulang kali setelah semua nilai lainnya habis.

Seperti yang ditunjukkan sebelumnya, hampir semua panggilan dapat dilakukan dengan rantai.

Jadi kamu bisa menelepon

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

Info lebih lanjut di Dokumentasi Mockito .

Anda bahkan dapat doReturn()mengaitkan pemanggilan metode seperti ini

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

imut bukan :)

Saya telah menerapkan MultipleAnswerkelas yang membantu saya untuk mematikan jawaban yang berbeda dalam setiap panggilan. Berikut potongan kode:

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

Mengikuti dapat digunakan sebagai metode umum untuk mengembalikan argumen yang berbeda pada panggilan metode yang berbeda. Satu-satunya hal yang perlu kita lakukan adalah kita harus melewati array dengan urutan objek mana yang harus diambil dalam setiap panggilan.

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

Ex. getAnswerForSubsequentCalls(mock1, mock3, mock2);akan mengembalikan objek mock1 pada panggilan pertama, objek mock3 pada panggilan kedua dan objek mock2 pada panggilan ketiga. Harus digunakan seperti when(something()).doAnswer(getAnswerForSubsequentCalls(mock1, mock3, mock2)); ini hampir mirip denganwhen(something()).thenReturn(mock1, mock3, mock2);

Terkait dengan jawaban @ [Igor Nikolaev] dari 8 tahun yang lalu, menggunakan Answercan dapat disederhanakan menggunakan ekspresi lambda yang tersedia di Java 8.

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

atau lebih sederhana:

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

Gaya BDD:

import static org.mockito.BDDMockito.*;
...
    @Test
    void submit() {
        given(yourMock.yourMethod()).willReturn(1, 2, 3);

doReturn (value1, value2, value3) .when (metode-panggilan)