Mockito Spy dan Suntikan Ketergantungan: Selesaikan Masalah bahawa kaedah tidak memanggil nilai mengejek dalam ujian

Artikel ini membincangkan masalah biasa apabila menggunakan fungsi pengintip Mockito untuk mensimulasikan kaedah kelas sebahagian, nilai simulasi tidak berkuatkuasa. Alasan teras ialah kod pengeluaran secara langsung meneliti objek yang diuji, yang menyebabkan contoh mata -mata yang dibuat dalam ujian yang akan digunakan. Artikel ini menghuraikan bagaimana menyelesaikan masalah ini melalui suntikan ketergantungan, corak reka bentuk, dan menyediakan contoh kod dan pertimbangan khusus untuk membantu pemaju melakukan ujian unit dengan lebih berkesan.

Analisis Masalah: Perisik Mockito bercanggah dengan Instantiation Langsung

Apabila menggunakan Mockito untuk ujian unit, fungsi pengintip membolehkan kita mensimulasikan sebahagian objek sebenar, iaitu, kita boleh memanggil kaedah sebenar atau kaedah tertentu. Walau bagaimanapun, perangkap yang sama ialah apabila kod pengeluaran (iaitu kaedah yang diuji) secara langsung mewujudkan contoh objek yang bergantung kepada, contoh mata -mata atau mock yang dibuat untuk objek bergantung dalam ujian tidak akan berkuatkuasa.

Pertimbangkan senario berikut:

Coretan kod pengeluaran asal:

 kelas awam myservice {
    CALLULATEPRICE DOUBLEPRICE () {
        GetOptionBidPrice GetOptionBidPrice = baru GetOptionBidPrice (...); // Masalahnya terletak: secara langsung instantiate double bidPrice = getOptionBidPrice.getBidPrice ();
        // ... logik perniagaan lain menggunakan bidprice
        kembali bidprice * 1.1; // Pengiraan sampel}
}

kelas awam GetOptionBidPrice {
    // ... pembina dan bidang lain GetBidPrice double public () {
        // logik perniagaan sebenar, yang mungkin melibatkan permintaan rangkaian atau pengiraan kompleks pulangan 0.0; // Andaikan bahawa pulangan lalai 0 dikembalikan 0.0
    }
}

Percubaan kod ujian yang sepadan:

 import org.junit.jupiter.api.test;
import org.mockito.mockito;
import statik org.mockito.mockito.doreturn;
import statik org.mockito.mockito.spy;
import statik org.junit.jupiter.api.assertions.assertequals;

kelas awam myservicetest {

    @Test
    void testCalculatePriceWithSpy () {
        // cuba mengintip getOptionbidprice
        GetOptionBidPrice SpyGetOptionBidPrice = spy (getOptionBidPrice.class);
        DORETURN (100.0) .When (SpyGetOptionBidPrice) .GetBIBPrice (); // bertumpu kaedah getbidprice // buat contoh myservice dan panggil myservice myservice = myservice baru ();
        hasil berganda = myservice.calculatePrice (); // Di sini, contoh GetOptionBidPrice baru masih dicipta secara dalaman // hasil yang diharapkan adalah berdasarkan 100.0 tumpukan, tetapi sebenarnya mungkin berdasarkan nilai pulangan sebenar GetOptionBidPrice 0.0
        // AssertEquals (110.0, hasil); // mengharapkan nilai}
}

Dalam contoh ini, walaupun kami mencipta SpyGetOptionBidPrice dalam ujian dan menumpuk kaedah getBidPrice (), kaedah MyService ClassPrice () secara dalaman mencipta contoh baru GetOptionBidPrice melalui GetOptionBidPrice baru (...). Contoh baru ini sepenuhnya bebas daripada contoh pengintip yang dibuat dalam ujian, jadi kaedah CalculatePrice () memanggil kaedah getBidPrice () contoh sebenar, dan bukannya kaedah yang ditimbun pada contoh mata -mata, mengakibatkan nilai simulasi 100.0 tidak berkuatkuasa, tetapi memperoleh 0.0 yang dikembalikan oleh kaedah sebenar.

Penyelesaian: Memperkenalkan suntikan ketergantungan

Idea utama menyelesaikan masalah di atas bukan untuk membiarkan kelas yang diuji (MyService) secara langsung membuat contoh pergantungannya (GetOptionBidPrice) secara dalaman. Sebaliknya, objek ketergantungan harus "disuntik" ke dalam kelas yang diuji dalam beberapa cara. Corak reka bentuk ini dipanggil suntikan ketergantungan (DI) .

Melalui suntikan pergantungan, kita boleh menyuntik objek ketergantungan sebenar ke dalam kod pengeluaran dan mata -mata atau objek mengejek ke dalam kod ujian untuk mencapai kawalan ke atas tingkah laku ketergantungan.

Kod Pengeluaran Refactored:

 kelas awam myservice {
    Final Private GetOptionBidPrice GetOptionBidPrice; // mengisytiharkan kebergantungan sebagai pemboleh ubah ahli // menyuntik kebergantungan melalui pembina awam myservice (getOptionbidprice getOptionbidPrice) {
        this.getOptionBidPrice = getOptionBidPrice;
    }

    CALLULATEPRICE DOUBLEPRICE () {
        double bidPrice = getOptionBidPrice.getBidPrice (); // Panggil contoh ketergantungan yang disuntik // ... logik perniagaan lain menggunakan bidprice
        kembali bidprice * 1.1;
    }
}

// Kelas GetOptionBidPrice tetap tidak berubah kelas awam GetOptionBidPrice {
    // ... pembina dan bidang lain GetBidPrice double public () {
        pulangan 0.0;
    }
}

Kod Ujian Refactored:

 import org.junit.jupiter.api.test;
import org.mockito.mockito;
import statik org.mockito.mockito.doreturn;
import statik org.mockito.mockito.spy;
import statik org.junit.jupiter.api.assertions.assertequals;

kelas awam myservicetest {

    @Test
    void testCalculatePriceWithInjectedSpy () {
        // cipta dan cerucuk spy instance getOptionbidPrice spygetOptionBidPrice = spy (getOptionBidPrice.class);
        DORETURN (100.0) .When (SpyGetOptionBidPrice) .GetBIBPrice ();

        // Inject Spy Instance ke myservice myservice myservice = myservice baru (spygetOptionbidPrice);
        hasil berganda = myservice.calculatePrice ();

        // Sekarang, CaltulatePrice akan memanggil kaedah getBidPrice () dari contoh -contoh yang disuntikkan sebagai AssertEquals (110.0, hasil, "hasil pengiraan harus berdasarkan bidprice bertumpuk");
        // Sahkan sama ada kaedah getBidPrice dipanggil mockito.verify (spyGetOptionBidPrice) .getBidPrice ();
    }

    // Cara Menggunakan Myservice dalam Kod Pengeluaran
    public static void main (string [] args) {
        // Dalam persekitaran pengeluaran, suntikan contoh sebenar getOptionbidPrice getOptionBidPrice RealGetOptionBidPrice = getOptionBidPrice baru (/* parameter sebenar*/);
        MyService RealMyService = Myservice baru (RealGetOptionBidPrice);
        Double ProductionResult = RealMyService.CalCulatePrice ();
        System.out.println ("Hasil Pengiraan Persekitaran Pengeluaran:" ProductionResult);
    }
}

Melalui suntikan pembina (salah satu cara suntikan ketergantungan yang paling biasa), MyService tidak lagi bertanggungjawab untuk membuat contoh GetOptionBidPrice, tetapi disediakan secara luaran. Dalam ujian, kami menyediakan contoh mata -mata; Dalam persekitaran pengeluaran, kami menyediakan contoh yang nyata. Dengan cara ini, ujian itu dapat mengawal kelakuan getOptionbidprice yang bergantung kepada MyService.

Nota dan ringkasan

1. Kepentingan suntikan ketergantungan: Suntikan ketergantungan bukan sahaja menyelesaikan masalah simulasi dalam ujian, tetapi juga merupakan prinsip teras dalam reka bentuk perisian moden. Ia meningkatkan modulariti, kesesuaian, kebolehpercayaan dan skalabiliti kod. Apabila kelas perlu bergantung pada kelas lain, lebih suka menyuntik kebergantungan ini melalui pembina, kaedah setter, atau antara muka dan bukannya secara langsung membuatnya di dalam kelas.
2. Pemilihan pengintip dan mengejek:
   • Mock: Ia biasanya digunakan untuk mensimulasikan sepenuhnya antara muka atau kelas. Semua kaedah sistem tidak melakukan logik sebenar secara lalai dan perlu ditumpuk secara eksplisit. Sesuai untuk senario di mana unit ujian sepenuhnya diasingkan dari luar.
   • SPY: Digunakan untuk mensimulasikan sebahagian objek sebenar, dan kaedah yang tidak terkawal akan melakukan logik sebenar. Sesuai untuk senario di mana kebanyakan fungsi objek sebenar perlu diuji dan hanya mengawal beberapa kaedah yang sukar untuk diuji atau memakan masa.
   • Adalah sesuai untuk menggunakan pengintip dalam kes ini kerana kami mahu kebanyakan tingkah laku GetOptionBidPrice untuk kekal tidak berubah dan hanya menumpuk kaedah GetBidPrice ().
3. Granularity ujian: Ujian unit harus memberi tumpuan kepada tingkah laku unit tunggal (biasanya kelas atau kaedah) dan mengasingkan kebergantungannya. Dengan mengejek atau mengintip kebergantungan, kita dapat memastikan fokus ujian terhad kepada unit yang diuji sendiri, mengelakkan faktor luaran yang mengganggu keputusan ujian.
4. Elakkan mewujudkan kebergantungan di dalam kaedah yang diuji: ini adalah anti-corak biasa yang menjadikan ujian unit sukar. Sekiranya kaedah mewujudkan kebergantungan yang kompleks secara dalaman, kaedah ini sukar untuk diuji secara berasingan kerana ia ditambah dengan ketergantungan yang dibuatnya.
5. Tingkah laku pengesahan: Selepas menggunakan mata -mata atau mengejek, selain mengesahkan nilai pulangan, mockito.verify () juga harus digunakan untuk mengesahkan sama ada kaedah pada objek mengejek dipanggil dengan betul, dan sama ada bilangan panggilan dan parameter seperti yang diharapkan.

Dengan mengamalkan corak suntikan pergantungan dan memahami bagaimana kerja -kerja Mockito Spy, pemaju boleh membina lebih mantap dan mudah untuk menguji aplikasi.

Atas ialah kandungan terperinci Mockito Spy dan Suntikan Ketergantungan: Selesaikan Masalah bahawa kaedah tidak memanggil nilai mengejek dalam ujian. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!