Menguji metode Privat menggunakan mockito

kelas publik A {

    metode public void (boolean b) {
          jika (b == benar)
               metode1 ();
          lain
               metode2 ();
    }

    private void method1 () {}
    private void method2 () {}
}

public class TestA {

    @Uji
    public void testMethod () {
      A a = mock (A.class);
      a. metode (benar);
      // cara menguji seperti verifikasi (a) .method1 ();
    }
}

Bagaimana cara menguji metode privat dipanggil atau tidak, dan bagaimana cara menguji metode privat menggunakan mockito ???

Anda tidak dapat melakukannya dengan Mockito tetapi Anda dapat menggunakan Powermock untuk memperluas Mockito dan metode pribadi tiruan. Powermock mendukung Mockito. Ini contohnya.

Tidak mungkin melalui mockito. Dari wiki mereka

Mengapa Mockito tidak mengejek metode pribadi?

Pertama, kami tidak dogmatis tentang mengejek metode privat. Kami hanya tidak peduli dengan metode privat karena dari sudut pandang pengujian metode privat tidak ada. Berikut beberapa alasan Mockito tidak mengejek metode privat:

Ini membutuhkan peretasan pemuat kelas yang tidak pernah anti peluru dan itu mengubah api (Anda harus menggunakan runner pengujian khusus, memberi anotasi kelas, dll.).

Sangat mudah untuk menyiasatinya - cukup ubah visibilitas metode dari pribadi menjadi dilindungi paket (atau dilindungi).

Saya harus menghabiskan waktu untuk menerapkan & memeliharanya. Dan itu tidak masuk akal mengingat poin # 2 dan fakta bahwa itu sudah diterapkan di alat yang berbeda (powermock).

Akhirnya ... Mengejek metode privat adalah petunjuk bahwa ada yang salah dengan pemahaman OO. Di OO ​​Anda ingin objek (atau peran) berkolaborasi, bukan metode. Lupakan kode pascal & prosedural. Pikirkan benda.

Berikut adalah contoh kecil bagaimana melakukannya dengan powermock

public class Hello {
    private Hello obj;
    private Integer method1(Long id) {
        return id + 10;
    }
} 

Untuk menguji metode1 gunakan kode:

Hello testObj = new Hello();
Integer result = Whitebox.invokeMethod(testObj, "method1", new Long(10L));

Untuk mengatur private object obj, gunakan ini:

Hello testObj = new Hello();
Hello newObject = new Hello();
Whitebox.setInternalState(testObj, "obj", newObject);

Pikirkan tentang hal ini dalam kaitannya dengan perilaku, bukan dalam metode apa yang ada. Metode yang dipanggil methodmemiliki perilaku tertentu jika bbenar. Ini memiliki perilaku yang berbeda jika bsalah. Ini berarti Anda harus menulis dua tes berbeda untuk method; satu untuk setiap kasus. Jadi, alih-alih memiliki tiga pengujian berorientasi metode (satu untuk method, satu untuk method1, satu untuk method2, Anda memiliki dua pengujian berorientasi perilaku.

Terkait dengan ini (saya menyarankan ini di utas SO lain baru-baru ini, dan sebagai hasilnya disebut kata empat huruf, jadi jangan ragu untuk mengambil ini dengan sebutir garam); Saya merasa terbantu untuk memilih nama pengujian yang mencerminkan perilaku yang saya uji, daripada nama metode. Jadi jangan sebut tes Anda testMethod(), testMethod1(), testMethod2()dan sebagainya. Saya suka nama yang disukai calculatedPriceIsBasePricePlusTax()atau taxIsExcludedWhenExcludeIsTrue()yang menunjukkan perilaku apa yang saya uji; kemudian dalam setiap metode pengujian, uji hanya perilaku yang ditunjukkan. Kebanyakan perilaku tersebut hanya akan melibatkan satu panggilan ke metode publik, tetapi mungkin melibatkan banyak panggilan ke metode privat.

Semoga ini membantu.

Meskipun Mockito tidak menyediakan kemampuan itu, Anda dapat mencapai hasil yang sama menggunakan Mockito + kelas JUnit ReflectionUtils atau kelas Spring ReflectionTestUtils . Silakan lihat contoh di bawah ini yang diambil dari sini yang menjelaskan cara memanggil metode pribadi:

ReflectionTestUtils.invokeMethod(student, "saveOrUpdate", "From Unit test");

Contoh lengkap dengan ReflectionTestUtils dan Mockito dapat ditemukan di buku Mockito for Spring

Anda tidak seharusnya menguji metode privat. Hanya metode non-privat yang perlu diuji karena metode ini harus memanggil metode privat. Jika Anda "ingin" menguji metode privat, ini mungkin menunjukkan bahwa Anda perlu memikirkan kembali desain Anda:

Apakah saya menggunakan injeksi ketergantungan yang tepat? Apakah saya mungkin perlu memindahkan metode privat ke kelas terpisah dan lebih baik mengujinya? Haruskah metode ini bersifat pribadi? ... tidak bisakah mereka menjadi default atau dilindungi?

Dalam contoh di atas, dua metode yang disebut "secara acak" mungkin sebenarnya perlu ditempatkan di kelasnya sendiri, diuji, dan kemudian dimasukkan ke dalam kelas di atas.

Saya dapat menguji metode pribadi di dalam menggunakan mockito menggunakan refleksi. Berikut adalah contohnya, mencoba menamainya sedemikian rupa sehingga masuk akal

//Service containing the mock method is injected with mockObjects

@InjectMocks
private ServiceContainingPrivateMethod serviceContainingPrivateMethod;

//Using reflection to change accessibility of the private method

Class<?>[] params = new Class<?>[]{PrivateMethodParameterOne.class, PrivateMethodParameterTwo.class};
    Method m = serviceContainingPrivateMethod .getClass().getDeclaredMethod("privateMethod", params);
    //making private method accessible
    m.setAccessible(true); 
    assertNotNull(m.invoke(serviceContainingPrivateMethod, privateMethodParameterOne, privateMethodParameterTwo).equals(null));

1. Dengan menggunakan refleksi, metode privat dapat dipanggil dari kelas pengujian. Pada kasus ini,

   // metode pengujian akan seperti ini ...

   public class TestA {
   
     @Test
       public void testMethod() {
   
       A a= new A();
       Method privateMethod = A.class.getDeclaredMethod("method1", null);
       privateMethod.setAccessible(true);
       // invoke the private method for test
       privateMethod.invoke(A, null);
   
       }
   }

2. Jika metode privat memanggil metode privat lainnya, maka kita perlu memata-matai objek dan menghentikan metode lain. Kelas pengujian akan seperti ...

   // metode pengujian akan seperti ini ...

   public class TestA {
   
     @Test
       public void testMethod() {
   
       A a= new A();
       A spyA = spy(a);
       Method privateMethod = A.class.getDeclaredMethod("method1", null);
       privateMethod.setAccessible(true);
       doReturn("Test").when(spyA, "method2"); // if private method2 is returning string data
       // invoke the private method for test
       privateMethod.invoke(spyA , null);
   
       }
   }

** Pendekatannya adalah menggabungkan refleksi dan memata-matai objek. ** metode1 dan ** metode2 adalah metode pribadi dan metode1 memanggil metode2.

Saya tidak begitu mengerti kebutuhan Anda untuk menguji metode privat. Akar masalahnya adalah metode publik Anda memiliki void sebagai tipe kembalian, dan karenanya Anda tidak dapat menguji metode publik Anda. Karenanya Anda dipaksa untuk menguji metode pribadi Anda. Apakah tebakan saya benar ??

Beberapa solusi yang mungkin (AFAIK):

1. Mengolok-olok metode pribadi Anda, tetapi tetap saja Anda tidak akan "benar-benar" menguji metode Anda.

2. Verifikasi status objek yang digunakan dalam metode ini. KEBANYAKAN metode melakukan beberapa pemrosesan nilai input dan mengembalikan output, atau mengubah status objek. Menguji objek untuk keadaan yang diinginkan juga dapat digunakan.

   public class A{
   
   SomeClass classObj = null;
   
   public void publicMethod(){
      privateMethod();
   }
   
   private void privateMethod(){
        classObj = new SomeClass();
   }
   
   }

   [Di sini Anda dapat menguji metode privat, dengan memeriksa perubahan status classObj dari nol menjadi bukan nol.]

3. Ubah sedikit kode Anda (Semoga ini bukan kode lama). Funda saya menulis metode adalah, seseorang harus selalu mengembalikan sesuatu (a int / a boolean). Nilai yang dikembalikan MUNGKIN atau MUNGKIN TIDAK digunakan oleh implementasi, tetapi PASTI akan digunakan oleh pengujian

   kode.

   public class A
   { 
       public int method(boolean b)
       {
             int nReturn = 0;
             if (b == true)
                  nReturn = method1();
             else
                  nReturn = method2();
       }
   
       private int method1() {}
   
       private int method2() {}
   
   }

Sebenarnya ada cara untuk menguji metode dari anggota pribadi dengan Mockito. Katakanlah Anda memiliki kelas seperti ini:

public class A {
    private SomeOtherClass someOtherClass;
    A() {
        someOtherClass = new SomeOtherClass();
    }
    public void method(boolean b){
        if (b == true)
            someOtherClass.method1();
        else
            someOtherClass.method2();
    }

}

public class SomeOtherClass {
    public void method1() {}
    public void method2() {}
}

Jika Anda ingin menguji a.methodakan memanggil metode dari SomeOtherClass, Anda dapat menulis sesuatu seperti di bawah ini.

@Test
public void testPrivateMemberMethodCalled() {
    A a = new A();
    SomeOtherClass someOtherClass = Mockito.spy(new SomeOtherClass());
    ReflectionTestUtils.setField( a, "someOtherClass", someOtherClass);
    a.method( true );

    Mockito.verify( someOtherClass, Mockito.times( 1 ) ).method1();
}

ReflectionTestUtils.setField(); akan menghentikan anggota pribadi dengan sesuatu yang dapat Anda mata-matai.

Letakkan pengujian Anda dalam paket yang sama, tetapi folder sumber berbeda (src / main / java vs. src / test / java) dan jadikan metode tersebut sebagai paket pribadi. Kemampuan untuk diuji lebih penting daripada privasi.

Jika metode privat tidak kosong dan nilai yang dikembalikan digunakan sebagai parameter untuk metode dependensi eksternal, Anda dapat memalsukan dependensi dan menggunakan an ArgumentCaptoruntuk menangkap nilai yang dikembalikan. Sebagai contoh:

ArgumentCaptor<ByteArrayOutputStream> csvOutputCaptor = ArgumentCaptor.forClass(ByteArrayOutputStream.class);
//Do your thing..
verify(this.awsService).uploadFile(csvOutputCaptor.capture());
....
assertEquals(csvOutputCaptor.getValue().toString(), "blabla");