Learn Rust Coding · Lekcja

Testowanie API

Testy integracyjne

Testowanie API to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Dlaczego testować API?

Testy dają pewność, że endpointy działają poprawnie i nadal działają po zmianach w kodzie. W przypadku REST API najcenniejsze są testy integracyjne: uruchamiają prawdziwy router od początku do końca, wysyłają żądania i sprawdzają odpowiedzi.

Ta lekcja obejmuje testy jednostkowe, sztuczkę z Tower i oneshot oraz pełne testy integracyjne.

Testy jednostkowe czystej logiki

Logikę, która nie korzysta z sieci, na przykład walidację, można testować za pomocą zwykłych testów jednostkowych Rust. Proszę umieścić je w module #[cfg(test)] obok testowanego kodu. Takie testy uruchamiają się szybko za pomocą 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"));
    }
}

Testy asynchroniczne

Handlery są asynchroniczne, dlatego funkcje testowe zawierające .await muszą działać w środowisku uruchomieniowym. Proszę używać #[tokio::test] zamiast #[test]. Uruchamia ono środowisko Tokio dla danego testu, dzięki czemu można wywoływać kod asynchroniczny za pomocą .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);
    }
}

Testowanie bez sieci

Routery Axum implementują cechę Tower Service, dlatego można przekazywać im żądania bezpośrednio, bez nasłuchiwania na porcie. Metoda oneshot przyjmuje pojedynczy obiekt Request i zwraca obiekt Response. Dzięki temu testy integracyjne są szybkie i deterministyczne.

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

Sprawdzanie kodu statusu

Większość testów najpierw sprawdza status HTTP. Brakujący zasób powinien zwrócić 404, pomyślne utworzenie zasobu 201, a nieprawidłowe ciało żądania 400. Proszę zbudować żądanie dla danej trasy i porównać res.status() z oczekiwanym kodem.

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

Odczytywanie ciała odpowiedzi

Aby sprawdzić dane JSON, proszę zebrać ciało odpowiedzi w bajty i zdeserializować je. Pomocnik http_body_util::BodyExt::collect zbiera ciało, a następnie serde_json analizuje je i przekształca w model, co pozwala sprawdzać poszczególne pola.

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

Wysyłanie ciała JSON

Aby przetestować żądanie POST, proszę zbudować żądanie z ciałem JSON i prawidłowym nagłówkiem typu zawartości. Proszę zserializować strukturę wejściową, ustawić content-type: application/json i przekazać żądanie przez 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);
}

Wielokrotnie używany konstruktor aplikacji testowej

Każdy test powinien rozpoczynać się od czystego stanu. Proszę napisać pomocniczą funkcję, która tworzy świeży router z nową bazą danych w pamięci lub bazą testową. Wywoływanie jej w każdym teście zapewnia izolację, dzięki czemu jeden test nie może wpłynąć na inny.

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
}

Katalog tests

Testy integracyjne znajdują się w głównym katalogu tests/. Każdy plik w tym katalogu jest kompilowany jako osobny crate korzystający z publicznego API biblioteki. Zmusza to do testowania za pośrednictwem tego samego interfejsu, który widzą rzeczywiści użytkownicy.

Plik tests/api.rs zawiera testy endpointów.
Wszystkie testy można uruchomić za pomocą 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 ...
}

Testowanie z użyciem bazy danych

Gdy handlery korzystają z sqlx, testy również potrzebują bazy danych. Typowe strategie to: dedykowana baza testowa, transakcje wycofywane po każdym teście albo makro sqlx #[sqlx::test], które automatycznie przygotowuje czystą bazę dla każdego testu.

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

Co testować

Proszę dążyć do zrównoważonego zestawu testów:

Ścieżka poprawnego działania: prawidłowe żądania zwracają właściwy status i ciało.
Błędy: brakujące zasoby zwracają 404, a nieprawidłowe dane wejściowe 400.
Przypadki brzegowe: puste listy, wartości graniczne i duplikaty.

Proszę uruchamiać cargo test w CI, aby wykrywać regresje przed wdrożeniem.

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat testowania API.

Podsumowanie

Nauczył(a) się Pan(i) testować REST API w Rust:

Proszę testować jednostkowo czystą logikę, a do kodu asynchronicznego używać #[tokio::test].
oneshot uruchamia router bezpośrednio, więc port nie jest potrzebny.
Proszę budować żądania z ciałami i nagłówkami, a następnie zbierać i analizować ciała odpowiedzi.
Proszę używać świeżego konstruktora aplikacji w każdym teście, aby zapewnić izolację, oraz umieszczać testy integracyjne w katalogu tests/.
#[sqlx::test] przygotowuje czyste bazy danych; proszę uwzględniać ścieżki poprawnego działania, błędy i przypadki brzegowe.

Często zadawane pytania

Czy lekcja „Testowanie API” jest bezpłatna?

Tak — pełny tekst „Testowanie API” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Testowanie API”?

Testy integracyjne Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Testowanie API”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding