wiremock-rs : Serveur HTTP Mock pour Rust

Dans le développement logiciel moderne, les tests sont une étape incontournable. Tester du code qui interagit avec des services HTTP externes peut s'avérer particulièrement complexe. C'est là qu'intervient la bibliothèque wiremock-rs, un outil puissant pour créer des serveurs HTTP mock dans l'écosystème Rust.

wiremock-rs permet d'émuler le comportement de services HTTP externes, offrant aux développeurs la possibilité de tester leur code dans un environnement isolé. Au lieu d'envoyer de vraies requêtes à des API externes (ce qui peut être lent, peu fiable ou coûteux), vous créez un serveur mock local qui répond exactement comme vous le définissez. C'est particulièrement utile pour les tests d'intégration, le test de la gestion des erreurs et le développement de bibliothèques clientes.

Cette bibliothèque s'inspire du célèbre outil Java WireMock, mais a été entièrement réécrite en Rust en respectant les idiomes et spécificités du langage. wiremock-rs prend en charge toutes les fonctionnalités essentielles : correspondance des requêtes par URL, en-têtes, corps ; renvoi de différents statuts HTTP ; délais de réponse ; vérification du nombre d'appels, et bien plus encore.

Installation

Pour installer wiremock-rs, ajoutez la dépendance dans votre fichier Cargo.toml :

[dev-dependencies]
wiremock = "0.6"

Exécutez ensuite la commande :

cargo build

Assurez-vous également d'avoir Rust et Cargo installés. Si ce n'est pas le cas, installez-les via rustup.

Démarrage rapide

Créons un serveur mock simple qui répond aux requêtes GET :

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

#[tokio::main]
async fn main() {
    // Lancement du serveur mock sur un port aléatoire
    let mock_server = MockServer::start().await;
    
    // Création d'une règle : sur GET /hello, répondre avec le statut 200 et le corps "Hello, World!"
    let mock = Mock::given(method("GET"))
        .and(path("/hello"))
        .respond_with(ResponseTemplate::new(200)
            .set_body_string("Hello, World!"));
    
    // Enregistrement de la règle sur le serveur
    mock_server.register(mock).await;
    
    // Vous pouvez maintenant envoyer des requêtes au serveur
    let client = reqwest::Client::new();
    let response = client.get(&format!("{}/hello", &mock_server.uri()))
        .send()
        .await
        .unwrap();
    
    println!("Statut : {}", response.status());
    println!("Corps : {}", response.text().await.unwrap());
    
    // Le serveur s'arrête automatiquement à la fin de main
}

Cet exemple minimal illustre l'idée principale : vous lancez un serveur, définissez des règles (matchers) et des réponses (response templates), puis les enregistrez. Ensuite, votre code client peut envoyer des requêtes au serveur mock.

Méthodes et fonctions principales

1. MockServer::start()

Signature : pub async fn start() -> MockServer

Description : Lance un nouveau serveur mock sur un port disponible aléatoire. Le serveur reste actif tant que l'objet MockServer n'est pas supprimé.

let server = MockServer::start().await;
println!("Serveur démarré sur {}", server.uri());

2. MockServer::start_on_port(port: u16)

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

Description : Lance un serveur mock sur un port spécifique. Utile lorsque vous avez besoin d'un port fixe pour la configuration.

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

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

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