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

Organisasi Test

Seperti yang disebutkan di awal bab ini, testing adalah disiplin yang kompleks, dan tiap orang memakai istilah serta cara pengorganisasian yang berbeda. Komunitas Rust memandang test dalam dua kategori utama: unit test dan integration test. Unit test berukuran kecil dan lebih terfokus, menguji satu module secara terpisah pada satu waktu, serta bisa menguji antarmuka private. Integration test sepenuhnya berada di luar library kamu dan memakai kode kamu seperti layaknya kode eksternal lainnya, hanya menggunakan antarmuka publik dan bisa jadi melibatkan beberapa module dalam satu test.

Menulis kedua jenis test itu penting untuk memastikan bagian-bagian library kamu melakukan apa yang kamu harapkan, baik secara terpisah maupun bersama-sama.

Unit Test

Tujuan unit test adalah menguji setiap unit kode secara terpisah dari kode lainnya agar kita bisa dengan cepat menemukan bagian mana yang bekerja dan mana yang tidak sesuai harapan. Kamu akan meletakkan unit test di direktori src, di dalam setiap file yang berisi kode yang diuji. Kebiasaannya, kamu membuat module bernama tests di tiap file untuk menampung fungsi-fungsi test, lalu menandai module itu dengan cfg(test).

Module tests dan #[cfg(test)]

Anotasi #[cfg(test)] pada module tests memberi tahu Rust untuk mengompilasi dan menjalankan kode test hanya saat kamu menjalankan cargo test, bukan saat menjalankan cargo build. Ini menghemat waktu kompilasi saat kamu hanya ingin membangun library, sekaligus menghemat ruang pada hasil kompilasi karena test tidak ikut disertakan. Kamu akan melihat bahwa karena integration test ditempatkan di direktori lain, mereka tidak memerlukan anotasi #[cfg(test)]. Namun, karena unit test berada di file yang sama dengan kode, kamu memakai #[cfg(test)] untuk menentukan bahwa test-test itu tidak boleh disertakan dalam hasil kompilasi.

Ingatlah bahwa saat kita membuat proyek baru adder di bagian pertama bab ini, Cargo menghasilkan kode ini untuk kita:

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);
    }
}

Pada module tests yang dihasilkan otomatis itu, atribut cfg adalah singkatan dari configuration dan memberi tahu Rust bahwa item setelahnya hanya boleh disertakan apabila ada opsi konfigurasi tertentu. Dalam kasus ini, opsi konfigurasi tersebut adalah test, yang disediakan Rust untuk mengompilasi dan menjalankan test. Dengan memakai atribut cfg, Cargo mengompilasi kode test kita hanya jika kita secara aktif menjalankan test dengan cargo test. Ini juga mencakup fungsi-fungsi pembantu yang mungkin ada di dalam module ini, selain fungsi-fungsi yang ditandai dengan #[test].

Test Fungsi Private

Ada perdebatan di kalangan komunitas testing soal apakah fungsi private sebaiknya diuji langsung atau tidak, dan bahasa lain ada yang membuat pengujian fungsi private menjadi sulit atau bahkan mustahil. Apapun aliran testing yang kamu ikuti, aturan privasi Rust tetap mengizinkan kamu menguji fungsi private. Perhatikan kode pada Listing 11-12 dengan fungsi private internal_adder.

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

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

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

    #[test]
    fn internal() {
        let result = internal_adder(2, 2);
        assert_eq!(result, 4);
    }
}
Listing 11-12: Testing a private function

Perhatikan bahwa fungsi internal_adder tidak ditandai sebagai pub. Test hanyalah kode Rust, dan module tests hanyalah module biasa. Seperti yang kita bahas di “Paths for Referring to an Item in the Module Tree”, item di dalam module anak bisa memakai item dari module induknya. Dalam test ini, kita membawa semua item milik induk module tests ke dalam scope dengan use super::*, lalu test itu bisa memanggil internal_adder. Kalau kamu berpendapat bahwa fungsi private tidak perlu diuji, tidak ada satupun dalam Rust yang memaksamu melakukannya.

Integration Test

Di Rust, integration test sepenuhnya berada di luar library kamu. Mereka memakai library kamu seperti kode lainnya, yang berarti mereka hanya bisa memanggil fungsi-fungsi yang merupakan bagian dari API publik library kamu. Tujuannya adalah menguji apakah banyak bagian dari library kamu bekerja bersama dengan benar. Unit kode yang bekerja dengan benar secara mandiri bisa saja bermasalah saat digabungkan, jadi cakupan test pada kode yang sudah terintegrasi juga penting. Untuk membuat integration test, kamu pertama-tama memerlukan direktori tests.

Direktori tests

Kita membuat direktori tests di level teratas direktori proyek, bersebelahan dengan src. Cargo tahu bahwa ia harus mencari file integration test di direktori ini. Setelah itu, kita bisa membuat sebanyak apapun file test yang kita mau, dan Cargo akan mengompilasi masing-masing file sebagai crate tersendiri.

Mari kita buat sebuah integration test. Dengan kode dari Listing 11-12 masih berada di file src/lib.rs, buatlah direktori tests, lalu buat file baru bernama tests/integration_test.rs. Struktur direktori kamu seharusnya terlihat seperti ini:

adder
├── Cargo.lock
├── Cargo.toml
├── src
│   └── lib.rs
└── tests
    └── integration_test.rs

Masukkan kode dari Listing 11-13 ke dalam file tests/integration_test.rs.

Filename: tests/integration_test.rs
use adder::add_two;

#[test]
fn it_adds_two() {
    let result = add_two(2);
    assert_eq!(result, 4);
}
Listing 11-13: An integration test of a function in the adder crate

Setiap file di direktori tests adalah crate tersendiri, jadi kita perlu membawa library kita ke dalam scope tiap crate test. Untuk itulah kita menambahkan use adder::add_two; di bagian atas kode, yang tidak kita perlukan pada unit test.

Kita tidak perlu menandai kode apapun di tests/integration_test.rs dengan #[cfg(test)]. Cargo memperlakukan direktori tests secara khusus dan hanya mengompilasi file-file di direktori ini saat kita menjalankan cargo test. Sekarang jalankan cargo test:

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

running 1 test
test tests::internal ... ok

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

     Running tests/integration_test.rs (target/debug/deps/integration_test-1082c4b063a8fbe6)

running 1 test
test 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

Tiga bagian pada keluaran itu mencakup unit test, integration test, dan doc test. Perhatikan bahwa jika ada test yang gagal di sebuah bagian, bagian-bagian setelahnya tidak akan dijalankan. Misalnya, jika sebuah unit test gagal, tidak akan ada keluaran untuk integration test dan doc test, karena test-test itu hanya akan dijalankan jika semua unit test lulus.

Bagian pertama untuk unit test sama seperti yang terus kita lihat: satu baris untuk setiap unit test (satu bernama internal yang kita tambahkan di Listing 11-12), lalu satu baris ringkasan untuk unit test.

Bagian integration test dimulai dengan baris Running tests/integration_test.rs. Berikutnya, ada satu baris untuk setiap fungsi test dalam integration test itu dan satu baris ringkasan untuk hasil integration test tepat sebelum bagian Doc-tests adder dimulai.

Setiap file integration test punya bagiannya sendiri, jadi kalau kita menambahkan lebih banyak file di direktori tests, akan ada lebih banyak bagian integration test.

Kita tetap bisa menjalankan satu fungsi integration test tertentu dengan menentukan nama fungsi itu sebagai argumen untuk cargo test. Untuk menjalankan semua test di dalam satu file integration test tertentu, gunakan argumen --test dari cargo test yang diikuti nama file tersebut:

$ cargo test --test integration_test
   Compiling adder v0.1.0 (file:///projects/adder)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.64s
     Running tests/integration_test.rs (target/debug/deps/integration_test-82e7799c1bc62298)

running 1 test
test it_adds_two ... ok

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

Perintah ini hanya menjalankan test-test di dalam file tests/integration_test.rs.

Submodule dalam Integration Test

Saat kamu menambahkan lebih banyak integration test, kamu mungkin ingin membuat lebih banyak file di direktori tests untuk membantu mengorganisasinya; misalnya, kamu bisa mengelompokkan fungsi-fungsi test berdasarkan fungsionalitas yang mereka uji. Seperti disebutkan sebelumnya, setiap file di direktori tests dikompilasi sebagai crate tersendiri, yang berguna untuk membuat scope terpisah agar lebih menyerupai cara pemakai akhir memakai crate kamu. Namun, ini berarti file-file di direktori tests tidak berperilaku sama seperti file-file di src, seperti yang kamu pelajari di Bab 7 tentang cara memisahkan kode ke dalam module dan file.

Perbedaan perilaku file-file di direktori tests ini paling terasa saat kamu memiliki sekumpulan fungsi pembantu yang dipakai di beberapa file integration test, lalu kamu mencoba mengikuti langkah-langkah di bagian “Separating Modules into Different Files” Bab 7 untuk mengekstraknya menjadi module bersama. Misalnya, jika kita membuat tests/common.rs dan meletakkan fungsi bernama setup di dalamnya, kita bisa menambahkan kode ke setup yang ingin kita panggil dari beberapa fungsi test di beberapa file test:

Filename: tests/common.rs

pub fn setup() {
    // setup code specific to your library's tests would go here
}

Saat kita menjalankan test lagi, kita akan melihat bagian baru pada keluaran test untuk file common.rs, meskipun file ini tidak berisi fungsi test apapun dan kita juga tidak memanggil fungsi setup dari mana pun:

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

running 1 test
test tests::internal ... ok

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

     Running tests/common.rs (target/debug/deps/common-92948b65e88960b4)

running 0 tests

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

     Running tests/integration_test.rs (target/debug/deps/integration_test-92948b65e88960b4)

running 1 test
test 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

Munculnya common di hasil test dengan tampilan running 0 tests bukanlah yang kita inginkan. Kita hanya ingin berbagi kode dengan file-file integration test lainnya. Untuk menghindari common muncul di keluaran test, alih-alih membuat tests/common.rs, kita akan membuat tests/common/mod.rs. Sekarang direktori proyek terlihat seperti ini:

├── Cargo.lock
├── Cargo.toml
├── src
│   └── lib.rs
└── tests
    ├── common
    │   └── mod.rs
    └── integration_test.rs

Ini adalah konvensi penamaan lama yang juga masih dipahami Rust dan kita singgung di “Alternate File Paths” Bab 7. Menamai file dengan cara ini memberi tahu Rust agar tidak memperlakukan module common sebagai file integration test. Saat kita memindahkan kode fungsi setup ke tests/common/mod.rs dan menghapus file tests/common.rs, bagian itu di keluaran test tidak akan muncul lagi. File-file di dalam subdirectory direktori tests tidak dikompilasi sebagai crate terpisah atau punya bagian tersendiri di keluaran test.

Setelah kita membuat tests/common/mod.rs, kita bisa memakainya dari file integration test manapun sebagai sebuah module. Berikut contoh memanggil fungsi setup dari test it_adds_two di tests/integration_test.rs:

Filename: tests/integration_test.rs

use adder::add_two;

mod common;

#[test]
fn it_adds_two() {
    common::setup();

    let result = add_two(2);
    assert_eq!(result, 4);
}

Perhatikan bahwa deklarasi mod common; sama dengan deklarasi module yang kita tunjukkan di Listing 7-21. Lalu, di dalam fungsi test, kita bisa memanggil fungsi common::setup().

Integration Test untuk Crate Biner

Jika proyek kita adalah crate biner yang hanya berisi file src/main.rs dan tidak punya file src/lib.rs, kita tidak bisa membuat integration test di direktori tests lalu membawa fungsi-fungsi yang didefinisikan di file src/main.rs ke dalam scope dengan pernyataan use. Hanya crate library yang mengekspos fungsi yang bisa dipakai crate lain; crate biner memang ditujukan untuk dijalankan sendiri.

Ini adalah salah satu alasan mengapa proyek Rust yang menyediakan biner punya file src/main.rs yang sederhana yang memanggil logika yang berada di file src/lib.rs. Dengan struktur seperti itu, integration test bisa menguji crate library dengan use agar fungsionalitas penting tersedia. Jika fungsionalitas penting itu bekerja, sedikit kode di file src/main.rs juga akan bekerja, dan sedikit kode itu tidak perlu diuji.

Ringkasan

Fitur testing Rust menyediakan cara untuk menentukan bagaimana kode seharusnya bekerja guna memastikan kode itu terus bekerja sesuai harapan, bahkan saat kamu melakukan perubahan. Unit test menguji bagian-bagian berbeda dari sebuah library secara terpisah dan bisa menguji detail implementasi private. Integration test memeriksa apakah banyak bagian dari library bekerja bersama dengan benar, dan mereka memakai API publik library untuk menguji kode dengan cara yang sama seperti kode eksternal akan memakainya. Meskipun sistem tipe dan aturan ownership Rust membantu mencegah beberapa jenis bug, test tetap penting untuk mengurangi bug logika yang berkaitan dengan perilaku yang diharapkan dari kode kamu.

Mari kita gabungkan pengetahuan yang kamu pelajari di bab ini dan bab-bab sebelumnya untuk mengerjakan sebuah proyek!