Bagaimana cara menguji fungsi pribadi atau kelas yang memiliki metode pribadi, bidang atau kelas dalam?

Bagaimana cara saya menguji unit (menggunakan xUnit) kelas yang memiliki metode privat internal, bidang atau kelas bersarang? Atau fungsi yang dibuat pribadi dengan memiliki tautan internal ( staticdalam C / C ++) atau dalam namespace pribadi ( anonim )?

Tampaknya buruk untuk mengubah pengubah akses untuk suatu metode atau fungsi hanya untuk dapat menjalankan tes.

Memperbarui:

Beberapa 10 tahun kemudian mungkin cara terbaik untuk menguji metode pribadi, atau anggota tidak dapat diakses, adalah melalui @Jailbreakdari Manifold kerangka.

@Jailbreak Foo foo = new Foo();
// Direct, *type-safe* access to *all* foo's members
foo.privateMethod(x, y, z);
foo.privateField = value;

Dengan cara ini kode Anda tetap aman dan mudah dibaca. Tidak ada kompromi desain, tidak ada metode dan bidang overexposing demi pengujian.

Jika Anda memiliki sedikit aplikasi Java lawas , dan Anda tidak diizinkan untuk mengubah visibilitas metode Anda, cara terbaik untuk menguji metode pribadi adalah dengan menggunakan refleksi .

Secara internal kami menggunakan bantuan untuk mendapatkan / mengatur privatedan private staticvariabel serta memohon privatedan private staticmetode. Pola-pola berikut akan memungkinkan Anda melakukan hampir semua hal yang berhubungan dengan metode dan bidang pribadi. Tentu saja, Anda tidak dapat mengubah private static finalvariabel melalui refleksi.

Method method = TargetClass.getDeclaredMethod(methodName, argClasses);
method.setAccessible(true);
return method.invoke(targetObject, argObjects);

Dan untuk bidang:

Field field = TargetClass.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);

Catatan:
1. TargetClass.getDeclaredMethod(methodName, argClasses)memungkinkan Anda melihat privatemetode. Hal yang sama berlaku untuk getDeclaredField.
2. setAccessible(true)Diperlukan untuk bermain-main dengan prajurit.

Cara terbaik untuk menguji metode pribadi adalah melalui metode publik lainnya. Jika ini tidak dapat dilakukan, maka salah satu dari kondisi berikut ini benar:

1. Metode pribadi adalah kode mati
2. Ada bau desain di dekat kelas yang Anda uji
3. Metode yang Anda coba uji tidak boleh bersifat pribadi

Ketika saya memiliki metode pribadi di kelas yang cukup rumit sehingga saya merasa perlu untuk menguji metode pribadi secara langsung, itu adalah bau kode: kelas saya terlalu rumit.

Pendekatan saya yang biasa untuk mengatasi masalah seperti itu adalah untuk menggoda kelas baru yang berisi bit-bit menarik. Seringkali, metode ini dan bidang yang berinteraksi dengannya, dan mungkin satu atau dua metode lain dapat diekstraksi ke kelas baru.

Kelas baru memperlihatkan metode ini sebagai 'publik', sehingga mereka dapat diakses untuk pengujian unit. Kelas-kelas baru dan lama sekarang lebih sederhana daripada kelas asli, yang bagus untuk saya (saya harus menjaga hal-hal sederhana, atau saya tersesat!)

Perhatikan bahwa saya tidak menyarankan agar orang membuat kelas tanpa menggunakan otak mereka! Intinya di sini adalah menggunakan kekuatan pengujian unit untuk membantu Anda menemukan kelas baru yang baik.

Saya telah menggunakan refleksi untuk melakukan ini untuk Jawa di masa lalu, dan menurut saya itu adalah kesalahan besar.

Sebenarnya, Anda tidak boleh menulis unit test yang langsung menguji metode pribadi. Yang harus Anda uji adalah kontrak publik yang dimiliki kelas dengan benda lain; Anda tidak boleh secara langsung menguji internal objek. Jika pengembang lain ingin membuat perubahan internal kecil ke kelas, yang tidak memengaruhi kontrak publik kelas, ia kemudian harus memodifikasi tes berbasis refleksi Anda untuk memastikan bahwa itu berfungsi. Jika Anda melakukan ini berulang kali di seluruh proyek, unit test kemudian berhenti menjadi pengukuran kesehatan kode yang berguna, dan mulai menjadi penghalang bagi pengembangan, dan gangguan pada tim pengembangan.

Apa yang saya sarankan lakukan adalah menggunakan alat cakupan kode seperti Cobertura, untuk memastikan bahwa tes unit yang Anda tulis memberikan cakupan kode yang layak dalam metode pribadi. Dengan begitu, Anda secara tidak langsung menguji apa yang dilakukan metode pribadi, dan mempertahankan tingkat kelincahan yang lebih tinggi.

Dari artikel ini: Menguji Metode Pribadi dengan JUnit dan SuiteRunner (Bill Venners), Anda pada dasarnya memiliki 4 opsi:

1. Jangan menguji metode pribadi.
2. Berikan metode akses paket.
3. Gunakan kelas tes bersarang.
4. Gunakan refleksi.

Umumnya tes unit dimaksudkan untuk menggunakan antarmuka publik dari suatu kelas atau unit. Oleh karena itu, metode pribadi adalah detail implementasi yang tidak Anda harapkan akan diuji secara eksplisit.

Hanya dua contoh di mana saya ingin menguji metode pribadi:

1. Rutin dekripsi - Saya tidak ingin membuatnya terlihat oleh siapa pun hanya untuk kepentingan pengujian, kalau tidak, siapa pun dapat menggunakannya untuk mendekripsi. Tetapi mereka intrinsik dengan kode, rumit, dan perlu selalu bekerja (pengecualian yang jelas adalah refleksi yang dapat digunakan untuk melihat bahkan metode pribadi dalam banyak kasus, ketikaSecurityManager tidak dikonfigurasi untuk mencegah hal ini).
2. Membuat SDK untuk konsumsi masyarakat. Di sini publik mengambil makna yang sepenuhnya berbeda, karena ini adalah kode yang dapat dilihat seluruh dunia (bukan hanya internal aplikasi saya). Saya memasukkan kode ke metode pribadi jika saya tidak ingin pengguna SDK melihatnya - saya tidak melihat ini sebagai kode bau, hanya seperti cara kerja pemrograman SDK. Tapi tentu saja saya masih perlu menguji metode pribadi saya, dan mereka di mana fungsi SDK saya benar-benar hidup.

Saya mengerti ide hanya menguji "kontrak". Tapi saya tidak melihat ada yang bisa menganjurkan sebenarnya tidak menguji kode - jarak tempuh Anda mungkin bervariasi.

Jadi pengorbanan saya melibatkan menyulitkan JUnits dengan refleksi, daripada mengorbankan keamanan & SDK saya.

Metode pribadi disebut dengan metode publik, jadi input untuk metode publik Anda juga harus menguji metode pribadi yang dipanggil oleh metode publik tersebut. Ketika metode publik gagal, maka itu bisa menjadi kegagalan dalam metode pribadi.

Pendekatan lain yang saya gunakan adalah mengubah metode pribadi untuk mengemas pribadi atau dilindungi kemudian melengkapinya dengan penjelasan @VisibleForTesting dari pustaka Google Guava.

Ini akan memberi tahu siapa pun yang menggunakan metode ini untuk berhati-hati dan tidak mengaksesnya langsung bahkan dalam sebuah paket. Juga kelas tes tidak harus dalam paket yang sama secara fisik , tetapi dalam paket yang sama di bawah folder tes .

Misalnya, jika metode yang akan diuji ada src/main/java/mypackage/MyClass.javamaka panggilan uji Anda harus dimasukkan src/test/java/mypackage/MyClassTest.java. Dengan begitu, Anda mendapat akses ke metode tes di kelas tes Anda.

Untuk menguji kode lama dengan kelas besar dan unik, seringkali sangat membantu untuk dapat menguji metode pribadi (atau publik) yang saya tulis saat ini .

Saya menggunakan paket- junitx.util.PrivateAccessor untuk Java. Banyak one-liner bermanfaat untuk mengakses metode pribadi dan bidang pribadi.

import junitx.util.PrivateAccessor;

PrivateAccessor.setField(myObjectReference, "myCrucialButHardToReachPrivateField", myNewValue);
PrivateAccessor.invoke(myObjectReference, "privateMethodName", java.lang.Class[] parameterTypes, java.lang.Object[] args);

Dalam Kerangka Kerja Spring Anda dapat menguji metode pribadi menggunakan metode ini:

ReflectionTestUtils.invokeMethod()

Sebagai contoh:

ReflectionTestUtils.invokeMethod(TestClazz, "createTest", "input data");

Setelah mencoba solusi Cem Catikkas menggunakan refleksi untuk Jawa, saya harus mengatakan bahwa itu adalah solusi yang lebih elegan daripada yang saya jelaskan di sini. Namun, jika Anda mencari alternatif untuk menggunakan refleksi, dan memiliki akses ke sumber yang Anda uji, ini masih akan menjadi pilihan.

Ada kemungkinan manfaat dalam menguji metode privat suatu kelas, khususnya dengan pengembangan berbasis tes , di mana Anda ingin merancang tes kecil sebelum Anda menulis kode apa pun.

Membuat tes dengan akses ke anggota pribadi dan metode dapat menguji area kode yang sulit untuk ditargetkan secara khusus dengan akses hanya ke metode publik. Jika metode publik memiliki beberapa langkah yang terlibat, itu dapat terdiri dari beberapa metode pribadi, yang kemudian dapat diuji secara individual.

Keuntungan:

• Dapat menguji granularity yang lebih halus

Kekurangan:

• Kode uji harus berada dalam file yang sama dengan kode sumber, yang bisa lebih sulit untuk dipelihara
• Demikian pula dengan file output .class, mereka harus tetap dalam paket yang sama seperti yang dinyatakan dalam kode sumber

Namun, jika pengujian terus-menerus memerlukan metode ini, itu mungkin merupakan sinyal bahwa metode pribadi harus diekstraksi, yang dapat diuji dengan cara tradisional dan publik.

Berikut adalah contoh berbelit-belit tentang bagaimana ini akan bekerja:

// Import statements and package declarations

public class ClassToTest
{
    private int decrement(int toDecrement) {
        toDecrement--;
        return toDecrement;
    }

    // Constructor and the rest of the class

    public static class StaticInnerTest extends TestCase
    {
        public StaticInnerTest(){
            super();
        }

        public void testDecrement(){
            int number = 10;
            ClassToTest toTest= new ClassToTest();
            int decremented = toTest.decrement(number);
            assertEquals(9, decremented);
        }

        public static void main(String[] args) {
            junit.textui.TestRunner.run(StaticInnerTest.class);
        }
    }
}

Kelas dalam akan dikompilasi ClassToTest$StaticInnerTest .

Lihat juga: Java Tip 106: Kelas dalam statis untuk kesenangan dan keuntungan

Seperti yang orang lain katakan ... jangan menguji metode pribadi secara langsung. Berikut ini beberapa pemikiran:

1. Jaga agar semua metode tetap kecil dan fokus (mudah diuji, mudah menemukan apa yang salah)
2. Gunakan alat cakupan kode. Saya suka Cobertura (oh selamat hari, sepertinya versi baru sudah keluar!)

Jalankan cakupan kode pada unit test. Jika Anda melihat bahwa metode tidak sepenuhnya diuji tambahkan ke tes untuk mendapatkan cakupan. Bertujuan untuk cakupan kode 100%, tetapi sadarilah bahwa Anda mungkin tidak akan mendapatkannya.

Metode pribadi dikonsumsi oleh yang umum. Kalau tidak, itu kode mati. Itu sebabnya Anda menguji metode publik, menegaskan hasil yang diharapkan dari metode publik dan dengan demikian, metode pribadi yang dikonsumsinya.

Menguji metode pribadi harus diuji dengan men-debug sebelum menjalankan pengujian unit Anda pada metode publik.

Mereka juga dapat didebug menggunakan pengembangan yang digerakkan oleh tes, men-debug tes unit Anda sampai semua pernyataan Anda dipenuhi.

Saya pribadi percaya bahwa lebih baik membuat kelas menggunakan TDD; membuat bertopik metode publik, kemudian menghasilkan unit test dengan semua pernyataan yang ditetapkan sebelumnya, sehingga hasil yang diharapkan dari metode ini ditentukan sebelum Anda mengkodekannya. Dengan cara ini, Anda tidak salah jalan membuat pernyataan pengujian unit cocok dengan hasilnya. Kelas Anda kemudian kuat dan memenuhi persyaratan ketika semua tes unit Anda lulus.

Jika menggunakan Spring, ReflectionTestUtils menyediakan beberapa alat praktis yang membantu di sini dengan upaya minimal. Misalnya, untuk membuat tiruan pada anggota pribadi tanpa dipaksa untuk menambahkan setter publik yang tidak diinginkan:

ReflectionTestUtils.setField(theClass, "theUnsettableField", theMockObject);

Jika Anda mencoba menguji kode yang ada yang enggan atau tidak dapat Anda ubah, refleksi adalah pilihan yang baik.

Jika desain kelas masih fleksibel, dan Anda memiliki metode pribadi yang rumit yang ingin Anda uji secara terpisah, saya sarankan Anda menariknya ke kelas yang terpisah dan menguji kelas itu secara terpisah. Ini tidak harus mengubah antarmuka publik dari kelas asli; itu secara internal dapat membuat instance dari kelas helper dan memanggil metode helper.

Jika Anda ingin menguji kondisi kesalahan yang sulit yang berasal dari metode helper, Anda dapat melangkah lebih jauh. Ekstrak antarmuka dari kelas helper, tambahkan pengambil publik dan setter ke kelas asli untuk menyuntikkan kelas helper (digunakan melalui antarmuka-nya), dan kemudian menyuntikkan versi tiruan dari kelas helper ke dalam kelas asli untuk menguji bagaimana kelas asli menanggapi pengecualian dari helper. Pendekatan ini juga membantu jika Anda ingin menguji kelas asli tanpa juga menguji kelas pembantu.

Menguji metode pribadi merusak enkapsulasi kelas Anda karena setiap kali Anda mengubah implementasi internal Anda melanggar kode klien (dalam hal ini, tes).

Jadi jangan menguji metode pribadi.

Jawaban dari halaman FAQ JUnit.org :

Tetapi jika Anda harus ...

Jika Anda menggunakan JDK 1.3 atau lebih tinggi, Anda dapat menggunakan refleksi untuk menumbangkan mekanisme kontrol akses dengan bantuan PrivilegedAccessor . Untuk detail tentang cara menggunakannya, baca artikel ini .

Jika Anda menggunakan JDK 1.6 atau lebih tinggi dan Anda membuat anotasi tes dengan @Test, Anda dapat menggunakan Dp4j untuk menyuntikkan refleksi dalam metode pengujian Anda. Untuk detail tentang cara menggunakannya, lihat skrip pengujian ini .

PS Saya kontributor utama untuk Dp4j , tanyakan kepada saya jika Anda membutuhkan bantuan. :)

Jika Anda ingin menguji metode pribadi dari aplikasi lawas di mana Anda tidak dapat mengubah kode, satu opsi untuk Java adalah jMockit , yang akan memungkinkan Anda untuk membuat tiruan ke objek bahkan ketika mereka pribadi ke kelas.

Saya cenderung tidak menguji metode pribadi. Disinilah letak kegilaan. Secara pribadi, saya percaya Anda hanya harus menguji antarmuka Anda yang terbuka untuk umum (dan itu termasuk metode yang dilindungi dan internal).

Jika Anda menggunakan JUnit, lihatlah junit-addons . Ini memiliki kemampuan untuk mengabaikan model keamanan Java dan mengakses metode dan atribut pribadi.

Saya sarankan Anda sedikit refactoring kode Anda. Ketika Anda harus mulai berpikir tentang menggunakan refleksi atau hal-hal lain, untuk hanya menguji kode Anda, ada yang salah dengan kode Anda.

Anda menyebutkan berbagai jenis masalah. Mari kita mulai dengan bidang pribadi. Dalam kasus bidang pribadi saya akan menambahkan konstruktor baru dan menyuntikkan bidang ke dalamnya. Alih-alih ini:

public class ClassToTest {

    private final String first = "first";
    private final List<String> second = new ArrayList<>();
    ...
}

Saya akan menggunakan ini:

public class ClassToTest {

    private final String first;
    private final List<String> second;

    public ClassToTest() {
        this("first", new ArrayList<>());
    }

    public ClassToTest(final String first, final List<String> second) {
        this.first = first;
        this.second = second;
    }
    ...
}

Ini tidak akan menjadi masalah bahkan dengan beberapa kode lawas. Kode lama akan menggunakan konstruktor kosong, dan jika Anda bertanya kepada saya, kode refactored akan terlihat lebih bersih, dan Anda akan dapat menyuntikkan nilai yang diperlukan dalam pengujian tanpa refleksi.

Sekarang tentang metode pribadi. Dalam pengalaman pribadi saya ketika Anda harus mematikan metode pribadi untuk pengujian, maka metode itu tidak ada hubungannya di kelas itu. Pola umum, dalam hal ini, adalah membungkusnya dalam sebuah antarmuka, seperti Callabledan kemudian Anda memasukkan antarmuka itu juga dalam konstruktor (dengan beberapa trik konstruktor):

public ClassToTest() {
    this(...);
}

public ClassToTest(final Callable<T> privateMethodLogic) {
    this.privateMethodLogic = privateMethodLogic;
}

Kebanyakan yang saya tulis sepertinya merupakan pola injeksi ketergantungan. Dalam pengalaman pribadi saya, ini sangat berguna saat pengujian, dan saya pikir kode semacam ini lebih bersih dan lebih mudah dirawat. Saya akan mengatakan hal yang sama tentang kelas bersarang. Jika kelas bersarang mengandung logika berat, akan lebih baik jika Anda memindahkannya sebagai paket kelas privat dan telah menyuntikkannya ke kelas yang membutuhkannya.

Ada juga beberapa pola desain lain yang telah saya gunakan saat refactoring dan mempertahankan kode lama, tetapi semuanya tergantung pada kasus kode Anda untuk diuji. Menggunakan refleksi sebagian besar bukan masalah, tetapi ketika Anda memiliki aplikasi perusahaan yang sangat diuji dan tes dijalankan sebelum setiap penyebaran semuanya menjadi sangat lambat (itu hanya mengganggu dan saya tidak suka hal-hal semacam itu).

Ada juga injeksi setter, tetapi saya tidak akan merekomendasikan menggunakannya. Saya lebih baik tetap dengan konstruktor dan menginisialisasi semuanya ketika itu benar-benar diperlukan, meninggalkan kemungkinan untuk menyuntikkan dependensi yang diperlukan.

Metode pribadi hanya dapat diakses dalam kelas yang sama. Jadi tidak ada cara untuk menguji metode "pribadi" dari kelas target dari kelas tes mana pun. Jalan keluarnya adalah Anda dapat melakukan pengujian unit secara manual atau dapat mengubah metode Anda dari "pribadi" menjadi "dilindungi".

Dan kemudian metode yang dilindungi hanya dapat diakses dalam paket yang sama di mana kelas didefinisikan. Jadi, menguji metode yang dilindungi dari kelas target berarti kami perlu mendefinisikan kelas uji Anda dalam paket yang sama dengan kelas target.

Jika semua hal di atas tidak sesuai dengan kebutuhan Anda, gunakan cara refleksi untuk mengakses metode pribadi.

Seperti yang banyak disarankan di atas, cara yang baik adalah mengujinya melalui antarmuka publik Anda.

Jika Anda melakukan ini, sebaiknya gunakan alat jangkauan kode (seperti Emma) untuk melihat apakah metode pribadi Anda sebenarnya dieksekusi dari pengujian Anda.

Inilah fungsi generik saya untuk menguji bidang pribadi:

protected <F> F getPrivateField(String fieldName, Object obj)
    throws NoSuchFieldException, IllegalAccessException {
    Field field =
        obj.getClass().getDeclaredField(fieldName);

    field.setAccessible(true);
    return (F)field.get(obj);
}

Silakan lihat di bawah untuk contoh;

Pernyataan impor berikut harus ditambahkan:

import org.powermock.reflect.Whitebox;

Sekarang Anda dapat langsung melewati objek yang memiliki metode pribadi, nama metode untuk dipanggil, dan parameter tambahan seperti di bawah ini.

Whitebox.invokeMethod(obj, "privateMethod", "param1");

Hari ini, saya mendorong perpustakaan Java untuk membantu menguji metode dan bidang pribadi. Ini telah dirancang dengan mempertimbangkan Android, tetapi benar-benar dapat digunakan untuk proyek Java apa pun.

Jika Anda mendapatkan kode dengan metode atau bidang atau konstruktor pribadi, Anda bisa menggunakan BoundBox . Itu tidak persis apa yang Anda cari. Di bawah ini adalah contoh dari tes yang mengakses dua bidang pribadi dari aktivitas Android untuk mengujinya:

@UiThreadTest
public void testCompute() {

    // Given
    boundBoxOfMainActivity = new BoundBoxOfMainActivity(getActivity());

    // When
    boundBoxOfMainActivity.boundBox_getButtonMain().performClick();

    // Then
    assertEquals("42", boundBoxOfMainActivity.boundBox_getTextViewMain().getText());
}

BoundBox memudahkan untuk menguji bidang, metode, dan konstruktor pribadi / yang dilindungi. Anda bahkan dapat mengakses hal-hal yang disembunyikan oleh warisan. Memang, BoundBox memecah enkapsulasi. Ini akan memberi Anda akses ke semua itu melalui refleksi, TETAPI semuanya diperiksa pada waktu kompilasi.

Ini sangat ideal untuk menguji beberapa kode lama. Gunakan dengan hati-hati. ;)

https://github.com/stephanenicolas/boundbox

Pertama, saya akan mengajukan pertanyaan ini: Mengapa anggota pribadi Anda perlu pengujian terisolasi? Apakah mereka begitu kompleks, memberikan perilaku yang rumit sehingga memerlukan pengujian terpisah dari permukaan publik? Ini unit testing, bukan pengujian 'line-of-code'. Jangan memusingkan hal-hal kecil.

Jika mereka sebesar itu, cukup besar sehingga anggota pribadi ini masing-masing merupakan 'unit' besar dalam kompleksitas - pertimbangkan untuk melakukan refactoring terhadap anggota pribadi seperti itu dari kelas ini.

Jika refactoring tidak sesuai atau tidak layak, dapatkah Anda menggunakan pola strategi untuk menggantikan akses ke fungsi anggota / kelas anggota privat ini saat diuji unit? Di bawah unit test, strategi akan memberikan validasi tambahan, tetapi dalam rilis rilis itu akan menjadi langkah sederhana.

Saya baru-baru ini memiliki masalah ini dan menulis sebuah alat kecil, yang disebut Picklock , yang menghindari masalah secara eksplisit menggunakan API refleksi Java, dua contoh:

Metode panggilan, misalnya private void method(String s)- dengan refleksi Java

Method method = targetClass.getDeclaredMethod("method", String.class);
method.setAccessible(true);
return method.invoke(targetObject, "mystring");

Metode panggilan, misalnya private void method(String s)- oleh Picklock

interface Accessible {
  void method(String s);
}

...
Accessible a = ObjectAccess.unlock(targetObject).features(Accessible.class);
a.method("mystring");

Pengaturan bidang, misalnya private BigInteger amount;- oleh refleksi Jawa

Field field = targetClass.getDeclaredField("amount");
field.setAccessible(true);
field.set(object, BigInteger.valueOf(42));

Pengaturan bidang, misalnya private BigInteger amount;- oleh Picklock

interface Accessible {
  void setAmount(BigInteger amount);
}

...
Accessible a = ObjectAccess.unlock(targetObject).features(Accessible.class);
a.setAmount(BigInteger.valueOf(42));

PowerMockito dibuat untuk ini. Gunakan ketergantungan pakar

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-mockito-release-full</artifactId>
    <version>1.6.4</version>
</dependency>

Maka Anda bisa melakukannya

import org.powermock.reflect.Whitebox;
...
MyClass sut = new MyClass();
SomeType rval = Whitebox.invokeMethod(sut, "myPrivateMethod", params, moreParams);