Menginisialisasi objek tiruan - MockIto

Ada banyak cara untuk menginisialisasi objek tiruan menggunakan MockIto. Apa cara terbaik di antara ini?

1.

 public class SampleBaseTestCase {

   @Before public void initMocks() {
       MockitoAnnotations.initMocks(this);
   }

2.

@RunWith(MockitoJUnitRunner.class)

[EDIT] 3.

mock(XXX.class);

sarankan saya jika ada cara lain yang lebih baik dari ini ...

Untuk inisialisasi tiruan , menggunakan pelari atau solusi MockitoAnnotations.initMocksyang benar-benar setara. Dari javadoc dari MockitoJUnitRunner :

JUnit 4.5 runner initializes mocks annotated with Mock, so that explicit usage of MockitoAnnotations.initMocks(Object) is not necessary. Mocks are initialized before each test method.

Solusi pertama (dengan MockitoAnnotations.initMocks) dapat digunakan ketika Anda telah mengkonfigurasi pelari tertentu (SpringJUnit4ClassRunner misalnya) pada kasus pengujian Anda.

Solusi kedua (dengan MockitoJUnitRunner) adalah yang lebih klasik dan favorit saya. Kodenya lebih sederhana. Menggunakan runner memberikan keuntungan besar dari validasi otomatis penggunaan framework (dijelaskan oleh @David Wallace dalam jawaban ini ).

Kedua solusi memungkinkan untuk berbagi tiruan (dan mata-mata) di antara metode pengujian. Ditambah dengan @InjectMocks, mereka memungkinkan untuk menulis tes unit dengan sangat cepat. Kode tiruan boilerplate dikurangi, pengujian lebih mudah dibaca. Sebagai contoh:

@RunWith(MockitoJUnitRunner.class)
public class ArticleManagerTest {

    @Mock private ArticleCalculator calculator;
    @Mock(name = "database") private ArticleDatabase dbMock;
    @Spy private UserProvider userProvider = new ConsumerUserProvider();

    @InjectMocks private ArticleManager manager;

    @Test public void shouldDoSomething() {
        manager.initiateArticle();
        verify(database).addListener(any(ArticleListener.class));
    }

    @Test public void shouldDoSomethingElse() {
        manager.finishArticle();
        verify(database).removeListener(any(ArticleListener.class));
    }
}

Kelebihan: Kodenya minimal

Kekurangan: Ilmu hitam. IMO ini terutama karena anotasi @InjectMocks. Dengan anotasi ini "Anda kehilangan rasa sakit kode" (lihat komentar bagus @Brice )

Solusi ketiga adalah membuat tiruan Anda pada setiap metode pengujian. Ini memungkinkan seperti yang dijelaskan oleh @mlk dalam jawabannya untuk memiliki " tes mandiri ".

public class ArticleManagerTest {

    @Test public void shouldDoSomething() {
        // given
        ArticleCalculator calculator = mock(ArticleCalculator.class);
        ArticleDatabase database = mock(ArticleDatabase.class);
        UserProvider userProvider = spy(new ConsumerUserProvider());
        ArticleManager manager = new ArticleManager(calculator, 
                                                    userProvider, 
                                                    database);

        // when 
        manager.initiateArticle();

        // then 
        verify(database).addListener(any(ArticleListener.class));
    }

    @Test public void shouldDoSomethingElse() {
        // given
        ArticleCalculator calculator = mock(ArticleCalculator.class);
        ArticleDatabase database = mock(ArticleDatabase.class);
        UserProvider userProvider = spy(new ConsumerUserProvider());
        ArticleManager manager = new ArticleManager(calculator, 
                                                    userProvider, 
                                                    database);

        // when 
        manager.finishArticle();

        // then
        verify(database).removeListener(any(ArticleListener.class));
    }
}

Pro: Anda dengan jelas menunjukkan cara kerja api Anda (BDD ...)

Kekurangan: ada lebih banyak kode boilerplate. (Penciptaan mengejek)

Rekomendasi saya adalah kompromi. Gunakan @Mockanotasi dengan @RunWith(MockitoJUnitRunner.class), tapi jangan gunakan @InjectMocks:

@RunWith(MockitoJUnitRunner.class)
public class ArticleManagerTest {

    @Mock private ArticleCalculator calculator;
    @Mock private ArticleDatabase database;
    @Spy private UserProvider userProvider = new ConsumerUserProvider();

    @Test public void shouldDoSomething() {
        // given
        ArticleManager manager = new ArticleManager(calculator, 
                                                    userProvider, 
                                                    database);

        // when 
        manager.initiateArticle();

        // then 
        verify(database).addListener(any(ArticleListener.class));
    }

    @Test public void shouldDoSomethingElse() {
        // given
        ArticleManager manager = new ArticleManager(calculator, 
                                                    userProvider, 
                                                    database);

        // when 
        manager.finishArticle();

        // then 
        verify(database).removeListener(any(ArticleListener.class));
    }
}

Kelebihan: Anda dengan jelas menunjukkan bagaimana api Anda bekerja (How my ArticleManager is instantiated). Tidak ada kode boilerplate.

Cons: Tes ini tidak mandiri, lebih sedikit kesulitan kode

Sekarang ada (mulai v1.10.7) cara keempat untuk membuat contoh tiruan, yang menggunakan aturan JUnit4 yang disebut MockitoRule .

@RunWith(JUnit4.class)   // or a different runner of your choice
public class YourTest
  @Rule public MockitoRule rule = MockitoJUnit.rule();
  @Mock public YourMock yourMock;

  @Test public void yourTestMethod() { /* ... */ }
}

JUnit mencari subclass TestRule yang dianotasi dengan @Rule , dan menggunakannya untuk menggabungkan Pernyataan pengujian yang disediakan Runner . Hasilnya adalah Anda dapat mengekstrak metode @Before, metode @After, dan bahkan mencoba ... menangkap pembungkus ke dalam aturan. Anda bahkan dapat berinteraksi dengan ini dari dalam pengujian Anda, seperti yang dilakukan ExpectedException .

MockitoRule berperilaku hampir persis seperti MockitoJUnitRunner , kecuali bahwa Anda dapat menggunakan pelari lain, seperti Parameterized (yang memungkinkan konstruktor pengujian Anda mengambil argumen sehingga pengujian Anda dapat dijalankan beberapa kali), atau runner pengujian Robolectric (sehingga classloadernya dapat menyediakan pengganti Java untuk kelas asli Android). Ini membuatnya lebih fleksibel untuk digunakan di versi JUnit dan Mockito terbaru.

Singkatnya:

• Mockito.mock(): Doa langsung tanpa dukungan anotasi atau validasi penggunaan.
• MockitoAnnotations.initMocks(this): Dukungan anotasi, tidak ada validasi penggunaan.
• MockitoJUnitRunner: Dukungan anotasi dan validasi penggunaan, tetapi Anda harus menggunakan runner itu.
• MockitoRule: Dukungan anotasi dan validasi penggunaan dengan pelari JUnit apa pun.

Lihat juga: Bagaimana JUnit @Rule bekerja?

Ada cara yang rapi untuk melakukan ini.

• Jika ini adalah Tes Unit, Anda dapat melakukan ini:

  @RunWith(MockitoJUnitRunner.class)
  public class MyUnitTest {
  
      @Mock
      private MyFirstMock myFirstMock;
  
      @Mock
      private MySecondMock mySecondMock;
  
      @Spy
      private MySpiedClass mySpiedClass = new MySpiedClass();
  
      // It's gonna inject the 2 mocks and the spied object per reflection to this object
      // The java doc of @InjectMocks explains it really well how and when it does the injection
      @InjectMocks
      private MyClassToTest myClassToTest;
  
      @Test
      public void testSomething() {
      }
  }

• EDIT: Jika ini adalah tes Integrasi, Anda dapat melakukan ini (tidak dimaksudkan untuk digunakan seperti itu dengan Spring. Tunjukkan saja bahwa Anda dapat menginisialisasi tiruan dengan Pelari yang berbeda):

  @RunWith(SpringJUnit4ClassRunner.class)
  @ContextConfiguration("aplicationContext.xml")
  public class MyIntegrationTest {
  
      @Mock
      private MyFirstMock myFirstMock;
  
      @Mock
      private MySecondMock mySecondMock;
  
      @Spy
      private MySpiedClass mySpiedClass = new MySpiedClass();
  
      // It's gonna inject the 2 mocks and the spied object per reflection to this object
      // The java doc of @InjectMocks explains it really well how and when it does the injection
      @InjectMocks
      private MyClassToTest myClassToTest;
  
      @Before
      public void setUp() throws Exception {
            MockitoAnnotations.initMocks(this);
      }
  
      @Test
      public void testSomething() {
      }
  }

MockitoAnnotation & runner telah dibahas dengan baik di atas, jadi saya akan memberikan tuppence saya untuk yang tidak dicintai:

XXX mockedXxx = mock(XXX.class);

Saya menggunakan ini karena menurut saya ini sedikit lebih deskriptif dan saya lebih suka pengujian unit (bukan larangan yang benar) untuk tidak menggunakan variabel anggota karena saya suka pengujian saya (sebanyak mungkin) mandiri.

Sebuah contoh kecil untuk JUnit 5 Jupiter, "RunWith" telah dihapus, Anda sekarang harus menggunakan Ekstensi menggunakan Anotasi "@ExtendWith".

@ExtendWith(MockitoExtension.class)
class FooTest {

  @InjectMocks
  ClassUnderTest test = new ClassUnderTest();

  @Spy
  SomeInject bla = new SomeInject();
}

Jawaban lainnya bagus dan berisi lebih banyak detail jika Anda menginginkan / membutuhkannya.
Selain itu, saya ingin menambahkan TL; DR:

1. Lebih suka menggunakan
   • @RunWith(MockitoJUnitRunner.class)
2. Jika Anda tidak bisa (karena Anda sudah menggunakan pelari yang berbeda), lebih baik gunakan
   • @Rule public MockitoRule rule = MockitoJUnit.rule();
3. Mirip dengan (2), tetapi Anda tidak boleh menggunakan ini lagi:
   • @Before public void initMocks() { MockitoAnnotations.initMocks(this); }
4. Jika Anda ingin menggunakan tiruan di salah satu pengujian dan tidak ingin mengeksposnya ke pengujian lain di kelas pengujian yang sama, gunakan
   • X x = mock(X.class)

(1) dan (2) dan (3) saling eksklusif.
(4) dapat digunakan dalam kombinasi dengan yang lain.