Rust में BDD: Cucumber और Specs के साथ लाइव कोड लिखना

Rust में BDD — यह उबाऊ परीक्षणों के बारे में नहीं है

कल्पना करें: आप Rust में एक उच्च-लोड सेवा लिख रहे हैं। कोड सुरक्षित, तेज़ है, लेकिन जब उत्पाद ग्राहक के पास जाता है, तो वह कहता है: "मुझे लगा कि बटन अलग तरह से काम करेगा।" परिचित लगता है? कोड और अपेक्षाओं के बीच एक क्लासिक अंतर। यहीं पर BDD (व्यवहार-संचालित विकास) मदद करता है — एक पद्धति जो व्यावसायिक आवश्यकताओं को ऐसी भाषा में अनुवादित करती है जो प्रबंधक और Rust कंपाइलर दोनों समझ सकें।

इस लेख में, हम व्यवहार में Rust में BDD को लागू करने का तरीका समझेंगे। आप सीखेंगे कि मानव भाषा (Gherkin) में परिदृश्य कैसे लिखें, cucumber और specs का उपयोग करके उन्हें स्वचालित करें, और यह आपके कोड को न केवल विश्वसनीय बल्कि पूरी टीम के लिए पारदर्शी क्यों बनाता है। कोई फालतू बात नहीं — केवल लाइव कोड और वास्तविक उदाहरण।

BDD क्या है और Rust इसके लिए आदर्श क्यों है

व्यवहार-संचालित विकास TDD का विकास है। यदि TDD "कोड का परीक्षण कैसे करें" पर ध्यान केंद्रित करता है, तो BDD इस प्रश्न का उत्तर देता है "हम क्या व्यवहार देखना चाहते हैं"। आप Gherkin भाषा (Given-When-Then) में परिदृश्य लिखते हैं, जो एक साथ परीक्षण और दस्तावेज़ीकरण दोनों हैं।

Rust एक ऐसी भाषा है जो कठोरता और पूर्वानुमान को पसंद करती है। Rust में BDD प्रदान करता है:

\n
• स्व-दस्तावेजीकरण कोड — कोई भी डेवलपर परिदृश्य पढ़ता है और व्यावसायिक तर्क को समझता है।
\n
• प्रकार स्तर पर सुरक्षा — कंपाइलर जाँचता है कि आपके चरण संरचना से मेल खाते हैं।
\n
• समानांतर निष्पादन — Rust में BDD परीक्षण async और मल्टीथ्रेडिंग के कारण तेज़ी से चलते हैं।
\n

Rust में BDD कब विशेष रूप से उपयोगी है?

\n
• स्पष्ट अनुबंधों वाली API सेवाएँ (REST, GraphQL)।
\n
• व्यावसायिक नियमों वाली प्रणालियाँ (वित्त, लॉजिस्टिक्स, गेम्स)।
\n
• माइक्रोसर्विसेज़ जहाँ घटकों के बीच एकीकरण महत्वपूर्ण है।
\n

Rust में BDD के लिए उपकरण: Cucumber और Specs

Rust पारिस्थितिकी तंत्र दो मुख्य दृष्टिकोण प्रदान करता है:

1. cucumber — क्लासिक BDD फ्रेमवर्क

Gherkin में परिदृश्य लिखने की अनुमति देता है (.feature फ़ाइलें) और उन्हें Rust कोड से जोड़ता है। async, कस्टम मैक्रोज़ और रिपोर्ट का समर्थन करता है।

2. specs — हल्का और तेज़ विकल्प

Gherkin फ़ाइलों की आवश्यकता नहीं है — परिदृश्य सीधे Rust में मैक्रोज़ का उपयोग करके लिखे जाते हैं। यदि आप एक अलग पार्सर नहीं लाना चाहते हैं तो आदर्श है।

हम cucumber पर ध्यान केंद्रित करेंगे, क्योंकि यह अधिकतम लचीलापन देता है और BDD मानक का अनुपालन करता है।

Rust में पहला BDD परिदृश्य लिखना

चलिए एक सरल डिस्काउंट कैलकुलेटर बनाते हैं। व्यावसायिक नियम: यदि खरीद राशि 1000 रुपये से अधिक है, तो 10% छूट। अन्यथा — 0%।

चरण 1. निर्भरताएँ स्थापित करना

Cargo.toml में जोड़ें:

[dev-dependencies]\ncucumber = "0.20"\ntokio = { version = "1", features = ["full"] }\nasync-trait = "0.1"\n

चरण 2. feature फ़ाइल बनाना

फ़ाइल tests/features/discount.feature:

Feature: छूट की गणना\n  As a खरीदार\n  I want बड़ी खरीद पर छूट प्राप्त करना\n  So that पैसे बचाना\n\n  Scenario: 1000 रुपये से अधिक की खरीद\n    Given खरीद राशि "1500" के बराबर है\n    When मैं छूट की गणना का अनुरोध करता हूँ\n    Then छूट की राशि "150" होनी चाहिए\n\n  Scenario: 1000 रुपये से कम की खरीद\n    Given खरीद राशि "500" के बराबर है\n    When मैं छूट की गणना का अनुरोध करता हूँ\n    Then छूट की राशि "0" होनी चाहिए\n

चरण 3. Rust में चरण लिखना

tests/steps/discount_steps.rs बनाएँ:

use cucumber::{given, then, when, World};\nuse async_trait::async_trait;\n\n#[derive(Debug, Default)]\nstruct DiscountWorld {\n    purchase_amount: f64,\n    discount: f64,\n}\n\n#[async_trait(?Send)]\nimpl World for DiscountWorld {\n    // सरलता के लिए खाली कार्यान्वयन\n    async fn new() -> Self {\n        Self::d