Belajar Rust - CI/CD, Testing, dan Release Workflow

#Pendahuluan

Kode yang berjalan di production harus melewati gerbang kualitas. Episode 17 membahas alur pengiriman: testing dalam berbagai level, pipeline CI/CD yang menjalankan semuanya secara otomatis, dan release management yang menghasilkan versi yang jelas dan bisa dilacak.

Cargo membawa tooling testing yang matang sejak awal — cargo test adalah standar emas yang tidak perlu setup rumit. Kalian akan melihat bagaimana testing, CI, dan release bekerja sebagai satu alur yang berkesinambungan.

#Unit dan Integration Testing

#Unit Test di Modul

Unit test ditulis di dalam file sumber, biasanya pada modul tests yang dijaga tidak ikut terkompilasi di production:

cat > src/lib.rs <<'EOF'
pub fn hitung_total(harga: u64, jumlah: u64) -> u64 {
    harga * jumlah
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn total_benar() {
        assert_eq!(hitung_total(5, 3), 15);
    }
 
    #[test]
    fn total_nol_jika_jumlah_nol() {
        assert_eq!(hitung_total(5, 0), 0);
    }
}
EOF
cargo test

#[cfg(test)] memastikan modul hanya ada saat testing. #[test] menandai fungsi penguji; assert_eq! memverifikasi hasil. cargo test mengompilasi dan menjalankan semua test, menampilkan ringkasan pass dan fail.

#Integration Test

Test integration berada di tests/ dan menguji crate dari luar, persis seperti pemakai nyata:

cat > tests/integrasi.rs <<'EOF'
use perpustakaan::hitung_total;
 
#[test]
fn pemakaian_dari_luar() {
    assert_eq!(hitung_total(10, 4), 40);
}
EOF
cargo test

File di tests/ dikompilasi sebagai crate terpisah. Ini membuktikan bahwa API publik kalian benar-benar bisa dipakai dari luar. Sebagian besar project menggunakan keduanya: unit test untuk logika internal, integration test untuk perilaku dari sudut pandang pemakai.

#Property-Based Testing dengan Proptest

#Menguji Banyak Kasus Sekaligus

Test biasa memakai input tetap. Property-based testing membangkitkan banyak input acak dan memverifikasi sifat (property) yang harus selalu benar. proptest adalah implementasi paling populer:

cargo add --dev proptest

cat > src/lib.rs <<'EOF'
pub fn saturasi_kuadrat(x: u32) -> u32 {
    x.saturating_mul(x)
}
 
#[cfg(test)]
mod tests {
    use super::*;
    use proptest::prelude::*;
 
    proptest! {
        #[test]
        fn kuadrat_tidak_overflow(n: u32) {
            let hasil = saturasi_kuadrat(n);
            assert!(hasil >= n);
        }
    }
}
EOF
cargo test

Macro proptest! membangkitkan ratusan nilai u32 dan menjalankan test untuk masing-masing. saturating_mul mencegah overflow. Property-based testing menemukan edge case yang tidak pernah terpikirkan saat menulis test manual.

#Memilih Strategi Testing

Pedoman: unit test untuk fungsi murni, integration test untuk API, dan property-based testing untuk fungsi dengan input besar atau aturan kompleks. Kombinasinya menangkap mayoritas bug sebelum masuk ke CI.

#Pipeline CI/CD dengan GitHub Actions

#Workflow Build dan Test

Setiap push ke repository memicu pipeline: format check, lint, test, lalu build. GitHub Actions adalah pilihan paling umum untuk project Rust:

name: ci
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - run: cargo fmt --check
      - run: cargo clippy -- -D warnings
      - run: cargo test
      - run: cargo build --release

dtolnay/rust-toolchain@stable menyiapkan toolchain stable. Empat perintah utama: cargo fmt --check memastikan format konsisten, cargo clippy -- -D warnings menolak lint, cargo test menjalankan test, dan cargo build --release memverifikasi build production. cargo test dengan cache bisa memakan beberapa menit; gunakan action caching untuk mempercepat.

#GitLab CI dan Tekton

Prinsip yang sama berlaku di GitLab CI dengan gitlab-ci.yml:

test:
  image: rust:latest
  script:
    - cargo fmt --check
    - cargo clippy -- -D warnings
    - cargo test

Tekton adalah pipeline Kubernetes-native: setiap step adalah pod. Konsepnya identik — jalankan fmt, clippy, test, build — hanya cara penyajiannya berbeda. Pilih pipeline yang selaras dengan platform tim kalian.

#Release Management dan Semantic Versioning

#Semantic Versioning

Rilis mengikuti semver: major.minor.patch. Patch untuk perbaikan bug, minor untuk fitur kompatibel, major untuk perubahan yang memecah API. Cargo memakai semver untuk resolusi dependency (episode 7), jadi memilih versi dengan benar penting untuk ekosistem.

#Otomasi Release

cargo release mengelola langkah-langkah rilis: menaikkan versi di Cargo.toml, membuat tag git, dan menjalankan publish:

cargo install cargo-release
cargo release minor

cargo release minor menaikkan versi minor, membuat commit dan tag, lalu menandai milestone. cargo install cargo-release memasang tool-nya sekali. Untuk crate di crates.io, cargo publish mengunggah paket; untuk binary, distribusikan lewat release GitHub atau arsitektur seperti cargo-binstall.

#Distribusi Binary

Untuk distribusi binary di banyak platform, pipeline membangun matrix target — Linux, macOS, Windows — dan mengunggah artifact ke GitHub Release. Tool seperti cargo-dist mengotomasi pembuatan installer dan format per platform.

#Penutup

Inti yang harus dibawa pulang:

• cargo test menjalankan unit dan integration test dalam satu perintah.
• Unit test di modul tests; integration test di direktori tests/.
• Proptest membangkitkan input acak untuk memverifikasi property.
• CI wajib: fmt check, clippy, test, dan build release.
• Semver menentukan kompatibilitas dan resolusi dependency.
• cargo release dan cargo publish mengotomasi rilis dan distribusi.

Di episode 18 selanjutnya, sebagai penutup series, kita akan membahas tooling modern dan fitur stabil terbaru — cargo, rustfmt, clippy, rust-analyzer, dan cargo nextest, fitur stabil terbaru seperti async dan impl Trait, serta tren produksi Rust di full-stack, microservices, embedded, dan safe systems programming.