rust-testing

Rust-Testmuster

Umfassende Rust-Testmuster zum Erstellen zuverlässiger, wartbarer Tests nach der TDD-Methodik.

Wann verwenden

• Beim Schreiben neuer Rust-Funktionen, -Methoden oder -Traits
• Hinzufügen von Testabdeckung zu vorhandenem Code
• Erstellen von Benchmarks für leistungskritischen Code
• Implementieren eigenschaftsbasierter Tests zur Eingabevalidierung
• Befolgen des TDD-Workflows in Rust-Projekten

Wie es funktioniert

1. Zielcode identifizieren — Die zu testende Funktion, das Trait oder Modul finden
2. Test schreiben — #[test] in einem #[cfg(test)]-Modul, rstest für parametrisierte Tests oder proptest für eigenschaftsbasierte Tests verwenden
3. Abhängigkeiten mocken — mockall verwenden, um die getestete Einheit zu isolieren
4. Tests ausführen (ROT) — Überprüfen, ob der Test mit dem erwarteten Fehler fehlschlägt
5. Implementieren (GRÜN) — Minimalen Code schreiben, um den Test zu bestehen
6. Refaktorieren — Verbessern, während die Tests grün bleiben
7. Abdeckung prüfen — cargo-llvm-cov verwenden, Ziel 80%+

TDD-Workflow für Rust

Der ROT-GRÜN-REFACTOR-Zyklus

ROT     → Zuerst einen fehlschlagenden Test schreiben
GRÜN    → Minimalen Code schreiben, um den Test zu bestehen
REFACTOR → Code verbessern, während die Tests grün bleiben
WIEDERHOLEN → Mit der nächsten Anforderung fortfahren

Schritt-für-Schritt-TDD in Rust

// ROT: Zuerst Test schreiben, todo!() als Platzhalter verwenden
pub fn add(a: i32, b: i32) -> i32 { todo!() }

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_add() { assert_eq!(add(2, 3), 5); }
}
// cargo test → panics at 'not yet implemented'

// GRÜN: todo!() durch minimale Implementierung ersetzen
pub fn add(a: i32, b: i32) -> i32 { a + b }
// cargo test → PASS, dann REFACTOR, während die Tests grün bleiben

Unit-Tests

Testorganisation auf Modulebene

// src/user.rs
pub struct User {
    pub name: String,
    pub email: String,
}

impl User {
    pub fn new(name: impl Into<String>, email: impl Into<String>) -> Result<Self, String> {
        let email = email.into();
        if !email.contains('@') {
            return Err(format!("ungültige E-Mail: {email}"));
        }
        Ok(Self { name: name.into(), email })
    }

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

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

    #[test]
    fn creates_user_with_valid_email() {
        let user = User::new("Alice", "[email protected]").unwrap();
        assert_eq!(user.display_name(), "Alice");
        assert_eq!(user.email, "[email protected]");
    }

    #[test]
    fn rejects_invalid_email() {
        let result = User::new("Bob", "noch-keine-email");
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("ungültige E-Mail"));
    }
}

Assertions-Makros

assert_eq!(2 + 2, 4);                                    // Gleichheit
assert_ne!(2 + 2, 5);                                    // Ungleichheit
assert!(vec![1, 2, 3].contains(&2));                     // Boolesch
assert_eq!(value, 42, "erwartete 42, aber {value} erhalten"); // Benutzerdefinierte Nachricht
assert!((0.1_f64 + 0.2 - 0.3).abs() < f64::EPSILON);   // Gleitkomma-Vergleich

Fehler- und Panic-Tests

Testen von Result-Rückgaben

#[test]
fn parse_returns_error_for_invalid_input() {
    let result = parse_config("}{invalid");
    assert!(result.is_err());

    // Auf spezifische Fehlervariante prüfen
    let err = result.unwrap_err();
    assert!(matches!(err, ConfigError::ParseError(_)));
}

#[test]
fn parse_succeeds_for_valid_input() -> Result<(), Box<dyn std::error::Error>> {
    let config = parse_config(r#"{"port": 8080}"#)?;
    assert_eq!(config.port, 8080);
    Ok(()) // Test schlägt fehl, wenn ein ? Err zurückgibt
}

Testen von Panics

#[test]
#[should_panic]
fn panics_on_empty_input() {
    process(&[]);
}

#[test]
#[should_panic(expected = "Index außerhalb des gültigen Bereichs")]
fn panics_with_specific_message() {
    let v: Vec<i32> = vec![];
    let _ = v[0];
}

Integrationstests

Dateistruktur

my_crate/
├── src/
│   └── lib.rs
├── tests/              # Integrationstests
│   ├── api_test.rs     # Jede Datei ist ein separates Testbinary
│   ├── db_test.rs
│   └── common/         # Gemeinsame Test-Hilfsfunktionen
│       └── mod.rs

Integrationstests schreiben

// tests/api_test.rs
use my_crate::{App, Config};

#[test]
fn full_request_lifecycle() {
    let config = Config::test_default();
    let app = App::new(config);

    let response = app.handle_request("/health");
    assert_eq!(response.status, 200);
    assert_eq!(response.body, "OK");
}

Async-Tests

Mit Tokio

#[tokio::test]
async fn fetches_data_successfully() {
    let client = TestClient::new().await;
    let result = client.get("/data").await;
    assert!(result.is_ok());
    assert_eq!(result.unwrap().items.len(), 3);
}

#[tokio::test]
async fn handles_timeout() {
    use std::time::Duration;
    let result = tokio::time::timeout(
        Duration::from_millis(100),
        slow_operation(),
    ).await;

    assert!(result.is_err(), "hätte timeout auslösen sollen");
}

Testorganisationsmuster

Parametrisierte Tests mit rstest

use rstest::{rstest, fixture};

#[rstest]
#[case("hallo", 5)]
#[case("", 0)]
#[case("rust", 4)]
fn test_string_length(#[case] input: &str, #[case] expected: usize) {
    assert_eq!(input.len(), expected);
}

// Fixtures
#[fixture]
fn test_db() -> TestDb {
    TestDb::new_in_memory()
}

#[rstest]
fn test_insert(test_db: TestDb) {
    test_db.insert("key", "value");
    assert_eq!(test_db.get("key"), Some("value".into()));
}

Test-Helfer

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

    /// Erstellt einen Testbenutzer mit sinnvollen Standardwerten.
    fn make_user(name: &str) -> User {
        User::new(name, &format!("{name}@test.com")).unwrap()
    }

    #[test]
    fn user_display() {
        let user = make_user("alice");
        assert_eq!(user.display_name(), "alice");
    }
}

Eigenschaftsbasierte Tests mit proptest

Grundlegende Eigenschaftstests

use proptest::prelude::*;

proptest! {
    #[test]
    fn encode_decode_roundtrip(input in ".*") {
        let encoded = encode(&input);
        let decoded = decode(&encoded).unwrap();
        assert_eq!(input, decoded);
    }

    #[test]
    fn sort_preserves_length(mut vec in prop::collection::vec(any::<i32>(), 0..100)) {
        let original_len = vec.len();
        vec.sort();
        assert_eq!(vec.len(), original_len);
    }

    #[test]
    fn sort_produces_ordered_output(mut vec in prop::collection::vec(any::<i32>(), 0..100)) {
        vec.sort();
        for window in vec.windows(2) {
            assert!(window[0] <= window[1]);
        }
    }
}

Benutzerdefinierte Strategien

use proptest::prelude::*;

fn valid_email() -> impl Strategy<Value = String> {
    ("[a-z]{1,10}", "[a-z]{1,5}")
        .prop_map(|(user, domain)| format!("{user}@{domain}.com"))
}

proptest! {
    #[test]
    fn accepts_valid_emails(email in valid_email()) {
        assert!(User::new("Test", &email).is_ok());
    }
}

Mocking mit mockall

Trait-basiertes Mocking

use mockall::{automock, predicate::eq};

#[automock]
trait UserRepository {
    fn find_by_id(&self, id: u64) -> Option<User>;
    fn save(&self, user: &User) -> Result<(), StorageError>;
}

#[test]
fn service_returns_user_when_found() {
    let mut mock = MockUserRepository::new();
    mock.expect_find_by_id()
        .with(eq(42))
        .times(1)
        .returning(|_| Some(User { id: 42, name: "Alice".into() }));

    let service = UserService::new(Box::new(mock));
    let user = service.get_user(42).unwrap();
    assert_eq!(user.name, "Alice");
}

#[test]
fn service_returns_none_when_not_found() {
    let mut mock = MockUserRepository::new();
    mock.expect_find_by_id()
        .returning(|_| None);

    let service = UserService::new(Box::new(mock));
    assert!(service.get_user(99).is_none());
}

Doc-Tests

Ausführbare Dokumentation

/// Addiert zwei Zahlen.
///
/// # Beispiele
///
/// ```
/// use my_crate::add;
///
/// assert_eq!(add(2, 3), 5);
/// assert_eq!(add(-1, 1), 0);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

/// Analysiert eine Konfigurationszeichenfolge.
///
/// # Fehler
///
/// Gibt `Err` zurück, wenn die Eingabe kein gültiges TOML ist.
///
/// ```no_run
/// use my_crate::parse_config;
///
/// let config = parse_config(r#"port = 8080"#).unwrap();
/// assert_eq!(config.port, 8080);
/// ```
///
/// ```no_run
/// use my_crate::parse_config;
///
/// assert!(parse_config("}{invalid").is_err());
/// ```
pub fn parse_config(input: &str) -> Result<Config, ParseError> {
    todo!()
}

Benchmarking mit Criterion

# Cargo.toml
[dev-dependencies]
criterion = { version = "0.5", features = ["html_reports"] }

[[bench]]
name = "benchmark"
harness = false

// benches/benchmark.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn fibonacci(n: u64) -> u64 {
    match n {
        0 | 1 => n,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

fn bench_fibonacci(c: &mut Criterion) {
    c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));
}

criterion_group!(benches, bench_fibonacci);
criterion_main!(benches);

Testabdeckung

Ausführen der Abdeckungsmessung

# Installation: cargo install cargo-llvm-cov (oder taiki-e/install-action in CI verwenden)
cargo llvm-cov                    # Zusammenfassung
cargo llvm-cov --html             # HTML-Bericht
cargo llvm-cov --lcov > lcov.info # LCOV-Format für CI
cargo llvm-cov --fail-under-lines 80  # Fehlschlag, wenn unter Schwellenwert

Abdeckungsziele

Code-Typ	Ziel
Kritische Geschäftslogik	100%
Öffentliche API	90%+
Allgemeiner Code	80%+
Generierter / FFI-Code	Ausschließen

Testbefehle

cargo test                        # Alle Tests ausführen
cargo test -- --nocapture         # println-Ausgabe anzeigen
cargo test test_name              # Tests ausführen, die auf Muster passen
cargo test --lib                  # Nur Unit-Tests
cargo test --test api_test        # Nur Integrationstests
cargo test --doc                  # Nur Doc-Tests
cargo test --no-fail-fast         # Nicht bei erstem Fehler stoppen
cargo test -- --ignored           # Ignorierte Tests ausführen

Best Practices

TUN:

• Tests ZUERST schreiben (TDD)
• #[cfg(test)]-Module für Unit-Tests verwenden
• Verhalten testen, nicht Implementierung
• Beschreibende Testnamen verwenden, die das Szenario erklären
• assert_eq! gegenüber assert! bevorzugen, bessere Fehlermeldungen
• ? in Tests verwenden, die Result zurückgeben, für sauberere Fehlerausgaben
• Tests unabhängig halten — kein gemeinsam genutzter veränderlicher Zustand

NICHT:

• #[should_panic] verwenden, wenn Result::is_err() getestet werden kann
• Alles mocken — Integrationstests bevorzugen, wenn praktikabel
• Flaky-Tests ignorieren — reparieren oder in Quarantäne verschieben
• sleep() in Tests verwenden — Channels, Barriers oder tokio::time::pause() benutzen
• Fehlerpfade nicht testen

CI-Integration

# GitHub Actions
test:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - uses: dtolnay/rust-toolchain@stable
      with:
        components: clippy, rustfmt

    - name: Formatierung prüfen
      run: cargo fmt --check

    - name: Clippy
      run: cargo clippy -- -D warnings

    - name: Tests ausführen
      run: cargo test

    - uses: taiki-e/install-action@cargo-llvm-cov

    - name: Codeabdeckung
      run: cargo llvm-cov --fail-under-lines 80

Denken Sie daran: Tests sind Dokumentation. Sie zeigen, wie Ihr Code verwendet werden soll. Schreiben Sie sie klar und halten Sie sie auf dem neuesten Stand.