wiremock-rs: Servidor HTTP Mock para Rust

En el desarrollo de software moderno, las pruebas son una parte esencial del proceso. Probar código que interactúa con servicios HTTP externos puede ser especialmente complejo. Aquí es donde entra en juego la librería wiremock-rs, una potente herramienta para crear servidores HTTP mock en el ecosistema de Rust.

wiremock-rs permite emular el comportamiento de servicios HTTP externos, facilitando a los desarrolladores probar su código en un entorno aislado. En lugar de enviar solicitudes reales a APIs externas (lo que puede ser lento, poco fiable o costoso), puedes crear un servidor mock local que responderá exactamente como tú definas. Esto es especialmente útil al escribir pruebas de integración, probar el manejo de errores y desarrollar librerías cliente.

La librería está inspirada en la popular herramienta Java WireMock, pero está completamente reescrita en Rust teniendo en cuenta los modismos y características del lenguaje. wiremock-rs soporta todas las funcionalidades principales: coincidencia de solicitudes por URL, cabeceras y cuerpo; devolución de diferentes estados HTTP; retardos en las respuestas; verificación del número de llamadas y mucho más.

Instalación

Para instalar wiremock-rs, añade la dependencia a tu archivo Cargo.toml:

[dev-dependencies]
wiremock = "0.6"

Luego ejecuta el comando:

cargo build

Asegúrate también de tener instalados Rust y Cargo. Si no es así, instálalos a través de rustup.

Inicio rápido

Vamos a crear un servidor mock simple que responda a solicitudes GET:

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

#[tokio::main]
async fn main() {
    // Iniciamos el servidor mock en un puerto aleatorio
    let mock_server = MockServer::start().await;
    
    // Creamos una regla: para GET /hello responder con estado 200 y cuerpo "¡Hola, Mundo!"
    let mock = Mock::given(method("GET"))
        .and(path("/hello"))
        .respond_with(ResponseTemplate::new(200)
            .set_body_string("¡Hola, Mundo!"));
    
    // Registramos la regla en el servidor
    mock_server.register(mock).await;
    
    // Ahora podemos hacer solicitudes al servidor
    let client = reqwest::Client::new();
    let response = client.get(&format!("{}/hello", &mock_server.uri()))
        .send()
        .await
        .unwrap();
    
    println!("Estado: {}", response.status());
    println!("Cuerpo: {}", response.text().await.unwrap());
    
    // El servidor se detendrá automáticamente al finalizar main
}

Este ejemplo mínimo muestra la idea principal: inicias el servidor, defines reglas (matchers) y respuestas (response templates), y luego las registras. Después, tu código cliente puede hacer solicitudes al servidor mock.

Métodos y funciones principales

1. MockServer::start()

Firma: pub async fn start() -> MockServer

Descripción: Inicia un nuevo servidor mock en un puerto disponible aleatorio. El servidor funcionará hasta que el objeto MockServer sea eliminado.

let server = MockServer::start().await;
println!("Servidor iniciado en {}", server.uri());

2. MockServer::start_on_port(port: u16)

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

Descripción: Inicia el servidor mock en un puerto específico. Útil cuando necesitas un puerto fijo para la configuración.

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

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

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