Testen in Rust: Unit-, Integrations- und E2E-Tests – vollständiger Leitfaden

Einführung in das Testen in Rust

Rust ist eine Systemprogrammiersprache, die für ihre Sicherheit und Leistung bekannt ist. Doch selbst der zuverlässigste Code muss überprüft werden. Testen in Rust ist nicht nur eine Option, sondern ein wesentlicher Bestandteil des Entwicklungsprozesses. Dank der integrierten Testunterstützung in Cargo können Sie problemlos Unit-, Integrations- und E2E-Tests schreiben und ausführen. In diesem Artikel werden wir alle drei Testebenen anhand praktischer Beispiele durchgehen.

Unit-Tests in Rust: Die Grundlage der Zuverlässigkeit

Unit-Tests (Modultests) überprüfen einzelne Funktionen und Methoden in Isolation. In Rust werden sie üblicherweise direkt in der Codedatei in einem speziellen tests-Modul platziert.

Struktur eines Unit-Tests

Jeder Unit-Test ist eine Funktion, die mit dem Attribut #[test] markiert ist. Darin verwenden Sie die Makros assert!, assert_eq! und assert_ne!, um die Ergebnisse zu überprüfen.

// src/math.rspub fn add(a: i32, b: i32) -> i32 {    a + b}

pub fn divide(a: f64, b: f64) -> Result<f64, String> {    if b == 0.0 {        Err(String::from("Division durch Null"))    } else {        Ok(a / b)    }}

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

    #[test]    fn test_add() {        assert_eq!(add(2, 3), 5);    }

    #[test]    fn test_divide_success() {        let result = divide(10.0, 2.0);        assert!(result.is_ok());        assert_eq!(result.unwrap(), 5.0);    }

    #[test]    fn test_divide_by_zero() {        let result = divide(10.0, 0.0);        assert!(result.is_err());        assert_eq!(result.unwrap_err(), "Division durch Null");    }}

Beachten Sie das Attribut #[cfg(test)]. Es weist den Compiler an, dieses Modul nur beim Bau der Tests einzubeziehen. Das spart Kompilierzeit für die endgültige Binärdatei.

Ausführen von Unit-Tests

Um alle Tests im Projekt auszuführen, verwenden Sie den Befehl:

cargo test

Sie können auch einen bestimmten Test nach Namen ausführen:

cargo test test_add

Oder Tests nach einem Schlüsselwort filtern:

cargo test divide

Integrationstests in Rust: Überprüfung der Interaktion

Integrationstests überprüfen, wie verschiedene Module Ihrer Anwendung zusammenarbeiten. Im Gegensatz zu Unit-Tests befinden sie sich in einem separaten Ordner tests/ auf der Stammebene des Projekts.

Struktur eines Integrationstests

Erstellen Sie eine Datei tests/integration_test.rs:

// tests/integration_test.rsuse my_project::math; // Angenommen, die Bibliothek heißt my_project

#[test]fn test_add_and_divide() {    let sum = math::add(10, 5);    let result = math::divide(sum as f64, 3.0).unwrap();    assert_eq!(result, 5.0);}

#[test]fn test_complex_calculation() {    let a = math::add(100, 200);    let b = math::add(50, 50);    let result = math::divide(a as f64, b as f64).unwrap();    assert_eq!(result, 3.0);}

Jede Datei in tests/ wird als separate Crate kompiliert. Das bedeutet, Sie können mehrere Dateien mit Tests für verschiedene Szenarien haben.

Gemeinsames Modul für Integrationstests

Wenn Sie gemeinsame Hilfsfunktionen für alle Integrationstests benötigen, erstellen Sie einen Unterordner tests/common/ mit einer Datei mod.rs:

// tests/common/mod.rspub fn setup() {    // Initialisierung der Testumgebung    println!("Testumgebung wird eingerichtet...");}

Und verwenden Sie es in den Tests:

// tests/integration_test.rsmod common;

#[test]fn test_with_setup() {    common::setup();    // Ihr Test}

E2E-Tests in Rust: Vollständige Abdeckung

E2E (End-to-End) Tests überprüfen die Arbeit der gesamten Anwendung von Anfang bis Ende. In Rust werden dafür oft externe