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

Rust में परीक्षण का परिचय

Rust एक सिस्टम प्रोग्रामिंग भाषा है जो अपनी सुरक्षा और प्रदर्शन के लिए प्रसिद्ध है। हालाँकि, सबसे विश्वसनीय कोड को भी जाँच की आवश्यकता होती है। Rust में परीक्षण केवल एक विकल्प नहीं है, बल्कि विकास प्रक्रिया का एक अभिन्न अंग है। Cargo में परीक्षणों के लिए अंतर्निहित समर्थन के कारण, आप आसानी से unit, integration और e2e परीक्षण लिख और चला सकते हैं। इस लेख में, हम व्यावहारिक उदाहरणों के साथ परीक्षण के तीनों स्तरों को समझेंगे।

Rust में Unit-परीक्षण: विश्वसनीयता की नींव

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

Unit-परीक्षण की संरचना

प्रत्येक unit-परीक्षण एक फ़ंक्शन है जो #[test] विशेषता से चिह्नित होता है। इसके अंदर, आप परिणामों की जाँच करने के लिए assert!, assert_eq! और assert_ne! मैक्रो का उपयोग करते हैं।

// src/math.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("शून्य से भाग"))    } else {        Ok(a / b)    }}

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

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

    #[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(), "शून्य से भाग");    }}

#[cfg(test)] विशेषता पर ध्यान दें। यह कंपाइलर को निर्देश देता है कि इस मॉड्यूल को केवल परीक्षण बनाते समय शामिल किया जाए। इससे अंतिम बाइनरी के संकलन समय की बचत होती है।

Unit-परीक्षण चलाना

प्रोजेक्ट में सभी परीक्षण चलाने के लिए, कमांड का उपयोग करें:

cargo test

आप नाम से एक विशिष्ट परीक्षण भी चला सकते हैं:

cargo test test_add

या कीवर्ड द्वारा परीक्षणों को फ़िल्टर कर सकते हैं:

cargo test divide

Rust में इंटीग्रेशन परीक्षण: अंतःक्रिया की जाँच

इंटीग्रेशन परीक्षण यह जाँचते हैं कि आपके एप्लिकेशन के विभिन्न मॉड्यूल एक साथ कैसे काम करते हैं। unit-परीक्षणों के विपरीत, वे प्रोजेक्ट रूट स्तर पर एक अलग tests/ फ़ोल्डर में स्थित होते हैं।

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

एक फ़ाइल बनाएँ tests/integration_test.rs:

// tests/integration_test.rsuse my_project::math; // मान लें कि लाइब्रेरी का नाम my_project है

#[test]fn test_add_and_divide() {    let sum = math::add(10, 5);    let result = math::divide(sum as f64, 3.0).unwrap();    assert_eq!(result, 5.0);}

#[test]fn test_complex_calculation() {    let a = math::add(100, 200);    let b = math::add(50, 50);    let result = math::divide(a as f64, b as f64).unwrap();    assert_eq!(result, 3.0);}

tests/ में प्रत्येक फ़ाइल एक अलग क्रेट के रूप में संकलित होती है। इसका मतलब है कि आपके पास विभिन्न परिदृश्यों के लिए कई परीक्षण फ़ाइलें हो सकती हैं।

इंटीग्रेशन परीक्षणों के लिए सामान्य मॉड्यूल

यदि आपको सभी इंटीग्रेशन परीक्षणों के लिए सामान्य उपयोगिताओं की आवश्यकता है, तो mod.rs फ़ाइल के साथ एक उपफ़ोल्डर tests/common/ बनाएँ:

// tests/common/mod.rspub fn setup() {    // परीक्षण वातावरण का आरंभीकरण    println!("परीक्षण वातावरण सेट अप किया जा रहा है...");}

और इसे परीक्षणों में उपयोग करें:

// tests/integration_test.rsmod common;

#[test]fn test_with_setup() {    common::setup();    // आपका परीक्षण}

Rust में E2E परीक्षण: पूर्ण विसर्जन

E2E (end-to-end) परीक्षण शुरू से अंत तक पूरे एप्लिकेशन के काम की जाँच करते हैं। Rust में, इसके लिए अक्सर बाहरी उपकरणों का उपयोग किया जाता है।