wiremock-rs: Servidor HTTP Mock para Rust

No desenvolvimento de software moderno, os testes são parte essencial do processo. Testar código que interage com serviços HTTP externos pode ser especialmente desafiador. É aí que entra a biblioteca wiremock-rs — uma ferramenta poderosa para criar servidores HTTP mock no ecossistema Rust.

O wiremock-rs permite simular o comportamento de serviços HTTP externos, possibilitando que desenvolvedores testem seu código em um ambiente isolado. Em vez de enviar requisições reais para APIs externas (o que pode ser lento, instável ou caro), você cria um servidor mock local que responde exatamente como você definir. Isso é especialmente útil para testes de integração, validação de tratamento de erros e desenvolvimento de bibliotecas cliente.

A biblioteca é inspirada na popular ferramenta Java WireMock, mas foi totalmente reescrita em Rust, respeitando os idiomas e particularidades da linguagem. O wiremock-rs suporta todos os recursos essenciais: correspondência de requisições por URL, cabeçalhos e corpo; retorno de diferentes códigos HTTP; atrasos nas respostas; verificação de número de chamadas e muito mais.

Instalação

Para instalar o wiremock-rs, adicione a dependência ao seu arquivo Cargo.toml:

[dev-dependencies]
wiremock = "0.6"

Em seguida, execute o comando:

cargo build

Certifique-se também de ter o Rust e o Cargo instalados. Caso contrário, instale-os via rustup.

Início Rápido

Vamos criar um servidor mock simples que responde a requisições GET:

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

#[tokio::main]
async fn main() {
    // Inicia o servidor mock em uma porta aleatória
    let mock_server = MockServer::start().await;
    
    // Cria uma regra: para GET /hello, responder com status 200 e corpo "Hello, World!"
    let mock = Mock::given(method("GET"))
        .and(path("/hello"))
        .respond_with(ResponseTemplate::new(200)
            .set_body_string("Hello, World!"));
    
    // Registra a regra no servidor
    mock_server.register(mock).await;
    
    // Agora podemos fazer requisições ao servidor
    let client = reqwest::Client::new();
    let response = client.get(&format!("{}/hello", &mock_server.uri()))
        .send()
        .await
        .unwrap();
    
    println!("Status: {}", response.status());
    println!("Corpo: {}", response.text().await.unwrap());
    
    // O servidor será automaticamente encerrado ao final do main
}

Este exemplo mínimo mostra a ideia principal: você inicia o servidor, define regras (matchers) e respostas (response templates), e então as registra. Depois disso, seu código cliente pode fazer requisições ao servidor mock.

Principais Métodos e Funções

1. MockServer::start()

Assinatura: pub async fn start() -> MockServer

Descrição: Inicia um novo servidor mock em uma porta disponível aleatória. O servidor permanecerá ativo até que o objeto MockServer seja descartado.

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

2. MockServer::start_on_port(port: u16)

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

Descrição: Inicia o servidor mock em uma porta específica. Útil quando você precisa de uma porta fixa para configuração.

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

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

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