Cara mengejek metode batal dengan Mockito

Bagaimana cara mengejek metode dengan tipe batal?

Saya menerapkan pola pengamat tetapi saya tidak bisa mengejeknya dengan Mockito karena saya tidak tahu caranya.

Dan saya mencoba mencari contoh di Internet tetapi tidak berhasil.

Kelas saya terlihat seperti ini:

public class World {

    List<Listener> listeners;

    void addListener(Listener item) {
        listeners.add(item);
    }

    void doAction(Action goal,Object obj) {
        setState("i received");
        goal.doAction(obj);
        setState("i finished");
    }

    private string state;
    //setter getter state
} 

public class WorldTest implements Listener {

    @Test public void word{
    World  w= mock(World.class);
    w.addListener(this);
    ...
    ...

    }
}

interface Listener {
    void doAction();
}

Sistem tidak dipicu dengan mock.

Saya ingin menunjukkan status sistem yang disebutkan di atas. Dan buatlah pernyataan menurut mereka.

Lihatlah dokumen Mockito API . Sebagai dokumen terkait menyebutkan (Point No. 12) Anda dapat menggunakan salah satu doThrow(), doAnswer(), doNothing(), doReturn()keluarga metode dari kerangka Mockito untuk mengejek metode batal.

Sebagai contoh,

Mockito.doThrow(new Exception()).when(instance).methodName();

atau jika Anda ingin menggabungkannya dengan perilaku tindak lanjut,

Mockito.doThrow(new Exception()).doNothing().when(instance).methodName();

Menganggap bahwa Anda mencari mengejek setter setState(String s)di kelas Dunia di bawah ini adalah kode menggunakan doAnswermetode untuk mengejek setState.

World  mockWorld = mock(World.class); 
doAnswer(new Answer<Void>() {
    public Void answer(InvocationOnMock invocation) {
      Object[] args = invocation.getArguments();
      System.out.println("called with arguments: " + Arrays.toString(args));
      return null;
    }
}).when(mockWorld).setState(anyString());

Saya pikir saya telah menemukan jawaban yang lebih sederhana untuk pertanyaan itu, untuk memanggil metode nyata hanya untuk satu metode (bahkan jika itu memiliki pengembalian kosong) Anda dapat melakukan ini:

Mockito.doCallRealMethod().when(<objectInstance>).<method>();
<objectInstance>.<method>();

Atau, Anda bisa memanggil metode nyata untuk semua metode kelas itu, melakukan ini:

<Object> <objectInstance> = mock(<Object>.class, Mockito.CALLS_REAL_METHODS);

Menambahkan apa yang dikatakan @sateesh, ketika Anda hanya ingin mengejek metode kosong untuk mencegah tes memanggilnya, Anda bisa menggunakan Spycara ini:

World world = new World();
World spy = Mockito.spy(world);
Mockito.doNothing().when(spy).methodToMock();

Ketika Anda ingin menjalankan tes Anda, pastikan Anda memanggil metode dalam pengujian pada spyobjek dan bukan pada worldobjek. Sebagai contoh:

assertEquals(0,spy.methodToTestThatShouldReturnZero());

Solusi masalah yang disebut adalah dengan menggunakan spy Mockito.spy (...) alih-alih mock Mockito.mock (..) .

Spy memungkinkan kita untuk mengejek sebagian. Mockito pandai dalam hal ini. Karena Anda memiliki kelas yang tidak lengkap, dengan cara ini Anda mengejek beberapa tempat yang diperlukan di kelas ini.

Pertama-tama: Anda harus selalu mengimpor mockito statis, dengan cara ini kode akan jauh lebih mudah dibaca (dan intuitif):

import static org.mockito.Mockito.*;

Untuk mengejek parsial dan tetap mempertahankan fungsionalitas asli, mockito lainnya menawarkan "Spy".

Anda dapat menggunakannya sebagai berikut:

private World world = spy(World.class);

Untuk menghilangkan metode dari eksekusi Anda dapat menggunakan sesuatu seperti ini:

doNothing().when(someObject).someMethod(anyObject());

untuk memberikan beberapa perilaku khusus ke metode, gunakan "when" dengan "thenReturn":

doReturn("something").when(this.world).someMethod(anyObject());

Untuk contoh lebih lanjut, silakan temukan sampel mockito yang sangat baik dalam dokumen.

Cara mempermainkan metode batal dengan mockito - ada dua opsi:

1. doAnswer - Jika kita ingin metode batal mengejek kita untuk melakukan sesuatu (mengejek perilaku meskipun batal).
2. doThrow- Lalu ada Mockito.doThrow()jika Anda ingin melempar pengecualian dari metode batal diejek.

Berikut ini adalah contoh cara menggunakannya (bukan usecase yang ideal tetapi hanya ingin menggambarkan penggunaan dasar).

@Test
public void testUpdate() {

    doAnswer(new Answer<Void>() {

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            Object[] arguments = invocation.getArguments();
            if (arguments != null && arguments.length > 1 && arguments[0] != null && arguments[1] != null) {

                Customer customer = (Customer) arguments[0];
                String email = (String) arguments[1];
                customer.setEmail(email);

            }
            return null;
        }
    }).when(daoMock).updateEmail(any(Customer.class), any(String.class));

    // calling the method under test
    Customer customer = service.changeEmail("[email protected]", "[email protected]");

    //some asserts
    assertThat(customer, is(notNullValue()));
    assertThat(customer.getEmail(), is(equalTo("[email protected]")));

}

@Test(expected = RuntimeException.class)
public void testUpdate_throwsException() {

    doThrow(RuntimeException.class).when(daoMock).updateEmail(any(Customer.class), any(String.class));

    // calling the method under test
    Customer customer = service.changeEmail("[email protected]", "[email protected]");

}
}

Anda dapat menemukan rincian lebih lanjut tentang cara mengejek dan menguji metode batal dengan Mockito di posting saya Cara mengejek dengan Mockito (Panduan komprehensif dengan contoh)

Menambahkan jawaban lain ke banyak (tidak ada permainan kata pun dimaksudkan) ...

Anda perlu memanggil metode doAnswer jika Anda tidak dapat \ tidak ingin menggunakan mata-mata. Namun, Anda tidak perlu menggulung Jawaban Anda sendiri . Ada beberapa implementasi standar. Khususnya, CallsRealMethods .

Dalam praktiknya, tampilannya seperti ini:

doAnswer(new CallsRealMethods()).when(mock)
        .voidMethod(any(SomeParamClass.class));

Atau:

doAnswer(Answers.CALLS_REAL_METHODS.get()).when(mock)
        .voidMethod(any(SomeParamClass.class));

Di Java 8 ini dapat dibuat sedikit lebih bersih, dengan asumsi Anda memiliki impor statis untuk org.mockito.Mockito.doAnswer:

doAnswer(i -> {
  // Do stuff with i.getArguments() here
  return null;
}).when(*mock*).*method*(*methodArguments*);

Itu return null;penting dan tanpa itu kompilasi akan gagal dengan beberapa kesalahan yang cukup tidak jelas karena tidak akan dapat menemukan penggantian yang sesuai doAnswer.

Misalnya sebuah ExecutorServiceyang langsung mengeksekusi yang Runnablediteruskan ke execute()dapat diimplementasikan menggunakan:

doAnswer(i -> {
  ((Runnable) i.getArguments()[0]).run();
  return null;
}).when(executor).execute(any());

Saya pikir masalah Anda disebabkan oleh struktur pengujian Anda. Saya merasa sulit untuk mencampur ejekan dengan metode tradisional mengimplementasikan antarmuka di kelas uji (seperti yang Anda lakukan di sini).

Jika Anda menerapkan pendengar sebagai Mock, Anda dapat memverifikasi interaksinya.

Listener listener = mock(Listener.class);
w.addListener(listener);
world.doAction(..);
verify(listener).doAction();

Ini seharusnya memuaskan Anda bahwa 'Dunia' melakukan hal yang benar.

Menggunakan Mockito.doThrow seperti pada:

Mockito.doThrow(new Exception()).when(instance).methodName();

Anda dapat mencoba contoh yang bagus ini:

public void testCloseStreamOnException() throws Exception {
    OutputStream outputStream = Mockito.mock(OutputStream.class);
    IFileOutputStream ifos = new IFileOutputStream(outputStream);
    Mockito.doThrow(new IOException("Dummy Exception")).when(outputStream).flush();
    try {
      ifos.close();
      fail("IOException is not thrown");
    } catch (IOException ioe) {
      assertEquals("Dummy Exception", ioe.getMessage());
    }
    Mockito.verify(outputStream).close();
  }

Sumber: http://apisonar.com/java-examples/org.mockito.Mockito.doThrow.html#Example-19