Rust में परीक्षण: unit, integration, e2e — पूर्ण गाइड

परिचय: Rust में परीक्षण क्यों सरल और विश्वसनीय है

Rust को शुरू से ही एक ऐसी भाषा के रूप में डिज़ाइन किया गया था जो सुरक्षित और विश्वसनीय कोड लिखने में मदद करती है। हालाँकि, सबसे सख्त टाइप सिस्टम भी व्यावसायिक तर्क की शुद्धता की गारंटी नहीं देता है। यहीं पर परीक्षण काम आता है। Rust में, परीक्षण लिखने की प्रक्रिया सीधे cargo टूलचेन में बनाई गई है, जो इसे अविश्वसनीय रूप से सुविधाजनक और सुलभ बनाती है।

इस लेख में, हम परीक्षण के तीन स्तरों पर चर्चा करेंगे: unit (मॉड्यूलर), integration (एकीकरण) और e2e (end-to-end)। आप सीखेंगे कि टेस्ट कैसे लिखें, कब किस दृष्टिकोण का उपयोग करें और अपने कोड की जाँच को कैसे स्वचालित करें। यह सामग्री शुरुआती और Rust पर स्विच करने वाले अनुभवी डेवलपर्स दोनों के लिए उपयोगी होगी।

Unit-टेस्ट: अंदर से परीक्षण

Unit-टेस्ट (मॉड्यूलर टेस्ट) परीक्षण का सबसे बुनियादी और सामान्य प्रकार है। वे सिस्टम के बाकी हिस्सों से अलग-थलग व्यक्तिगत फ़ंक्शन, विधियों या मॉड्यूल की जाँच करते हैं। Rust में, unit-टेस्ट को उसी फ़ाइल में लिखने की प्रथा है जिसमें परीक्षण किया जा रहा कोड होता है, या मॉड्यूल के अंदर एक अलग tests.rs फ़ाइल में।

Rust में unit-टेस्ट कैसे लिखें

टेस्ट बनाने के लिए #[test] एट्रिब्यूट का उपयोग किया जाता है। टेस्ट को #[cfg(test)] एट्रिब्यूट वाले मॉड्यूल में रखा जाता है, जो सुनिश्चित करता है कि टेस्ट कोड अंतिम बिल्ड में शामिल न हो।

// src/lib.rspub fn add(a: i32, b: i32) -> i32 {    a + b}

pub fn divide(a: f64, b: f64) -> Result<f64, String> {    if b == 0.0 {        Err(String::from("Division by zero"))    } else {        Ok(a / b)    }}

#[cfg(test)]mod tests {    use super::*;

    #[test]    fn test_add() {        assert_eq!(add(2, 3), 5);    }

    #[test]    fn test_add_negative() {        assert_eq!(add(-1, 1), 0);    }

    #[test]    fn test_divide_success() {        let result = divide(10.0, 2.0);        assert!(result.is_ok());        assert_eq!(result.unwrap(), 5.0);    }

    #[test]    fn test_divide_by_zero() {        let result = divide(10.0, 0.0);        assert!(result.is_err());        assert_eq!(result.unwrap_err(), "Division by zero");    }}

Unit-टेस्ट चलाना

टेस्ट एक कमांड से चलाए जा सकते हैं:

cargo test

आउटपुट दिखाएगा कि कितने टेस्ट पास हुए और कितने फेल हुए। किसी विशिष्ट टेस्ट को चलाने के लिए फ़िल्टर का उपयोग करें:

cargo test test_add

Unit-टेस्ट बॉर्डर केस, एरर हैंडलिंग और एल्गोरिदम की शुद्धता की जाँच के लिए आदर्श हैं। वे तेज़ होते हैं और उन्हें बाहरी निर्भरता की आवश्यकता नहीं होती है।

Integration-टेस्ट: मॉड्यूल के इंटरैक्शन की जाँच

इंटीग्रेशन टेस्ट जाँचते हैं कि आपकी लाइब्रेरी या एप्लिकेशन के विभिन्न मॉड्यूल एक साथ कैसे काम करते हैं। Unit-टेस्ट के विपरीत, उनके पास आंतरिक फ़ंक्शन तक पहुँच नहीं होती है (जब तक कि उन्हें pub के रूप में निर्यात नहीं किया गया हो)। इंटीग्रेशन टेस्ट प्रोजेक्ट रूट स्तर पर एक अलग tests/ फ़ोल्डर में लिखे जाते हैं।

इंटीग्रेशन टेस्ट की संरचना

अपने प्रोजेक्ट के रूट में tests/ फ़ोल्डर बनाएँ और उसमें टेस्ट फ़ाइलें जोड़ें। प्रत्येक फ़ाइल को एक अलग क्रेट के रूप में संकलित किया जाएगा।

// tests/integration_test.rsuse my_crate; // आपके क्रेट का नाम

#[test]fn test_add_integration() {    assert_eq!(my_crate::add(10, 20), 30);}

#[test]fn test_divide_integration() {    let result = my_crate::divide(100.0, 4.0);    assert_eq!(result.unwrap(), 25.0);}

टेस्ट के लिए सामान्य मॉड्यूल

यदि कई इंटीग्रेशन टेस्ट समान सहायक फ़ंक्शन का उपयोग करते हैं, तो उन्हें एक सामान्य मॉड्यूल में रखें। इसके लिए tests/common/mod.rs फ़ोल्डर बनाएँ:

// tests/common/mod.rspub fn setup() {    // लॉगर, डेटाबेस आदि का आरंभीकरण    println!("Setting up test environment...");}

// tests/another_test.rsmod common;

#[test]fn test