Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Cara Menulis Test

Test adalah fungsi Rust yang memverifikasi bahwa kode non-test berjalan sebagaimana mestinya. Isi dari fungsi test biasanya melakukan tiga tindakan ini:

  • Menyiapkan data atau state yang dibutuhkan.
  • Menjalankan kode yang ingin kamu test.
  • Memastikan bahwa hasilnya sesuai dengan yang kamu harapkan.

Mari kita lihat fitur-fitur yang disediakan Rust khusus untuk menulis test yang melakukan tindakan-tindakan ini, antara lain atribut test, beberapa macro, dan atribut should_panic.

Menyusun Fungsi Test

Paling sederhana, sebuah test dalam Rust adalah fungsi yang diberi anotasi atribut test. Atribut adalah metadata tentang bagian-bagian kode Rust; salah satu contohnya adalah atribut derive yang kita pakai pada struct di Bab 5. Untuk mengubah sebuah fungsi menjadi fungsi test, tambahkan #[test] pada baris sebelum fn. Saat kamu menjalankan test dengan perintah cargo test, Rust membangun biner test runner yang menjalankan fungsi-fungsi yang diberi anotasi dan melaporkan apakah setiap fungsi test lulus atau gagal.

Setiap kali kita membuat proyek library baru dengan Cargo, sebuah module test beserta sebuah fungsi test di dalamnya otomatis dibuatkan untuk kita. Module ini memberi kamu templat untuk menulis test sehingga kamu tidak perlu mencari tahu struktur dan sintaks pastinya setiap kali memulai proyek baru. Kamu bisa menambahkan sebanyak mana pun fungsi test dan module test yang kamu mau!

Kita akan menjelajahi beberapa aspek cara kerja test dengan bereksperimen pada test templat sebelum kita benar-benar mengetes kode apa pun. Lalu, kita akan menulis beberapa test dunia nyata yang memanggil kode yang sudah kita tulis dan memastikan bahwa perilakunya benar.

Mari kita buat proyek library baru bernama adder yang akan menjumlahkan dua angka:

$ cargo new adder --lib
     Created library `adder` project
$ cd adder

Isi file src/lib.rs di library adder kamu harusnya terlihat seperti Daftar 11-1.

Filename: src/lib.rs
pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

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

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}
Listing 11-1: Kode yang dibuat secara otomatis oleh cargo new

File ini dimulai dengan sebuah fungsi add contoh agar kita punya sesuatu untuk ditest.

Untuk sekarang, mari kita fokus hanya pada fungsi it_works. Perhatikan anotasi #[test]: atribut ini menandakan bahwa ini adalah fungsi test, sehingga test runner tahu harus memperlakukan fungsi ini sebagai test. Kita mungkin juga punya fungsi non-test di module tests untuk membantu menyiapkan skenario umum atau melakukan operasi yang biasa dilakukan, jadi kita selalu perlu menandakan fungsi mana yang merupakan test.

Isi fungsi contoh tersebut menggunakan macro assert_eq! untuk memastikan bahwa result, yang berisi hasil pemanggilan add dengan 2 dan 2, sama dengan 4. Assertion ini menjadi contoh format untuk test pada umumnya. Mari kita jalankan untuk melihat bahwa test ini lulus.

Perintah cargo test menjalankan semua test di proyek kita, seperti yang ditunjukkan Daftar 11-2.

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.57s
     Running unittests src/lib.rs (target/debug/deps/adder-01ad14159ff659ab)

running 1 test
test tests::it_works ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests adder

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Listing 11-2: Keluaran dari menjalankan test yang dibuat secara otomatis

Cargo mengompilasi dan menjalankan test tersebut. Kita melihat baris running 1 test. Baris berikutnya menampilkan nama fungsi test yang dibuat, yaitu tests::it_works, dan bahwa hasil menjalankan test itu adalah ok. Ringkasan keseluruhan test result: ok. berarti semua test lulus, dan bagian yang bertuliskan 1 passed; 0 failed menjumlahkan test yang lulus dan yang gagal.

Dimungkinkan untuk menandai sebuah test sebagai diabaikan agar tidak dijalankan dalam situasi tertentu; kita akan membahasnya di bagian “Mengabaikan Test Kecuali Diminta Secara Khusus” nanti dalam bab ini. Karena kita belum melakukan itu di sini, ringkasan menampilkan 0 ignored. Kita juga bisa memberikan argumen pada perintah cargo test untuk hanya menjalankan test yang namanya cocok dengan sebuah string; ini disebut filtering, dan kita akan membahasnya di bagian “Menjalankan Sebagian Test berdasarkan Nama”. Di sini, kita tidak memfilter test yang dijalankan, sehingga akhir ringkasan menampilkan 0 filtered out.

Statistik 0 measured untuk test benchmark yang mengukur kinerja. Test benchmark, pada saat tulisan ini dibuat, hanya tersedia di Rust nightly. Lihat dokumentasi tentang test benchmark untuk mempelajari lebih lanjut.

Bagian berikutnya dari keluaran test yang dimulai dari Doc-tests adder adalah hasil dari documentation test. Kita belum punya documentation test apa pun, tetapi Rust bisa mengompilasi contoh kode apa pun yang muncul di dokumentasi API kita. Fitur ini membantu menjaga dokumentasi dan kode kamu tetap sinkron! Kita akan membahas cara menulis documentation test di bagian “Komentar Dokumentasi sebagai Test” Bab 14. Untuk sekarang, kita abaikan keluaran Doc-tests.

Mari kita mulai menyesuaikan test sesuai kebutuhan kita. Pertama, ubah nama fungsi it_works menjadi nama lain, misalnya exploration, seperti ini:

Nama file: src/lib.rs

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

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

    #[test]
    fn exploration() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

Lalu, jalankan cargo test lagi. Keluaran sekarang menampilkan exploration, bukan it_works:

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.59s
     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)

running 1 test
test tests::exploration ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests adder

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Sekarang kita akan menambahkan test lagi, tetapi kali ini kita buat test yang gagal! Sebuah test gagal ketika ada sesuatu di dalam fungsi test yang panic. Setiap test dijalankan di thread baru, dan ketika thread utama melihat bahwa thread test telah mati, test ditandai sebagai gagal. Di Bab 9, kita sudah berbicara bahwa cara paling sederhana untuk panic adalah memanggil macro panic!. Masukkan test baru sebagai fungsi bernama another, sehingga file src/lib.rs kamu terlihat seperti Daftar 11-3.

Filename: src/lib.rs
pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

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

    #[test]
    fn exploration() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }

    #[test]
    fn another() {
        panic!("Make this test fail");
    }
}
Listing 11-3: Menambahkan test kedua yang akan gagal karena kita memanggil macro panic!

Jalankan test lagi menggunakan cargo test. Keluarannya harusnya terlihat seperti Daftar 11-4, yang menunjukkan bahwa test exploration kita lulus dan another gagal.

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.72s
     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)

running 2 tests
test tests::another ... FAILED
test tests::exploration ... ok

failures:

---- tests::another stdout ----

thread 'tests::another' (6019162) panicked at src/lib.rs:17:9:
Make this test fail
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::another

test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`
Listing 11-4: Hasil test ketika satu test lulus dan satu test gagal

Alih-alih ok, baris test tests::another menampilkan FAILED. Dua bagian baru muncul di antara hasil per test dan ringkasan: yang pertama menampilkan alasan terperinci untuk setiap kegagalan test. Dalam kasus ini, kita mendapat rincian bahwa tests::another gagal karena panic dengan pesan Make this test fail pada baris 17 di file src/lib.rs. Bagian berikutnya hanya mencantumkan nama semua test yang gagal, yang berguna ketika ada banyak test dan banyak keluaran rinci tentang test yang gagal. Kita bisa memakai nama test yang gagal untuk menjalankan hanya test itu agar lebih mudah di-debug; kita akan berbicara lebih banyak tentang cara menjalankan test di bagian “Mengontrol Cara Test Dijalankan”.

Baris ringkasan muncul di akhir: Secara keseluruhan, hasil test kita adalah FAILED. Kita punya satu test yang lulus dan satu yang gagal.

Sekarang setelah kamu melihat seperti apa hasil test dalam berbagai skenario, mari kita lihat beberapa macro selain panic! yang berguna dalam test.

Memeriksa Hasil dengan assert!

Macro assert!, yang disediakan oleh library standar, berguna ketika kamu ingin memastikan bahwa suatu kondisi dalam test bernilai true. Kita memberikan macro assert! sebuah argumen yang mengevaluasi ke nilai Boolean. Jika nilainya true, tidak ada yang terjadi dan test lulus. Jika nilainya false, macro assert! memanggil panic! untuk membuat test gagal. Memakai macro assert! membantu kita memeriksa bahwa kode kita berjalan sesuai yang kita maksud.

Di Bab 5, Daftar 5-15, kita memakai struct Rectangle dan method can_hold, yang diulang di sini pada Daftar 11-5. Mari kita letakkan kode ini di file src/lib.rs, lalu tulis beberapa test untuknya memakai macro assert!.

Filename: src/lib.rs
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}
Listing 11-5: Struct Rectangle dan method can_hold-nya dari Bab 5

Method can_hold mengembalikan nilai Boolean, yang berarti ini adalah kasus penggunaan yang pas untuk macro assert!. Di Daftar 11-6, kita menulis test yang mencoba method can_hold dengan membuat instance Rectangle yang lebar 8 dan tinggi 7, lalu memastikan bahwa instance itu bisa menampung instance Rectangle lain yang lebar 5 dan tinggi 1.

Filename: src/lib.rs
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

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

    #[test]
    fn larger_can_hold_smaller() {
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(larger.can_hold(&smaller));
    }
}
Listing 11-6: Sebuah test untuk can_hold yang memeriksa apakah persegi panjang yang lebih besar memang bisa menampung persegi panjang yang lebih kecil

Perhatikan baris use super::*; di dalam module tests. Module tests adalah module biasa yang mengikuti aturan visibilitas seperti biasa yang kita bahas di Bab 7 pada bagian “Path untuk Merujuk ke Item di Pohon Module”. Karena module tests adalah module dalam, kita perlu membawa kode yang ditest di module luar ke dalam scope module dalam. Kita memakai glob di sini, sehingga apa pun yang kita definisikan di module luar tersedia bagi module tests ini.

Kita menamai test kita larger_can_hold_smaller, dan kita sudah membuat dua instance Rectangle yang kita butuhkan. Lalu, kita memanggil macro assert! dan memberikan hasil pemanggilan larger.can_hold(&smaller). Ekspresi ini seharusnya mengembalikan true, jadi test kita harusnya lulus. Mari kita lihat!

$ cargo test
   Compiling rectangle v0.1.0 (file:///projects/rectangle)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)

running 1 test
test tests::larger_can_hold_smaller ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests rectangle

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Test itu memang lulus! Mari kita tambahkan test lagi, kali ini memastikan bahwa persegi panjang yang lebih kecil tidak bisa menampung persegi panjang yang lebih besar:

Nama file: src/lib.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

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

    #[test]
    fn larger_can_hold_smaller() {
        // --snip--
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(larger.can_hold(&smaller));
    }

    #[test]
    fn smaller_cannot_hold_larger() {
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(!smaller.can_hold(&larger));
    }
}

Karena hasil yang benar dari fungsi can_hold dalam kasus ini adalah false, kita perlu membalik hasil itu sebelum memberikannya ke macro assert!. Dengan demikian, test kita akan lulus jika can_hold mengembalikan false:

$ cargo test
   Compiling rectangle v0.1.0 (file:///projects/rectangle)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)

running 2 tests
test tests::larger_can_hold_smaller ... ok
test tests::smaller_cannot_hold_larger ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests rectangle

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Dua test yang lulus! Sekarang mari kita lihat apa yang terjadi pada hasil test ketika kita memasukkan bug ke dalam kode. Kita akan mengubah implementasi method can_hold dengan mengganti tanda lebih besar (>) dengan tanda lebih kecil (<) saat membandingkan lebar:

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

// --snip--
impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width < other.width && self.height > other.height
    }
}

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

    #[test]
    fn larger_can_hold_smaller() {
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(larger.can_hold(&smaller));
    }

    #[test]
    fn smaller_cannot_hold_larger() {
        let larger = Rectangle {
            width: 8,
            height: 7,
        };
        let smaller = Rectangle {
            width: 5,
            height: 1,
        };

        assert!(!smaller.can_hold(&larger));
    }
}

Menjalankan test sekarang menghasilkan ini:

$ cargo test
   Compiling rectangle v0.1.0 (file:///projects/rectangle)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)

running 2 tests
test tests::larger_can_hold_smaller ... FAILED
test tests::smaller_cannot_hold_larger ... ok

failures:

---- tests::larger_can_hold_smaller stdout ----

thread 'tests::larger_can_hold_smaller' (6020788) panicked at src/lib.rs:28:9:
assertion failed: larger.can_hold(&smaller)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::larger_can_hold_smaller

test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

Test kita berhasil menangkap bug! Karena larger.width adalah 8 dan smaller.width adalah 5, perbandingan lebar di can_hold sekarang mengembalikan false: 8 tidak lebih kecil dari 5.

Menguji Kesetaraan dengan assert_eq! dan assert_ne!

Cara umum untuk memverifikasi fungsi adalah menguji kesetaraan antara hasil kode yang ditest dan nilai yang kamu harapkan dikembalikan kode itu. Kamu bisa melakukan ini dengan memakai macro assert! dan memberinya ekspresi yang memakai operator ==. Namun, test semacam ini sangat umum sehingga library standar menyediakan sepasang macro—assert_eq! dan assert_ne!—untuk melakukan test ini dengan lebih praktis. Kedua macro ini membandingkan dua argumen untuk kesetaraan atau ketidaksetaraan. Keduanya juga akan mencetak kedua nilai jika assertion gagal, sehingga lebih mudah melihat mengapa test gagal; sebaliknya, macro assert! hanya menunjukkan bahwa ia mendapat nilai false untuk ekspresi ==, tanpa mencetak nilai-nilai yang menyebabkan nilai false itu.

Di Daftar 11-7, kita menulis fungsi bernama add_two yang menambahkan 2 pada parameternya, lalu kita test fungsi ini memakai macro assert_eq!.

Filename: src/lib.rs
pub fn add_two(a: u64) -> u64 {
    a + 2
}

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

    #[test]
    fn it_adds_two() {
        let result = add_two(2);
        assert_eq!(result, 4);
    }
}
Listing 11-7: Menguji fungsi add_two memakai macro assert_eq!

Mari kita cek bahwa test ini lulus!

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.58s
     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)

running 1 test
test tests::it_adds_two ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests adder

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Kita membuat variabel bernama result yang menyimpan hasil pemanggilan add_two(2). Lalu, kita memberikan result dan 4 sebagai argumen macro assert_eq!. Baris keluaran untuk test ini adalah test tests::it_adds_two ... ok, dan teks ok menunjukkan bahwa test kita lulus!

Mari kita masukkan bug ke dalam kode untuk melihat seperti apa assert_eq! ketika gagal. Ubah implementasi fungsi add_two sehingga menambahkan 3:

pub fn add_two(a: u64) -> u64 {
    a + 3
}

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

    #[test]
    fn it_adds_two() {
        let result = add_two(2);
        assert_eq!(result, 4);
    }
}

Jalankan test lagi:

$ cargo test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.61s
     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)

running 1 test
test tests::it_adds_two ... FAILED

failures:

---- tests::it_adds_two stdout ----

thread 'tests::it_adds_two' (6020955) panicked at src/lib.rs:12:9:
assertion `left == right` failed
  left: 5
 right: 4
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::it_adds_two

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

Test kita menangkap bug! Test tests::it_adds_two gagal, dan pesannya memberi tahu kita bahwa assertion yang gagal adalah left == right serta apa nilai left dan right-nya. Pesan ini membantu kita mulai melakukan debug: argumen left, tempat kita menyimpan hasil add_two(2), adalah 5, tetapi argumen right adalah 4. Kamu bisa bayangkan betapa bergunanya ini ketika ada banyak test yang berjalan.

Perlu dicatat bahwa di beberapa bahasa dan framework test, parameter fungsi assertion kesetaraan disebut expected dan actual, dan urutan kita menentukan argumen itu penting. Namun, di Rust keduanya disebut left dan right, dan urutan kita menentukan nilai yang kita harapkan serta nilai yang dihasilkan kode tidak penting. Kita bisa menulis assertion dalam test ini sebagai assert_eq!(4, result), yang akan menghasilkan pesan kegagalan yang sama yaitu assertion `left == right` failed.

Macro assert_ne! akan lulus jika dua nilai yang kita berikan tidak sama dan akan gagal jika keduanya sama. Macro ini paling berguna untuk kasus ketika kita tidak yakin apa nilai sesuatu akan menjadi, tetapi kita tahu nilai itu pasti tidak boleh menjadi apa. Misalnya, jika kita mengetes fungsi yang dijamin akan mengubah inputnya dengan cara tertentu, tetapi cara input itu diubah bergantung pada hari dalam seminggu saat kita menjalankan test, hal terbaik untuk ditegaskan mungkin bahwa keluaran fungsi tidak sama dengan inputnya.

Di balik permukaan, macro assert_eq! dan assert_ne! memakai operator == dan !=. Saat assertion gagal, kedua macro ini mencetak argumennya memakai format debug, yang berarti nilai yang dibandingkan harus mengimplementasikan trait PartialEq dan Debug. Semua tipe primitif dan sebagian besar tipe di library standar mengimplementasikan trait ini. Untuk struct dan enum yang kamu definisikan sendiri, kamu perlu mengimplementasikan PartialEq untuk menyatakan kesetaraan tipe-tipe itu. Kamu juga perlu mengimplementasikan Debug untuk mencetak nilai ketika assertion gagal. Karena kedua trait tersebut adalah trait yang bisa diturunkan (derivable), seperti disebutkan di Daftar 5-12 Bab 5, ini biasanya semudah menambahkan anotasi #[derive(PartialEq, Debug)] pada definisi struct atau enum kamu. Lihat Lampiran C, “Trait yang Bisa Diturunkan,” untuk rincian lebih lanjut tentang trait ini dan trait lain yang bisa diturunkan.

Menambahkan Pesan Kegagalan Kustom

Kamu juga bisa menambahkan pesan kustom untuk dicetak bersama pesan kegagalan sebagai argumen opsional pada macro assert!, assert_eq!, dan assert_ne!. Argumen apa pun yang ditentukan setelah argumen wajib diteruskan ke macro format! (dibahas di “Menggabungkan dengan + atau format!” Bab 8), jadi kamu bisa memberikan string format yang berisi placeholder {} dan nilai-nilai untuk mengisi placeholder itu. Pesan kustom berguna untuk mendokumentasikan maksud sebuah assertion; ketika test gagal, kamu akan lebih paham apa masalahnya dengan kode kamu.

Misalnya, kita punya fungsi yang menyapa orang berdasarkan nama, dan kita ingin mengetes bahwa nama yang kita berikan ke fungsi itu muncul di keluaran:

Nama file: src/lib.rs

pub fn greeting(name: &str) -> String {
    format!("Hello {name}!")
}

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

    #[test]
    fn greeting_contains_name() {
        let result = greeting("Carol");
        assert!(result.contains("Carol"));
    }
}

Persyaratan program ini belum disepakati, dan kita cukup yakin teks Hello di awal sapaan akan berubah. Kita memutuskan tidak ingin harus memperbarui test ketika persyaratan berubah, jadi alih-alih memeriksa kesetaraan persis dengan nilai yang dikembalikan fungsi greeting, kita cukup memastikan bahwa keluarannya mengandung teks dari parameter masukan.

Sekarang mari kita masukkan bug ke kode ini dengan mengubah greeting agar tidak menyertakan name, untuk melihat seperti apa kegagalan test bawaan:

pub fn greeting(name: &str) -> String {
    String::from("Hello!")
}

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

    #[test]
    fn greeting_contains_name() {
        let result = greeting("Carol");
        assert!(result.contains("Carol"));
    }
}

Menjalankan test ini menghasilkan sebagai berikut:

$ cargo test
   Compiling greeter v0.1.0 (file:///projects/greeter)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.91s
     Running unittests src/lib.rs (target/debug/deps/greeter-170b942eb5bf5e3a)

running 1 test
test tests::greeting_contains_name ... FAILED

failures:

---- tests::greeting_contains_name stdout ----

thread 'tests::greeting_contains_name' (6021143) panicked at src/lib.rs:12:9:
assertion failed: result.contains("Carol")
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::greeting_contains_name

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

Hasil ini hanya menunjukkan bahwa assertion gagal dan di baris mana assertion itu berada. Pesan kegagalan yang lebih berguna akan mencetak nilai dari fungsi greeting. Mari kita tambahkan pesan kegagalan kustom yang terdiri dari string format dengan placeholder yang diisi nilai aktual yang kita dapat dari fungsi greeting:

pub fn greeting(name: &str) -> String {
    String::from("Hello!")
}

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

    #[test]
    fn greeting_contains_name() {
        let result = greeting("Carol");
        assert!(
            result.contains("Carol"),
            "Greeting did not contain name, value was `{result}`"
        );
    }
}

Sekarang saat kita menjalankan test, kita akan mendapat pesan error yang lebih informatif:

$ cargo test
   Compiling greeter v0.1.0 (file:///projects/greeter)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.93s
     Running unittests src/lib.rs (target/debug/deps/greeter-170b942eb5bf5e3a)

running 1 test
test tests::greeting_contains_name ... FAILED

failures:

---- tests::greeting_contains_name stdout ----

thread 'tests::greeting_contains_name' (6021333) panicked at src/lib.rs:12:9:
Greeting did not contain name, value was `Hello!`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::greeting_contains_name

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

Kita bisa melihat nilai yang benar-benar kita dapat di keluaran test, yang membantu kita melakukan debug tentang apa yang terjadi alih-alih apa yang kita harapkan terjadi.

Memeriksa Panic dengan should_panic

Selain memeriksa nilai kembalian, penting juga untuk memeriksa bahwa kode kita menangani kondisi error sesuai yang kita harapkan. Misalnya, pertimbangkan tipe Guess yang kita buat di Bab 9, Daftar 9-13. Kode lain yang memakai Guess bergantung pada jaminan bahwa instance Guess hanya berisi nilai antara 1 dan 100. Kita bisa menulis test yang memastikan bahwa percobaan membuat instance Guess dengan nilai di luar rentang itu menyebabkan panic.

Kita melakukan ini dengan menambahkan atribut should_panic pada fungsi test kita. Test lulus jika kode di dalam fungsi itu panic; test gagal jika kode di dalam fungsi itu tidak panic.

Daftar 11-8 menampilkan test yang memeriksa bahwa kondisi error dari Guess::new terjadi pada saat yang kita harapkan.

Filename: src/lib.rs
pub struct Guess {
    value: i32,
}

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 || value > 100 {
            panic!("Guess value must be between 1 and 100, got {value}.");
        }

        Guess { value }
    }
}

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

    #[test]
    #[should_panic]
    fn greater_than_100() {
        Guess::new(200);
    }
}
Listing 11-8: Menguji bahwa suatu kondisi akan menyebabkan panic!

Kita menempatkan atribut #[should_panic] setelah atribut #[test] dan sebelum fungsi test yang dikenainya. Mari kita lihat hasilnya ketika test ini lulus:

$ cargo test
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.58s
     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)

running 1 test
test tests::greater_than_100 - should panic ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests guessing_game

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Terlihat bagus! Sekarang mari kita masukkan bug ke dalam kode dengan menghapus kondisi bahwa fungsi new akan panic jika nilainya lebih dari 100:

pub struct Guess {
    value: i32,
}

// --snip--
impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 {
            panic!("Guess value must be between 1 and 100, got {value}.");
        }

        Guess { value }
    }
}

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

    #[test]
    #[should_panic]
    fn greater_than_100() {
        Guess::new(200);
    }
}

Saat kita menjalankan test di Daftar 11-8, test itu akan gagal:

$ cargo test
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.62s
     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)

running 1 test
test tests::greater_than_100 - should panic ... FAILED

failures:

---- tests::greater_than_100 stdout ----
note: test did not panic as expected at src/lib.rs:21:8

failures:
    tests::greater_than_100

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

Kita tidak mendapat pesan yang terlalu membantu dalam kasus ini, tetapi ketika melihat fungsi testnya, kita mendapati bahwa ia diberi anotasi #[should_panic]. Kegagalan yang kita dapat berarti kode di dalam fungsi test itu tidak menyebabkan panic.

Test yang memakai should_panic bisa kurang tepat. Sebuah test should_panic akan lulus meskipun test panic karena alasan yang berbeda dari yang kita harapkan. Agar test should_panic lebih tepat, kita bisa menambahkan parameter opsional expected pada atribut should_panic. Test harness akan memastikan bahwa pesan kegagalan mengandung teks yang diberikan. Misalnya, pertimbangkan kode Guess yang dimodifikasi di Daftar 11-9, di mana fungsi new panic dengan pesan berbeda bergantung pada apakah nilainya terlalu kecil atau terlalu besar.

Filename: src/lib.rs
pub struct Guess {
    value: i32,
}

// --snip--

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 {
            panic!(
                "Guess value must be greater than or equal to 1, got {value}."
            );
        } else if value > 100 {
            panic!(
                "Guess value must be less than or equal to 100, got {value}."
            );
        }

        Guess { value }
    }
}

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

    #[test]
    #[should_panic(expected = "less than or equal to 100")]
    fn greater_than_100() {
        Guess::new(200);
    }
}
Listing 11-9: Menguji panic! dengan pesan panic yang berisi substring tertentu

Test ini akan lulus karena nilai yang kita letakkan pada parameter expected atribut should_panic adalah substring dari pesan yang dipakai Guess::new saat panic. Kita bisa saja menentukan seluruh pesan panic yang kita harapkan, yang dalam kasus ini adalah Guess value must be less than or equal to 100, got 200. Apa yang kamu pilih untuk ditentukan bergantung pada seberapa unik atau dinamis pesan panic itu dan seberapa tepat kamu ingin test kamu. Dalam kasus ini, substring dari pesan panic sudah cukup untuk memastikan bahwa kode dalam fungsi test menjalankan cabang else if value > 100.

Untuk melihat apa yang terjadi ketika test should_panic dengan pesan expected gagal, mari kita masukkan bug lagi ke dalam kode dengan menukar isi blok if value < 1 dan else if value > 100:

pub struct Guess {
    value: i32,
}

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 {
            panic!(
                "Guess value must be less than or equal to 100, got {value}."
            );
        } else if value > 100 {
            panic!(
                "Guess value must be greater than or equal to 1, got {value}."
            );
        }

        Guess { value }
    }
}

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

    #[test]
    #[should_panic(expected = "less than or equal to 100")]
    fn greater_than_100() {
        Guess::new(200);
    }
}

Kali ini saat kita menjalankan test should_panic, test itu akan gagal:

$ cargo test
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)

running 1 test
test tests::greater_than_100 - should panic ... FAILED

failures:

---- tests::greater_than_100 stdout ----

thread 'tests::greater_than_100' (6021675) panicked at src/lib.rs:12:13:
Guess value must be greater than or equal to 1, got 200.
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: panic did not contain expected string
      panic message: "Guess value must be greater than or equal to 1, got 200."
 expected substring: "less than or equal to 100"

failures:
    tests::greater_than_100

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

Pesan kegagalan menunjukkan bahwa test ini memang panic seperti yang kita harapkan, tetapi pesan panicnya tidak memuat string yang diharapkan less than or equal to 100. Pesan panic yang benar-benar kita dapat dalam kasus ini adalah Guess value must be greater than or equal to 1, got 200. Sekarang kita bisa mulai mencari tahu di mana bug kita!

Memakai Result<T, E> dalam Test

Semua test kita sejauh ini panic saat gagal. Kita juga bisa menulis test yang memakai Result<T, E>! Ini test dari Daftar 11-1, yang ditulis ulang untuk memakai Result<T, E> dan mengembalikan Err alih-alih panic:

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

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

    #[test]
    fn it_works() -> Result<(), String> {
        let result = add(2, 2);

        if result == 4 {
            Ok(())
        } else {
            Err(String::from("two plus two does not equal four"))
        }
    }
}

Fungsi it_works sekarang memiliki tipe kembalian Result<(), String>. Di dalam badan fungsi, alih-alih memanggil macro assert_eq!, kita mengembalikan Ok(()) ketika test lulus dan Err yang berisi String ketika test gagal.

Menulis test sehingga mengembalikan Result<T, E> memungkinkan kamu memakai operator tanda tanya di dalam badan test, yang bisa menjadi cara praktis untuk menulis test yang seharusnya gagal jika ada operasi di dalamnya yang mengembalikan varian Err.

Kamu tidak bisa memakai anotasi #[should_panic] pada test yang memakai Result<T, E>. Untuk menyatakan bahwa sebuah operasi mengembalikan varian Err, jangan pakai operator tanda tanya pada nilai Result<T, E> itu. Sebagai gantinya, pakai assert!(value.is_err()).

Sekarang setelah kamu tahu beberapa cara menulis test, mari kita lihat apa yang terjadi saat kita menjalankan test dan menjelajahi berbagai opsi yang bisa kita pakai dengan cargo test.