Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi · Pelajaran

Kitar Hayat dan Susunan Ujian

Kawal susunan pelaksanaan ujian dan urus persediaan serta pembersihan ujian menggunakan anotasi kitar hayat lanjutan.

Pelajaran 1 daripada 411 langkah

Kitar Hayat dan Susunan Ujian ialah pelajaran Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi percuma di CoddyKit. Ini ialah pelajaran 1 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.

Pengenalan Kitar Hayat Ujian JUnit

Selamat datang! Dalam pelajaran ini, kita akan mendalami ciri lanjutan JUnit 5 untuk mengawal cara ujian anda dijalankan. Memahami kitar hayat ujian penting untuk mengurus sumber serta memastikan persediaan dan pembersihan ujian dilakukan dengan betul.

Kitar hayat mentakrifkan urutan tindakan yang diambil oleh JUnit sebelum dan selepas kaedah serta kelas ujian anda.

Persediaan Peringkat Kelas: @BeforeAll

Kadangkala, anda perlu melakukan operasi persediaan sekali sahaja untuk semua ujian dalam kelas ujian tertentu. Anotasi @BeforeAll menandakan kaedah yang akan dijalankan sebelum sebarang kaedah ujian dalam kelas tersebut.

Secara lalai, kaedah @BeforeAll mestilah static. Kita akan melihat cara mengubahnya tidak lama lagi!

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class BeforeAllDemo {
    private static StringBuilder log = new StringBuilder();

    @BeforeAll
    static void setupOnce() {
        log.append("-> @BeforeAll: Setup done once.\n");
        System.out.println("Setup for all tests.");
    }

    @Test
    void testA() {
        log.append("  -> @Test: Running testA.\n");
        System.out.println("  Running testA.");
        assertTrue(true);
    }

    @Test
    void testB() {
        log.append("  -> @Test: Running testB.\n");
        System.out.println("  Running testB.");
        assertTrue(true);
    }
    // The log output would typically be verified in @AfterAll or debugger.
}

Pembersihan Peringkat Kelas: @AfterAll

Begitu juga, anda mungkin perlu membersihkan sumber sekali sahaja selepas semua ujian dalam kelas selesai. Anotasi @AfterAll menandakan kaedah yang akan dijalankan selepas semua kaedah ujian dalam kelas tersebut.

Seperti @BeforeAll, kaedah ini mestilah static secara lalai.

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class AfterAllDemo {
    private static StringBuilder log = new StringBuilder();

    @BeforeAll
    static void setup() {
        log.append("-> @BeforeAll: Setup for AfterAllDemo.\n");
    }

    @Test
    void testOne() {
        log.append("  -> @Test: Running testOne.\n");
        assertTrue(true);
    }

    @Test
    void testTwo() {
        log.append("  -> @Test: Running testTwo.\n");
        assertTrue(true);
    }

    @AfterAll
    static void teardown() {
        log.append("-> @AfterAll: Teardown for AfterAllDemo.\n");
        System.out.println("--- Execution Log ---");
        System.out.println(log.toString()); // See the full order
        System.out.println("--- End Log ---");
    }
}

Kitar Hayat @TestInstance: PER_CLASS

Secara lalai, JUnit mencipta instans baharu bagi kelas ujian anda untuk setiap kaedah ujian (Lifecycle.PER_METHOD). Ini memastikan pengasingan ujian.

Jika anda memerlukan kaedah @BeforeAll dan @AfterAll bukan statik, atau mahu berkongsi keadaan merentas semua ujian dalam kelas, anda boleh menukar kitar hayat instans ujian kepada Lifecycle.PER_CLASS.

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.TestInstance.Lifecycle;
import static org.junit.jupiter.api.Assertions.assertEquals;

@TestInstance(Lifecycle.PER_CLASS) // Allows non-static @BeforeAll/@AfterAll
public class PerClassLifecycleDemo {
    private int counter = 0; // Instance variable, shared across tests

    @BeforeAll // No longer needs to be static!
    void setupPerClass() {
        counter = 10; 
        System.out.println("-> @BeforeAll (PER_CLASS). Counter: " + counter);
    }

    @Test
    void testIncrementOne() {
        counter++;
        System.out.println("  -> @Test 1. Counter: " + counter);
        assertEquals(11, counter); // Shared state is modified
    }

    @Test
    void testIncrementTwo() {
        counter++;
        System.out.println("  -> @Test 2. Counter: " + counter);
        assertEquals(12, counter); // Counter continues from previous test
    }

    @AfterAll // No longer needs to be static!
    void teardownPerClass() {
        System.out.println("-> @AfterAll (PER_CLASS). Final Counter: " + counter);
    }
}

Susunan Ujian: Bila Perlu Digunakan

Idealnya, ujian JUnit hendaklah bebas dan berjalan dengan betul dalam apa-apa susunan. Bergantung pada susunan tertentu boleh menjadikan ujian anda rapuh dan lebih sukar diselenggara.

Namun begitu, terdapat situasi tertentu yang menjadikan susunan eksplisit berguna:

Menguji aliran kerja kompleks yang mempunyai langkah berjujukan dan jelas.
Mengoptimumkan prestasi dengan mengumpulkan ujian pantas atau ujian yang menggunakan persediaan mahal yang dikongsi.
Bekerja dengan sistem legasi yang memerlukan urutan interaksi tertentu.

Anotasi @TestMethodOrder

Untuk mentakrifkan susunan pelaksanaan bagi kaedah ujian dalam kelas, gunakan anotasi @TestMethodOrder pada peringkat kelas. Anotasi ini menerima pelaksanaan MethodOrderer sebagai hujah.

JUnit 5 menyediakan beberapa strategi terbina dalam:

Alphanumeric.class: Menyusun berdasarkan nama kaedah mengikut abjad.
OrderAnnotation.class: Menggunakan anotasi @Order.
Random.class: Menjadikan susunan rawak.
DisplayName.class: Menyusun berdasarkan nama paparan kaedah.

Susunan Kaedah Alfanumerik

Mari lihat MethodOrderer.Alphanumeric.class dalam tindakan. JUnit hanya akan menyusun kaedah ujian berdasarkan nama mengikut susunan abjad.

Ini ialah cara mudah untuk mendapatkan susunan yang boleh dijangka jika nama kaedah anda secara semula jadi mengikut urutan.

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.MethodOrderer.Alphanumeric;
import static org.junit.jupiter.api.Assertions.assertTrue;

@TestMethodOrder(Alphanumeric.class) // Tests run A, B, C
public class AlphanumericOrderDemo {

    @Test
    void testA_First() {
        System.out.println("-> Running testA_First");
        assertTrue(true);
    }

    @Test
    void testC_Third() {
        System.out.println("-> Running testC_Third");
        assertTrue(true);
    }

    @Test
    void testB_Second() {
        System.out.println("-> Running testB_Second");
        assertTrue(true);
    }
}

Susunan Tersuai dengan @Order

Untuk kawalan terperinci, gabungkan @TestMethodOrder(MethodOrderer.OrderAnnotation.class) dengan anotasi @Order(value) pada kaedah ujian individu. Nombor value yang lebih kecil bermaksud pelaksanaan yang lebih awal.

Ini membolehkan anda mentakrifkan susunan tersuai yang tepat bagi ujian anda.

import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import static org.junit.jupiter.api.Assertions.assertTrue;

@TestMethodOrder(OrderAnnotation.class) // Activate @Order annotation
public class CustomOrderDemo {

    @Test
    @Order(2) // This test runs second
    void processStepTwo() {
        System.out.println("-> Running processStepTwo");
        assertTrue(true);
    }

    @Test
    @Order(1) // This test runs first
    void initializeSystem() {
        System.out.println("-> Running initializeSystem");
        assertTrue(true);
    }

    @Test
    @Order(3) // This test runs third
    void finalizeReport() {
        System.out.println("-> Running finalizeReport");
        assertTrue(true);
    }
}

Amalan Terbaik untuk Penyusunan

Walaupun berkuasa, penyusunan ujian secara eksplisit hendaklah digunakan dengan berhati-hati:

Utamakan Kebebasan: Setiap ujian sebaik-baiknya boleh berjalan sendiri.
Kebolehbacaan: Penyusunan yang berlebihan boleh menjadikan ujian lebih sukar difahami dan diselenggara.
Beban Penyelenggaraan: Perubahan pada sistem mungkin memerlukan nilai susunan dinilai semula dan dikemas kini.

Gunakan penyusunan hanya apabila terdapat sebab yang kukuh dan munasabah, serta utamakan @Order untuk tujuan yang jelas.

Semakan Kitar Hayat & Susunan

Perhatikan kelas ujian JUnit 5 berikut:

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.assertEquals;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class QuizTest {
    private int sharedValue = 0;

    @BeforeAll
    void setup() {
        sharedValue = 10;
        System.out.println("BeforeAll: sharedValue = " + sharedValue);
    }

    @Test
    @Order(2)
    void testB() {
        sharedValue += 2;
        System.out.println("  TestB: sharedValue = " + sharedValue);
        assertEquals(13, sharedValue);
    }

    @Test
    @Order(1)
    void testA() {
        sharedValue += 1;
        System.out.println("  TestA: sharedValue = " + sharedValue);
        assertEquals(11, sharedValue);
    }

    @AfterAll
    void teardown() {
        System.out.println("AfterAll: sharedValue = " + sharedValue);
    }
}

Apakah nilai akhir sharedValue yang dicetak dalam kaedah @AfterAll?

Jawab dalam pelajaran interaktif

Imbas Kembali: Kitar Hayat & Penyusunan

Dalam pelajaran ini, anda telah menguasai ciri lanjutan JUnit 5 untuk mengawal pelaksanaan ujian:

Kitar Hayat Peringkat Kelas: @BeforeAll dan @AfterAll untuk persediaan serta pembersihan sekali sahaja.
Kitar Hayat Instans: @TestInstance(Lifecycle.PER_CLASS) untuk membolehkan keadaan dikongsi dan cangkuk peringkat kelas bukan statik.
Susunan Kaedah Ujian: @TestMethodOrder (dengan strategi seperti Alphanumeric atau OrderAnnotation) untuk mentakrifkan susunan pelaksanaan.
Susunan Tersuai: @Order untuk kawalan tepat terhadap urutan kaedah.

Ingat untuk menggunakan penyusunan eksplisit dengan bijak, sambil mengutamakan ujian yang bebas dan kukuh!

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 “Kitar Hayat dan Susunan Ujian” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Penguasaan Pengujian: JUnit, Mockito & Ujian Integrasi, termasuk “Kitar Hayat dan Susunan Ujian”, 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 “Kitar Hayat dan Susunan Ujian”?

Kawal susunan pelaksanaan ujian dan urus persediaan serta pembersihan ujian menggunakan anotasi kitar hayat lanjutan. 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 1 daripada 4.

Berapa lamakah pelajaran “Kitar Hayat dan Susunan Ujian” 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

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