Belajar Rust,
pelan-pelan saja.

Masuk bab 0, tampilkan lokasinya, kembali ke folder kursus; prediksi dua keluaran pwd.

cd /home/sysadmin/lab/belajar-rust/0-inisialisasi
pwd
cd ..
pwd

Di Remote-SSH, Rust dipasang di laptop atau server? Bedakan rustup, rustc dan Cargo.

2-hello-world-dan-cargo/contoh/Cargo.toml

[package]
name = "bab02-hello"
version = "0.1.0"
edition = "2021"

[dependencies]

2-hello-world-dan-cargo/contoh/src/main.rs

/// Program pertama: menyapa dan mencetak hasil hitungan sederhana.
/// Menjalankan: cargo run
fn main() {
    // println! adalah macro (perhatikan tanda seru).
    // {} adalah lubang yang diisi nilai setelah koma.
    println!("Halo, Rust!");
    println!("Perkenalkan, saya program daftar tugas.");

    // Lubang bisa diisi langsung dari nama variabel,
    // atau dari hasil perhitungan.
    let tahun = 2026;
    println!("Belajar di tahun {tahun}.");
    println!("2 + 3 = {}", 2 + 3);

    // Panggil fungsi biasa yang kita buat sendiri.
    let pesan = sapaan("Rustacean baru");
    println!("{pesan}");
}

/// Fungsi sederhana: menerima &str, mengembalikan String.
fn sapaan(nama: &str) -> String {
    format!("Selamat datang, {nama}!")
}

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

    #[test]
    fn sapaan_berisi_nama() {
        assert_eq!(sapaan("Andi"), "Selamat datang, Andi!");
    }
}

Buat fungsi yang menerima sisi 4 dan mengembalikan 16.

fn luas_persegi(sisi: u32) -> u32 {
    sisi * sisi
}

3-variabel-dan-tipe-data/contoh/Cargo.toml

[package]
name = "bab03-variabel"
version = "0.1.0"
edition = "2021"

[dependencies]

3-variabel-dan-tipe-data/contoh/src/main.rs

/// Menyimpan satu tugas dengan variabel, lalu mengubahnya.
/// Menjalankan: cargo run
// Konstanta: nama kapital, tipe wajib ditulis, dihitung saat kompilasi.
const MAKS_JUDUL: usize = 200;

fn main() {
    // Variabel immutable: label ini tidak bisa dipindah ke nilai lain.
    let id: i64 = 1;
    let judul = "Belajar variabel"; // tipe ditebak: &str
    let mut selesai = false;        // mut: isi boleh diganti

    println!("Tugas #{id}: {judul} ({})", status_teks(selesai));

    selesai = true; // OK karena ada mut
    println!("Setelah diubah: ({})", status_teks(selesai));

    // Shadowing: variabel BARU menutupi nama lama, tipe boleh beda.
    let jumlah = "42";
    let jumlah: u32 = jumlah.parse().expect("bukan angka");
    println!("Shadowing: \"42\" -> {jumlah}");

    println!("Konstanta batas judul: {MAKS_JUDUL}");

    // Konversi angka dengan `as`: memotong desimal, bukan membulatkan.
    let pecahan: f64 = 3.9;
    let bulat = pecahan as i32;
    println!("Konversi: {pecahan} -> {bulat}");

    // char adalah SATU karakter Unicode.
    let tanda: char = '✓';
    println!("Tanda selesai: {tanda}");
}

/// Mengubah bool menjadi teks ramah.
fn status_teks(selesai: bool) -> &'static str {
    if selesai {
        "sudah selesai"
    } else {
        "belum selesai"
    }
}

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

    #[test]
    fn konversi_memotong_desimal() {
        assert_eq!(3.9_f64 as i32, 3);
        assert_eq!(-3.9_f64 as i32, -3);
    }

    #[test]
    fn batas_judul_masuk_akal() {
        assert!(MAKS_JUDUL > 0);
        assert_eq!(status_teks(true), "sudah selesai");
    }
}

Ubah teks "90" ke u32 lewat shadowing dan cetak “Durasi: 90 menit”.

let durasi = "90";
let durasi: u32 = durasi.parse().expect("bukan angka");
println!("Durasi: {durasi} menit");

4-fungsi-dan-control-flow/contoh/Cargo.toml

[package]
name = "bab04-fungsi"
version = "0.1.0"
edition = "2021"

[dependencies]

4-fungsi-dan-control-flow/contoh/src/main.rs

/// Fungsi, keputusan, dan pengulangan pada daftar tugas sederhana.
/// Menjalankan: cargo run
fn main() {
    // Daftar tugas: pasangan (judul, sudah_selesai).
    let tugas = [
        ("Belajar fungsi", false),
        ("Belajar variabel", true),
        ("Belajar loop", false),
    ];

    tampilkan(&tugas);

    let teks = ringkasan(&tugas);
    println!("Ringkasan: {teks}");

    println!("Prioritas #1: {}", prioritas(1));
    println!("Prioritas #5: {}", prioritas(5));

    hitung_mundur(3);
}

/// Menampilkan setiap tugas dengan kotak centang.
/// `&[(...)]` adalah slice: daftar yang DIPINJAMKAN, bukan dipindahkan (bab 5).
fn tampilkan(tugas: &[(&str, bool)]) {
    for (judul, selesai) in tugas {
        // if sebagai expression: memilih nilai tanpa variabel perantara.
        let tanda = if *selesai { "x" } else { " " };
        println!("- [{tanda}] {judul}");
    }
}

/// Membuat kalimat ringkasan. Baris terakhir tanpa titik koma = nilai kembali.
fn ringkasan(tugas: &[(&str, bool)]) -> String {
    let mut selesai = 0_u32;
    for (_, s) in tugas {
        if *s {
            selesai += 1;
        }
    }
    let total = tugas.len() as u32;
    format!("{total} tugas, {selesai} selesai, sisa {}", total - selesai)
}

/// match pada angka: compiler memastikan semua kemungkinan ditangani.
fn prioritas(nomor: u32) -> &'static str {
    match nomor {
        1 => "tinggi",
        2 | 3 => "sedang", // | artinya "atau"
        _ => "biasa",      // _ menangkap semua sisanya
    }
}

/// while: ulangi selama kondisi benar. Cocok bila jumlah ulang tak pasti.
fn hitung_mundur(mut dari: u32) {
    print!("Hitung mundur:");
    while dari > 0 {
        print!(" {dari}");
        dari -= 1;
    }
    println!(" selesai!");
}

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

    #[test]
    fn ringkasan_menghitung_dengan_benar() {
        let tugas = [("a", true), ("b", false), ("c", true)];
        assert_eq!(ringkasan(&tugas), "3 tugas, 2 selesai, sisa 1");
    }

    #[test]
    fn ringkasan_daftar_kosong() {
        assert_eq!(ringkasan(&[]), "0 tugas, 0 selesai, sisa 0");
    }

    #[test]
    fn prioritas_semua_cabang() {
        assert_eq!(prioritas(1), "tinggi");
        assert_eq!(prioritas(3), "sedang");
        assert_eq!(prioritas(99), "biasa");
    }
}

Tulis fungsi sisa(total: u32, selesai: u32) -> u32. Jika 5 total dan 2 selesai, hasilnya 3.

fn sisa(total: u32, selesai: u32) -> u32 {
    total - selesai
}

5-ownership-dan-borrowing/contoh/Cargo.toml

[package]
name = "bab05-ownership"
version = "0.1.0"
edition = "2021"

[dependencies]

5-ownership-dan-borrowing/contoh/src/main.rs

/// Ownership, borrowing, dan slice dalam satu cerita kecil.
/// Menjalankan: cargo run
fn main() {
    // --- Meminjam untuk membaca ---
    let judul = String::from("Belajar Rust");
    let n = hitung_panjang(&judul); // dipinjam, bukan dipindah
    println!("Panjang \"{judul}\": {n}");

    // --- Meminjam untuk mengubah ---
    let mut judul_lengkap = judul; // ownership pindah ke judul_lengkap
    tandai_selesai(&mut judul_lengkap);
    println!("Setelah ditandai: {judul_lengkap}");

    // --- Slice: jendela ke sebagian data ---
    let daftar = [String::from("Belajar Rust"), String::from("Belajar slice")];
    println!("Judul pertama: {}", judul_pertama(&daftar));
    println!("Jumlah judul: {}", daftar.len());

    // CONTOH GAGAL 1: hapus "//" pada dua baris ini lalu jalankan cargo check.
    // let pemilik = String::from("halo");
    // let r1 = &pemilik; let r2 = &mut pemilik; println!("{r1} {r2}");

    // CONTOH GAGAL 2: nilai yang sudah pindah tidak bisa dipakai lagi.
    // let a = String::from("pindah"); let b = a; println!("{a}");
}

/// Membaca lewat pinjaman: `&String` tidak mengambil kepemilikan.
fn hitung_panjang(teks: &String) -> usize {
    teks.len()
}

/// Mengubah lewat pinjaman mutabel: hanya boleh SATU pada satu waktu.
fn tandai_selesai(teks: &mut String) {
    teks.push_str(" [SELESAI]");
}

/// Mengembalikan pinjaman dari parameter; detail lifetime di bab 10.
fn judul_pertama(daftar: &[String]) -> &str {
    &daftar[0]
}

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

    #[test]
    fn menandai_menambah_akhiran() {
        let mut s = String::from("tugas");
        tandai_selesai(&mut s);
        assert_eq!(s, "tugas [SELESAI]");
    }

    #[test]
    fn judul_pertama_adalah_pinjaman() {
        let daftar = [String::from("satu"), String::from("dua")];
        let pertama = judul_pertama(&daftar);
        assert_eq!(pertama, "satu");
        // daftar masih utuh karena hanya dipinjam.
        assert_eq!(daftar.len(), 2);
    }
}

Kenapa let baca = &x; let tulis = &mut x; println!("{baca:?}"); gagal? Bagaimana mengaturnya?

let mut x = vec![1];
let baca = &x;
println!("{baca:?}"); // pembaca selesai dipakai
let tulis = &mut x;
tulis.push(2);

6-string-slice-dan-collections/contoh/Cargo.toml

[package]
name = "bab06-collections"
version = "0.1.0"
edition = "2021"

[dependencies]

6-string-slice-dan-collections/contoh/src/main.rs

/// String/&str, Vec, HashMap, iterator, dan catatan Unicode.
/// Menjalankan: cargo run
use std::collections::HashMap;

fn main() {
    // Vec: daftar tugas yang bisa tumbuh.
    let mut tugas: Vec<(String, bool)> = Vec::new();
    tugas.push(("Belajar Vec".to_owned(), true));
    tugas.push(("Belajar HashMap".to_owned(), false));
    tugas.push(("Belajar iterator".to_owned(), false));

    let semua: Vec<&str> = tugas.iter().map(|t| t.0.as_str()).collect();
    println!("Semua: {semua:?}");
    println!("Yang selesai: {:?}", judul_selesai(&tugas));

    // HashMap: mencari tugas berdasarkan ID.
    let mut per_id: HashMap<i64, String> = HashMap::new();
    for (i, (judul, _)) in tugas.iter().enumerate() {
        per_id.insert((i + 1) as i64, judul.clone());
    }
    println!("Cari ID 2: {:?}", cari(&per_id, 2));

    // Unicode: byte ≠ karakter.
    let teks = "hàlo";
    println!(
        "Byte vs karakter \"{teks}\": {} byte, {} karakter",
        teks.len(),
        teks.chars().count()
    );
}

/// Mengambil judul tugas yang sudah selesai dengan iterator.
/// Baca: untuk tiap tugas -> saring yang selesai -> ambil judul -> kumpulkan.
fn judul_selesai(tugas: &[(String, bool)]) -> Vec<&str> {
    tugas
        .iter()
        .filter(|(_, selesai)| *selesai)
        .map(|(judul, _)| judul.as_str())
        .collect()
}

/// get() mengembalikan Option: Some jika ada, None jika tidak (bab 8).
fn cari<'a>(per_id: &'a HashMap<i64, String>, id: i64) -> Option<&'a String> {
    per_id.get(&id)
}

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

    #[test]
    fn filter_hanya_yang_selesai() {
        let tugas = vec![
            ("a".to_owned(), true),
            ("b".to_owned(), false),
            ("c".to_owned(), true),
        ];
        assert_eq!(judul_selesai(&tugas), vec!["a", "c"]);
    }

    #[test]
    fn cari_yang_tidak_ada() {
        let map = HashMap::new();
        assert_eq!(cari(&map, 99), None);
    }

    #[test]
    fn byte_beda_dari_karakter() {
        assert_eq!("hàlo".len(), 5);
        assert_eq!("hàlo".chars().count(), 4);
    }
}

Buat Vec baru berisi judul-judul berhuruf besar dari Vec tugas.

let besar: Vec<String> = tugas.iter()
    .map(|(judul, _)| judul.to_uppercase())
    .collect();

7-struct-enum-dan-pattern-matching/contoh/Cargo.toml

[package]
name = "bab07-model"
version = "0.1.0"
edition = "2021"

[dependencies]

7-struct-enum-dan-pattern-matching/contoh/src/main.rs

#[derive(Debug, Clone, PartialEq)]
enum Status {
    Baru,
    Dikerjakan { oleh: String },
    Selesai,
}

#[derive(Debug, Clone, PartialEq)]
struct Tugas {
    id: u32,
    judul: String,
    status: Status,
}

impl Tugas {
    // Fungsi pembuat: belum memiliki sebuah nilai self.
    fn baru(id: u32, judul: &str) -> Self {
        Self {
            id,
            judul: judul.to_owned(),
            status: Status::Baru,
        }
    }

    fn mulai(&mut self, oleh: &str) {
        self.status = Status::Dikerjakan {
            oleh: oleh.to_owned(),
        };
    }

    fn selesaikan(&mut self) {
        self.status = Status::Selesai;
    }

    fn sudah_selesai(&self) -> bool {
        self.status == Status::Selesai
    }

    fn ringkasan(&self) -> String {
        // Pinjam status agar String di dalamnya tidak dipindahkan.
        let keterangan = match &self.status {
            Status::Baru => String::from("baru"),
            Status::Dikerjakan { oleh } => format!("dikerjakan oleh {oleh}"),
            Status::Selesai => String::from("selesai"),
        };
        format!("#{} {} [{}]", self.id, self.judul, keterangan)
    }
}

fn main() {
    let mut tugas = Tugas::baru(1, "Belajar struct");
    println!("Awal: {tugas:?}");

    tugas.mulai("Rani");
    if let Status::Dikerjakan { oleh } = &tugas.status {
        println!("Penanggung jawab: {oleh}");
    }
    println!("{}", tugas.ringkasan());

    let salinan = tugas.clone();
    println!("Salinan sama: {}", salinan == tugas);
    tugas.selesaikan();
    println!("{}", tugas.ringkasan());
    println!("Salinan ikut selesai: {}", salinan.sudah_selesai());
}

#[cfg(test)]
mod tests {
    use super::{Status, Tugas};

    #[test]
    fn tugas_baru_memiliki_status_baru() {
        let tugas = Tugas::baru(7, "Latihan");
        assert_eq!(tugas.status, Status::Baru);
        assert_eq!(tugas.ringkasan(), "#7 Latihan [baru]");
    }

    #[test]
    fn mengubah_asli_tidak_mengubah_salinan() {
        let mut asli = Tugas::baru(1, "Membaca");
        asli.mulai("Rani");
        let salinan = asli.clone();
        asli.selesaikan();
        assert!(asli.sudah_selesai());
        assert!(!salinan.sudah_selesai());
        assert_ne!(asli, salinan);
    }
}

Metode apa yang dibutuhkan untuk mengubah status dan untuk sekadar memeriksanya?

fn selesaikan(&mut self) { self.status = Status::Selesai; }
fn sudah_selesai(&self) -> bool { self.status == Status::Selesai }

8-option-result-dan-error-handling/contoh/Cargo.toml

[package]
name = "bab08-hasil"
version = "0.1.0"
edition = "2021"

[dependencies]

8-option-result-dan-error-handling/contoh/src/lib.rs

use std::error::Error;
use std::fmt;
use std::num::ParseIntError;

#[derive(Debug)]
pub enum ErrorInput {
    Kosong,
    Angka(ParseIntError),
    Nol,
}

impl fmt::Display for ErrorInput {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Kosong => write!(f, "ID tidak boleh kosong"),
            Self::Angka(_) => write!(f, "ID harus berupa angka dalam rentang u32"),
            Self::Nol => write!(f, "ID harus lebih besar dari nol"),
        }
    }
}

impl Error for ErrorInput {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::Angka(sumber) => Some(sumber),
            Self::Kosong | Self::Nol => None,
        }
    }
}

pub fn parse_id(input: &str) -> Result<u32, ErrorInput> {
    let input = input.trim();
    if input.is_empty() {
        return Err(ErrorInput::Kosong);
    }

    // map_err membungkus error bawaan; ? meneruskan Err ke pemanggil.
    let id = input.parse::<u32>().map_err(ErrorInput::Angka)?;
    if id == 0 {
        return Err(ErrorInput::Nol);
    }
    Ok(id)
}

pub fn cari_judul(id: u32) -> Option<&'static str> {
    // Teks literal hidup selama program berjalan; tidak meminjam input.
    match id {
        1 => Some("Membaca Option"),
        2 => Some("Menulis pengujian"),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::{cari_judul, parse_id, ErrorInput};
    use std::error::Error;

    #[test]
    fn angka_valid_dan_spasi_diterima() {
        assert!(matches!(parse_id(" 2 "), Ok(2)));
        assert!(matches!(parse_id("4294967295"), Ok(u32::MAX)));
    }

    #[test]
    fn kosong_dan_nol_ditolak() {
        assert!(matches!(parse_id(" \t "), Err(ErrorInput::Kosong)));
        assert!(matches!(parse_id("0"), Err(ErrorInput::Nol)));
    }

    #[test]
    fn teks_negatif_dan_angka_terlalu_besar_ditolak() {
        for input in ["abc", "-1", "4294967296"] {
            assert!(matches!(parse_id(input), Err(ErrorInput::Angka(_))));
        }
    }

    #[test]
    fn error_parse_menyimpan_penyebab() {
        let error = parse_id("abc").expect_err("abc bukan ID yang valid");
        assert!(error.source().is_some());
        assert_eq!(error.to_string(), "ID harus berupa angka dalam rentang u32");
    }

    #[test]
    fn pencarian_bisa_tidak_menemukan_tugas() {
        assert_eq!(cari_judul(2), Some("Menulis pengujian"));
        assert_eq!(cari_judul(99), None);
    }
}

8-option-result-dan-error-handling/contoh/src/main.rs

use bab08_hasil::{cari_judul, parse_id};

fn main() {
    for input in [" 2 ", "", "abc", "0", "9"] {
        match parse_id(input) {
            Ok(id) => match cari_judul(id) {
                Some(judul) => println!("ID {id}: {judul}"),
                None => println!("ID {id}: tugas tidak ditemukan"),
            },
            Err(error) => println!("Input {input:?} ditolak: {error}"),
        }
    }
}

Bagaimana hasil parse_id(" "), parse_id("0"), parse_id("abc"), parse_id("2")?

9-module-dan-crate/contoh/Cargo.toml

[package]
name = "bab09-modul"
version = "0.1.0"
edition = "2021"

[dependencies]

9-module-dan-crate/contoh/src/tugas.rs

#[derive(Debug)]
pub struct Tugas {
    id: usize,
    judul: String,
    selesai: bool,
}

impl Tugas {
    // Hanya kode dalam library crate ini yang boleh membuat Tugas langsung.
    pub(crate) fn baru(id: usize, judul: &str) -> Self {
        Self {
            id,
            judul: judul.to_owned(),
            selesai: false,
        }
    }

    pub fn id(&self) -> usize {
        self.id
    }

    pub fn judul(&self) -> &str {
        &self.judul
    }

    pub fn sudah_selesai(&self) -> bool {
        self.selesai
    }

    pub(crate) fn selesaikan(&mut self) {
        self.selesai = true;
    }
}

9-module-dan-crate/contoh/src/daftar.rs

use crate::tugas::Tugas;

#[derive(Debug)]
pub struct DaftarTugas {
    tugas: Vec<Tugas>,
}

impl DaftarTugas {
    pub fn baru() -> Self {
        Self { tugas: Vec::new() }
    }

    pub fn tambah(&mut self, judul: &str) -> usize {
        // Contoh ini tidak menghapus tugas, jadi panjang + 1 menjadi ID baru.
        let id = self.tugas.len() + 1;
        self.tugas.push(Tugas::baru(id, judul));
        id
    }

    pub fn selesaikan(&mut self, id: usize) -> bool {
        if let Some(tugas) = self.tugas.iter_mut().find(|tugas| tugas.id() == id) {
            tugas.selesaikan();
            true
        } else {
            false
        }
    }

    pub fn semua(&self) -> &[Tugas] {
        &self.tugas
    }
}

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

    #[test]
    fn id_berurutan_dan_status_terpisah() {
        let mut daftar = DaftarTugas::baru();
        assert_eq!(daftar.tambah("Pertama"), 1);
        assert_eq!(daftar.tambah("Kedua"), 2);
        assert!(daftar.selesaikan(1));
        assert!(daftar.semua()[0].sudah_selesai());
        assert!(!daftar.semua()[1].sudah_selesai());
        assert!(!daftar.selesaikan(99));
    }
}

9-module-dan-crate/contoh/src/lib.rs

mod daftar;
mod tugas;

// Pengguna cukup mengenal dua nama ini, bukan susunan file internal.
pub use daftar::DaftarTugas;
pub use tugas::Tugas;

9-module-dan-crate/contoh/src/main.rs

use bab09_modul::DaftarTugas;

fn main() {
    let mut daftar = DaftarTugas::baru();
    let pertama = daftar.tambah("Pelajari modul");
    daftar.tambah("Pisahkan file");
    daftar.selesaikan(pertama);

    for tugas in daftar.semua() {
        let status = if tugas.sudah_selesai() {
            "selesai"
        } else {
            "belum selesai"
        };
        println!("#{} {} [{status}]", tugas.id(), tugas.judul());
    }
    println!("ID 99 ditemukan: {}", daftar.selesaikan(99));
}

Tambah method publik jumlah pada DaftarTugas.

// Di dalam impl DaftarTugas pada daftar.rs
pub fn jumlah(&self) -> usize { self.tugas.len() }

10-trait-generics-dan-lifetime-dasar/contoh/Cargo.toml

[package]
name = "bab10-abstraksi"
version = "0.1.0"
edition = "2021"

[dependencies]

10-trait-generics-dan-lifetime-dasar/contoh/src/lib.rs

pub trait Ringkas {
    fn ringkas(&self) -> String;
}

#[derive(Debug)]
pub struct Tugas {
    judul: String,
    selesai: bool,
}

impl Tugas {
    pub fn baru(judul: &str, selesai: bool) -> Self {
        Self {
            judul: judul.to_owned(),
            selesai,
        }
    }
}

impl Ringkas for Tugas {
    fn ringkas(&self) -> String {
        let status = if self.selesai { "selesai" } else { "belum" };
        format!("{} ({status})", self.judul)
    }
}

impl Ringkas for String {
    fn ringkas(&self) -> String {
        format!("Catatan: {self}")
    }
}

#[derive(Debug)]
pub struct Wadah<T> {
    isi: T,
}

// Metode ini tersedia untuk semua tipe T.
impl<T> Wadah<T> {
    pub fn baru(isi: T) -> Self {
        Self { isi }
    }

    pub fn isi(&self) -> &T {
        &self.isi
    }
}

// Metode ini hanya tersedia jika T mengimplementasikan Ringkas.
impl<T: Ringkas> Wadah<T> {
    pub fn ringkasan(&self) -> String {
        self.isi.ringkas()
    }
}

pub fn buat_label<T: Ringkas>(nilai: &T) -> String {
    format!("Ringkasan: {}", nilai.ringkas())
}

pub fn judul_lebih_panjang<'a>(kiri: &'a str, kanan: &'a str) -> &'a str {
    // Hitung char, bukan byte; jika sama panjang, pilih kiri.
    if kiri.chars().count() >= kanan.chars().count() {
        kiri
    } else {
        kanan
    }
}

#[cfg(test)]
mod tests {
    use super::{buat_label, judul_lebih_panjang, Tugas, Wadah};

    #[test]
    fn wadah_tanpa_bound_bisa_menyimpan_angka() {
        let wadah = Wadah::baru(42);
        assert_eq!(*wadah.isi(), 42);
    }

    #[test]
    fn trait_yang_sama_memiliki_dua_implementasi() {
        let tugas = Tugas::baru("Belajar", false);
        assert_eq!(buat_label(&tugas), "Ringkasan: Belajar (belum)");
        let catatan = Wadah::baru(String::from("Baca ulang"));
        assert_eq!(catatan.ringkasan(), "Catatan: Baca ulang");
    }

    #[test]
    fn pilihan_judul_mencakup_kedua_cabang_dan_seri() {
        assert_eq!(judul_lebih_panjang("Rust", "Go"), "Rust");
        assert_eq!(judul_lebih_panjang("Go", "Rust"), "Rust");
        assert_eq!(judul_lebih_panjang("ab", "cd"), "ab");
        assert_eq!(judul_lebih_panjang("", ""), "");
    }

    #[test]
    fn panjang_tidak_dihitung_dalam_byte() {
        assert_eq!(judul_lebih_panjang("é", "ab"), "ab");
    }
}

10-trait-generics-dan-lifetime-dasar/contoh/src/main.rs

use bab10_abstraksi::{buat_label, judul_lebih_panjang, Tugas, Wadah};

fn main() {
    let tugas = Wadah::baru(Tugas::baru("Belajar trait", false));
    println!("{}", tugas.ringkasan());

    let catatan = String::from("Ulangi contoh");
    println!("{}", buat_label(&catatan));

    let angka = Wadah::baru(42);
    println!("Isi angka: {}", angka.isi());

    let kiri = String::from("Baca");
    let kanan = String::from("Tulis pengujian");
    let pilihan = judul_lebih_panjang(&kiri, &kanan);
    println!("Judul lebih panjang: {pilihan}");
}

Definisikan kemampuan bunyi(&self) -> String untuk i32.

trait Bersuara { fn bunyi(&self) -> String; }
impl Bersuara for i32 {
    fn bunyi(&self) -> String { format!("angka {self}") }
}

11-testing-dan-debugging/contoh/Cargo.toml

[package]
name = "bab11-uji"
version = "0.1.0"
edition = "2021"

[dependencies]

11-testing-dan-debugging/contoh/src/lib.rs

use std::error::Error;
use std::fmt;

#[derive(Debug, PartialEq)]
pub enum ErrorTugas {
    JudulKosong,
    TidakDitemukan(usize),
}

impl fmt::Display for ErrorTugas {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::JudulKosong => write!(f, "judul tidak boleh kosong"),
            Self::TidakDitemukan(id) => write!(f, "tugas dengan ID {id} tidak ditemukan"),
        }
    }
}

impl Error for ErrorTugas {}

#[derive(Debug, PartialEq)]
pub struct Tugas {
    id: usize,
    judul: String,
    selesai: bool,
}

impl Tugas {
    pub fn id(&self) -> usize { self.id }
    pub fn judul(&self) -> &str { &self.judul }
    pub fn sudah_selesai(&self) -> bool { self.selesai }
}

#[derive(Debug)]
pub struct DaftarTugas { tugas: Vec<Tugas> }

impl DaftarTugas {
    pub fn baru() -> Self { Self { tugas: Vec::new() } }

    pub fn tambah(&mut self, judul: &str) -> Result<usize, ErrorTugas> {
        // Validasi dilakukan sebelum data berubah atau ID dialokasikan.
        let judul = bersihkan_judul(judul)?;
        let id = self.tugas.len() + 1;
        self.tugas.push(Tugas { id, judul, selesai: false });
        Ok(id)
    }

    pub fn cari(&self, id: usize) -> Option<&Tugas> {
        self.tugas.iter().find(|tugas| tugas.id == id)
    }

    pub fn selesaikan(&mut self, id: usize) -> Result<(), ErrorTugas> {
        let tugas = self.tugas.iter_mut()
            .find(|tugas| tugas.id == id)
            .ok_or(ErrorTugas::TidakDitemukan(id))?;
        tugas.selesai = true;
        Ok(())
    }
}

fn bersihkan_judul(judul: &str) -> Result<String, ErrorTugas> {
    let judul = judul.trim();
    if judul.is_empty() {
        Err(ErrorTugas::JudulKosong)
    } else {
        Ok(judul.to_owned())
    }
}

#[cfg(test)]
mod tests {
    use super::{bersihkan_judul, DaftarTugas, ErrorTugas};

    #[test]
    fn judul_dirapikan_tanpa_menghapus_spasi_tengah() {
        assert_eq!(bersihkan_judul("  Belajar Rust \n"),
            Ok(String::from("Belajar Rust")));
    }

    #[test]
    fn judul_kosong_termasuk_whitespace_ditolak() {
        for judul in ["", " ", "\n\t"] {
            assert_eq!(bersihkan_judul(judul), Err(ErrorTugas::JudulKosong));
        }
    }

    #[test]
    fn daftar_baru_tidak_memiliki_tugas() {
        let daftar = DaftarTugas::baru();
        assert!(daftar.tugas.is_empty());
        assert_eq!(daftar.cari(1), None);
    }

    #[test]
    fn pesan_error_menyertakan_id() {
        assert_eq!(ErrorTugas::TidakDitemukan(9).to_string(),
            "tugas dengan ID 9 tidak ditemukan");
    }
}

11-testing-dan-debugging/contoh/src/main.rs

use bab11_uji::{DaftarTugas, ErrorTugas};

fn main() -> Result<(), ErrorTugas> {
    let mut daftar = DaftarTugas::baru();
    let id = daftar.tambah("  Tulis tes pertama  ")?;
    daftar.selesaikan(id)?;

    if let Some(tugas) = daftar.cari(id) {
        println!("#{} {} | selesai: {}", tugas.id(), tugas.judul(), tugas.sudah_selesai());
    }
    if let Err(error) = daftar.tambah("   ") {
        println!("Ditolak: {error}");
    }
    if let Err(error) = daftar.selesaikan(99) {
        println!("Ditolak: {error}");
    }
    Ok(())
}

11-testing-dan-debugging/contoh/tests/alur_tugas.rs

// Integration test: hanya API publik dari library yang terlihat.
use bab11_uji::{DaftarTugas, ErrorTugas};

#[test]
fn tambah_cari_dan_selesaikan_melalui_api_publik() {
    let mut daftar = DaftarTugas::baru();
    let pertama = daftar.tambah("  Baca modul  ").expect("judul valid");
    let kedua = daftar.tambah("Tulis tes").expect("judul valid");
    assert_eq!((pertama, kedua), (1, 2));
    let tugas = daftar.cari(pertama).expect("tugas baru harus ada");
    assert_eq!(tugas.id(), pertama);
    assert_eq!(tugas.judul(), "Baca modul");
    assert!(!tugas.sudah_selesai());
    assert_eq!(daftar.selesaikan(pertama), Ok(()));
    assert!(daftar.cari(pertama).expect("ID pertama").sudah_selesai());
    assert!(!daftar.cari(kedua).expect("ID kedua").sudah_selesai());
}

#[test]
fn input_gagal_tidak_menghabiskan_id_atau_mengubah_tugas() {
    let mut daftar = DaftarTugas::baru();
    assert_eq!(daftar.tambah(" \t"), Err(ErrorTugas::JudulKosong));
    assert_eq!(daftar.tambah("Tetap utuh"), Ok(1));
    assert_eq!(daftar.selesaikan(99), Err(ErrorTugas::TidakDitemukan(99)));
    assert_eq!(daftar.cari(99), None);
    let tugas = daftar.cari(1).expect("tugas valid tetap ada");
    assert_eq!(tugas.judul(), "Tetap utuh");
    assert!(!tugas.sudah_selesai());
    assert_eq!(daftar.tambah("Berikutnya"), Ok(2));
}

#[test]
fn menyelesaikan_dua_kali_tetap_berhasil() {
    let mut daftar = DaftarTugas::baru();
    let id = daftar.tambah("Sekali saja").expect("judul valid");
    assert_eq!(daftar.selesaikan(id), Ok(()));
    assert_eq!(daftar.selesaikan(id), Ok(()));
    assert!(daftar.cari(id).expect("tugas tetap ada").sudah_selesai());
}

Uji tugas pertama memperoleh ID 1.

#[test]
fn tugas_pertama_id_satu() {
    let mut daftar = DaftarTugas::baru();
    assert_eq!(daftar.tambah("Belajar"), Ok(1));
}

12-proyek-cli-task-manager/contoh/Cargo.toml

[package]
name = "bab12-cli"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

12-proyek-cli-task-manager/contoh/src/main.rs

use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::ffi::OsString;
use std::fs::{self, OpenOptions};
use std::io::{self, Write};
use std::path::{Path, PathBuf};

// Format perintah yang ditampilkan ketika pengguna salah mengetik argumen.
const USAGE: &str = "Pemakaian: bab12-cli [--file PATH] add \"judul\" | list | done ID";

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct Task {
    id: i64,
    title: String,
    completed: bool,
}

#[derive(Debug, PartialEq)]
enum Command {
    // Setiap varian mewakili tepat satu tindakan; Add/Done juga menyimpan inputnya.
    Add(String),
    List,
    Done(i64),
}

fn title_valid(title: &str) -> bool {
    // chars() menghitung karakter Unicode, bukan jumlah byte UTF-8.
    (1..=200).contains(&title.chars().count()) && title == title.trim()
}

fn parse_args(args: Vec<OsString>) -> Result<(PathBuf, Command), String> {
    // args tidak memuat nama executable (main memanggil .skip(1)).
    let mut args = args.into_iter();
    let first = args.next().ok_or_else(|| USAGE.to_owned())?;
    // Path tetap OsString agar nama file non-UTF-8 tidak membuat program panik.
    let (path, command) = if first == "--file" {
        let path = PathBuf::from(args.next().ok_or("--file memerlukan PATH")?);
        if path.as_os_str().is_empty() {
            return Err("PATH tidak boleh kosong".into());
        }
        (path, args.next().ok_or_else(|| USAGE.to_owned())?)
    } else {
        (PathBuf::from("tasks.json"), first)
    };
    let command = command.into_string().map_err(|_| "Perintah harus UTF-8")?;
    let result = match command.as_str() {
        "add" => {
            let title = args.next().ok_or("add memerlukan satu judul dalam tanda kutip")?;
            let title = title.into_string().map_err(|_| "Judul harus UTF-8")?;
            let title = title.trim().to_owned();
            if !title_valid(&title) {
                return Err("Judul harus 1..200 karakter setelah trim".into());
            }
            Command::Add(title)
        }
        "list" => Command::List,
        "done" => {
            // Jangan izinkan angka negatif ataupun nol menjadi ID tugas.
            let raw = args.next().ok_or("done memerlukan ID")?;
            let raw = raw.into_string().map_err(|_| "ID harus UTF-8")?;
            let id = raw.parse::<i64>().map_err(|_| "ID harus bilangan bulat positif")?;
            if id <= 0 {
                return Err("ID harus bilangan bulat positif".into());
            }
            Command::Done(id)
        }
        _ => return Err(format!("Perintah tidak dikenal: {command}. {USAGE}")),
    };
    if args.next().is_some() {
        return Err(format!("Argumen berlebih. {USAGE}"));
    }
    Ok((path, result))
}

fn decode_tasks(contents: &str) -> Result<Vec<Task>, String> {
    // JSON yang sudah ada dibaca ke Vec<Task>; format rusak menjadi Err.
    let tasks: Vec<Task> = serde_json::from_str(contents)
        .map_err(|error| format!("JSON tidak valid: {error}"))?;
    let mut ids = HashSet::new();
    for task in &tasks {
        // Tolak data rusak, bukan diam-diam menimpa atau memperbaikinya.
        if task.id <= 0 || !ids.insert(task.id) || !title_valid(&task.title) {
            return Err("Data tidak valid: ID harus positif/unik dan judul valid".into());
        }
    }
    Ok(tasks)
}

fn load_tasks(path: &Path) -> Result<Vec<Task>, String> {
    // File belum ada berarti tugas masih kosong; error lain jangan disembunyikan.
    match fs::read_to_string(path) {
        Ok(contents) => decode_tasks(&contents),
        Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(Vec::new()),
        Err(error) => Err(format!("Gagal membaca {}: {error}", path.display())),
    }
}

fn add_task(tasks: &mut Vec<Task>, title: String) -> Result<i64, String> {
    // Validasi sebelum Vec berubah agar kegagalan tidak meninggalkan tugas setengah jadi.
    if !title_valid(&title) {
        return Err("Judul harus 1..200 karakter setelah trim".into());
    }
    // len() + 1 salah jika ID yang tersimpan tidak berurutan.
    let id = tasks.iter().map(|task| task.id).max().unwrap_or(0)
        .checked_add(1).ok_or("ID sudah mencapai batas i64")?;
    tasks.push(Task { id, title, completed: false });
    Ok(id)
}

fn mark_done(tasks: &mut [Task], id: i64) -> Result<(), String> {
    let task = tasks.iter_mut().find(|task| task.id == id)
        .ok_or_else(|| format!("Tugas #{id} tidak ditemukan"))?;
    task.completed = true;
    Ok(())
}

fn save_tasks(path: &Path, tasks: &[Task]) -> Result<(), String> {
    // Ubah Vec menjadi JSON dengan indentasi supaya file mudah dibaca manusia.
    let mut bytes = serde_json::to_vec_pretty(tasks)
        .map_err(|error| format!("Gagal membuat JSON: {error}"))?;
    bytes.push(b'\n');
    let mut temporary = path.as_os_str().to_os_string();
    temporary.push(".tmp");
    let temporary = PathBuf::from(temporary);
    // create_new mencegah penimpaan file sementara milik proses lain.
    let mut file = OpenOptions::new().write(true).create_new(true).open(&temporary)
        .map_err(|error| format!("Gagal membuat {}: {error}", temporary.display()))?;
    let written = file.write_all(&bytes).and_then(|()| file.sync_all());
    drop(file);
    // File sementara berada di direktori yang sama: rename atomik pada Linux.
    let result = written.and_then(|()| fs::rename(&temporary, path));
    if let Err(error) = result {
        let _ = fs::remove_file(&temporary);
        return Err(format!("Gagal menyimpan {}: {error}", path.display()));
    }
    Ok(())
}

fn run() -> Result<(), String> {
    // parse -> muat -> ubah/tampilkan -> simpan bila memang ada perubahan.
    let (path, command) = parse_args(std::env::args_os().skip(1).collect())?;
    let mut tasks = load_tasks(&path)?;
    match command {
        Command::Add(title) => {
            let id = add_task(&mut tasks, title)?;
            save_tasks(&path, &tasks)?;
            println!("Ditambahkan #{id}.");
        }
        Command::List => {
            if tasks.is_empty() {
                println!("Belum ada tugas.");
            }
            for task in tasks {
                let status = if task.completed { "x" } else { " " };
                println!("[{}] #{} {}", status, task.id, task.title);
            }
        }
        Command::Done(id) => {
            mark_done(&mut tasks, id)?;
            save_tasks(&path, &tasks)?;
            println!("Tugas #{id} ditandai selesai.");
        }
    }
    Ok(())
}

fn main() {
    // run() yang gagal dicetak ke stderr, lalu proses keluar dengan kode gagal.
    if let Err(error) = run() {
        eprintln!("Error: {error}");
        std::process::exit(1);
    }
}

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

    fn args(values: &[&str]) -> Vec<OsString> {
        values.iter().map(OsString::from).collect()
    }

    #[test]
    fn parser_memangkas_judul_dan_memilih_file() {
        assert_eq!(parse_args(args(&["--file", "data.json", "add", "  Belajar  "])),
            Ok((PathBuf::from("data.json"), Command::Add("Belajar".into()))));
    }

    #[test]
    fn argumen_salah_ditolak() {
        for input in [vec![], vec!["--file"], vec!["add"], vec!["add", "  "],
            vec!["add", "dua", "kata"], vec!["list", "extra"], vec!["done", "0"],
            vec!["done", "abc"], vec!["done", "-1"], vec!["hapus", "1"]] {
            assert!(parse_args(args(&input)).is_err());
        }
        assert!(parse_args(args(&["add", &"é".repeat(200)])).is_ok());
        assert!(parse_args(args(&["add", &"é".repeat(201)])).is_err());
    }

    #[test]
    fn id_dari_maksimum_bukan_panjang() {
        let mut tasks = vec![Task { id: 7, title: "Lama".into(), completed: false }];
        assert_eq!(add_task(&mut tasks, "Baru".into()), Ok(8));
        mark_done(&mut tasks, 7).expect("ID ada");
        mark_done(&mut tasks, 7).expect("done boleh diulang");
        assert!(tasks[0].completed);
        assert!(mark_done(&mut tasks, 99).is_err());
    }

    #[test]
    fn overflow_tidak_mengubah_data() {
        let mut tasks = vec![Task { id: i64::MAX, title: "Batas".into(), completed: false }];
        assert!(add_task(&mut tasks, "Baru".into()).is_err());
        assert_eq!(tasks.len(), 1);
    }

    #[test]
    fn json_rusak_dan_id_duplikat_ditolak() {
        assert!(decode_tasks("bukan json").is_err());
        assert!(decode_tasks(r#"[{"id":1,"title":"A","completed":false},
            {"id":1,"title":"B","completed":false}]"#).is_err());
        let original = vec![Task { id: 1, title: "Belajar".into(), completed: false }];
        let json = serde_json::to_string(&original).expect("serialisasi test");
        assert_eq!(decode_tasks(&json).expect("JSON valid"), original);
    }
}

Jika mengetik cargo run -- done 99 saat hanya ada tugas ID 1, apa yang terjadi?

13-async-await-dan-tokio/contoh/Cargo.toml

[package]
name = "bab13-async"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }

13-async-await-dan-tokio/contoh/src/main.rs

/// async/await dan join! dengan runtime Tokio.
/// Menjalankan: cargo run
use std::time::{Duration, Instant};
use tokio::time::sleep;

/// Menyimulasikan pekerjaan yang menunggu (I/O) selama `detik` detik.
/// sleep dari tokio TIDAK memblokir tugas lain — berbeda dengan std::thread::sleep.
async fn seduh(nama: &'static str, detik: u64) -> &'static str {
    sleep(Duration::from_secs(detik)).await;
    nama
}

/// Menunggu satu per satu: total waktu = jumlah semua.
async fn berurutan() {
    let awal = Instant::now();
    seduh("kopi", 3).await;
    seduh("teh", 2).await;
    println!("Berurutan selesai dalam {} detik", awal.elapsed().as_secs());
}

/// Menunggu bersamaan dengan join!: total waktu = yang terlama.
async fn bersamaan() {
    let awal = Instant::now();
    // join! menjalankan keduanya bersamaan; hasilnya tuple sesuai urutan future.
    let (a, b) = tokio::join!(seduh("kopi", 3), seduh("teh", 2));
    println!("Bersamaan selesai dalam {} detik", awal.elapsed().as_secs());
    println!("Hasil join: ({a:?}, {b:?})");
}

// #[tokio::main] mengubah main menjadi titik masuk runtime Tokio.
#[tokio::main]
async fn main() {
    println!("Mulai...");
    berurutan().await;
    bersamaan().await;
}

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

    // Test async memakai #[tokio::test] alih-alih #[test].
    #[tokio::test]
    async fn bersamaan_lebih_cepat_dari_jumlah() {
        let awal = Instant::now();
        let _ = tokio::join!(seduh("a", 1), seduh("b", 1));
        // Bersamaan: ±1 detik, bukan 2.
        assert!(awal.elapsed().as_secs() < 2);
    }
}

Jalankan seduh kopi 3 detik, teh 2 detik, susu 1 detik secara bersamaan. Berapa waktu minimalnya?

let (kopi, teh, susu) = tokio::join!(
    seduh("kopi", 3), seduh("teh", 2), seduh("susu", 1)
);

14-http-json-dan-serde/contoh/Cargo.toml

[package]
name = "bab14-serde"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

14-http-json-dan-serde/contoh/src/main.rs

/// Serialize/Deserialize JSON dengan serde.
/// Menjalankan: cargo run
use serde::{Deserialize, Serialize};

/// Bentuk lengkap sebuah tugas — inilah yang dikirim server ke klien.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct Task {
    id: i64,
    title: String,
    completed: bool,
}

/// Yang boleh dikirim klien saat membuat tugas — TANPA id dan completed.
/// Server yang menentukan keduanya.
#[derive(Debug, Deserialize)]
struct NewTask {
    title: String,
}

fn main() {
    // Struct -> JSON (serialize).
    let tugas = Task {
        id: 1,
        title: "Belajar serde".to_owned(),
        completed: false,
    };
    let json = serde_json::to_string(&tugas).expect("serialize selalu bisa untuk struct ini");
    println!("JSON: {json}");

    // JSON -> struct (deserialize).
    let masuk = r#"{"id":2,"title":"Balas JSON","completed":true}"#;
    let dari_json: Task = serde_json::from_str(masuk).expect("JSON valid");
    println!("Dari JSON: {dari_json:?}");

    // Struct input: hanya title yang diterima.
    let kiriman_klien = r#"{"title":"Setor PR"}"#;
    let baru: NewTask = serde_json::from_str(kiriman_klien).expect("title wajib ada");
    println!("Judul baru dari klien: {}", baru.title);

    // JSON rusak -> Err informatif (bukan panic). Nanti dibalas status 400.
    match serde_json::from_str::<NewTask>("{judul: tanpa kutip}") {
        Ok(_) => println!("tidak akan sampai sini"),
        Err(e) => println!("Error input rusak: {e}"),
    }
}

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

    #[test]
    fn bolak_balik_json() {
        let t = Task {
            id: 7,
            title: "Uji".to_owned(),
            completed: true,
        };
        let s = serde_json::to_string(&t).expect("serialize");
        let kembali: Task = serde_json::from_str(&s).expect("deserialize");
        assert_eq!(t, kembali);
    }

    #[test]
    fn field_hilang_ditolak() {
        assert!(serde_json::from_str::<NewTask>("{}").is_err());
    }

    #[test]
    fn field_ekstra_diabaikan() {
        // Klien nakal mengirim id — diabaikan karena NewTask tidak punya field itu.
        let n: NewTask = serde_json::from_str(r#"{"title":"x","id":999}"#).expect("ok");
        assert_eq!(n.title, "x");
    }
}

Buat struct input untuk mengganti judul dan status sebuah tugas. Apakah JSON tanpa status diterima?

#[derive(Deserialize)]
struct UpdateTask { title: String, completed: bool }

15-api-pertama-dengan-axum/contoh/Cargo.toml

[package]
name = "bab15-axum-pertama"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = "0.8"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }

15-api-pertama-dengan-axum/contoh/src/main.rs

/// API pertama: /health, /hello/{nama}, dan /echo.
/// Menjalankan: cargo run, lalu uji dengan curl (lihat README).
use axum::{
    extract::Path,
    http::StatusCode,
    response::Json,
    routing::{get, post},
    Router,
};
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/health", get(health))
        .route("/hello/{nama}", get(sapa))
        .route("/echo", post(gema));

    // 127.0.0.1: hanya bisa diakses dari komputer ini — aman untuk belajar.
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .expect("port 3000 harus bebas");
    println!("Mendengarkan di http://127.0.0.1:3000");
    axum::serve(listener, app).await.expect("server berjalan");
}

/// GET /health — tanda server hidup.
async fn health() -> Json<Value> {
    Json(json!({ "status": "ok" }))
}

/// GET /hello/{nama} — extractor Path membaca bagian URL.
async fn sapa(Path(nama): Path<String>) -> Json<Value> {
    Json(json!({ "pesan": format!("Halo, {nama}!") }))
}

#[derive(Debug, Deserialize)]
struct Kiriman {
    pesan: String,
}

#[derive(Debug, Serialize)]
struct Jawaban {
    pesan: String,
}

/// POST /echo — extractor Json memparse body; JSON rusak otomatis dibalas 400.
async fn gema(Json(kiriman): Json<Kiriman>) -> (StatusCode, Json<Jawaban>) {
    let jawaban = Jawaban {
        pesan: format!("kamu berkata: {}", kiriman.pesan),
    };
    (StatusCode::CREATED, Json(jawaban))
}

Tambahkan GET /about yang membalas {"nama":"belajar-rust"}.

async fn about() -> Json<Value> {
    Json(json!({ "nama": "belajar-rust" }))
}
// Di Router::new(): .route("/about", get(about))

16-crud-in-memory/contoh/Cargo.toml

[package]
name = "bab16-crud-memori"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = "0.8"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }

[dev-dependencies]
tower = { version = "0.5", features = ["util"] }

16-crud-in-memory/contoh/src/lib.rs

/// Logika CRUD + pembuatan Router, dipisah dari main agar bisa diuji.
use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::Json,
    routing::get,
    Router,
};
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Task {
    pub id: i64,
    pub title: String,
    pub completed: bool,
}

/// Body untuk POST: klien hanya boleh mengirim judul.
#[derive(Debug, Deserialize)]
pub struct NewTask { pub title: String }

/// Body untuk PUT: mengganti seluruh resource, dua-duanya wajib.
#[derive(Debug, Deserialize)]
pub struct UpdateTask {
    pub title: String,
    pub completed: bool,
}

#[derive(Debug, Serialize)]
pub struct ErrorBody { pub error: String }

/// State bersama seluruh handler. Mutex std cukup karena kunci TIDAK
/// ditahan melewati .await (tidak ada await di dalam blok kunci).
#[derive(Debug)]
pub struct AppState {
    pub tasks: Mutex<Vec<Task>>,
    pub next_id: Mutex<i64>,
}

impl Default for AppState {
    fn default() -> Self {
        Self {
            tasks: Mutex::new(Vec::new()),
            next_id: Mutex::new(1), // ID pertama adalah 1, sesuai contoh curl.
        }
    }
}

pub fn app() -> Router {
    // Method HTTP berbeda dapat memakai path yang sama.
    Router::new()
        .route("/tasks", get(daftar).post(buat))
        .route("/tasks/{id}", get(ambil).put(ubah).delete(hapus))
        .with_state(Arc::new(AppState::default()))
}

/// Validasi aturan bisnis: judul 1..=200 karakter setelah trim.
fn validasi_judul(judul: &str) -> Result<String, String> {
    let judul = judul.trim();
    let panjang = judul.chars().count();
    if panjang == 0 {
        Err("title tidak boleh kosong".to_owned())
    } else if panjang > 200 {
        Err("title maksimal 200 karakter".to_owned())
    } else {
        Ok(judul.to_owned())
    }
}

fn err400(pesan: String) -> (StatusCode, Json<ErrorBody>) {
    (StatusCode::BAD_REQUEST, Json(ErrorBody { error: pesan }))
}

fn err404() -> (StatusCode, Json<ErrorBody>) {
    (
        StatusCode::NOT_FOUND,
        Json(ErrorBody { error: "tugas tidak ditemukan".to_owned() }),
    )
}

/// GET /tasks
async fn daftar(State(state): State<Arc<AppState>>) -> Json<Vec<Task>> {
    let tasks = state.tasks.lock().expect("mutex tidak diracun");
    Json(tasks.clone())
}

/// POST /tasks
async fn buat(
    State(state): State<Arc<AppState>>,
    Json(input): Json<NewTask>,
) -> Result<(StatusCode, Json<Task>), (StatusCode, Json<ErrorBody>)> {
    // Validasi judul sebelum memegang kunci atau mengambil ID.
    let title = validasi_judul(&input.title).map_err(err400)?;

    // next_id pertama bernilai 1; kunci menjamin dua request tidak mendapat ID sama.
    let mut next_id = state.next_id.lock().expect("mutex tidak diracun");
    let id = *next_id;
    *next_id += 1;

    let tugas = Task { id, title, completed: false };
    // clone karena satu salinan disimpan, salinan lain dikirim sebagai respons.
    state.tasks.lock().expect("mutex tidak diracun").push(tugas.clone());
    Ok((StatusCode::CREATED, Json(tugas)))
}

/// GET /tasks/{id}
async fn ambil(
    State(state): State<Arc<AppState>>,
    Path(id): Path<i64>,
) -> Result<Json<Task>, (StatusCode, Json<ErrorBody>)> {
    let tasks = state.tasks.lock().expect("mutex tidak diracun");
    // Jika ID tidak ada, ubah None menjadi respons 404 lewat ok_or_else.
    tasks.iter().find(|t| t.id == id).cloned().map(Json).ok_or_else(err404)
}

/// PUT /tasks/{id}
async fn ubah(
    State(state): State<Arc<AppState>>,
    Path(id): Path<i64>,
    Json(input): Json<UpdateTask>,
) -> Result<Json<Task>, (StatusCode, Json<ErrorBody>)> {
    let title = validasi_judul(&input.title).map_err(err400)?;
    let mut tasks = state.tasks.lock().expect("mutex tidak diracun");
    let tugas = tasks.iter_mut().find(|t| t.id == id).ok_or_else(err404)?;
    tugas.title = title;
    tugas.completed = input.completed;
    Ok(Json(tugas.clone()))
}

/// DELETE /tasks/{id}
async fn hapus(
    State(state): State<Arc<AppState>>,
    Path(id): Path<i64>,
) -> Result<StatusCode, (StatusCode, Json<ErrorBody>)> {
    let mut tasks = state.tasks.lock().expect("mutex tidak diracun");
    // position mencari indeks; remove menghapus item tepat pada indeks itu.
    let posisi = tasks.iter().position(|t| t.id == id).ok_or_else(err404)?;
    tasks.remove(posisi);
    Ok(StatusCode::NO_CONTENT)
}

16-crud-in-memory/contoh/src/main.rs

/// CRUD in-memory. Menjalankan: cargo run, lalu uji dengan curl (lihat README).
#[tokio::main]
async fn main() {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .expect("port 3000 harus bebas");
    println!("Mendengarkan di http://127.0.0.1:3000");
    axum::serve(listener, bab16_crud_memori::app())
        .await
        .expect("server berjalan");
}

16-crud-in-memory/contoh/tests/api.rs

//! Integration test untuk seluruh alur CRUD, tanpa menyalakan port.
use axum::body::Body;
use axum::http::{Request, StatusCode};
use serde_json::{json, Value};
use tower::ServiceExt; // untuk .oneshot()

/// Helper: kirim request ke Router dan kembalikan (status, body sebagai Value).
async fn panggil(
    app: &mut axum::Router,
    method: &str,
    path: &str,
    body: Option<Value>,
) -> (StatusCode, Option<Value>) {
    let mut builder = Request::builder().method(method).uri(path);
    let http_body = match body {
        Some(v) => {
            builder = builder.header("content-type", "application/json");
            Body::from(serde_json::to_vec(&v).expect("serialize"))
        }
        None => Body::empty(),
    };
    let respons = app
        .oneshot(builder.body(http_body).expect("request valid"))
        .await
        .expect("router merespons");
    let status = respons.status();
    let bytes = axum::body::to_bytes(respons.into_body(), usize::MAX)
        .await
        .expect("membaca body");
    let nilai = if bytes.is_empty() {
        None
    } else {
        Some(serde_json::from_slice(&bytes).expect("respons JSON"))
    };
    (status, nilai)
}

#[tokio::test]
async fn alur_crud_lengkap() {
    let mut app = bab16_crud_memori::app();
    // Buat tugas; judul awal/akhir yang berspasi harus di-trim.
    let (status, body) = panggil(
        &mut app, "POST", "/tasks", Some(json!({"title": "  Belajar Axum  "})),
    ).await;
    assert_eq!(status, StatusCode::CREATED);
    let tugas = body.expect("ada body");
    assert_eq!(tugas["id"], 1);
    assert_eq!(tugas["title"], "Belajar Axum");
    assert_eq!(tugas["completed"], false);

    // Daftar dan ambil.
    let (status, body) = panggil(&mut app, "GET", "/tasks", None).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(body.expect("array").as_array().expect("array").len(), 1);
    let (status, _) = panggil(&mut app, "GET", "/tasks/1", None).await;
    assert_eq!(status, StatusCode::OK);

    // Ubah lalu hapus.
    let (status, body) = panggil(
        &mut app, "PUT", "/tasks/1",
        Some(json!({"title": "Revisi", "completed": true})),
    ).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(body.expect("body")["completed"], true);
    let (status, body) = panggil(&mut app, "DELETE", "/tasks/1", None).await;
    assert_eq!(status, StatusCode::NO_CONTENT);
    assert!(body.is_none());
    let (status, _) = panggil(&mut app, "GET", "/tasks/1", None).await;
    assert_eq!(status, StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn validasi_dan_kasus_gagal() {
    let mut app = bab16_crud_memori::app();
    let (status, _) = panggil(&mut app, "POST", "/tasks", Some(json!({"title": "   "}))).await;
    assert_eq!(status, StatusCode::BAD_REQUEST);
    let (status, body) = panggil(&mut app, "POST", "/tasks", Some(json!({"title": "ok"}))).await;
    assert_eq!(status, StatusCode::CREATED);
    assert_eq!(body.expect("body")["id"], 1);

    // PUT tanpa completed ditolak oleh extractor JSON.
    let (status, _) = panggil(&mut app, "PUT", "/tasks/1", Some(json!({"title": "x"}))).await;
    assert_eq!(status, StatusCode::BAD_REQUEST);

    for (m, p) in [("GET", "/tasks/99"), ("PUT", "/tasks/99"), ("DELETE", "/tasks/99")] {
        let body = if m == "PUT" {
            Some(json!({"title": "x", "completed": false}))
        } else {
            None
        };
        let (status, _) = panggil(&mut app, m, p, body).await;
        assert_eq!(status, StatusCode::NOT_FOUND, "{m} {p}");
    }
}

Bagaimana membuktikan judul 201 karakter ditolak?

let judul = "a".repeat(201);
let hasil = validasi_judul(&judul);
assert!(hasil.is_err());

17-mariadb-dan-sqlx/contoh/Cargo.toml

[package]
name = "bab17-mariadb"
version = "0.1.0"
edition = "2021"

[dependencies]
sqlx = { version = "0.8", default-features = false, features = [
    "runtime-tokio",
    "tls-rustls",
    "mysql",
    "derive",
] }
tokio = { version = "1", features = ["full"] }

17-mariadb-dan-sqlx/contoh/src/main.rs

/// Program kecil (bukan server) untuk mencoba SQLx + MariaDB.
/// Prasyarat: DATABASE_URL sudah di-set (lihat README bab 17).
/// Menjalankan: cargo run
use sqlx::mysql::MySqlPool;

/// Bentuk satu baris tabel latihan_tasks.
/// BIGINT -> i64, VARCHAR -> String, BOOLEAN/TINYINT(1) -> bool.
#[derive(Debug, sqlx::FromRow)]
struct Task {
    id: i64,
    title: String,
    completed: bool,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // DATABASE_URL tidak ditulis di kode; dibaca dari environment.
    let url = std::env::var("DATABASE_URL")
        .map_err(|_| "set dulu DATABASE_URL (contoh di README bab 17)")?;

    // Pool = kumpulan koneksi siap pakai yang dibagi banyak tugas async.
    // .await menunggu jaringan; ? meneruskan error bila koneksi gagal.
    let pool = MySqlPool::connect(&url).await?;
    println!("Terhubung ke MariaDB.");

    // Idempoten: aman dijalankan berulang kali.
    sqlx::query(
        "CREATE TABLE IF NOT EXISTS latihan_tasks (
            id         BIGINT AUTO_INCREMENT PRIMARY KEY,
            title      VARCHAR(200) NOT NULL,
            completed  BOOLEAN NOT NULL DEFAULT FALSE
        ) CHARACTER SET utf8mb4",
    )
    .execute(&pool)
    .await?;
    println!("Tabel latihan_tasks siap.");

    // INSERT dengan parameter terikat (?). Nilai dikirim terpisah dari SQL,
    // sehingga input jahat tidak bisa menjadi perintah (anti SQL injection).
    // Tanda ? ditempati .bind(), bukan digabung dengan format! ke teks SQL.
    let hasil = sqlx::query("INSERT INTO latihan_tasks (title) VALUES (?)")
        .bind("Coba SQLx")
        .execute(&pool)
        .await?;
    let id = hasil.last_insert_id() as i64;

    // Baca kembali baris yang baru dibuat.
    // query_as mengubah kolom hasil SELECT menjadi field struct Task.
    let tugas: Task = sqlx::query_as("SELECT id, title, completed FROM latihan_tasks WHERE id = ?")
        .bind(id)
        .fetch_one(&pool)
        .await?;
    println!("Tersimpan: {tugas:?}");

    // UPDATE lalu baca ulang (MySQL/MariaDB tidak punya UPDATE ... RETURNING generik).
    sqlx::query("UPDATE latihan_tasks SET completed = TRUE WHERE id = ?")
        .bind(id)
        .execute(&pool)
        .await?;
    let tugas: Task = sqlx::query_as("SELECT id, title, completed FROM latihan_tasks WHERE id = ?")
        .bind(id)
        .fetch_one(&pool)
        .await?;
    println!("Setelah ditandai: {tugas:?}");

    // Hitung isi tabel. query_scalar mengambil satu nilai (COUNT).
    let jumlah: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM latihan_tasks")
        .fetch_one(&pool)
        .await?;
    println!("Isi tabel: {jumlah} baris");

    pool.close().await;
    Ok(())
}

Apa yang terjadi jika judul adalah teks '); DROP TABLE latihan_tasks; -- tetapi dipasangkan lewat .bind?

Bagaimana query SQL untuk GET /tasks?completed=true jika ingin menyaring di MariaDB?

sqlx::query_as::<_, Task>(
    "SELECT id, title, completed FROM tasks WHERE completed = ? ORDER BY id"
).bind(true).fetch_all(&self.pool).await

Cargo.toml

[package]
name = "bab18-task-api"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = "0.8"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
sqlx = { version = "0.8", default-features = false, features = [
    "runtime-tokio", "tls-rustls", "mysql", "derive",
] }
tokio = { version = "1", features = ["full"] }

[dev-dependencies]
tower = { version = "0.5", features = ["util"] }

src/config.rs

#[derive(Debug, Clone)]
pub struct Config {
    pub database_url: String,
    pub port: u16,
}

impl Config {
    pub fn dari_env() -> Result<Self, String> {
        let database_url = std::env::var("DATABASE_URL")
            .map_err(|_| "DATABASE_URL belum di-set (lihat .env.example)".to_owned())?;
        let port = std::env::var("PORT")
            .ok()
            .and_then(|p| p.parse::<u16>().ok())
            .unwrap_or(3000);
        Ok(Self { database_url, port })
    }
}

src/models.rs

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, sqlx::FromRow)]
pub struct Task {
    pub id: i64,
    pub title: String,
    pub completed: bool,
}

#[derive(Debug, Deserialize)]
pub struct NewTask { pub title: String }

#[derive(Debug, Deserialize)]
pub struct UpdateTask {
    pub title: String,
    pub completed: bool,
}

pub fn validasi_judul(judul: &str) -> Result<String, String> {
    let judul = judul.trim();
    let panjang = judul.chars().count();
    if panjang == 0 {
        Err("title tidak boleh kosong".to_owned())
    } else if panjang > 200 {
        Err("title maksimal 200 karakter".to_owned())
    } else {
        Ok(judul.to_owned())
    }
}

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

    #[test]
    fn judul_divalidasi_dengan_benar() {
        assert_eq!(validasi_judul("  halo  ").as_deref(), Ok("halo"));
        assert!(validasi_judul("   ").is_err());
        assert!(validasi_judul(&"a".repeat(201)).is_err());
        assert!(validasi_judul(&"a".repeat(200)).is_ok());
    }
}

src/error.rs

use axum::{
    http::StatusCode,
    response::{IntoResponse, Json, Response},
};
use serde::Serialize;

#[derive(Debug)]
pub enum AppError {
    Validasi(String),
    TidakDitemukan,
    Internal(sqlx::Error),
}

impl From<sqlx::Error> for AppError {
    fn from(e: sqlx::Error) -> Self { Self::Internal(e) }
}

#[derive(Serialize)]
struct ErrorBody { error: String }

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, pesan) = match self {
            Self::Validasi(p) => (StatusCode::BAD_REQUEST, p),
            Self::TidakDitemukan =>
                (StatusCode::NOT_FOUND, "tugas tidak ditemukan".to_owned()),
            Self::Internal(e) => {
                eprintln!("error database: {e}");
                (StatusCode::INTERNAL_SERVER_ERROR,
                 "terjadi kesalahan di server".to_owned())
            }
        };
        (status, Json(ErrorBody { error: pesan })).into_response()
    }
}

src/store.rs

use crate::models::{Task, UpdateTask};
use sqlx::mysql::MySqlPool;

#[derive(Debug, Clone)]
pub struct TaskStore { pool: MySqlPool }

impl TaskStore {
    pub fn baru(pool: MySqlPool) -> Self { Self { pool } }

    pub async fn migrasi(&self) -> Result<(), sqlx::Error> {
        sqlx::query(
            "CREATE TABLE IF NOT EXISTS tasks (
                id BIGINT AUTO_INCREMENT PRIMARY KEY,
                title VARCHAR(200) NOT NULL,
                completed BOOLEAN NOT NULL DEFAULT FALSE
            ) CHARACTER SET utf8mb4",
        ).execute(&self.pool).await?;
        Ok(())
    }

    pub async fn semua(&self) -> Result<Vec<Task>, sqlx::Error> {
        sqlx::query_as("SELECT id, title, completed FROM tasks ORDER BY id")
            .fetch_all(&self.pool).await
    }

    pub async fn cari(&self, id: i64) -> Result<Option<Task>, sqlx::Error> {
        sqlx::query_as("SELECT id, title, completed FROM tasks WHERE id = ?")
            .bind(id).fetch_optional(&self.pool).await
    }

    pub async fn buat(&self, title: &str) -> Result<Task, sqlx::Error> {
        let hasil = sqlx::query("INSERT INTO tasks (title) VALUES (?)")
            .bind(title).execute(&self.pool).await?;
        let id = hasil.last_insert_id() as i64;
        self.cari(id).await?.ok_or(sqlx::Error::RowNotFound)
    }

    pub async fn ubah(&self, id: i64, input: &UpdateTask, title: &str)
        -> Result<Option<Task>, sqlx::Error> {
        let hasil = sqlx::query("UPDATE tasks SET title = ?, completed = ? WHERE id = ?")
            .bind(title).bind(input.completed).bind(id)
            .execute(&self.pool).await?;
        if hasil.rows_affected() == 0 {
            return self.cari(id).await;
        }
        self.cari(id).await
    }

    pub async fn hapus(&self, id: i64) -> Result<bool, sqlx::Error> {
        let hasil = sqlx::query("DELETE FROM tasks WHERE id = ?")
            .bind(id).execute(&self.pool).await?;
        Ok(hasil.rows_affected() > 0)
    }

    pub async fn kosongkan(&self) -> Result<(), sqlx::Error> {
        sqlx::query("DELETE FROM tasks").execute(&self.pool).await?;
        Ok(())
    }
}

src/handlers.rs

use crate::{
    error::AppError,
    models::{validasi_judul, NewTask, Task, UpdateTask},
    store::TaskStore,
};
use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::Json,
};

pub async fn daftar(State(store): State<TaskStore>)
    -> Result<Json<Vec<Task>>, AppError> {
    Ok(Json(store.semua().await?))
}

pub async fn ambil(State(store): State<TaskStore>, Path(id): Path<i64>)
    -> Result<Json<Task>, AppError> {
    store.cari(id).await?.map(Json).ok_or(AppError::TidakDitemukan)
}

pub async fn buat(State(store): State<TaskStore>, Json(input): Json<NewTask>)
    -> Result<(StatusCode, Json<Task>), AppError> {
    let title = validasi_judul(&input.title).map_err(AppError::Validasi)?;
    let tugas = store.buat(&title).await?;
    Ok((StatusCode::CREATED, Json(tugas)))
}

pub async fn ubah(
    State(store): State<TaskStore>, Path(id): Path<i64>,
    Json(input): Json<UpdateTask>,
) -> Result<Json<Task>, AppError> {
    let title = validasi_judul(&input.title).map_err(AppError::Validasi)?;
    store.ubah(id, &input, &title).await?
        .map(Json).ok_or(AppError::TidakDitemukan)
}

pub async fn hapus(State(store): State<TaskStore>, Path(id): Path<i64>)
    -> Result<StatusCode, AppError> {
    if store.hapus(id).await? {
        Ok(StatusCode::NO_CONTENT)
    } else {
        Err(AppError::TidakDitemukan)
    }
}

src/lib.rs

pub mod config;
pub mod error;
pub mod handlers;
pub mod models;
pub mod store;

use axum::{routing::get, Router};
use store::TaskStore;

pub fn app(store: TaskStore) -> Router {
    Router::new()
        .route("/health", get(|| async { "ok" }))
        .route("/tasks", get(handlers::daftar).post(handlers::buat))
        .route("/tasks/{id}",
            get(handlers::ambil).put(handlers::ubah).delete(handlers::hapus))
        .with_state(store)
}

src/main.rs

use bab18_task_api::{app, config::Config, store::TaskStore};
use sqlx::mysql::MySqlPool;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = Config::dari_env()?;
    let pool = MySqlPool::connect(&config.database_url).await?;
    let store = TaskStore::baru(pool);
    store.migrasi().await?;
    let alamat = format!("127.0.0.1:{}", config.port);
    let listener = tokio::net::TcpListener::bind(&alamat).await?;
    println!("Migrasi selesai. Mendengarkan di http://{alamat}");
    axum::serve(listener, app(store)).await?;
    Ok(())
}

Berkas ini contoh konfigurasi. Sebelum cargo run kamu tetap perlu export DATABASE_URL='...' di terminal karena aplikasi tidak membaca .env otomatis.

.env.example

# Salin file ini menjadi .env atau set lewat `export` di terminal.
# GANTI sandinya dengan milikmu. Jangan pernah commit sandi asli.

# URL koneksi MariaDB untuk server API.
DATABASE_URL=mysql://task_app:ganti-dengan-sandi-kuat@127.0.0.1:3306/belajar_rust

# Database TERPISAH untuk integration test (dipakai oleh cargo test).
TEST_DATABASE_URL=mysql://task_app:ganti-dengan-sandi-kuat@127.0.0.1:3306/belajar_rust_test

# Port server (opsional, bawaan 3000).
PORT=3000

Test ini memakai database belajar_rust_test, bukan database utama. Jika TEST_DATABASE_URL tidak di-export, test database akan dilewati; buat database test sesuai langkah di bab 18 sebelum menjalankan cargo test.

tests/api.rs

//! Test integrasi: mengirim request ke Router dengan database test terpisah.
use axum::body::Body;
use axum::http::{Request, StatusCode};
use bab18_task_api::{app, models::Task, store::TaskStore};
use serde_json::{json, Value};
use sqlx::mysql::MySqlPool;
use tower::ServiceExt;

// Satu tabel dipakai bersama: jangan bersihkan saat test lain sedang berjalan.
static DB_TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());

async fn siapkan() -> Option<(TaskStore, axum::Router)> {
    let Ok(url) = std::env::var("TEST_DATABASE_URL") else {
        eprintln!("TEST_DATABASE_URL belum di-set: test database dilewati");
        return None;
    };
    let pool = MySqlPool::connect(&url)
        .await
        .expect("koneksi database test berhasil");
    let store = TaskStore::baru(pool);
    store.migrasi().await.expect("migrasi berhasil");
    store.kosongkan().await.expect("tabel test bersih");
    let router = app(store.clone());
    Some((store, router))
}

async fn panggil(
    app: &mut axum::Router,
    method: &str,
    path: &str,
    body: Option<Value>,
) -> (StatusCode, Option<Value>) {
    let mut builder = Request::builder().method(method).uri(path);
    let http_body = match body {
        Some(v) => {
            builder = builder.header("content-type", "application/json");
            Body::from(serde_json::to_vec(&v).expect("serialize"))
        }
        None => Body::empty(),
    };
    let respons = app
        .oneshot(builder.body(http_body).expect("request valid"))
        .await
        .expect("router merespons");
    let status = respons.status();
    let bytes = axum::body::to_bytes(respons.into_body(), usize::MAX)
        .await
        .expect("baca body");
    let nilai = if bytes.is_empty() {
        None
    } else {
        Some(serde_json::from_slice(&bytes).expect("respons JSON"))
    };
    (status, nilai)
}

#[tokio::test]
async fn alur_crud_lengkap() {
    let _guard = DB_TEST_LOCK.lock().await;
    let Some((_store, mut app)) = siapkan().await else { return };

    let (status, body) = panggil(&mut app, "POST", "/tasks",
        Some(json!({"title": "  Tulis docs  "}))).await;
    assert_eq!(status, StatusCode::CREATED);
    let tugas = body.expect("body");
    assert_eq!(tugas["title"], "Tulis docs");
    assert_eq!(tugas["completed"], false);
    let id = tugas["id"].as_i64().expect("id angka");

    let (status, body) = panggil(&mut app, "GET", "/tasks", None).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(body.expect("array").as_array().expect("array").len(), 1);
    let (status, body) = panggil(&mut app, "GET", &format!("/tasks/{id}"), None).await;
    assert_eq!(status, StatusCode::OK);
    let tugas_db: Task = serde_json::from_value(body.expect("body")).expect("bentuk Task");
    assert_eq!(tugas_db.title, "Tulis docs");

    let (status, body) = panggil(&mut app, "PUT", &format!("/tasks/{id}"),
        Some(json!({"title": "Revisi", "completed": true}))).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(body.expect("body")["completed"], true);

    let (status, body) = panggil(&mut app, "DELETE", &format!("/tasks/{id}"), None).await;
    assert_eq!(status, StatusCode::NO_CONTENT);
    assert!(body.is_none());
    let (status, _) = panggil(&mut app, "GET", &format!("/tasks/{id}"), None).await;
    assert_eq!(status, StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn validasi_dan_kasus_gagal() {
    let _guard = DB_TEST_LOCK.lock().await;
    let Some((_store, mut app)) = siapkan().await else { return };

    let (status, body) = panggil(&mut app, "POST", "/tasks",
        Some(json!({"title": "  "}))).await;
    assert_eq!(status, StatusCode::BAD_REQUEST);
    assert_eq!(body.expect("body")["error"], "title tidak boleh kosong");

    let (status, _) = panggil(&mut app, "PUT", "/tasks/1",
        Some(json!({"title": "x"}))).await;
    assert_eq!(status, StatusCode::BAD_REQUEST);

    for (m, p, b) in [
        ("GET", "/tasks/424242", None),
        ("PUT", "/tasks/424242", Some(json!({"title": "x", "completed": false}))),
        ("DELETE", "/tasks/424242", None),
    ] {
        let (status, _) = panggil(&mut app, m, p, b).await;
        assert_eq!(status, StatusCode::NOT_FOUND, "{m} {p}");
    }

    let (status, _) = panggil(&mut app, "POST", "/tasks",
        Some(json!({"title": "permanen"}))).await;
    assert_eq!(status, StatusCode::CREATED);
}

#[tokio::test]
async fn data_tidak_tercampur_antar_test() {
    let _guard = DB_TEST_LOCK.lock().await;
    let Some((_store, mut app)) = siapkan().await else { return };
    let (status, body) = panggil(&mut app, "GET", "/tasks", None).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(body.expect("array").as_array().expect("array").len(), 0);
}

#[tokio::test]
async fn put_identik_tetap_berhasil() {
    let _guard = DB_TEST_LOCK.lock().await;
    let Some((_store, mut app)) = siapkan().await else { return };
    let (status, body) = panggil(&mut app, "POST", "/tasks",
        Some(json!({"title": "Tetap sama"}))).await;
    assert_eq!(status, StatusCode::CREATED);
    let id = body.expect("tugas baru")["id"].as_i64().expect("ID angka");

    for _ in 0..2 {
        let (status, body) = panggil(&mut app, "PUT", &format!("/tasks/{id}"),
            Some(json!({"title": "Tetap sama", "completed": false}))).await;
        assert_eq!(status, StatusCode::OK);
        assert_eq!(body.expect("tugas masih ada")["id"], id);
    }
}

Jelaskan dengan kalimatmu sendiri: kenapa kita tidak menyimpan password apa adanya di database? Apa yang terjadi kalau database bocor?

Urutkan langkah berikut dengan benar: (a) buat token, (b) verifikasi password, (c) cari user by username, (d) simpan session di DB, (e) kirim token ke klien.

Kapan server membalas 401 dan kapan 404 untuk task yang tidak bisa diakses? Mengapa task orang lain dibalas 404, bukan 403?

Ubah SESSION_DURASI_DETIK agar session berlaku 30 hari, bukan 7 hari. Konstanta mana yang kamu ubah?

// Dari:
const SESSION_DURASI_DETIK: i64 = 7 * 24 * 60 * 60;
// Menjadi:
const SESSION_DURASI_DETIK: i64 = 30 * 24 * 60 * 60;

Bayangkan kamu ingin endpoint /admin/users yang hanya bisa diakses user dengan username == "admin". Di mana kamu akan menambah pengecekan itu?

pub async fn admin_users(
    State(store): State<Store>,
    user: CurrentUser,
) -> Result<Json<Vec<User>>, AppError> {
    if user.user.username != "admin" {
        return Err(AppError::Forbidden("khusus admin".to_owned()));
    }
    // ... ambil semua users
}

Cargo.toml

[package]
name = "bab19-auth-api"
version = "0.1.0"
edition = "2021"

[dependencies]
argon2 = "0.5"
axum = "0.8"
rand = "0.8"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
sqlx = { version = "0.8", default-features = false, features = [
    "runtime-tokio",
    "tls-rustls",
    "mysql",
    "derive",
] }
tokio = { version = "1", features = ["full"] }

[dev-dependencies]
tower = { version = "0.5", features = ["util"] }

src/config.rs

/// Konfigurasi dari environment — tidak ada rahasia yang ditulis di kode.
#[derive(Debug, Clone)]
pub struct Config {
    pub database_url: String,
    pub port: u16,
}

impl Config {
    pub fn dari_env() -> Result<Self, String> {
        let database_url = std::env::var(&quot;DATABASE_URL&quot;)
            .map_err(|_| &quot;DATABASE_URL belum di-set (lihat .env.example)&quot;.to_owned())?;
        let port = std::env::var(&quot;PORT&quot;)
            .ok()
            .and_then(|p| p.parse::<u16>().ok())
            .unwrap_or(3000);
        Ok(Self { database_url, port })
    }
}

src/models.rs

/// Bentuk data untuk user, session, dan task.
/// Tidak ada logika database di sini — hanya bentuk data.
use serde::{Deserialize, Serialize};

/// Satu baris tabel users. password_hash TIDAK pernah dikirim ke klien.
#[derive(Debug, Clone, sqlx::FromRow)]
pub struct User {
    pub id: i64,
    pub username: String,
    pub password_hash: String,
}

/// Input saat mendaftar akun baru.
#[derive(Debug, Deserialize)]
pub struct RegisterInput {
    pub username: String,
    pub password: String,
}

/// Input saat login.
#[derive(Debug, Deserialize)]
pub struct LoginInput {
    pub username: String,
    pub password: String,
}

/// Satu baris tabel sessions. Token inilah yang dipakai klien untuk masuk.
#[derive(Debug, Clone, sqlx::FromRow)]
pub struct Session {
    pub id: i64,
    pub user_id: i64,
    pub token: String,
    pub expires_at: i64, // timestamp Unix (detik)
}

/// Satu baris tabel tasks — sekarang dengan pemilik (user_id).
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, sqlx::FromRow)]
pub struct Task {
    pub id: i64,
    pub user_id: i64,
    pub title: String,
    pub completed: bool,
}

/// Body POST /tasks: klien hanya mengirim judul.
#[derive(Debug, Deserialize)]
pub struct NewTask {
    pub title: String,
}

/// Body PUT /tasks/{id}: mengganti seluruh tugas.
#[derive(Debug, Deserialize)]
pub struct UpdateTask {
    pub title: String,
    pub completed: bool,
}

/// Respons saat login berhasil: token untuk dipakai di header Authorization.
#[derive(Debug, Serialize)]
pub struct LoginResponse {
    pub token: String,
}

/// Respons untuk GET /auth/me: siapa yang sedang login.
#[derive(Debug, Serialize)]
pub struct MeResponse {
    pub id: i64,
    pub username: String,
}

/// Validasi aturan bisnis untuk judul tugas (1..=200 karakter setelah trim).
pub fn validasi_judul(judul: &str) -> Result<String, String> {
    let judul = judul.trim();
    let panjang = judul.chars().count();
    if panjang == 0 {
        Err(&quot;title tidak boleh kosong&quot;.to_owned())
    } else if panjang > 200 {
        Err(&quot;title maksimal 200 karakter&quot;.to_owned())
    } else {
        Ok(judul.to_owned())
    }
}

/// Validasi username dan password saat register/login.
/// Username 3..=50 karakter, password minimal 8 karakter.
pub fn validasi_kredensial(username: &str, password: &str) -> Result<(String, String), String> {
    let username = username.trim();
    let jumlah = username.chars().count();
    if jumlah < 3 {
        return Err(&quot;username minimal 3 karakter&quot;.to_owned());
    }
    if jumlah > 50 {
        return Err(&quot;username maksimal 50 karakter&quot;.to_owned());
    }
    if password.chars().count() < 8 {
        return Err(&quot;password minimal 8 karakter&quot;.to_owned());
    }
    Ok((username.to_owned(), password.to_owned()))
}

src/error.rs

/// Satu pintu untuk semua kegagalan -> respons HTTP yang konsisten.
use axum::{
    http::StatusCode,
    response::{IntoResponse, Json, Response},
};
use serde::Serialize;

#[derive(Debug)]
pub enum AppError {
    /// Input klien tidak memenuhi aturan bisnis.
    Validasi(String),
    /// Belum login atau token tidak valid (401).
    Unauthorized(String),
    /// Login tapi akses data milik orang lain (403).
    Forbidden(String),
    /// Resource yang diminta tidak ada (404).
    TidakDitemukan,
    /// Kegagalan di sisi kami: database atau hashing (500).
    Internal(String),
}

impl From<sqlx::Error> for AppError {
    fn from(e: sqlx::Error) -> Self {
        Self::Internal(format!(&quot;database: {e}&quot;))
    }
}

#[derive(Serialize)]
struct ErrorBody {
    error: String,
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, pesan) = match self {
            Self::Validasi(p) => (StatusCode::BAD_REQUEST, p),
            Self::Unauthorized(p) => (StatusCode::UNAUTHORIZED, p),
            Self::Forbidden(p) => (StatusCode::FORBIDDEN, p),
            Self::TidakDitemukan => (
                StatusCode::NOT_FOUND,
                &quot;tugas tidak ditemukan&quot;.to_owned(),
            ),
            Self::Internal(p) => {
                // Detail teknis hanya dicatat, tidak dibocorkan ke klien.
                eprintln!(&quot;error internal: {p}&quot;);
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    &quot;terjadi kesalahan di server&quot;.to_owned(),
                )
            }
        };
        (status, Json(ErrorBody { error: pesan })).into_response()
    }
}

src/store.rs

/// Semua SQL berkumpul di sini. Store murah di-clone karena pool
/// berbagi koneksi yang sama — aman menjadi state Axum.
use crate::models::{Session, Task, UpdateTask, User};
use sqlx::mysql::MySqlPool;

#[derive(Debug, Clone)]
pub struct Store {
    pool: MySqlPool,
}

impl Store {
    pub fn baru(pool: MySqlPool) -> Self {
        Self { pool }
    }

    // ========== MIGRASI ==========
    /// Buat ketiga tabel jika belum ada. Aman dijalankan berulang.
    pub async fn migrasi(&self) -> Result<(), sqlx::Error> {
        // users: akun yang bisa login
        sqlx::query(
            &quot;CREATE TABLE IF NOT EXISTS users (
                id            BIGINT AUTO_INCREMENT PRIMARY KEY,
                username      VARCHAR(50) NOT NULL UNIQUE,
                password_hash VARCHAR(255) NOT NULL,
                created_at    TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            ) CHARACTER SET utf8mb4&quot;,
        )
        .execute(&self.pool)
        .await?;

        // sessions: token yang aktif. expires_at = timestamp Unix.
        sqlx::query(
            &quot;CREATE TABLE IF NOT EXISTS sessions (
                id         BIGINT AUTO_INCREMENT PRIMARY KEY,
                user_id    BIGINT NOT NULL,
                token      VARCHAR(255) NOT NULL UNIQUE,
                expires_at BIGINT NOT NULL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
            ) CHARACTER SET utf8mb4&quot;,
        )
        .execute(&self.pool)
        .await?;

        // tasks: daftar tugas per-user.
        sqlx::query(
            &quot;CREATE TABLE IF NOT EXISTS tasks (
                id        BIGINT AUTO_INCREMENT PRIMARY KEY,
                user_id   BIGINT NOT NULL,
                title     VARCHAR(200) NOT NULL,
                completed BOOLEAN NOT NULL DEFAULT FALSE,
                FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
            ) CHARACTER SET utf8mb4&quot;,
        )
        .execute(&self.pool)
        .await?;
        Ok(())
    }

    // ========== USERS ==========
    pub async fn buat_user(&self, username: &str, password_hash: &str) -> Result<User, sqlx::Error> {
        sqlx::query(&quot;INSERT INTO users (username, password_hash) VALUES (?, ?)&quot;)
            .bind(username)
            .bind(password_hash)
            .execute(&self.pool)
            .await?;
        self.cari_user_by_username(username)
            .await?
            .ok_or(sqlx::Error::RowNotFound)
    }

    pub async fn cari_user_by_username(&self, username: &str) -> Result<Option<User>, sqlx::Error> {
        sqlx::query_as(&quot;SELECT id, username, password_hash FROM users WHERE username = ?&quot;)
            .bind(username)
            .fetch_optional(&self.pool)
            .await
    }

    pub async fn cari_user_by_id(&self, id: i64) -> Result<Option<User>, sqlx::Error> {
        sqlx::query_as(&quot;SELECT id, username, password_hash FROM users WHERE id = ?&quot;)
            .bind(id)
            .fetch_optional(&self.pool)
            .await
    }

    // ========== SESSIONS ==========
    pub async fn buat_session(&self, user_id: i64, token: &str, expires_at: i64) -> Result<Session, sqlx::Error> {
        sqlx::query(&quot;INSERT INTO sessions (user_id, token, expires_at) VALUES (?, ?, ?)&quot;)
            .bind(user_id)
            .bind(token)
            .bind(expires_at)
            .execute(&self.pool)
            .await?;
        self.cari_session_by_token(token)
            .await?
            .ok_or(sqlx::Error::RowNotFound)
    }

    pub async fn cari_session_by_token(&self, token: &str) -> Result<Option<Session>, sqlx::Error> {
        sqlx::query_as(&quot;SELECT id, user_id, token, expires_at FROM sessions WHERE token = ?&quot;)
            .bind(token)
            .fetch_optional(&self.pool)
            .await
    }

    pub async fn hapus_session(&self, token: &str) -> Result<bool, sqlx::Error> {
        let hasil = sqlx::query(&quot;DELETE FROM sessions WHERE token = ?&quot;)
            .bind(token)
            .execute(&self.pool)
            .await?;
        Ok(hasil.rows_affected() > 0)
    }

    // ========== TASKS (per-user) ==========
    pub async fn semua_tasks(&self, user_id: i64) -> Result<Vec<Task>, sqlx::Error> {
        sqlx::query_as(&quot;SELECT id, user_id, title, completed FROM tasks WHERE user_id = ? ORDER BY id&quot;)
            .bind(user_id)
            .fetch_all(&self.pool)
            .await
    }

    pub async fn cari_task(&self, user_id: i64, id: i64) -> Result<Option<Task>, sqlx::Error> {
        sqlx::query_as(&quot;SELECT id, user_id, title, completed FROM tasks WHERE id = ? AND user_id = ?&quot;)
            .bind(id)
            .bind(user_id)
            .fetch_optional(&self.pool)
            .await
    }

    pub async fn buat_task(&self, user_id: i64, title: &str) -> Result<Task, sqlx::Error> {
        let hasil = sqlx::query(&quot;INSERT INTO tasks (user_id, title) VALUES (?, ?)&quot;)
            .bind(user_id)
            .bind(title)
            .execute(&self.pool)
            .await?;
        let id = hasil.last_insert_id() as i64;
        self.cari_task(user_id, id)
            .await?
            .ok_or(sqlx::Error::RowNotFound)
    }

    pub async fn ubah_task(&self, user_id: i64, id: i64, input: &UpdateTask, title: &str) -> Result<Option<Task>, sqlx::Error> {
        let hasil = sqlx::query(&quot;UPDATE tasks SET title = ?, completed = ? WHERE id = ? AND user_id = ?&quot;)
            .bind(title)
            .bind(input.completed)
            .bind(id)
            .bind(user_id)
            .execute(&self.pool)
            .await?;
        if hasil.rows_affected() == 0 {
            return self.cari_task(user_id, id).await;
        }
        self.cari_task(user_id, id).await
    }

    pub async fn hapus_task(&self, user_id: i64, id: i64) -> Result<bool, sqlx::Error> {
        let hasil = sqlx::query(&quot;DELETE FROM tasks WHERE id = ? AND user_id = ?&quot;)
            .bind(id)
            .bind(user_id)
            .execute(&self.pool)
            .await?;
        Ok(hasil.rows_affected() > 0)
    }

    /// Dipakai test untuk membersihkan tabel.
    pub async fn kosongkan(&self) -> Result<(), sqlx::Error> {
        sqlx::query(&quot;DELETE FROM tasks&quot;).execute(&self.pool).await?;
        sqlx::query(&quot;DELETE FROM sessions&quot;).execute(&self.pool).await?;
        sqlx::query(&quot;DELETE FROM users&quot;).execute(&self.pool).await?;
        Ok(())
    }
}

src/auth.rs

/// Fungsi untuk password (Argon2) dan token (acak), plus extractor CurrentUser
/// yang membaca header Authorization dan memvalidasi session.
use crate::{error::AppError, models::User, store::Store};
use argon2::{
    password_hash::{rand_core::OsRng, PasswordHash, PasswordHasher, PasswordVerifier, SaltString},
    Argon2,
};
use axum::{
    extract::FromRequestParts,
    http::request::Parts,
};
use rand::RngCore;
use std::time::{SystemTime, UNIX_EPOCH};

/// Durasi session: 7 hari dalam detik.
const SESSION_DURASI_DETIK: i64 = 7 * 24 * 60 * 60;

// ========== PASSWORD (Argon2) ==========

/// Hash password menjadi string Argon2 yang aman disimpan.
/// Salt dibuat otomatis dan ikut tertanam di string hash.
pub fn hash_password(password: &str) -> Result<String, AppError> {
    let salt = SaltString::generate(&mut OsRng);
    let argon2 = Argon2::default();
    let hash = argon2
        .hash_password(password.as_bytes(), &salt)
        .map_err(|e| AppError::Internal(format!(&quot;hash password: {e}&quot;)))?;
    Ok(hash.to_string())
}

/// Verifikasi: apakah password ini cocok dengan hash yang tersimpan?
/// Mengembalikan true/false, bukan panik.
pub fn verifikasi_password(password: &str, hash: &str) -> bool {
    let parsed = match PasswordHash::new(hash) {
        Ok(p) => p,
        Err(_) => return false,
    };
    Argon2::default()
        .verify_password(password.as_bytes(), &parsed)
        .is_ok()
}

// ========== TOKEN (acak) ==========

/// Buat token acak 32 byte (64 karakter hex) untuk session.
/// Tidak perlu disimpan di kode — hanya di database saat login.
pub fn buat_token() -> String {
    let mut bytes = [0u8; 32];
    rand::thread_rng().fill_bytes(&mut bytes);
    bytes.iter().map(|b| format!(&quot;{b:02x}&quot;)).collect()
}

/// Timestamp Unix sekarang (detik), untuk membandingkan expires_at.
pub fn sekarang_unix() -> i64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|d| d.as_secs() as i64)
        .unwrap_or(0)
}

/// Berapa detik session berlaku mulai dari sekarang.
pub fn durasi_session() -> i64 {
    SESSION_DURASI_DETIK
}

// ========== EXTRACTOR CurrentUser ==========

/// Extractor ini dipakai handler untuk mendapatkan user yang sedang login
/// beserta token yang dipakai (untuk logout).
/// Cara pakai: tambahkan `CurrentUser` sebagai parameter handler.
pub struct CurrentUser {
    pub user: User,
    pub token: String,
}

impl FromRequestParts<Store> for CurrentUser {
    type Rejection = AppError;

    async fn from_request_parts(
        parts: &mut Parts,
        store: &Store,
    ) -> Result<Self, Self::Rejection> {
        // 1. Baca header Authorization: Bearer <token>
        let header = parts
            .headers
            .get(&quot;authorization&quot;)
            .and_then(|h| h.to_str().ok())
            .ok_or_else(|| AppError::Unauthorized(&quot;header Authorization tidak ada&quot;.to_owned()))?;

        let token = header
            .strip_prefix(&quot;Bearer &quot;)
            .ok_or_else(|| AppError::Unauthorized(&quot;format harus &#x27;Bearer <token>&#x27;&quot;.to_owned()))?
            .trim();

        if token.is_empty() {
            return Err(AppError::Unauthorized(&quot;token kosong&quot;.to_owned()));
        }

        // 2. Cari session di database
        let session = store
            .cari_session_by_token(token)
            .await?
            .ok_or_else(|| AppError::Unauthorized(&quot;token tidak valid&quot;.to_owned()))?;

        // 3. Cek kedaluwarsa
        if session.expires_at < sekarang_unix() {
            return Err(AppError::Unauthorized(&quot;token sudah kedaluwarsa&quot;.to_owned()));
        }

        // 4. Ambil data user
        let user = store
            .cari_user_by_id(session.user_id)
            .await?
            .ok_or_else(|| AppError::Unauthorized(&quot;user tidak ditemukan&quot;.to_owned()))?;

        Ok(CurrentUser {
            user,
            token: token.to_owned(),
        })
    }
}

src/handlers.rs

/// Handler HTTP: auth (register/login/logout/me) dan tasks (per-user).
use crate::{
    auth::{
        buat_token, durasi_session, hash_password, sekarang_unix, verifikasi_password, CurrentUser,
    },
    error::AppError,
    models::{
        validasi_judul, validasi_kredensial, LoginInput, LoginResponse, MeResponse, NewTask,
        RegisterInput, Task, UpdateTask,
    },
    store::Store,
};
use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::Json,
};

// ========== AUTH ==========

/// POST /auth/register — buat akun baru.
pub async fn register(
    State(store): State<Store>,
    Json(input): Json<RegisterInput>,
) -> Result<(StatusCode, Json<MeResponse>), AppError> {
    let (username, password) = validasi_kredensial(&input.username, &input.password)
        .map_err(AppError::Validasi)?;

    // Cek username sudah dipakai?
    if store.cari_user_by_username(&username).await?.is_some() {
        return Err(AppError::Validasi(&quot;username sudah dipakai&quot;.to_owned()));
    }

    let hash = hash_password(&password)?;
    let user = store.buat_user(&username, &hash).await?;
    Ok((
        StatusCode::CREATED,
        Json(MeResponse {
            id: user.id,
            username: user.username,
        }),
    ))
}

/// POST /auth/login — verifikasi password, buat session, balas token.
pub async fn login(
    State(store): State<Store>,
    Json(input): Json<LoginInput>,
) -> Result<Json<LoginResponse>, AppError> {
    let (username, password) = validasi_kredensial(&input.username, &input.password)
        .map_err(AppError::Validasi)?;

    let user = store
        .cari_user_by_username(&username)
        .await?
        .ok_or_else(|| AppError::Unauthorized(&quot;username atau password salah&quot;.to_owned()))?;

    if !verifikasi_password(&password, &user.password_hash) {
        return Err(AppError::Unauthorized(
            &quot;username atau password salah&quot;.to_owned(),
        ));
    }

    // Buat session baru
    let token = buat_token();
    let expires_at = sekarang_unix() + durasi_session();
    store.buat_session(user.id, &token, expires_at).await?;

    Ok(Json(LoginResponse { token }))
}

/// POST /auth/logout — hapus session (token mati). Perlu login.
pub async fn logout(
    State(store): State<Store>,
    user: CurrentUser,
) -> Result<StatusCode, AppError> {
    store.hapus_session(&user.token).await?;
    Ok(StatusCode::NO_CONTENT)
}

/// GET /auth/me — siapa yang sedang login.
pub async fn me(user: CurrentUser) -> Json<MeResponse> {
    Json(MeResponse {
        id: user.user.id,
        username: user.user.username,
    })
}

// ========== TASKS (per-user) ==========

/// GET /tasks — daftar tugas milik user yang login.
pub async fn daftar(
    State(store): State<Store>,
    user: CurrentUser,
) -> Result<Json<Vec<Task>>, AppError> {
    Ok(Json(store.semua_tasks(user.user.id).await?))
}

/// GET /tasks/{id} — baca satu tugas milik sendiri.
pub async fn ambil(
    State(store): State<Store>,
    Path(id): Path<i64>,
    user: CurrentUser,
) -> Result<Json<Task>, AppError> {
    store
        .cari_task(user.user.id, id)
        .await?
        .map(Json)
        .ok_or(AppError::TidakDitemukan)
}

/// POST /tasks — buat tugas milik sendiri.
pub async fn buat(
    State(store): State<Store>,
    user: CurrentUser,
    Json(input): Json<NewTask>,
) -> Result<(StatusCode, Json<Task>), AppError> {
    let title = validasi_judul(&input.title).map_err(AppError::Validasi)?;
    let tugas = store.buat_task(user.user.id, &title).await?;
    Ok((StatusCode::CREATED, Json(tugas)))
}

/// PUT /tasks/{id} — ganti tugas milik sendiri.
pub async fn ubah(
    State(store): State<Store>,
    Path(id): Path<i64>,
    user: CurrentUser,
    Json(input): Json<UpdateTask>,
) -> Result<Json<Task>, AppError> {
    let title = validasi_judul(&input.title).map_err(AppError::Validasi)?;
    store
        .ubah_task(user.user.id, id, &input, &title)
        .await?
        .map(Json)
        .ok_or(AppError::TidakDitemukan)
}

/// DELETE /tasks/{id} — hapus tugas milik sendiri.
pub async fn hapus(
    State(store): State<Store>,
    Path(id): Path<i64>,
    user: CurrentUser,
) -> Result<StatusCode, AppError> {
    if store.hapus_task(user.user.id, id).await? {
        Ok(StatusCode::NO_CONTENT)
    } else {
        Err(AppError::TidakDitemukan)
    }
}

src/lib.rs

/// Perpustakaan proyek: merangkai module dan menyediakan Router.
pub mod auth;
pub mod config;
pub mod error;
pub mod handlers;
pub mod models;
pub mod store;

use axum::{
    routing::{get, post},
    Router,
};
use store::Store;

/// Router aplikasi dengan Store sebagai state.
/// Route /auth/register dan /auth/login publik; /auth/logout, /auth/me, dan
/// /tasks terproteksi (butuh login).
pub fn app(store: Store) -> Router {
    Router::new()
        .route("/health", get(|| async { "ok" }))
        // Auth publik
        .route("/auth/register", post(handlers::register))
        .route("/auth/login", post(handlers::login))
        // Auth terproteksi
        .route("/auth/logout", post(handlers::logout))
        .route("/auth/me", get(handlers::me))
        // Tasks per-user (semua butuh login)
        .route("/tasks", get(handlers::daftar).post(handlers::buat))
        .route(
            "/tasks/{id}",
            get(handlers::ambil).put(handlers::ubah).delete(handlers::hapus),
        )
        .with_state(store)
}

src/main.rs

/// Titik masuk server: config -> pool -> migrasi -> serve.
/// Menjalankan: export DATABASE_URL=... && cargo run
use bab19_auth_api::{app, config::Config, store::Store};
use sqlx::mysql::MySqlPool;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = Config::dari_env()?;
    let pool = MySqlPool::connect(&config.database_url).await?;
    let store = Store::baru(pool);
    store.migrasi().await?;

    let alamat = format!(&quot;127.0.0.1:{}&quot;, config.port);
    let listener = tokio::net::TcpListener::bind(&alamat).await?;
    println!(&quot;Migrasi selesai. Mendengarkan di http://{alamat}&quot;);
    axum::serve(listener, app(store)).await?;
    Ok(())
}

.env.example

# Salin file ini menjadi .env atau set lewat `export` di terminal.
# GANTI sandinya dengan milikmu. Jangan pernah commit sandi asli.

# URL koneksi MariaDB untuk server API.
DATABASE_URL=mysql://task_app:ganti-dengan-sandi-kuat@127.0.0.1:3306/belajar_rust

# Database TERPISAH untuk integration test (dipakai oleh cargo test).
TEST_DATABASE_URL=mysql://task_app:ganti-dengan-sandi-kuat@127.0.0.1:3306/belajar_rust_test

# Port server (opsional, bawaan 3000).
PORT=3000

tests/api.rs

//! Integration test untuk autentikasi dan tasks per-user.
//! Memakai database test terpisah (TEST_DATABASE_URL). Jika tidak di-set,
//! test dilewati sehingga unit test lain tetap berjalan.
use axum::body::Body;
use axum::http::{Request, StatusCode};
use bab19_auth_api::{app, store::Store};
use serde_json::{json, Value};
use sqlx::mysql::MySqlPool;
use tower::ServiceExt;

// Semua test DB berbagi satu tabel; kunci mencegah saling mengosongkan.
static DB_TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());

/// Siapkan store + router bersih. None bila database test belum disiapkan.
async fn siapkan() -> Option<(Store, axum::Router)> {
    let Ok(url) = std::env::var(&quot;TEST_DATABASE_URL&quot;) else {
        eprintln!(&quot;TEST_DATABASE_URL belum di-set: test database dilewati&quot;);
        return None;
    };
    let pool = MySqlPool::connect(&url)
        .await
        .expect(&quot;koneksi database test berhasil&quot;);
    let store = Store::baru(pool);
    store.migrasi().await.expect(&quot;migrasi berhasil&quot;);
    store.kosongkan().await.expect(&quot;tabel test bersih&quot;);
    let router = app(store.clone());
    Some((store, router))
}

/// Helper: kirim request ke Router dan kembalikan (status, body sebagai Value).
async fn panggil(
    app: &mut axum::Router,
    method: &str,
    path: &str,
    token: Option<&str>,
    body: Option<Value>,
) -> (StatusCode, Option<Value>) {
    let mut builder = Request::builder().method(method).uri(path);
    if let Some(t) = token {
        builder = builder.header(&quot;authorization&quot;, format!(&quot;Bearer {t}&quot;));
    }
    let http_body = match body {
        Some(v) => {
            builder = builder.header(&quot;content-type&quot;, &quot;application/json&quot;);
            Body::from(serde_json::to_vec(&v).expect(&quot;serialize&quot;))
        }
        None => Body::empty(),
    };
    let respons = app
        .oneshot(builder.body(http_body).expect(&quot;request valid&quot;))
        .await
        .expect(&quot;router merespons&quot;);
    let status = respons.status();
    let bytes = axum::body::to_bytes(respons.into_body(), usize::MAX)
        .await
        .expect(&quot;baca body&quot;);
    let nilai = if bytes.is_empty() {
        None
    } else {
        Some(serde_json::from_slice(&bytes).expect(&quot;respons JSON&quot;))
    };
    (status, nilai)
}

/// Register user baru dan kembalikan token login.
async fn register_dan_login(app: &mut axum::Router, username: &str) -> String {
    // Register
    let (status, _) = panggil(
        app,
        &quot;POST&quot;,
        &quot;/auth/register&quot;,
        None,
        Some(json!({&quot;username&quot;: username, &quot;password&quot;: &quot;password123&quot;})),
    )
    .await;
    assert_eq!(status, StatusCode::CREATED);

    // Login
    let (status, body) = panggil(
        app,
        &quot;POST&quot;,
        &quot;/auth/login&quot;,
        None,
        Some(json!({&quot;username&quot;: username, &quot;password&quot;: &quot;password123&quot;})),
    )
    .await;
    assert_eq!(status, StatusCode::OK);
    body.expect(&quot;token login&quot;)[&quot;token&quot;]
        .as_str()
        .expect(&quot;token string&quot;)
        .to_owned()
}

#[tokio::test]
async fn alur_auth_dan_tasks() {
    let _guard = DB_TEST_LOCK.lock().await;
    let Some((_store, mut app)) = siapkan().await else { return };

    let token = register_dan_login(&mut app, &quot;andi&quot;).await;

    // GET /auth/me tanpa token -> 401
    let (status, _) = panggil(&mut app, &quot;GET&quot;, &quot;/auth/me&quot;, None, None).await;
    assert_eq!(status, StatusCode::UNAUTHORIZED);

    // GET /auth/me dengan token -> 200
    let (status, body) = panggil(&mut app, &quot;GET&quot;, &quot;/auth/me&quot;, Some(&token), None).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(body.expect(&quot;me&quot;)[&quot;username&quot;], &quot;andi&quot;);

    // Buat task dengan token
    let (status, body) = panggil(
        &mut app,
        &quot;POST&quot;,
        &quot;/tasks&quot;,
        Some(&token),
        Some(json!({&quot;title&quot;: &quot;Belajar auth&quot;})),
    )
    .await;
    assert_eq!(status, StatusCode::CREATED);
    let task_id = body.expect(&quot;task&quot;)[&quot;id&quot;].as_i64().expect(&quot;id angka&quot;);

    // Daftar tasks milik sendiri
    let (status, body) = panggil(&mut app, &quot;GET&quot;, &quot;/tasks&quot;, Some(&token), None).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(body.expect(&quot;array&quot;).as_array().expect(&quot;array&quot;).len(), 1);

    // User lain: register dan pastikan tidak bisa lihat task andi
    let token_lain = register_dan_login(&mut app, &quot;budi&quot;).await;
    let (status, _) = panggil(
        &mut app,
        &quot;GET&quot;,
        &format!(&quot;/tasks/{task_id}&quot;),
        Some(&token_lain),
        None,
    )
    .await;
    assert_eq!(status, StatusCode::NOT_FOUND); // 404 karena bukan milik budi

    // Logout
    let (status, _) = panggil(&mut app, &quot;POST&quot;, &quot;/auth/logout&quot;, Some(&token), None).await;
    assert_eq!(status, StatusCode::NO_CONTENT);

    // Setelah logout, token lama ditolak
    let (status, _) = panggil(&mut app, &quot;GET&quot;, &quot;/auth/me&quot;, Some(&token), None).await;
    assert_eq!(status, StatusCode::UNAUTHORIZED);
}

#[tokio::test]
async fn validasi_kredensial_ditolak() {
    let _guard = DB_TEST_LOCK.lock().await;
    let Some((_store, mut app)) = siapkan().await else { return };

    // Username terlalu pendek
    let (status, body) = panggil(
        &mut app,
        &quot;POST&quot;,
        &quot;/auth/register&quot;,
        None,
        Some(json!({&quot;username&quot;: &quot;ab&quot;, &quot;password&quot;: &quot;password123&quot;})),
    )
    .await;
    assert_eq!(status, StatusCode::BAD_REQUEST);
    assert_eq!(body.expect(&quot;error&quot;)[&quot;error&quot;], &quot;username minimal 3 karakter&quot;);

    // Password terlalu pendek
    let (status, body) = panggil(
        &mut app,
        &quot;POST&quot;,
        &quot;/auth/register&quot;,
        None,
        Some(json!({&quot;username&quot;: &quot;andi&quot;, &quot;password&quot;: &quot;short&quot;})),
    )
    .await;
    assert_eq!(status, StatusCode::BAD_REQUEST);
    assert_eq!(body.expect(&quot;error&quot;)[&quot;error&quot;], &quot;password minimal 8 karakter&quot;);

    // Username sudah dipakai
    let _ = register_dan_login(&mut app, &quot;andi&quot;).await;
    let (status, body) = panggil(
        &mut app,
        &quot;POST&quot;,
        &quot;/auth/register&quot;,
        None,
        Some(json!({&quot;username&quot;: &quot;andi&quot;, &quot;password&quot;: &quot;password123&quot;})),
    )
    .await;
    assert_eq!(status, StatusCode::BAD_REQUEST);
    assert_eq!(body.expect(&quot;error&quot;)[&quot;error&quot;], &quot;username sudah dipakai&quot;);

    // Login dengan password salah
    let (status, body) = panggil(
        &mut app,
        &quot;POST&quot;,
        &quot;/auth/login&quot;,
        None,
        Some(json!({&quot;username&quot;: &quot;andi&quot;, &quot;password&quot;: &quot;salahpassword&quot;})),
    )
    .await;
    assert_eq!(status, StatusCode::UNAUTHORIZED);
    assert_eq!(
        body.expect(&quot;error&quot;)[&quot;error&quot;],
        &quot;username atau password salah&quot;
    );
}

#[tokio::test]
async fn tasks_per_user_tidak_bisa_diakses_orang_lain() {
    let _guard = DB_TEST_LOCK.lock().await;
    let Some((_store, mut app)) = siapkan().await else { return };

    let token_andi = register_dan_login(&mut app, &quot;andi&quot;).await;
    let token_budi = register_dan_login(&mut app, &quot;budi&quot;).await;

    // Andi buat task
    let (status, body) = panggil(
        &mut app,
        &quot;POST&quot;,
        &quot;/tasks&quot;,
        Some(&token_andi),
        Some(json!({&quot;title&quot;: &quot;Rahasia andi&quot;})),
    )
    .await;
    assert_eq!(status, StatusCode::CREATED);
    let task_id = body.expect(&quot;task&quot;)[&quot;id&quot;].as_i64().expect(&quot;id angka&quot;);

    // Budi tidak bisa lihat task andi
    let (status, _) = panggil(
        &mut app,
        &quot;GET&quot;,
        &format!(&quot;/tasks/{task_id}&quot;),
        Some(&token_budi),
        None,
    )
    .await;
    assert_eq!(status, StatusCode::NOT_FOUND);

    // Budi tidak bisa ubah task andi
    let (status, _) = panggil(
        &mut app,
        &quot;PUT&quot;,
        &format!(&quot;/tasks/{task_id}&quot;),
        Some(&token_budi),
        Some(json!({&quot;title&quot;: &quot;dicolong&quot;, &quot;completed&quot;: true})),
    )
    .await;
    assert_eq!(status, StatusCode::NOT_FOUND);

    // Budi tidak bisa hapus task andi
    let (status, _) = panggil(
        &mut app,
        &quot;DELETE&quot;,
        &format!(&quot;/tasks/{task_id}&quot;),
        Some(&token_budi),
        None,
    )
    .await;
    assert_eq!(status, StatusCode::NOT_FOUND);

    // Daftar task budi tetap kosong
    let (status, body) = panggil(&mut app, &quot;GET&quot;, &quot;/tasks&quot;, Some(&token_budi), None).await;
    assert_eq!(status, StatusCode::OK);
    assert_eq!(body.expect(&quot;array&quot;).as_array().expect(&quot;array&quot;).len(), 0);
}

Rustup terpasang pada akun Ubuntu, tetapi shell belum memuat PATH. Buka terminal baru atau jalankan source "$HOME/.cargo/env"; cek cargo --version.

Kamu berada di folder bab, bukan folder contoh/. Jalankan pwd lalu cd .../contoh seperti perintah pada bab tersebut.

Contoh mengikat server di 127.0.0.1 milik Ubuntu. Jalankan curl di terminal Ubuntu/VS Code Server yang sama. Bila perlu akses dari laptop, gunakan port forwarding Remote-SSH sesuai pengaturan VS Code.

Periksa sudo systemctl status mariadb, URL di DATABASE_URL, nama DB dan password. Jangan kirim password aslimu saat meminta bantuan.

Ya, materi pada halaman ini ada di satu file; buka HTML secara langsung. Font/CDN butuh internet untuk tampil maksimal. Untuk menjalankan proyek Cargo lengkap, tetap gunakan folder contoh/ yang sudah ada di kursus.