Pertanyaan @RunWith (MockitoJUnitRunner.class) vs MockitoAnnotations.initMocks (ini)


Saat menulis tes jUnit4 baru, saya bertanya-tanya apakah akan digunakan @RunWith (MockitoJUnitRunner.class)  atau MockitoAnnotations.initMocks (ini).

Saya membuat tes baru & wizard secara otomatis menghasilkan tes dengan Runner. Javadocs untuk MockitoJUnitRunner menyatakan sebagai berikut:

Kompatibel dengan JUnit 4.4 dan lebih tinggi, pelari ini menambahkan perilaku berikut:

Menginisialisasi anutan yang dianotasikan dengan Mock, sehingga penggunaan eksplisit MockitoAnnotations.initMocks (Objek) tidak diperlukan. Pemeriksaan dilakukan sebelum setiap metode pengujian.   memvalidasi penggunaan kerangka kerja setelah setiap metode pengujian.

Tidak jelas bagi saya apakah menggunakan Runner memiliki keuntungan lebih dari itu initMocks () metode yang saya gunakan di masa lalu.

Setiap pikiran atau tautan akan dihargai!


76
2018-05-29 20:34


asal


Jawaban:


MockitoJUnitRunner memberi Anda validasi otomatis penggunaan kerangka kerja, serta otomatis initMocks().

Validasi otomatis dari penggunaan kerangka kerja sebenarnya berharga. Ini memberi Anda pelaporan yang lebih baik jika Anda membuat salah satu dari kesalahan ini.

  • Anda menyebut statis when metode, tetapi tidak menyelesaikan stubbing dengan pencocokan thenReturn, thenThrow atau then. (Kesalahan 1 dalam kode di bawah ini)

  • Kamu panggil verify pada tiruan, tetapi lupa untuk memberikan panggilan metode yang Anda coba verifikasi. (Galat 2 dalam kode di bawah ini)

  • Anda memanggil when metode setelah doReturn, doThrow atau doAnswer dan lulus tiruan, tetapi lupa untuk memberikan metode itu Anda mencoba untuk rintisan. (Galat 3 dalam kode di bawah ini)

Jika Anda tidak memiliki validasi penggunaan kerangka kerja, kesalahan ini tidak dilaporkan sampai berikut panggilan ke metode Mockito. Ini mungkin

  • dalam metode tes yang sama (seperti kesalahan 1 di bawah),
  • dalam metode tes berikutnya (seperti kesalahan 2 di bawah),
  • di kelas tes selanjutnya.

Jika mereka terjadi pada tes terakhir yang Anda jalankan (seperti kesalahan 3 di bawah), mereka tidak akan dilaporkan sama sekali.

Inilah cara masing-masing jenis kesalahan tersebut terlihat. Asumsikan di sini bahwa JUnit menjalankan pengujian ini dalam urutan yang tercantum di sini.

@Test
public void test1() {

    // ERROR 1
    // This compiles and runs, but it's an invalid use of the framework because 
    // Mockito is still waiting to find out what it should do when myMethod is called.
    // But Mockito can't report it yet, because the call to thenReturn might 
    // be yet to happen.
    when(myMock.method1());

    doSomeTestingStuff();

    // ERROR 1 is reported on the following line, even though it's not the line with
    // the error.
    verify(myMock).method2();

}

@Test
public void test2() {

    doSomeTestingStuff();

    // ERROR 2
    // This compiles and runs, but it's an invalid use of the framework because
    // Mockito doesn't know what method call to verify.  But Mockito can't report 
    // it yet, because the call to the method that's being verified might 
    // be yet to happen.
    verify(myMock);
}

@Test
public void test3() {

    // ERROR 2 is reported on the following line, even though it's not even in 
    // the same test as the error.
    doReturn("Hello").when(myMock).method1();


    // ERROR 3
    // This compiles and runs, but it's an invalid use of the framework because
    // Mockito doesn't know what method call is being stubbed.  But Mockito can't 
    // report it yet, because the call to the method that's being stubbed might 
    // be yet to happen.

    doReturn("World").when(myMock);

    doSomeTestingStuff(); 

    //  ERROR 3 is never reported, because there are no more Mockito calls. 
}

Sekarang ketika saya pertama kali menulis jawaban ini lebih dari lima tahun yang lalu, saya menulis

Jadi saya akan merekomendasikan penggunaan MockitoJUnitRunner sedapat mungkin. Namun, seperti yang telah ditunjukkan Tomasz Nurkiewicz dengan tepat, Anda tidak dapat menggunakannya jika Anda membutuhkan pelari JUnit lain, seperti Spring.

Rekomendasi saya sekarang telah berubah. Tim Mockito telah menambahkan fitur baru sejak saya pertama kali menulis jawaban ini. Ini adalah aturan JUnit, yang melakukan fungsi yang sama persis seperti MockitoJUnitRunner. Tapi lebih baik, karena itu tidak menghalangi penggunaan pelari lain.

Termasuk

@Rule 
public MockitoRule rule = MockitoJUnit.rule();

di kelas tes Anda. Ini menginisialisasi tiruan, dan mengotomatiskan validasi kerangka; seperti MockitoJUnitRunner tidak. Tetapi sekarang, Anda bisa menggunakannya SpringJUnit4ClassRunner atau JUnitRunner lainnya juga. Dari Mockito 2.1.0 dan seterusnya, ada opsi tambahan yang mengontrol masalah apa yang dilaporkan.


95
2018-05-30 08:36



Menggunakan pelari memungkinkan Anda menyimpan sedikit pengkodean (tidak perlu @Before metode). Di sisi lain menggunakan pelari kadang-kadang tidak mungkin, yaitu ketika Anda sudah menggunakan satu, suka SpringJUnit4ClassRunner.

Itu dia. Itu hanya masalah preferensi.


23
2018-05-29 20:40