Python में टेस्ट-ड्रिवन डेवलपमेंट: एक शुरुआती मार्गदर्शिका

टेस्टिंग आपको यह भरोसा देती है कि आपका कोड वही करता है जिसकी आप अपेक्षा करते हैं। इस ट्यूटोरियल में, हम Python का उपयोग करके टेस्ट-ड्रिवन डेवलपमेंट (TTD) की बुनियादी बातें सीखेंगे। शुरुआत में, हम टेस्ट-ड्रिवन डेवलपमेंट की पृष्ठभूमि कवर करेंगे – यह क्या है और कोड लिखते समय पहले टेस्ट लिखना क्यों सहायक होता है। हम एक टेस्ट-फर्स्ट अप्रोच अपनाएँगे, जिसमें हम वांछित फ़ंक्शनलिटी के लिए पहले फेल होने वाले टेस्ट केस लिखेंगे और उसके बाद वास्तविक फ़ंक्शंस लिखेंगे।

ट्यूटोरियल के लिए पूर्वापेक्षाएँ

इस ट्यूटोरियल के लिए, आपको Python की बुनियादी समझ की आवश्यकता होगी; यदि आप अपने Python ज्ञान को ताज़ा करना चाहते हैं, तो आप यह कोर्स देख सकते हैं: Introduction to Python for Developers.

एक टेस्ट-फर्स्ट अप्रोच हमें वांछित व्यवहार और अपेक्षित आउटपुट के बारे में सोचने की सुविधा देता है। आप Python में टेस्ट करने के लिए विभिन्न लाइब्रेरीज़ का उपयोग कर सकते हैं, जैसे pytest और unnitest। हालाँकि, फिलहाल हम Native Python का उपयोग करके सरल टेस्ट केस लिखने पर ध्यान देंगे, जो यह मान्य करेंगे कि वांछित फ़ंक्शनलिटी अपेक्षित आउटपुट देती है।

हम एक सरल टेस्ट केस से शुरुआत करेंगे और धीरे-धीरे टेस्ट केस का विस्तार करके अलग-अलग परिदृश्यों को कवर करेंगे। जैसे-जैसे हम अपने टेस्ट केस बढ़ाएँगे, हमें शुरुआती इम्प्लीमेंटेशन लॉजिक में बग्स या कमियाँ मिल सकती हैं जिन्हें सुधारने की आवश्यकता होगी। Python के साथ टेस्ट-ड्रिवन डेवलपमेंट के मूल में यही क्रमिक प्रक्रिया है: और उन्नत टेस्ट केस लिखना, उन्हें फेल होते देखना, और फिर वापस जाकर अपने इम्प्लीमेंटेशन में सुधार करना।

इस ट्यूटोरियल के लिए, हम DataLab का उपयोग करेंगे, जो DataCamp का क्लाउड-आधारित डेटा नोटबुक है, जहाँ आप बिना कोई लोकल इंस्टॉल किए Python कोड लिख और चला सकते हैं। आइए शुरू करें!

DataLab के साथ शुरुआत

टेस्ट-ड्रिवन डेवलपमेंट शुरू करने से पहले, हमें DataLab को देखना और समझना होगा ताकि यह हमारी सीखने की यात्रा में मदद कर सके। यदि आप DataLab खोलते हैं, तो आपको कई विकल्प दिखाई देंगे। फिलहाल, हम DataLab में Python लिखने पर ध्यान केंद्रित करेंगे।

यदि आप Python चुनते हैं, तो वर्कबुक आपके लिए Python लिखने हेतु एक कोडिंग सेल खोल देगी। यह कुछ ऐसा दिखेगा:

यहाँ आपके पास कुछ उपयोगी विकल्प उपलब्ध हैं। उदाहरण के लिए, आप आउटपुट प्राप्त करने के लिए सेल चला सकते हैं, अपने सीखने में सहायक टिप्पणियाँ या नोट्स जोड़ सकते हैं और शुरुआत करने या अटकने पर AI की मदद ले सकते हैं। आप आवश्यकता अनुसार जितने चाहें सेल जोड़ या हटा भी सकते हैं। हम "Run" विकल्प से सेल चलाने पर ध्यान देंगे। जैसा कि आप नीचे दिए गए कोड में देख सकते हैं, जब आप सेल चलाते हैं तो आपके कोड द्वारा उत्पन्न कोई भी आउटपुट नीचे लॉग हो जाता है।

एक त्वरित नोट: यदि आपने कई सेल का उपयोग किया है और किसी एक सेल में एक वैरिएबल परिभाषित किया है, लेकिन उसे किसी अन्य सेल में एक्सेस करने का प्रयास कर रहे हैं, तो आपको हर सेल को अलग-अलग या पूरे वर्कबुक को (अपने वर्कबुक के ऊपर दाईं ओर "Run" बटन से) चलाना होगा।

अब जब हमने DataLab की बुनियादी बातें समझ ली हैं, तो टेस्ट-ड्रिवन डेवलपमेंट के साथ शुरुआत करें।

टेस्ट-ड्रिवन डेवलपमेंट

टेस्ट-ड्रिवन डेवलपमेंट का अर्थ है कि आप अपने कोड से पहले उसके टेस्ट लिखते हैं। TTD समझाने के लिए, आइए एक सरल उदाहरण से शुरू करें जिसमें संख्याओं को जोड़ने वाला Python स्क्रिप्ट लिखना शामिल है। हालाँकि, फ़ंक्शन लिखने से पहले, हम यह जाँचने के लिए एक टेस्ट लिखेंगे कि 1 + 1, 2 के बराबर है या नहीं। आप इसे नीचे दिखाए अनुसार Native Python का उपयोग करके पूरा कर सकते हैं।

assert 1 + 1 == 2

Python में assert कीवर्ड का उपयोग टेस्ट केस लिखने और यह पुष्टि करने के लिए किया जाता है कि प्रोग्राम की शर्तें True पर मूल्यांकित होती हैं। यह आपको अपने कोड के व्यवहार और आउटपुट को मान्य करने देता है। जब कोई assert स्टेटमेंट फेल होता है, तो यह एक AssertionError उठाता है, जो कोड में किसी समस्या का संकेत देता है। यह आपके DataLab वर्कबुक में कुछ ऐसा दिखेगा:

उदाहरण 1: एक सरल फ़ंक्शन का परीक्षण

टेस्टिंग फ़ंक्शन से शुरू करते हैं। शुरुआत करने के लिए, DataLab में एक Python फ़ाइल खोलें। टेस्ट-ड्रिवन डेवलपमेंट में पहले एक फेलिंग टेस्ट लिखना शामिल है। तो, आइए एक फेलिंग टेस्ट लिखते हैं, जिसमें हम add() फ़ंक्शन को कॉल करेंगे, जिसे अभी परिभाषित नहीं किया गया है।

assert add(1, 1) == 2

इससे NameError मिलेगा, जो यह दर्शाता है कि कोई इम्प्लीमेंटेशन मौजूद नहीं है, जिसे "रेड" स्टेप कहा जाता है। जब आप किसी ऐसे फ़ंक्शन या वैरिएबल को कॉल करने का प्रयास करते हैं जो परिभाषित नहीं है, तब NameError मिलता है।

अब, फ़ंक्शन को इम्प्लीमेंट करने का समय है। हम फ़ंक्शन परिभाषित करके यह कर सकते हैं:

def add(num1, num2):
    return

हमने अपना फ़ंक्शन add परिभाषित कर लिया है, जो दो पैरामीटर num1 और num2 लेता है। हमारा फ़ंक्शन अभी कुछ भी रिटर्न नहीं करता। आइए देखें कि क्या हमारे फ़ंक्शन का इम्प्लीमेंटेशन हमारे टेस्ट पास करता है!

अब हमें NameError नहीं दिखता। हालाँकि, सेल चलाने पर अभी भी एक त्रुटि आती है! इस बार यह AssertionError है। यानी हमारा टेस्ट अब भी फेल हो रहा है! हमें यह त्रुटि क्यों मिल रही हो सकती है? क्योंकि हमने एक ऐसा फ़ंक्शन परिभाषित किया है जो अभी कुछ भी रिटर्न नहीं करता।

टेस्ट चलाते समय हमें AssertionError मिलता है क्योंकि हमारी खाली इम्प्लीमेंटेशन में 1 + 1, 2 के बराबर नहीं होता। अंततः, हम फ़ंक्शन में सही लॉजिक इम्प्लीमेंट करके इसे पास करा सकते हैं।

आप सेल के कोने में हरा डॉट देखेंगे। यह दिखाता है कि जब आप सेल चलाते हैं तो आपका कोड वैध है और पास हो गया है। पहले आप देखेंगे कि यह रन एरर के साथ लाल था और सेल के नीचे एरर टाइप दिखा रहा था। DataLab में अपने कोड को डिबग करने के लिए यह फ़ीचर उपयोगी है।

आपने अब Python में टेस्ट-ड्रिवन डेवलपमेंट का उपयोग करके अपना पहला टेस्ट लिख लिया है। बहुत बढ़िया! अब हम अपने टेस्ट को विस्तार देने और संभावित त्रुटियों के बारे में सोचने पर बढ़ेंगे जो हमारे फ़ंक्शन को फेल करा सकती हैं या अपेक्षित आउटपुट नहीं दे सकतीं।

उदाहरण 2: बहु टेस्ट केस

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

उदाहरण के लिए, यदि फ़ंक्शन को गलत डेटा टाइप पास कर दिया जाए तो क्या होगा? आप Python टेस्टिंग फ्रेमवर्क का उपयोग कर सकते हैं, लेकिन आइए बेसिक Python ही इस्तेमाल करें। पहले, मैं अलग-अलग उपयोग परिदृश्यों का अनुकरण करने के लिए इनपुट डिक्शनरीज़ की एक सूची परिभाषित करूँगा:

test_cases = [
    {"num1": 1, "num2": 3, "expected": 4},
    {"num1": 1, "num2": "invalid", "expected": "Error: num2 must be a number"}, 
    {"num1": [1,2,3], "num2": 2, "expected": "Error: num1 must be a number"},
    {"num1": -1, "num2": 1, "expected": 0},
    {"num1": 3.5, "num2": 2.5, "expected": 6.0}, 
    {"num1": 100, "num2": 200, "expected": 300}
]

ऊपर दिया गया कोड फ़ंक्शन के इनपुट के साथ अपेक्षित आउटपुट दिखाता है। हालाँकि, हमें अपने टेस्ट को इन टेस्ट केस पर इटरेट करने के लिए अपडेट करना होगा। हम for लूप के भीतर assert रखकर सूची में प्रत्येक डिक्शनरी को वैलिडेट कर सकते हैं।

for test in test_cases:
    assert add(test["num1"], test["num2"]) == test["expected"]

चूँकि फ़ंक्शन अपरिवर्तित है, क्या हम उम्मीद करेंगे कि यह टेस्ट पास होगा या फेल? और कौन सी त्रुटि आ सकती है?

टेस्ट में TypeError आता है क्योंकि हमने नॉन-नंबर इनपुट्स को हैंडल नहीं किया है; यदि int की जगह स्ट्रिंग या बूलियन पास कर दिया जाए तो क्या होगा? हम फ़ंक्शन को इन मामलों को पकड़ने के लिए अपडेट कर सकते हैं! हम इनपुट वैरिएबल के integer या float होने की जाँच करके अवैध टाइप पर एक कस्टम संदेश रिटर्न कर सकते हैं।

def add(num1, num2):
    if type(num1) is not int and type(num1) is not float:
        return "Error: num1 must be a number"
    elif type(num2) is not int and type(num2) is not float:
        return "Error: num2 must be a number"
    else:
        return num1 + num2

जब हम अपने टेस्ट फिर से चलाते हैं, तो हमें अब कोई त्रुटि नहीं मिलती, यानी हमारे टेस्ट पास हो गए हैं। अब हम हरे रंग का गोला देख सकते हैं, जो दर्शाता है कि हमने अब पास होते हुए कुछ टेस्ट इम्प्लीमेंट कर लिए हैं। बहुत अच्छा!

अंतिम विचार

इस ट्यूटोरियल में, हमने DataLab का उपयोग करके Python में टेस्ट-ड्रिवन डेवलपमेंट की मूल बातें कवर कीं। DataLab एक क्लाउड IDE प्रदान करता है जो आपको बिना लोकल इंस्टॉलेशन के Python कोड लिखने और चलाने देता है। टेस्ट कोड के व्यवहार को मान्य करते हैं और शुरुआती चरण में ही त्रुटियाँ पकड़ लेते हैं। Assert स्टेटमेंट शर्तों की जाँच करते हैं और फेल होने पर अपवाद उठाते हैं।

आप और अधिक टेस्ट केस तलाश सकते हैं और DataLab में अपने टेस्ट लिखना शुरू कर सकते हैं! यदि आप Python में टेस्टिंग के बारे में और सीखना चाहते हैं, तो हमारा DataCamp कोर्स देखें - Introduction to Testing in Python.