0Pricing
Learn Rust Coding · Pelajaran

Menguji API

Pengujian integrasi

Menguji API adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Mengapa Menguji API?

Pengujian memberi Anda keyakinan bahwa titik akhir berperilaku dengan benar dan tetap berfungsi saat Anda mengubah kode. Untuk API REST, pengujian yang paling bermanfaat adalah pengujian integrasi: pengujian ini menjalankan router nyata dari awal hingga akhir, mengirim permintaan, dan memeriksa respons.

Pelajaran ini membahas pengujian unit, trik oneshot Tower, dan pengujian integrasi menyeluruh.

Pengujian Unit untuk Logika Murni

Logika yang tidak berhubungan dengan jaringan, seperti validasi, dapat diuji dengan pengujian unit Rust biasa. Letakkan pengujian tersebut dalam modul #[cfg(test)] di dekat kodenya. Pengujian ini berjalan cepat dengan cargo test.

fn validate_title(title: &str) -> bool {
    !title.trim().is_empty()
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn rejects_empty() {
        assert!(!validate_title("   "));
        assert!(validate_title("buy milk"));
    }
}

Pengujian Asinkron

Penangan bersifat asinkron, jadi fungsi pengujian yang menunggu harus berjalan pada runtime. Gunakan #[tokio::test], bukan #[test]. Anotasi ini memulai runtime Tokio untuk pengujian tersebut, sehingga Anda dapat memanggil kode asinkron dengan .await.

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

#[cfg(test)]
mod tests {
    use super::*;
    #[tokio::test]
    async fn adds() {
        assert_eq!(add(2, 3).await, 5);
    }
}

Menguji Tanpa Jaringan

Router Axum mengimplementasikan sifat Service milik Tower, sehingga Anda dapat langsung memberinya permintaan tanpa mengikat porta. Metode oneshot menerima satu Request dan mengembalikan Response. Hal ini membuat pengujian integrasi cepat dan deterministik.

// dev-dependencies needed: tower (for ServiceExt), http-body-util
use axum::{Router, routing::get};
use axum::http::{Request, StatusCode};
use axum::body::Body;
use tower::ServiceExt; // brings in oneshot

async fn check() {
    let app = Router::new().route("/health", get(|| async { "ok" }));
    let res = app
        .oneshot(Request::builder().uri("/health").body(Body::empty()).unwrap())
        .await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
}

Memeriksa Kode Status

Hal pertama yang diperiksa oleh sebagian besar pengujian adalah status HTTP. Sumber daya yang tidak ditemukan harus memberikan 404, pembuatan yang berhasil memberikan 201, dan isi yang tidak valid memberikan 400. Buat permintaan untuk rute tersebut dan bandingkan res.status() dengan kode yang diharapkan.

use axum::http::{Request, StatusCode};
use axum::body::Body;
use tower::ServiceExt;

async fn missing_returns_404(app: axum::Router) {
    let res = app
        .oneshot(Request::builder()
            .uri("/todos/999")
            .body(Body::empty()).unwrap())
        .await.unwrap();
    assert_eq!(res.status(), StatusCode::NOT_FOUND);
}

Membaca Isi Respons

Untuk memeriksa JSON, kumpulkan isi respons menjadi byte lalu deserialisasikan. Pembantu http_body_util::BodyExt::collect mengumpulkan isi tersebut, kemudian serde_json menguraikannya menjadi model Anda untuk pemeriksaan pada tingkat bidang.

use http_body_util::BodyExt;

async fn read_json(res: axum::http::Response<axum::body::Body>) {
    let bytes = res.into_body().collect().await.unwrap().to_bytes();
    let todo: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
    assert_eq!(todo["done"], false);
}

Mengirim Isi JSON

Untuk menguji POST, buat permintaan dengan isi JSON dan header tipe konten yang benar. Serialisasikan struktur input Anda, tetapkan content-type: application/json, lalu teruskan melalui oneshot.

use axum::http::{Request, StatusCode, header};
use axum::body::Body;
use tower::ServiceExt;

async fn create_returns_201(app: axum::Router) {
    let body = serde_json::json!({ "title": "test" }).to_string();
    let res = app
        .oneshot(Request::builder()
            .method("POST").uri("/todos")
            .header(header::CONTENT_TYPE, "application/json")
            .body(Body::from(body)).unwrap())
        .await.unwrap();
    assert_eq!(res.status(), StatusCode::CREATED);
}

Pembuat Aplikasi Pengujian yang Dapat Digunakan Kembali

Setiap pengujian harus dimulai dari keadaan yang bersih. Tulis pembantu yang membuat router baru dengan basis data dalam memori atau basis data pengujian yang baru. Memanggilnya di setiap pengujian akan mengisolasi pengujian sehingga satu pengujian tidak dapat memengaruhi pengujian lainnya.

use axum::Router;
use std::sync::{Arc, Mutex};

fn test_app() -> Router {
    let store = Arc::new(Mutex::new(Vec::new()));
    build(store) // same build() the real server uses
}

Direktori tests

Pengujian integrasi berada dalam folder tingkat teratas tests/. Setiap file di sana dikompilasi sebagai crate terpisah yang menggunakan API publik pustaka Anda. Hal ini memaksa Anda menguji melalui antarmuka yang sama seperti yang dilihat pengguna sebenarnya.

  • tests/api.rs berisi pengujian titik akhir Anda.
  • Jalankan semuanya dengan cargo test.
// tests/api.rs
use my_api::build_router; // exported from lib.rs

#[tokio::test]
async fn health_ok() {
    let _app = build_router();
    // send a request and assert ...
}

Menguji dengan Basis Data

Saat penangan menggunakan sqlx, pengujian juga memerlukan basis data. Strategi yang umum meliputi: basis data pengujian khusus, transaksi yang dibatalkan setelah setiap pengujian, atau makro #[sqlx::test] milik sqlx yang secara otomatis menyediakan basis data bersih untuk setiap pengujian.

// requires sqlx test features and a DATABASE_URL
use sqlx::PgPool;

#[sqlx::test]
async fn inserts_todo(pool: PgPool) {
    let todo = create(&pool, "learn rust").await.unwrap();
    assert_eq!(todo.title, "learn rust");
    assert_eq!(todo.done, false);
}

Apa yang Perlu Diuji

Upayakan rangkaian pengujian yang seimbang:

  • Alur berhasil: permintaan yang valid mengembalikan status dan isi yang benar.
  • Kesalahan: sumber daya yang tidak ditemukan memberikan 404, input yang tidak valid memberikan 400.
  • Kasus tepi: daftar kosong, nilai batas, duplikat.

Jalankan cargo test di CI agar kemunduran terdeteksi sebelum penerapan.

Pemeriksaan Singkat

Uji pemahaman Anda tentang pengujian API.

Ringkasan

Anda telah mempelajari cara menguji API REST Rust:

  • Uji unit logika murni; gunakan #[tokio::test] untuk kode asinkron.
  • oneshot menjalankan router secara langsung, tanpa memerlukan porta.
  • Buat permintaan dengan isi dan header; kumpulkan dan uraikan isi respons.
  • Gunakan pembuat aplikasi baru untuk setiap pengujian demi isolasi; letakkan pengujian integrasi di tests/.
  • #[sqlx::test] menyediakan basis data bersih; cakup alur berhasil, kesalahan, dan kasus tepi.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menguji API” gratis?

Ya — teks lengkap “Menguji API” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menguji API”?

Pengujian integrasi Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Menguji API” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Penyiapan Proyek
  2. Endpoint dan Model
  3. Integrasi Database
  4. Menguji API
← Kembali ke Learn Rust Coding