Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi · Pelajaran

Memerhati Objek Sebenar

Temui cara menggunakan spy Mockito untuk melakukan mock separa terhadap objek sebenar, memanggil kaedah sebenar sambil mengesahkan interaksi.

Pelajaran 3 daripada 411 langkah

Memerhati Objek Sebenar ialah pelajaran Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi merangkumi sejumlah 4 pelajaran.

Apakah Objek Intipan Mockito?

Dalam Mockito, anda telah mempelajari cara mencipta olokan untuk mengawal tingkah laku objek sepenuhnya. Tetapi bagaimana jika anda hanya mahu mengubah beberapa kaedah sambil mengekalkan tingkah laku asal bagi kaedah yang lain?

Di sinilah objek intipan berguna! Objek intipan membalut objek sebenar, lalu membolehkan anda:

Memanggil kaedah sebenar objek secara lalai.
Mengatasi (menetapkan tingkah laku) kaedah tertentu supaya mengembalikan nilai yang telah ditentukan.
Mengesahkan interaksi dengan objek sebenar.

Anggaplah ia sebagai 'olokan separa' – menggunakan objek sebenar, tetapi dengan beberapa pelarasan.

Mencipta Objek Intipan Pertama Anda

Mencipta objek intipan adalah mudah. Sebagai ganti Mockito.mock(), anda menggunakan Mockito.spy() dan menghantar tika objek sebenar yang ingin anda intip.

Mari kita takrifkan kelas DataService yang ringkas untuk contoh kita. Perkhidmatan ini akan melaksanakan beberapa operasi.

import org.mockito.Mockito;

public class DataService {
    public String fetchData(String id) {
        return "Real data for " + id;
    }

    public int processData(String data) {
        return data.length();
    }
}

public class Main {
    public static void main(String[] args) {
        DataService realService = new DataService();
        DataService spyService = Mockito.spy(realService);

        System.out.println("Spy created successfully!");
    }
}

Objek Intipan Memanggil Kaedah Sebenar

Ciri utama objek intipan ialah, secara lalai, ia akan memanggil kaedah sebenar objek yang dibalutnya. Ini berbeza daripada olokan, yang tidak mempunyai pelaksanaan sebenar dan mengembalikan nilai lalai.

Mari lihat spyService kita memanggil kaedah sebenar:

import org.mockito.Mockito;

public class DataService {
    public String fetchData(String id) {
        System.out.println("--- Calling REAL fetchData for ID: " + id + " ---");
        return "Real data for " + id;
    }

    public int processData(String data) {
        return data.length();
    }
}

public class Main {
    public static void main(String[] args) {
        DataService realService = new DataService();
        DataService spyService = Mockito.spy(realService);

        String result = spyService.fetchData("123");
        System.out.println("Result from spy: " + result);

        int processed = spyService.processData("Hello");
        System.out.println("Processed data length: " + processed);
    }
}

Menetapkan Tingkah Laku Objek Intipan: Mengatasi Tingkah Laku

Walaupun objek intipan memanggil kaedah sebenar secara lalai, anda masih boleh menetapkan tingkah lakunya supaya mengembalikan nilai tertentu atau melontarkan pengecualian, sama seperti olokan. Ini membolehkan anda mengawal sebahagian tingkah laku objek.

Walau bagaimanapun, apabila menetapkan tingkah laku objek intipan, biasanya lebih selamat menggunakan sintaks doReturn().when():

Mockito.when(spy.method()).thenReturn(value) mungkin melaksanakan kaedah sebenar terlebih dahulu jika kaedah itu dipanggil semasa bahagian when().
Mockito.doReturn(value).when(spy).method() mengelakkan pemanggilan kaedah sebenar semasa penetapan tingkah laku, yang amat penting jika kaedah sebenar mempunyai kesan sampingan atau melontarkan pengecualian.

Menetapkan Tingkah Laku Objek Intipan dalam Tindakan

Mari kita tetapkan tingkah laku kaedah fetchData milik spyService supaya mengembalikan nilai tersuai untuk ID tertentu, manakala panggilan lain masih menggunakan kaedah sebenar:

import org.mockito.Mockito;

public class DataService {
    public String fetchData(String id) {
        System.out.println("--- Calling REAL fetchData for ID: " + id + " ---");
        return "Real data for " + id;
    }

    public int processData(String data) {
        return data.length();
    }
}

public class Main {
    public static void main(String[] args) {
        DataService realService = new DataService();
        DataService spyService = Mockito.spy(realService);

        // Stubbing the spy for a specific input
        Mockito.doReturn("Mocked data for specific ID")
               .when(spyService)
               .fetchData("specialId");

        // This call will return the mocked data
        String result1 = spyService.fetchData("specialId");
        System.out.println("Result for specialId: " + result1);

        // This call will go to the real method
        String result2 = spyService.fetchData("regularId");
        System.out.println("Result for regularId: " + result2);
    }
}

Mengesahkan Interaksi Objek Intipan

Sama seperti olokan, anda boleh menggunakan Mockito.verify() untuk memastikan kaedah tertentu dipanggil pada objek intipan anda. Ini berkuasa untuk mengesahkan bahawa kod anda berinteraksi dengan objek sebenar seperti yang dijangka.

verify() berfungsi dengan cara yang sama untuk objek intipan seperti untuk olokan. Anda boleh menyemak:

Sama ada sesuatu kaedah dipanggil.
Berapa kali kaedah itu dipanggil.
Dengan argumen apakah kaedah itu dipanggil.

Contoh Pengesahan Panggilan Objek Intipan

Mari kita sahkan bahawa kaedah fetchData dipanggil pada objek intipan, walaupun ia melaksanakan pelaksanaan sebenar:

import org.mockito.Mockito;

public class DataService {
    public String fetchData(String id) {
        System.out.println("--- Calling REAL fetchData for ID: " + id + " ---");
        return "Real data for " + id;
    }

    public int processData(String data) {
        return data.length();
    }
}

public class Main {
    public static void main(String[] args) {
        DataService realService = new DataService();
        DataService spyService = Mockito.spy(realService);

        // Call a method on the spy (it will execute the real method)
        spyService.fetchData("user1");
        spyService.processData("data1");
        spyService.fetchData("user2");

        // Verify interactions
        Mockito.verify(spyService).fetchData("user1");
        Mockito.verify(spyService, Mockito.times(2)).fetchData(Mockito.anyString());
        Mockito.verify(spyService).processData("data1");

        System.out.println("Verification successful!");
    }
}

Objek Intipan berbanding Olokan: Perbezaan Utama

Amat penting untuk memahami bila hendak menggunakan objek intipan berbanding olokan tradisional:

Olokan: Mencipta objek palsu sepenuhnya. Semua kaedah adalah 'kosong' dan mengembalikan nilai lalai kecuali anda menetapkan tingkah lakunya secara jelas. Sesuai untuk mengasingkan unit yang sedang diuji.
Objek intipan: Membalut objek sebenar. Semua kaedah melaksanakan pelaksanaan sebenar masing-masing kecuali anda menetapkan tingkah lakunya secara jelas. Berguna apabila anda mahu menggunakan kebanyakan tingkah laku objek sebenar tetapi mengawal beberapa interaksi tertentu.

Utamakan olokan untuk pengasingan unit yang sebenar. Gunakan objek intipan apabila berurusan dengan objek kompleks yang hanya memerlukan kawalan terhadap beberapa kaedah tertentu, atau untuk kod legasi.

Bila Hendak Menggunakan Objek Intipan

Objek intipan amat berguna dalam senario apabila:

Anda menguji kelas yang berinteraksi dengan kebergantungan kompleks dan hanya perlu mengatasi sebahagian kecil tingkah laku kebergantungan tersebut.
Anda mempunyai kelas legasi dengan banyak kaedah dan penciptaan olokan penuh akan menyusahkan, tetapi anda perlu memastikan beberapa kaedah dipanggil atau mengembalikan nilai tertentu.
Anda mahu menguji tingkah laku separa objek sebenar tanpa menggantikannya sepenuhnya.

Walau bagaimanapun, gunakannya secara berhemat. Kebergantungan yang berlebihan pada objek intipan boleh menghasilkan pengujian yang kurang terasing dan lebih sukar diselenggara.

Semakan Ringkas: Tingkah Laku Objek Intipan

Pertimbangkan kelas Logger dengan kaedah log(String message) yang mencetak ke konsol. Jika anda mengintip objek new Logger(), apakah yang berlaku apabila anda memanggil spyLogger.log("Test") tanpa sebarang penetapan tingkah laku?

Jawab dalam pelajaran interaktif

Imbas Kembali: Mengintip Objek Sebenar

Anda telah berjaya mempelajari tentang objek intipan Mockito!

Objek intipan membalut objek sebenar, lalu membolehkan anda menggunakan kaedah sebenar objek tersebut secara lalai.
Anda menciptanya dengan Mockito.spy(realObject).
Anda boleh menetapkan tingkah laku kaedah tertentu menggunakan doReturn().when(spy).method() untuk mengatasi tingkah lakunya.
Anda boleh mengesahkan interaksi pada objek intipan menggunakan Mockito.verify(), sama seperti dengan olokan.
Gunakan objek intipan dengan berhati-hati, terutamanya apabila kawalan separa terhadap objek sebenar diperlukan, bukannya pengasingan penuh.

Fleksibiliti ini membantu anda menulis pengujian yang lebih terarah untuk senario kompleks.

Percuma untuk bermula

Pelajari Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Memerhati Objek Sebenar” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi, termasuk “Memerhati Objek Sebenar”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Memerhati Objek Sebenar”?

Temui cara menggunakan spy Mockito untuk melakukan mock separa terhadap objek sebenar, memanggil kaedah sebenar sambil mengesahkan interaksi. Anda berlatih Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Memerhati Objek Sebenar” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi ini?

Ya. Setiap pelajaran Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Menetapkan Nilai Pulangan
Pemadan Argumen Mockito
Memerhati Objek Sebenar
Melontar Pengecualian dan Panggilan Berturutan

← Kembali ke Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi