Tulis kod yang boleh diuji menggunakan suntikan ketergantungan untuk membolehkan gandingan longgar, seperti yang dilihat dengan menggantikan kebergantungan keras dengan yang disuntik; 2. Gunakan Junit 5 untuk ujian berstruktur dengan ciri -ciri seperti @Beforeeach, @test, dan menegaskan untuk memastikan ujian yang bersih, boleh dibaca, dan boleh dipercayai; 3. Mengejutkan kebergantungan luaran dengan mockito menggunakan mock (), ketika (). Thenreturn (), dan sahkan () untuk mengasingkan tingkah laku dan mengelakkan pergantungan pada sistem sebenar; 4. Ikuti amalan terbaik seperti nama ujian deskriptif, corak AAA, mengelakkan ujian terperinci pelaksanaan, menjaga ujian bebas, tidak terlalu mengejek, dan meliputi kes kelebihan untuk memastikan ujian yang boleh dipelihara dan berkesan; Akhirnya, mereka bentuk untuk kesesuaian meningkatkan kualiti kod, menjadikannya lebih mudah untuk berubah, debug, dan kepercayaan.

Menulis kod Java yang boleh diuji adalah kemahiran kritikal untuk membina aplikasi yang boleh dipelihara dan mantap. Dengan Junit 5 sebagai rangka kerja ujian moden dan mockito untuk kebergantungan mengejek, anda boleh menulis ujian unit yang bersih dan boleh dipercayai yang mengesahkan tingkah laku tanpa bergantung pada sistem luaran. Berikut adalah cara menyusun kod dan ujian anda dengan berkesan.

1. Tulis kod yang boleh diuji: suntikan pergantungan dan gandingan longgar

Asas kod yang boleh diuji adalah suntikan ketergantungan (DI) dan gandingan longgar . Elakkan kebergantungan keras atau panggilan statik yang membuat ujian sukar.

Contoh buruk (sukar untuk diuji):

 Pesanan Pesanan Kelas Awam {
    EmailService EmailService Private = NewService baru (); // ketergantungan keras

    proses kekosongan awam (perintah pesanan) {
        // logik
        EmailService.SendConfirmation (perintah);
    }
}

OrderService pasangan yang ketat ini ke EmailService , menjadikannya mustahil untuk menguji process() tanpa benar -benar menghantar e -mel.

Pendekatan yang baik (boleh diuji dengan DI):

 Pesanan Pesanan Kelas Awam {
    E -melService E -melService Final Private;

    Pesanan Pesanan Awam (e -melService E -melService) {
        this.emailservice = e -melService;
    }

    proses kekosongan awam (perintah pesanan) {
        // logik perniagaan
        EmailService.SendConfirmation (perintah);
    }
}

Sekarang anda boleh menyuntik EmailService yang dihina semasa ujian menggunakan Mockito.

2. Gunakan Junit 5 untuk ujian berstruktur dan boleh dibaca

Junit 5 menawarkan sintaks moden dengan pengurusan kitaran hayat yang lebih baik dan pernyataan ekspresif.

Contoh kelas ujian:

 import org.junit.jupiter.api.*;
import statik org.mockito.mockito.*;
import statik org.junit.jupiter.api.assertions.*;

@TestInstance (testInstance.lifecycle.per_method)
kelas orderServiceTest {

    E -melService EmailService Private;
    Pesanan pesanan pesanan peribadi;

    @Beforeach
    void setup () {
        e -melService = mock (emailService.class);
        orderService = Pesanan Pesanan Baru (EmailService);
    }

    @Test
    @DisplayName ("Harus menghantar e -mel pengesahan semasa membuat pesanan")
    void shouldSendemailonProcess () {
        // diberikan
        Pesanan Pesanan = Perintah Baru ("123", 100.0);

        // Bila
        OrderService.Process (Order);

        // kemudian
        sahkan (e -melService, Times (1)). SendConfirmation (perintah);
    }

    @Test
    @DisplayName ("harus membuang pengecualian untuk pesanan null")
    void shouldThrowExceptionFornullorder () {
        // bila & kemudian
        AssertHrows (IllegalArgumentException.class, () -> {
            orderService.process (null);
        });
    }
}

Ciri -ciri utama Junit 5 yang digunakan:

• @BeforeEach - berjalan sebelum setiap ujian (keadaan bersih)
• @Test - Kaedah ujian Marks
• @DisplayName - Meningkatkan kebolehbacaan dalam laporan ujian
• assertThrows - mengesahkan pengecualian yang diharapkan
• verify() - Memeriksa interaksi dengan mengejek

3. Mengejutkan ketergantungan dengan mockito

Mockito membolehkan anda mensimulasikan perkhidmatan luaran (contohnya, pangkalan data, API, e -mel) supaya ujian unit anda berjalan pantas dan mengasingkan tingkah laku.

Corak mockito biasa:

• Penciptaan Mock: mock(ClassName.class)
• Kaedah Stubbing: when(mock.method()).thenReturn(value)
• Mengesahkan Interaksi: verify(mock).method()

Contoh: Menanggalkan panggilan repositori

 UserService Kelas Awam {
    Userrepository UserRepository akhir swasta;

    Public Userservice (userrepository userrepository) {
        this.userrepository = userrepository;
    }

    pengguna awam findUserById (ID String) {
        Kembalikan userrepository.findbyId (ID)
                .orelsethrow (() -> New UsernotFoundException ("Pengguna tidak dijumpai"));
    }
}

Uji dengan Mockito:

 @Test
@DisplayName ("harus mengembalikan pengguna apabila ditemui di repositori")
void hendaklahReturnuserWhenFound () {
    // diberikan
    Userrepository userrepository = mock (userrepository.class);
    Pengguna MockUser = pengguna baru ("1", "Alice");
    apabila (userrepository.findbyId ("1")). thenReturn (optional.of (mockUser));

    UserService userService = New userService (userRepository);

    // Bila
    Hasil Pengguna = UserService.FindUserById ("1");

    // kemudian
    AssertEquals ("Alice", result.getName ());
    sahkan (userrepository) .findbyId ("1");
}

Anda hanya menguji logik dalam UserService , bukan pangkalan data sebenar.

4. Amalan terbaik untuk ujian yang bersih dan boleh dipelihara

Ikuti garis panduan ini untuk memastikan ujian anda berkesan:

• Gunakan nama ujian deskriptif
  Lebih suka shouldThrowExceptionWhenOrderIsNull() over testProcess() .

• Ikuti corak AAA
  Mengatur ujian ke dalam mengatur , bertindak , menegaskan blok untuk kejelasan.

• Elakkan ujian perincian pelaksanaan
  Uji kaedah yang dilakukan, bukan bagaimana ia melakukannya. Jangan mengesahkan kaedah peribadi dalaman.

• Pastikan ujian bebas dan pantas
  Tiada keadaan bersama antara ujian. Gunakan @BeforeEach atau kaedah kilang sebaliknya.

• Jangan terlalu mengejek
  Hanya mengejek kebergantungan luaran. Jangan mengejek objek nilai atau utiliti mudah.

• Kes kelebihan ujian
  Input null, koleksi kosong, pengecualian - ini adalah titik kegagalan biasa.

Pemikiran terakhir

Menulis kod Java yang boleh diuji bukan sekadar menambah ujian -ini mengenai merancang kelas anda dengan kesesuaian dalam fikiran. Gunakan suntikan ketergantungan, komposisi memihak kepada instantiasi, dan kebimbangan berasingan secara bersih.

Dengan Junit 5 dan Mockito, anda mendapat alat yang kuat untuk:

• Tulis ujian ekspresif dan boleh dibaca
• Mengasingkan unit tingkah laku
• Mensimulasikan kebergantungan dengan selamat

Hasilnya? Kod yang lebih mudah untuk diubah, debug, dan kepercayaan.

Pada asasnya, jika anda tidak dapat mengujinya dengan mudah, memikirkan semula reka bentuk.

Atas ialah kandungan terperinci Menulis kod Java yang boleh diuji dengan Junit 5 dan Mockito. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!