wiremock-rs: HTTP Mock-Server für Rust

In der modernen Softwareentwicklung ist Testen ein unverzichtbarer Bestandteil des Prozesses. Besonders schwierig ist es oft, Code zu testen, der mit externen HTTP-Diensten interagiert. Hier kommt die Bibliothek wiremock-rs ins Spiel – ein leistungsstarkes Werkzeug zur Erstellung von HTTP-Mock-Servern im Rust-Ökosystem.

wiremock-rs ermöglicht es, das Verhalten externer HTTP-Dienste zu emulieren, sodass Entwickler ihren Code in einer isolierten Umgebung testen können. Anstatt echte Anfragen an externe APIs zu senden (was langsam, unzuverlässig oder teuer sein kann), erstellen Sie einen lokalen Mock-Server, der genau so antwortet, wie Sie es vorgeben. Dies ist besonders nützlich beim Schreiben von Integrationstests, beim Testen der Fehlerbehandlung und bei der Entwicklung von Client-Bibliotheken.

Die Bibliothek ist vom beliebten Java-Tool WireMock inspiriert, wurde aber vollständig in Rust unter Berücksichtigung der Sprachidiome und Besonderheiten neu geschrieben. wiremock-rs unterstützt alle wesentlichen Funktionen: Abgleich von Anfragen nach URL, Headern und Body; Rückgabe verschiedener HTTP-Statuscodes; Antwortverzögerungen; Überprüfung der Aufrufanzahl und vieles mehr.

Installation

Fügen Sie zur Installation von wiremock-rs die folgende Abhängigkeit in Ihre Cargo.toml ein:

[dev-dependencies]
wiremock = "0.6"

Führen Sie anschließend den Befehl aus:

cargo build

Stellen Sie außerdem sicher, dass Rust und Cargo installiert sind. Falls nicht, installieren Sie diese über rustup.

Schnellstart

Erstellen wir einen einfachen Mock-Server, der auf GET-Anfragen antwortet:

use wiremock::{MockServer, Mock, ResponseTemplate};
use wiremock::matchers::{method, path};

#[tokio::main]
async fn main() {
    // Mock-Server auf einem zufälligen Port starten
    let mock_server = MockServer::start().await;
    
    // Regel erstellen: Auf GET /hello mit Status 200 und Body "Hello, World!" antworten
    let mock = Mock::given(method("GET"))
        .and(path("/hello"))
        .respond_with(ResponseTemplate::new(200)
            .set_body_string("Hello, World!"));
    
    // Regel auf dem Server registrieren
    mock_server.register(mock).await;
    
    // Jetzt können Anfragen an den Server gesendet werden
    let client = reqwest::Client::new();
    let response = client.get(&format!("{}/hello", &mock_server.uri()))
        .send()
        .await
        .unwrap();
    
    println!("Status: {}", response.status());
    println!("Body: {}", response.text().await.unwrap());
    
    // Server wird automatisch beim Beenden von main gestoppt
}

Dieses minimale Beispiel zeigt die grundlegende Idee: Sie starten einen Server, definieren Regeln (Matcher) und Antworten (Response Templates) und registrieren diese. Danach kann Ihr Client-Code Anfragen an den Mock-Server stellen.

Wichtige Methoden und Funktionen

1. MockServer::start()

Signatur: pub async fn start() -> MockServer

Beschreibung: Startet einen neuen Mock-Server auf einem zufälligen, verfügbaren Port. Der Server läuft, bis das MockServer-Objekt gelöscht wird.

let server = MockServer::start().await;
println!("Server gestartet auf {}", server.uri());

2. MockServer::start_on_port(port: u16)

Signatur: pub async fn start_on_port(port: u16) -> MockServer

Beschreibung: Startet den Mock-Server auf einem bestimmten Port. Nützlich, wenn ein fester Port für die Konfiguration benötigt wird.

let server = MockServer::start_on_port(8080).await;
assert_eq!(server.uri(), "http://127.0.0.1:8080");

3. Mock::given(matcher: impl Matcher)

Signatur: pub fn given(matcher: impl Matcher) ->