wiremock-rs: Rust के लिए HTTP मॉक-सर्वर

आधुनिक सॉफ्टवेयर डेवलपमेंट में टेस्टिंग एक अहम हिस्सा है। खासकर उस कोड को टेस्ट करना जो बाहरी HTTP-सर्विसेज से जुड़ता है, काफी चुनौतीपूर्ण हो सकता है। यहां wiremock-rs लाइब्रेरी काम आती है — यह Rust इकोसिस्टम में HTTP मॉक-सर्वर बनाने का एक शक्तिशाली टूल है।

wiremock-rs आपको बाहरी HTTP-सर्विसेज के व्यवहार को इम्यूलेट करने की सुविधा देता है, जिससे डेवलपर्स अपने कोड को एक आइसोलेटेड एनवायरनमेंट में टेस्ट कर सकते हैं। असली बाहरी API को कॉल करने (जो धीमा, अविश्वसनीय या महंगा हो सकता है) के बजाय, आप एक लोकल मॉक-सर्वर बना सकते हैं जो बिल्कुल आपकी इच्छानुसार रिस्पॉन्स देगा। यह इंटीग्रेशन टेस्ट, एरर हैंडलिंग टेस्ट और क्लाइंट लाइब्रेरी डेवलपमेंट के लिए बेहद उपयोगी है।

यह लाइब्रेरी लोकप्रिय Java टूल WireMock से प्रेरित है, लेकिन इसे पूरी तरह से Rust में फिर से लिखा गया है, जिसमें Rust की भाषा और शैली का ध्यान रखा गया है। wiremock-rs सभी मुख्य फीचर्स सपोर्ट करता है: URL, हेडर, बॉडी के आधार पर रिक्वेस्ट मैचिंग; अलग-अलग HTTP स्टेटस लौटाना; रिस्पॉन्स में देरी; कॉल्स की संख्या जांचना और भी बहुत कुछ।

इंस्टॉलेशन

wiremock-rs को इंस्टॉल करने के लिए अपने Cargo.toml फाइल में यह डिपेंडेंसी जोड़ें:

[dev-dependencies]
wiremock = "0.6"

फिर यह कमांड चलाएं:

cargo build

सुनिश्चित करें कि आपके पास Rust और Cargo इंस्टॉल है। अगर नहीं है, तो rustup के जरिए इंस्टॉल करें।

त्वरित शुरुआत

चलिए एक सरल मॉक-सर्वर बनाते हैं जो GET रिक्वेस्ट पर रिस्पॉन्स देता है:

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

#[tokio::main]
async fn main() {
    // रैंडम पोर्ट पर मॉक-सर्वर शुरू करें
    let mock_server = MockServer::start().await;
    
    // नियम बनाएं: GET /hello पर स्टेटस 200 और बॉडी "Hello, World!" लौटाएं
    let mock = Mock::given(method("GET"))
        .and(path("/hello"))
        .respond_with(ResponseTemplate::new(200)
            .set_body_string("Hello, World!"));
    
    // सर्वर पर नियम रजिस्टर करें
    mock_server.register(mock).await;
    
    // अब सर्वर पर रिक्वेस्ट भेज सकते हैं
    let client = reqwest::Client::new();
    let response = client.get(&format!("{}/hello", &mock_server.uri()))
        .send()
        .await
        .unwrap();
    
    println!("स्टेटस: {}", response.status());
    println!("बॉडी: {}", response.text().await.unwrap());
    
    // सर्वर बंद हो जाएगा (main के खत्म होने पर ऑटोमैटिक)
}

यह छोटा सा उदाहरण मुख्य विचार दिखाता है: आप सर्वर शुरू करते हैं, नियम (matchers) और रिस्पॉन्स (response templates) डिफाइन करते हैं, और फिर उन्हें रजिस्टर करते हैं। इसके बाद आपका क्लाइंट कोड मॉक-सर्वर पर रिक्वेस्ट भेज सकता है।

मुख्य तरीके और फंक्शन

1. MockServer::start()

सिग्नेचर: pub async fn start() -> MockServer

विवरण: एक नया मॉक-सर्वर रैंडम उपलब्ध पोर्ट पर शुरू करता है। सर्वर तब तक चलेगा जब तक MockServer ऑब्जेक्ट डिलीट नहीं हो जाता।

let server = MockServer::start().await;
println!("सर्वर चालू है: {}", server.uri());

2. MockServer::start_on_port(port: u16)

सिग्नेचर: pub async fn start_on_port(port: u16) -> MockServer

विवरण: मॉक-सर्वर को निर्दिष्ट पोर्ट पर शुरू करता है। जब फिक्स्ड पोर्ट की जरूरत हो तो उपयोगी है।

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

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

सिग्नेचर: pub fn given(matcher: impl Matcher) ->