Teststrategien für Rust-Webanwendungen

Die Entwicklung von Webanwendungen in Rust bietet unvergleichliche Leistung, Speichersicherheit und Nebenläufigkeit. Der Aufbau einer hochzuverlässigen und wartbaren Anwendung geht jedoch über das reine Schreiben funktionalen Codes hinaus. Ein kritischer Aspekt, der oft übersehen oder schlecht umgesetzt wird, ist umfassendes Testen. In der dynamischen Welt der Webentwicklung, in der Anwendungen ständig weiterentwickelt werden und mit verschiedenen externen Komponenten interagieren, sind robuste Teststrategien nicht nur eine bewährte Methode; sie sind eine Notwendigkeit. Sie geben die Sicherheit, Refactorings durchzuführen, neue Features bereitzustellen und sicherzustellen, dass Änderungen keine Regressionen einführen. Dieser Artikel befasst sich mit effektiven Methoden für Unit- und Integrationstests von Handlern und Services in Rust-Webanwendungen und stattet Sie mit den Werkzeugen und Kenntnissen aus, um widerstandsfähigere Systeme zu entwickeln.

Kernkonzepte beim Testen

Bevor wir uns mit den praktischen Aspekten befassen, sollten wir ein gemeinsames Verständnis einiger wichtiger Testterminologien etablieren, die in unserer Diskussion häufig vorkommen werden.

• Unit Test: Konzentriert sich auf das Testen einzelner, isolierter Codeeinheiten wie einer einzelnen Funktion, Methode oder eines kleinen Moduls. Ziel ist es, zu überprüfen, ob jede Einheit isoliert korrekt funktioniert, oft durch Mocking von Abhängigkeiten.
• Integration Test: Konzentriert sich auf das Testen, wie verschiedene Teile oder Module einer Anwendung zusammenarbeiten. Dies beinhaltet typischerweise die Interaktion mehrerer Komponenten, möglicherweise einschließlich Datenbanken, APIs oder anderer Dienste, um sicherzustellen, dass sie nahtlos integriert sind und das erwartete Ergebnis liefern.
• Handler: Im Kontext von Web-Frameworks (z. B. Actix Web, Axum, Warp) ist ein Handler eine Funktion oder Methode, die eingehende HTTP-Anfragen verarbeitet und eine HTTP-Antwort zurückgibt. Es ist der Einstiegspunkt für bestimmte API-Endpunkte.
• Service (oder Business Logic): Diese Schicht kapselt die Kerngeschäftsregeln und -operationen Ihrer Anwendung. Handler rufen Services auf, um komplexe Aufgaben auszuführen, mit Datenbanken zu interagieren oder mit externen Systemen zu kommunizieren. Services sind typischerweise so konzipiert, dass sie unabhängig vom eigentlichen Web-Framework sind.
• Mocking: Ersetzen einer echten Abhängigkeit (z. B. eine Datenbankverbindung, ein externer API-Client) durch ein kontrolliertes Ersatzobjekt während des Tests. Mocks ermöglichen es Ihnen, die getestete Einheit zu isolieren und verschiedene Szenarien zu simulieren, ohne auf tatsächliche externe Ressourcen angewiesen zu sein.
• Stubbing: Ähnlich wie Mocking, bezieht sich aber typischerweise auf die Bereitstellung vorprogrammierter Antworten auf Methodenaufrufe, ohne notwendigerweise Interaktionen zu überprüfen.
• Fixture: Ein fester Zustand oder Daten, der als Basis für Tests verwendet wird. Er stellt sicher, dass Tests in einer konsistenten und vorhersehbaren Umgebung ausgeführt werden.

Unit Testing von Handlern und Services

Unit Testing zielt auf Isolation und Geschwindigkeit ab. Für Handler und Services bedeutet dies, ihre Logik unabhängig vom Webserver oder externen Ressourcen zu testen.

Unit Testing von Services

Services enthalten oft die komplexeste Geschäftslogik, was sie zu idealen Kandidaten für gründliche Unit-Tests macht. Da Services Framework-unabhängig sein sollten, ist das Testen im Allgemeinen unkompliziert.

Betrachten Sie einen einfachen UserService, der mit einem UserRepository-Trait interagiert:

// src/user_service.rs

pub struct User {
    pub id: u32,
    pub name: String,
    pub email: String,
}

#[derive(Debug, PartialEq)]
pub enum ServiceError {
    UserNotFound,
    DatabaseError(String),
}

// Ein Trait für unser Repository, was ihn mockbar macht
pub trait UserRepository: Send + Sync + 'static {
    fn get_user_by_id(&self, id: u32) -> Result<Option<User>, String>;
    fn create_user(&self, name: String, email: String) -> Result<User, String>;
}

pub struct UserService<R: UserRepository> {
    repository: R,
}

impl<R: UserRepository> UserService<R> {
    pub fn new(repository: R) -> Self {
        UserService { repository }
    }

    pub fn fetch_user_details(&self, user_id: u32) -> Result<User, ServiceError> {
        match self.repository.get_user_by_id(user_id) {
            Ok(Some(user)) => Ok(user),
            Ok(None) => Err(ServiceError::UserNotFound),
            Err(e) => Err(ServiceError::DatabaseError(e)),
        }
    }

    pub fn register_new_user(&self, name: String, email: String) -> Result<User, ServiceError> {
        if name.is_empty() || email.is_empty() {
            return Err(ServiceError::DatabaseError("Name or email cannot be empty".to_string()));
        }
        match self.repository.create_user(name, email) {
            Ok(user) => Ok(user),
            Err(e) => Err(ServiceError::DatabaseError(e)),
        }
    }
}

Schreiben wir nun Unit-Tests für UserService, indem wir ein Mock UserRepository erstellen. Wir können eine Crate wie mockall für anspruchsvollere Mockings verwenden oder ein einfaches Mock manuell zur Verdeutlichung implementieren.

// src/user_service.rs (fortgesetzt) oder src/tests/user_service_test.rs

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

    // Ein einfaches manuelles Mock für UserRepository
    struct MockUserRepository {
        // Wir können vordefinierte Ergebnisse oder eine Closure für dynamisches Verhalten speichern
        get_user_by_id_result: Option<Result<Option<User>, String>>,
        create_user_result: Option<Result<User, String>>,
    }

    impl MockUserRepository {
        fn new() -> Self {
            MockUserRepository {
                get_user_by_id_result: None,
                create_user_result: None,
            }
        }

        fn expect_get_user_by_id(mut self, result: Result<Option<User>, String>) -> Self {
            self.get_user_by_id_result = Some(result);
            self
        }

        fn expect_create_user(mut self, result: Result<User, String>) -> Self {
            self.create_user_result = Some(result);
            self
        }
    }

    impl UserRepository for MockUserRepository {
        fn get_user_by_id(&self, id: u32) -> Result<Option<User>, String> {
            self.get_user_by_id_result
                .clone()
                .unwrap_or_else(|| panic!("get_user_by_id not mocked for id {}", id))
        }

        fn create_user(&self, name: String, email: String) -> Result<User, String> {
            self.create_user_result
                .clone()
                .unwrap_or_else(|| panic!("create_user not mocked for name {} email {}", name, email))
        }
    }

    #[test]
    fn test_fetch_user_details_success() {
        let expected_user = User {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
        };
        let mock_repo = MockUserRepository::new()
            .expect_get_user_by_id(Ok(Some(expected_user.clone())));
        let user_service = UserService::new(mock_repo);

        let result = user_service.fetch_user_details(1);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), expected_user);
    }

    #[test]
    fn test_fetch_user_details_not_found() {
        let mock_repo = MockUserRepository::new()
            .expect_get_user_by_id(Ok(None));
        let user_service = UserService::new(mock_repo);

        let result = user_service.fetch_user_details(2);
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), ServiceError::UserNotFound);
    }

    #[test]
    fn test_register_new_user_success() {
        let expected_user = User {
            id: 100,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
        };
        let mock_repo = MockUserRepository::new()
            .expect_create_user(Ok(expected_user.clone()));
        let user_service = UserService::new(mock_repo);

        let result = user_service.register_new_user("Bob".to_string(), "bob@example.com".to_string());
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), expected_user);
    }

    #[test]
    fn test_register_new_user_empty_input() {
        let mock_repo = MockUserRepository::new(); // No need to mock create_user if it won't be called
        let user_service = UserService::new(mock_repo);

        let result = user_service.register_new_user("".to_string(), "bob@example.com".to_string());
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), ServiceError::DatabaseError("Name or email cannot be empty".to_string()));
    }
}

Dieser manuelle Mocking-Ansatz demonstriert klar, wie Sie Abhängigkeiten steuern können, um Service-Logik isoliert zu testen. Für komplexere Szenarien können Crates wie mockall Mock-Implementierungen automatisch aus Traits generieren, was den Boilerplate-Code reduziert.

Unit Testing von Handlern

Handler sind etwas kniffliger zu unit-testen, da sie oft von Web-Framework-spezifischen Kontexten abhängen (z. B. Request-Objekte, Extraktoren für JSON-Bodies, Pfadparameter). Ziel ist es hier, die Request-Verarbeitung, Fehlerbehandlung und korrekte Aufrufe der zugrundeliegenden Services des Handlers zu testen, ohne einen tatsächlichen Webserver zu starten.

Nehmen wir einen Actix Web Handler an:

// src/api_handler.rs
extern crate actix_web;
use actix_web::{web, HttpResponse, Responder};
use serde::{Deserialize, Serialize};

use crate::user_service::{ServiceError, User, UserService, UserRepository};

#[derive(Serialize)]
pub struct UserResponse {
    id: u32,
    name: String,
    email: String,
}

impl From<User> for UserResponse {
    fn from(user: User) -> Self {
        UserResponse {
            id: user.id,
            name: user.name,
            email: user.email,
        }
    }
}

pub async fn get_user_handler<R: UserRepository>(
    path: web::Path<u32>,
    user_service: web::Data<UserService<R>>,
) -> impl Responder {
    let user_id = path.into_inner();
    match user_service.fetch_user_details(user_id) {
        Ok(user) => HttpResponse::Ok().json(UserResponse::from(user)),
        Err(ServiceError::UserNotFound) => HttpResponse::NotFound().body("User not found"),
        Err(ServiceError::DatabaseError(e)) => HttpResponse::InternalServerError().body(e),
    }
}

#[derive(Deserialize)]
pub struct CreateUserRequest {
    pub name: String,
    pub email: String,
}

pub async fn create_user_handler<R: UserRepository>(
    user_data: web::Json<CreateUserRequest>,
    user_service: web::Data<UserService<R>>,
) -> impl Responder {
    match user_service.register_new_user(user_data.name.clone(), user_data.email.clone()) {
        Ok(user) => HttpResponse::Created().json(UserResponse::from(user)),
        Err(ServiceError::DatabaseError(e)) => HttpResponse::InternalServerError().body(e),
        // UserNotFound ist nicht von register_new_user zu erwarten, als interner Fehler behandeln
        Err(ServiceError::UserNotFound) => HttpResponse::InternalServerError().body("Unexpected service error"),
    }
}

Um diese Handler zu unit-testen, müssen wir manuell die Äquivalente für web::Path, web::Json und web::Data konstruieren, die Actix Web normalerweise bereitstellen würde.

// src/api_handler.rs (fortgesetzt) oder src/tests/api_handler_test.rs

#[cfg(test)]
mod handler_tests {
    use super::*;
    use actix_web::{test, web::Bytes};
    use crate::user_service::tests::MockUserRepository; // Unser Mock aus Service-Tests verwenden

    // Helper zum Extrahieren von JSON aus der Antwort
    async fn get_json_body<T: for<'de> Deserialize<'de>>(response: HttpResponse) -> T {
        let response_body = test::read_body(response).await;
        serde_json::from_slice(&response_body).expect("Failed to deserialize response body")
    }

    #[actix_web::test]
    async fn test_get_user_handler_success() {
        let expected_user = User {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
        };
        let mock_repo = MockUserRepository::new()
            .expect_get_user_by_id(Ok(Some(expected_user.clone())));
        let user_service = web::Data::new(UserService::new(mock_repo));

        let resp = get_user_handler(web::Path::from(1), user_service).await;
        assert_eq!(resp.status(), 200);

        let user_resp: UserResponse = get_json_body(resp).await;
        assert_eq!(user_resp.id, expected_user.id);
        assert_eq!(user_resp.name, expected_user.name);
    }

    #[actix_web::test]
    async fn test_get_user_handler_not_found() {
        let mock_repo = MockUserRepository::new()
            .expect_get_user_by_id(Ok(None));
        let user_service = web::Data::new(UserService::new(mock_repo));

        let resp = get_user_handler(web::Path::from(99), user_service).await;
        assert_eq!(resp.status(), 404);
        let body = test::read_body(resp).await;
        assert_eq!(body, Bytes::from_static(b"User not found"));
    }

    #[actix_web::test]
    async fn test_create_user_handler_success() {
        let new_user_req = CreateUserRequest {
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
        };
        let expected_user = User {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
        };
        let mock_repo = MockUserRepository::new()
            .expect_create_user(Ok(expected_user.clone()));
        let user_service = web::Data::new(UserService::new(mock_repo));

        let resp = create_user_handler(web::Json(new_user_req), user_service).await;
        assert_eq!(resp.status(), 201); // Created

        let user_resp: UserResponse = get_json_body(resp).await;
        assert_eq!(user_resp.id, expected_user.id);
        assert_eq!(user_resp.name, expected_user.name);
    }
}

Dieser Ansatz ermöglicht das Testen des Handlers mit gemockten Services, um sicherzustellen, dass seine Logik für Request-Parsing, Service-Interaktion und Response-Generierung korrekt ist, ohne tatsächliche Datenbankaufrufe oder Netzwerkanfragen. Beachten Sie die Verwendung von #[actix_web::test], das eine Actix Web-Laufzeit für asynchrone Tests bereitstellt.

Integrationstests von Handlern und Services

Integrationstests überprüfen, ob verschiedene Komponenten Ihrer Anwendung, einschließlich Handlern, Services und möglicherweise einer Datenbank, wie erwartet zusammenarbeiten. Für Webanwendungen bedeutet dies oft, eine leichtgewichtige Instanz Ihrer Anwendung zu starten und tatsächliche HTTP-Anfragen an sie zu senden.

Für Actix Web bietet das actix_web::test-Modul Hilfsmittel zur Vereinfachung. Für andere Frameworks wie Axum oder Warp existieren ähnliche Testwerkzeuge oder können manuell eingewickelt werden.

Zuerst ist eine tatsächliche Datenbank für echte End-to-End-Integrationstests erforderlich. Für die Entwicklung und das Testen ist eine In-Memory-Datenbank wie SQLite oder ein Test-Container für PostgreSQL/MySQL ideal. Hier gehen wir davon aus, dass ein PostgresRepository unser UserRepository-Trait implementiert.

// src/pg_repository.rs (vereinfacht für das Beispiel)
use async_trait::async_trait;
use sqlx::{PgPool, Row};
use crate::user_service::{User, UserRepository};

pub struct PostgresRepository {
    pool: PgPool,
}

impl PostgresRepository {
    pub fn new(pool: PgPool) -> Self {
        PostgresRepository { pool }
    }
}

// Implementieren Sie den zuvor definierten Trait mithilfe von async_trait
#[async_trait]
impl UserRepository for PostgresRepository {
    fn get_user_by_id(&self, id: u32) -> Result<Option<User>, String> {
        // In einem echten Async-Trait wäre dies eine async fn. F
        // ür die Einfachheit halten wir sie im Beispiel synchron-ähnlich,
        // aber normalerweise würden Sie hier SQL-Operationen awaiten.
        // Ein besserer Ansatz für einen Trait wäre `async fn get_user_by_id(&self, id: u32) -> Result<Option<User>, sqlx::Error>`
        // und dann diesen Fehler zu `String` für den ServiceError abbilden.
        // Für dieses Beispiel tun wir so, als wäre `sqlx` synchron zur Vereinfachung, oder wir passen den Trait an.

        // Echter Code würde ungefähr so aussehen, innerhalb einer `async fn`:
        // let user = sqlx::query_as!(User, "SELECT id, name, email FROM users WHERE id = $1", id as i32)
        //     .fetch_optional(&self.pool)
        //     .await
        //     .map_err(|e| e.to_string())?;
        // Ok(user)
        
        // Vorerst Dummy-Daten zurückgeben oder im nicht-asynchronen Trait-Kontext mocken
        // Dies ist eine Vereinfachung; ein vollständiger asynchroner UserRepository-Trait wäre besser.
        if id == 1 {
            Ok(Some(User { id: 1, name: "Integration Alice".to_string(), email: "inta@example.com".to_string() }))
        } else {
            Ok(None)
        }
    }

    fn create_user(&self, name: String, email: String) -> Result<User, String> {
        // Ähnliche Vereinfachung für asynchrone DB-Operationen
        // Beispiel:
        // sqlx::query!("INSERT INTO users (name, email) VALUES ($1, $2)", name, email)
        //     .execute(&self.pool)
        //     .await
        //     .map_err(|e| e.to_string())?;
        // Ok(User { id: 100, name, email }) // Tatsächliche ID aus der DB abrufen

        Ok(User { id: 100, name, email })
    }
}

// Einstiegspunkt unserer Anwendung
// src/main.rs
use actix_web::{App, HttpServer};
use crate::pg_repository::PostgresRepository; // Angenommen ein echtes PG-Repository
use crate::user_service::UserService;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // Echten Datenbank-Pool einrichten
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPool::connect(&database_url)
        .await
        .expect("Failed to connect to Postgres.");

    // Einen echten Service mit dem echten Repository erstellen
    let user_svc = UserService::new(PostgresRepository::new(pool.clone()));

    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(user_svc.clone())) // Service als app_data übergeben
            .service(web::resource("/users/{id}").to(api_handler::get_user_handler::<PostgresRepository>))
            .service(web::resource("/users").post(api_handler::create_user_handler::<PostgresRepository>))
    })
    .bind(("127.0.0.1", 8080))? 
    .run()
    .await
}

Jetzt schreiben wir Integrationstests für unsere Anwendung. Wir verwenden die Test-Utilities von Actix Web, um einen Testserver zu erstellen und Anfragen an ihn zu senden.

// src/tests/integration_tests.rs
#[cfg(test)]
mod integration_tests {
    use actix_web::{test, web, App, HttpResponse, http::StatusCode};
    use serde_json::json;

    use crate::{
        api_handler::{self, CreateUserRequest, UserResponse},
        PgRepository, // Unser tatsächliches Repository
        user_service::UserService,
    };
    use sqlx::PgPool;

    // Helper zum Einrichten eines Testservers
    async fn setup_test_app(pool: PgPool) -> actix_web::App<impl actix_web::dev::ServiceFactory> {
        let user_repo = PgRepository::new(pool);
        let user_service = UserService::new(user_repo);

        App::new()
            .app_data(web::Data::new(user_service))
            .service(web::resource("/users/{id}").to(api_handler::get_user_handler::<PgRepository>))
            .service(web::resource("/users").post(api_handler::create_user_handler::<PgRepository>))
    }

    // In einem realen Szenario würden Sie hier eine Testdatenbank einrichten (z. B. über einen Docker-Container oder eine In-Memory-SQLite-Datenbank)
    // Für einfache Zwecke verwendet dieses Beispiel einen Dummy-Pool oder geht davon aus, dass eine Test-DB läuft.
    // Das Einrichten einer transaktionalen Testdatenbank ist ideal:
    // func setup_test_db() -> PgPool { ... Test-DB erstellen, Migrationen ausführen, Pool zurückgeben ... }
    // Rufen Sie dies vor jedem Test oder einmal für alle Tests auf und bereinigen Sie.

    #[actix_web::test]
    async fn test_get_user_integration() {
        // Dies ist ein Platzhalter für einen echten Datenbank-Pool.
        // In einem echten Test würden Sie hier eine Verbindung zu einer Testdatenbank herstellen.
        let pool = PgPool::connect("postgresql://user:password@localhost/test_db")
            .await
            .expect("Failed to connect to test database");

        // Bereinigen Sie potenziell vorhandene Daten oder fügen Sie Fixture-Daten ein (transaktional ist besser)
        sqlx::query!("INSERT INTO users (id, name, email) VALUES (1, 'Alice', 'alice@example.com') ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, email = EXCLUDED.email")
            .execute(&pool)
            .await
            .expect("Failed to insert test user");
            
        let app = test::init_service(setup_test_app(pool.clone()).await).await;

        let req = test::TestRequest::get().uri("/users/1").to_request();
        let resp = test::call_service(&app, req).await;

        assert_eq!(resp.status(), StatusCode::OK);
        let user_response: UserResponse = test::read_body_json(resp).await;
        assert_eq!(user_response.id, 1);
        assert_eq!(user_response.name, "Alice");
        assert_eq!(user_response.email, "alice@example.com");

        // Testdaten bereinigen, falls keine transaktionalen Tests verwendet werden
        sqlx::query!("DELETE FROM users WHERE id = 1")
            .execute(&pool)
            .await
            .expect("Failed to delete test user");
    }

    #[actix_web::test]
    async fn test_create_user_integration() {
        let pool = PgPool::connect("postgresql://user:password@localhost/test_db")
            .await
            .expect("Failed to connect to test database");

        let app = test::init_service(setup_test_app(pool.clone()).await).await;

        let new_user = CreateUserRequest {
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
        };

        let req = test::TestRequest::post()
            .uri("/users")
            .set_json(&new_user)
            .to_request();
        let resp = test::call_service(&app, req).await;

        assert_eq!(resp.status(), StatusCode::CREATED);
        let user_response: UserResponse = test::read_body_json(resp).await;
        assert_eq!(user_response.name, "Bob");
        assert_eq!(user_response.email, "bob@example.com");

        // Überprüfen, ob es tatsächlich in der Datenbank ist
        let user_in_db: User = sqlx::query_as!(User, "SELECT id, name, email FROM users WHERE name = $1", "Bob")
            .fetch_one(&pool)
            .await
            .expect("Failed to fetch user from DB after creation");
        assert_eq!(user_in_db.name, "Bob");
        
        // Testdaten bereinigen
        sqlx::query!("DELETE FROM users WHERE id = $1", user_in_db.id as i32)
            .execute(&pool)
            .await
            .expect("Failed to delete created test user");
    }
}

Für ordnungsgemäße Datenbank-Integrationstests wird dringend empfohlen, eine dedizierte Testdatenbank (oder eine Container-Instanz, die für Ihre Tests gestartet und beendet wird) zu verwenden. Tools wie testcontainers-rs können helfen, Datenbankcontainer für Ihre Integrationstests zu verwalten und sicherzustellen, dass jeder Testlauf oder jede Testsuite einen sauberen Neustart hat. Darüber hinaus ermöglicht die Verwendung von Datenbanktransaktionen für jeden Test ein einfaches Rollback, wodurch sichergestellt wird, dass Tests den Datenbankstatus für nachfolgende Läufe nicht verunreinigen.

Fazit: Vertrauen durch umfassende Tests aufbauen

Effektive Unit- und Integrationstests von Handlern und Services in Rust-Webanwendungen sind für die Entwicklung zuverlässiger, skalierbarer und wartbarer Systeme von größter Bedeutung. Unit-Tests bieten eine granulare Überprüfung einzelner Komponenten und bieten Geschwindigkeit und präzise Fehlererkennung durch Abhängigkeits-Mocking. Integrationstests hingegen validieren die kritischen Interaktionen zwischen diesen Komponenten, einschließlich der Persistenzschicht, und stellen sicher, dass die Anwendung als Ganzes korrekt funktioniert. Durch den Einsatz dieser unterschiedlichen, aber komplementären Teststrategien können Entwickler ein robustes Sicherheitsnetz um ihren Code herum aufbauen und Vertrauen in ihre Rust-Webanwendungen schaffen.