unisbadri.com » Python Java Golang Typescript Kotlin Ruby Rust Dart PHP
Unit Test

Unit Test #

Unit testing adalah proses pengujian bagian terkecil dari aplikasi, seperti fungsi atau modul, untuk memastikan bahwa mereka berfungsi sebagaimana mestinya. Dalam Rust, unit testing merupakan bagian integral dari pengembangan, dan Rust menyediakan alat bawaan untuk menulis dan menjalankan tes unit. Unit test di Rust membantu memastikan bahwa kode tetap bekerja dengan benar saat mengalami perubahan atau penambahan fitur.

Berikut adalah penjelasan lengkap dan mendetail mengenai unit test dalam Rust.

Dasar-dasar Unit Testing di Rust #

Rust menyediakan alat testing melalui cargo, alat manajemen proyek dan build system Rust. Unit tests biasanya ditempatkan dalam modul #[cfg(test)] di dalam file yang sama dengan kode yang diuji.

Untuk menulis unit test di Rust, Anda menggunakan atribut #[test] sebelum fungsi tes. Fungsi tes biasanya memanggil kode yang ingin diuji dan kemudian menggunakan macro assert!, assert_eq!, atau assert_ne! untuk memverifikasi hasilnya.

Contoh Sederhana Unit Test:

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        let result = add(2, 3);
        assert_eq!(result, 5);
    }
}

Penjelasan:

  • #[cfg(test)] adalah atribut yang memastikan modul tests hanya dikompilasi saat menjalankan tes, bukan dalam build biasa.
  • use super::*; memungkinkan kode tes untuk mengakses semua item dalam modul induk, termasuk fungsi add.
  • #[test] menandai fungsi test_add sebagai tes unit.
  • assert_eq!(result, 5); memverifikasi bahwa hasil dari add(2, 3) adalah 5. Jika tidak, tes akan gagal.

Menjalankan Unit Test #

Untuk menjalankan tes, Anda menggunakan perintah cargo test di terminal.

Contoh Menjalankan Tes:

$ cargo test

Output yang dihasilkan akan menunjukkan hasil dari semua tes yang dijalankan, termasuk tes yang lulus dan gagal.

Menggunakan Assertions #

Rust menyediakan beberapa jenis assertion untuk memverifikasi kondisi dalam tes. Assertions yang umum digunakan meliputi assert!, assert_eq!, dan assert_ne!.

assert! #

Macro assert! memverifikasi bahwa kondisi tertentu bernilai true. Jika tidak, tes akan gagal.

Contoh assert!:

#[test]
fn test_condition() {
    let condition = true;
    assert!(condition);
}

assert_eq! #

Macro assert_eq! memverifikasi bahwa dua nilai adalah sama (==). Jika tidak, tes akan gagal dan menunjukkan perbedaan antara nilai yang diharapkan dan nilai yang sebenarnya.

Contoh assert_eq!:

#[test]
fn test_equality() {
    let x = 5;
    let y = 5;
    assert_eq!(x, y);
}

assert_ne! #

Macro assert_ne! memverifikasi bahwa dua nilai tidak sama (!=). Jika nilai-nilai tersebut sama, tes akan gagal.

Contoh assert_ne!:

#[test]
fn test_inequality() {
    let x = 5;
    let y = 6;
    assert_ne!(x, y);
}

Mengelompokkan Tes dengan Modul #

Untuk menjaga keteraturan dalam pengujian, Anda dapat mengelompokkan tes ke dalam modul. Setiap modul dapat menguji fungsionalitas tertentu atau bagian kode yang berbeda.

Contoh Modul Tes:

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }

    #[test]
    fn test_subtract() {
        assert_eq!(subtract(5, 3), 2);
    }
}

Penjelasan:

  • Modul tests berisi dua tes yang menguji fungsi add dan subtract secara terpisah.

Tes untuk Panik (Testing for Panic) #

Kadang-kadang, Anda perlu menguji apakah kode Anda akan “panic” (menghentikan eksekusi secara tidak normal) dalam situasi tertentu. Untuk menguji ini, Anda dapat menggunakan atribut #[should_panic].

Menguji Panik dengan #[should_panic] #

Contoh Menguji Panik:

pub fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("Pembagian oleh nol");
    }
    a / b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    #[should_panic(expected = "Pembagian oleh nol")]
    fn test_divide_by_zero() {
        divide(10, 0);
    }
}

Penjelasan:

  • #[should_panic(expected = "Pembagian oleh nol")] memastikan bahwa tes akan lulus hanya jika fungsi divide memicu panic dengan pesan yang sesuai saat membagi dengan nol.

Mengabaikan Tes (Ignoring Tests) #

Dalam beberapa kasus, Anda mungkin ingin mengabaikan tes tertentu agar tidak dijalankan dengan tes lain. Untuk melakukan ini, Anda bisa menggunakan atribut #[ignore].

Contoh Mengabaikan Tes:

#[cfg(test)]
mod tests {
    #[test]
    #[ignore]
    fn test_to_be_ignored() {
        // Tes ini akan diabaikan
    }
}

Penjelasan:

  • #[ignore] menandai bahwa tes ini tidak akan dijalankan kecuali secara eksplisit diminta dengan cargo test -- --ignored.

Menjalankan Tes Secara Selektif #

Anda dapat menjalankan tes tertentu secara selektif dengan menggunakan nama tes atau dengan mengabaikan tes yang diberi atribut #[ignore].

Contoh Menjalankan Tes Tertentu:

cargo test test_add

Contoh Menjalankan Tes yang Diabaikan:

cargo test -- --ignored

Tes Unit dengan Dependency Eksternal #

Dalam beberapa kasus, Anda mungkin perlu melakukan mocking atau isolasi dari dependensi eksternal saat melakukan unit testing. Untuk ini, Anda bisa menggunakan trait dan mocking.

Contoh Mocking dengan Trait:

trait DataFetcher {
    fn fetch_data(&self) -> String;
}

struct RealFetcher;

impl DataFetcher for RealFetcher {
    fn fetch_data(&self) -> String {
        "Data asli".to_string()
    }
}

struct MockFetcher;

impl DataFetcher for MockFetcher {
    fn fetch_data(&self) -> String {
        "Data tiruan".to_string()
    }
}

pub fn process_data(fetcher: &impl DataFetcher) -> String {
    fetcher.fetch_data()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_process_data_with_mock() {
        let fetcher = MockFetcher;
        let result = process_data(&fetcher);
        assert_eq!(result, "Data tiruan");
    }
}

Penjelasan:

  • MockFetcher digunakan dalam tes untuk menggantikan RealFetcher, memungkinkan pengujian kode tanpa bergantung pada sumber data eksternal.

Advanced Testing: Test Fixtures dan Setup #

Dalam kasus yang lebih kompleks, Anda mungkin memerlukan setup atau teardown khusus sebelum dan setelah menjalankan tes. Hal ini dapat dicapai dengan menggunakan fungsi setup yang dipanggil dalam setiap tes.

Contoh Menggunakan Setup:

#[cfg(test)]
mod tests {
    fn setup() {
        // Kode setup, misalnya menginisialisasi database mock
    }

    #[test]
    fn test_example() {
        setup();
        assert_eq!(2 + 2, 4);
    }
}

Penjelasan:

  • setup() dipanggil secara manual dalam setiap tes untuk menyiapkan lingkungan yang diperlukan sebelum pengujian dilakukan.

Dokumentasi dan Testing dengan doc-tests #

Rust juga mendukung pengujian yang tertanam dalam dokumentasi kode (doc-tests). Tes ini ditulis sebagai bagian dari komentar dokumentasi (///) dan dijalankan oleh Rust secara otomatis.

Contoh Doc-test:

/// Menambahkan dua angka.
/// 
/// # Contoh
///
/// ```
/// let result = my_crate::add(2, 3);
/// assert_eq!(result, 5);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

Penjelasan:

  • Doc-test ini secara otomatis dijalankan saat Anda menjalankan cargo test. Rust akan mengeksekusi kode yang ada di dalam blok kode pada komentar dokumentasi.

Benchmarking (Pengujian Performa) #

Selain unit test, Rust juga mendukung pengujian performa menggunakan #[bench]. Namun, fitur ini memerlukan pustaka test yang hanya tersedia pada mode nightly.

**

Contoh Benchmark:**

#![feature(test)]

extern crate test;

use test::Bencher;

pub fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

#[bench]
fn bench_fibonacci(b: &mut Bencher) {
    b.iter(|| fibonacci(20));
}

Penjelasan:

  • #[bench] menandai fungsi sebagai benchmark.
  • b.iter(|| fibonacci(20)); mengukur berapa lama eksekusi fungsi fibonacci(20) berlangsung.

Kesimpulan #

Unit testing di Rust adalah cara yang sangat efektif untuk memastikan bahwa kode Anda bekerja dengan benar dan tetap berfungsi setelah perubahan dilakukan. Dengan dukungan bawaan untuk testing melalui cargo, Rust memudahkan pengembangan berbasis test-driven development (TDD). Melalui penggunaan assertions, mock objects, dan bahkan doc-tests, Rust menyediakan alat yang fleksibel untuk menulis tes yang kuat dan terisolasi. Memahami dan menggunakan fitur-fitur ini dengan benar akan membantu Anda dalam menulis kode yang lebih aman, andal, dan dapat di-maintain dengan lebih baik.

« Web Server
Mocking »