👤 🕒 💪🏾 पायथन में परीक्षण के साथ परिचित। भाग 1 🍟 🛃 🈺

सभी को शुभ दिन!

~~हमारी तालिका से आपके लिए ...~~ अर्थात, हमारे पाठ्यक्रम "पायथन डेवलपर" से, नए साल के तेजी से निकट होने के बावजूद, हमने पायथन में विभिन्न परीक्षण विधियों के बारे में आपके लिए एक दिलचस्प अनुवाद तैयार किया है।

यह गाइड उन लोगों के लिए है जिन्होंने पहले से ही एक शांत पायथन एप्लिकेशन लिखा है, लेकिन अभी तक नहीं लिखा है
उन्हें परीक्षण।

पायथन में परीक्षण एक व्यापक विषय है जिसमें सूक्ष्मता का एक समूह है, लेकिन चीजों को जटिल करना आवश्यक नहीं है। कुछ सरल चरणों में, आप आवेदन के लिए सरल परीक्षण बना सकते हैं, धीरे-धीरे उनके आधार पर जटिलता बढ़ रही है।

इस गाइड में, आप सीखेंगे कि एक मूल परीक्षण कैसे बनाया जाए, इसे चलाएं और उपयोगकर्ताओं द्वारा इसे करने से पहले सभी बगों को ढूंढें! आप परीक्षण और परीक्षण चलाने के लिए उपलब्ध उपकरणों के बारे में जानेंगे, आवेदन प्रदर्शन की जांच करेंगे, और यहां तक कि सुरक्षा मुद्दों को भी देखेंगे।

कोड परीक्षण

आप कई तरीकों से कोड का परीक्षण कर सकते हैं। इस गाइड में, आप सबसे सरल से सबसे उन्नत तक के तरीकों के बारे में जानेंगे।

स्वचालित बनाम मैनुअल परीक्षण

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

अनुसंधान परीक्षण - परीक्षण जो एक योजना के बिना किया जाता है। शोध परीक्षण के दौरान, आप अनुप्रयोग पर शोध करते हैं।

मैनुअल परीक्षणों की एक पूरी सूची बनाने के लिए, यह एप्लिकेशन के सभी कार्यों की सूची बनाने के लिए पर्याप्त है, विभिन्न प्रकार के इनपुट जो इसे लेते हैं, और अपेक्षित परिणाम। अब, हर बार जब आप कोड में कुछ बदलते हैं, तो आपको इस सूची के प्रत्येक तत्वों को फिर से जांचना होगा।

धूमिल लगता है, है ना?

इसलिए, स्वचालित परीक्षणों की आवश्यकता है। स्वचालित परीक्षण - परीक्षण योजना का निष्पादन (आवेदन के कुछ हिस्सों को परीक्षण, परीक्षण के क्रम और अपेक्षित परिणाम) एक स्क्रिप्ट का उपयोग करना, और मानव हाथों से नहीं। पायथन में पहले से ही आपके आवेदन के लिए स्वचालित परीक्षण बनाने में मदद करने के लिए उपकरणों और पुस्तकालयों का एक सेट है। आइए इन टूल्स और लाइब्रेरी को अपने ट्यूटोरियल में देखें।

यूनिट टेस्ट वी.एस. एकीकरण टेस्ट

परीक्षण की दुनिया शर्तों से भरी है, और अब, मैनुअल और स्वचालित परीक्षण के बीच के अंतर को जानने के बाद, हम एक स्तर और नीचे जाएंगे।

इस बारे में सोचें कि आप कार की हेडलाइट्स का परीक्षण कैसे कर सकते हैं? आप हेडलाइट्स चालू करते हैं (चलो इसे परीक्षण कदम कहते हैं), खुद कार से बाहर निकलें या किसी मित्र से पूछें कि हेडलाइट्स जलाए गए हैं (और यह एक परीक्षण प्रस्ताव है)। कई घटकों के परीक्षण को एकीकरण परीक्षण कहा जाता है।

उन सभी चीजों के बारे में सोचें जो सही तरीके से काम करें ताकि एक सरल कार्य सही परिणाम उत्पन्न करे। ये घटक आपके आवेदन के कुछ हिस्सों के समान हैं: उन सभी वर्गों, कार्यों, मॉड्यूल जो आपने लिखे थे।

एकीकरण परीक्षण की मुख्य कठिनाई तब उत्पन्न होती है जब एकीकरण परीक्षण सही परिणाम नहीं देता है। समस्या का आकलन करना मुश्किल है, सिस्टम के टूटे हुए हिस्से को अलग करने में सक्षम नहीं है। यदि हेडलाइट्स नहीं जलाए जाते हैं, तो बल्ब टूट सकते हैं। या शायद बैटरी कम है? या शायद समस्या जनरेटर में है? या मशीन के कंप्यूटर में भी कोई दुर्घटना?

आधुनिक कारें खुद आपको टूटे हुए बल्ब की सूचना देंगी। यह एक इकाई परीक्षण का उपयोग करके निर्धारित किया जाता है।

यूनिट टेस्ट (यूनिट टेस्ट) एक छोटा परीक्षण है जो एक व्यक्तिगत घटक के सही संचालन की जांच करता है। यूनिट टेस्ट ब्रेकडाउन को अलग करने और इसे तेजी से ठीक करने में मदद करता है।

हमने दो प्रकार के परीक्षणों के बारे में बात की:

एक एकीकरण परीक्षण जो सिस्टम के घटकों और एक दूसरे के साथ उनकी बातचीत की जांच करता है;
एक इकाई परीक्षण जो किसी अनुप्रयोग के एकल घटक का परीक्षण करता है।
आप पायथन में दोनों परीक्षण बना सकते हैं। अंतर्निहित योग () फ़ंक्शन के लिए एक परीक्षण लिखने के लिए, आपको ज्ञात मानों के साथ योग () के आउटपुट की तुलना करने की आवश्यकता है।

उदाहरण के लिए, इस तरह आप जांच सकते हैं कि संख्याओं का योग (1, 2, 3) 6 है:

>>> assert sum([1, 2, 3]) == 6, "Should be 6"

मान सही हैं, इसलिए REPL में कुछ भी आउटपुट नहीं होगा। यदि sum() का परिणाम गलत है, तो " AssertionError 6 होना चाहिए" संदेश के साथ एक AssertionError जाएगा। कथन विवरण को फिर से जाँचें, लेकिन अब अमान्य मानों के साथ एक AssertionError

 >>> assert sum([1, 1, 1]) == 6, "Should be 6" Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError: Should be 6

REPL में, आप AssertionError देखेंगे क्योंकि sum() मान 6 नहीं है।

REPL के बजाय, इसे test_sum.py नामक एक नए पायथन फ़ाइल में test_sum.py और इसे फिर से चलाएँ:

 def test_sum(): assert sum([1, 2, 3]) == 6, "Should be 6" if __name__ == "__main__": test_sum() print("Everything passed")

अब आपके पास लिखित परीक्षा का मामला (टेस्ट केस), स्टेटमेंट और एंट्री पॉइंट (कमांड लाइन) है। अब यह कमांड लाइन पर किया जा सकता है:

 $ python test_sum.py Everything passed

आप सफल परिणाम देखते हैं, "सब कुछ बीत गया"।

sum() में पायथन किसी भी तर्क को पहले तर्क के रूप में स्वीकार करता है। आपने लिस्ट चेक कर ली है। आइए टपल का परीक्षण करने का प्रयास करें। निम्नलिखित कोड के साथ test_sum_2.py नामक एक नई फ़ाइल बनाएँ:

 def test_sum(): assert sum([1, 2, 3]) == 6, "Should be 6" def test_sum_tuple(): assert sum((1, 2, 2)) == 6, "Should be 6" if __name__ == "__main__": test_sum() test_sum_tuple() print("Everything passed")

test_sum_2.py , स्क्रिप्ट में test_sum_2.py त्रुटि होगी, क्योंकि s um() (1, 2, 2) 5 होना चाहिए, न कि 6. परिणामस्वरूप, स्क्रिप्ट एक त्रुटि संदेश देती है, कोड की एक पंक्ति और एक ट्रेसबैक:

 $ python test_sum_2.py Traceback (most recent call last): File "test_sum_2.py", line 9, in <module> test_sum_tuple() File "test_sum_2.py", line 5, in test_sum_tuple assert sum((1, 2, 2)) == 6, "Should be 6" AssertionError: Should be 6

आप देख सकते हैं कि कोड में कोई त्रुटि कैसे कंसोल में एक त्रुटि का कारण बनती है, जहां यह जानकारी होती है कि अपेक्षित परिणाम क्या था।

इस तरह के परीक्षण सरल सत्यापन के लिए उपयुक्त हैं, लेकिन क्या होगा अगर एक से अधिक त्रुटियां हैं? टेस्ट धावक बचाव के लिए आते हैं। टेस्ट एक्ज़ीक्यूसर एक विशेष एप्लिकेशन है जो परीक्षणों का संचालन करने, आउटपुट डेटा को सत्यापित करने और डिबगिंग और निदान परीक्षणों और अनुप्रयोगों के लिए उपकरण प्रदान करने के लिए डिज़ाइन किया गया है।

टेस्ट एक्ज़ीक्यूटर चुनना

पायथन के लिए कई परीक्षण धावक उपलब्ध हैं। उदाहरण के लिए, unittest को पायथन मानक पुस्तकालय में बनाया गया है। इस गाइड में, हम परीक्षण मामलों और बिना परीक्षण परीक्षण निष्पादकों का उपयोग करेंगे। सबसे बेहतर ऑपरेटिंग सिद्धांत आसानी से अन्य रूपरेखाओं के अनुकूल होते हैं। हम सबसे लोकप्रिय परीक्षण निष्पादकों की सूची देते हैं:

unittest;
नाक या नाक 2;
pytest।

एक परीक्षण ठेकेदार चुनना महत्वपूर्ण है जो आपकी आवश्यकताओं और अनुभव को पूरा करता है।

unittest

संस्करण 2.1 के बाद से यूनिस्टेस्ट को पायथन मानक पुस्तकालय में एकीकृत किया गया है। आप शायद व्यावसायिक पायथन अनुप्रयोगों और ओपन सोर्स परियोजनाओं में इसके पार आएंगे।
यूनीटेस्ट में टेस्ट फ्रेमवर्क और टेस्ट रनर है। परीक्षण लिखने और चलाने के दौरान, आपको कुछ महत्वपूर्ण आवश्यकताओं का पालन करना होगा।

एकमत की आवश्यकता है:

तरीकों के रूप में कक्षाओं में परीक्षण रखो;
विशेष अनुमोदन विधियों का उपयोग करें। सामान्य रूप से निर्मित मुखर अभिव्यक्ति के बजाय टेस्टकेस क्लास।

पहले लिखित उदाहरण को एक अनटेस्ट टेस्ट केस में बदलने के लिए, आपको यह करना होगा:

मानक पुस्तकालय से एकतरफा आयात करें;
TestSum नामक एक क्लास बनाएं जो TestSum क्लास को इनहेरिट करेगा;
पहले तर्क के रूप में self को जोड़कर परीक्षण कार्यों को विधियों में बदलें;
self.assertEqual() क्लास में self.assertEqual() विधि के उपयोग को जोड़कर बयानों को संशोधित करें;
कमांड लाइन पर प्रवेश बिंदु को unittest.main() कॉल करने के लिए बदलें।

इन चरणों का पालन करते हुए, इस कोड के साथ एक नया test_sum_unittest.py फ़ाइल बनाएं:

 import unittest class TestSum(unittest.TestCase): def test_sum(self): self.assertEqual(sum([1, 2, 3]), 6, "Should be 6") def test_sum_tuple(self): self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") if __name__ == '__main__': unittest.main()

कमांड लाइन पर ऐसा करने से, आपको एक सफल समापन (द्वारा इंगित किया गया) और एक असफल (एफ द्वारा इंगित) मिलेगा:

 $ python test_sum_unittest.py .F ====================================================================== FAIL: test_sum_tuple (__main__.TestSum) ---------------------------------------------------------------------- Traceback (most recent call last): File "test_sum_unittest.py", line 9, in test_sum_tuple self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") AssertionError: Should be 6 ---------------------------------------------------------------------- Ran 2 tests in 0.001s FAILED (failures=1)

इस प्रकार, आपने दो परीक्षण किए जिनमें से सबसे बेकार परीक्षण धावक का उपयोग किया गया।

नोट: यदि आप पायथन 2 और 3 के लिए परीक्षण मामले लिख रहे हैं, तो सावधान रहें। पायथन 2.7 और उससे नीचे के संस्करणों में, यूनिस्टेस्ट को यूनीटेस्ट 2 कहा जाता है। जब आप यूनिस्टेस्ट से आयात करते हैं, तो आपको पायथन 2 और पायथन 3 में विभिन्न कार्यों के साथ अलग-अलग संस्करण मिलेंगे।

यूनीटेस्ट के बारे में अधिक जानने के लिए, सबसे अच्छे दस्तावेज को पढ़ें।

नाक

समय के साथ, एक आवेदन के लिए सैकड़ों या हजारों परीक्षण लिखने के बाद, एकतरफा आउटपुट डेटा को समझना और उसका उपयोग करना मुश्किल हो जाता है।

नाक सभी रूपरेखाओं के साथ लिखे गए परीक्षण के अनुकूल है, और इसके परीक्षण निष्पादक को बदल सकता है। नाक के विकास, एक खुले स्रोत अनुप्रयोग के रूप में, धीमा करना शुरू हुआ, और nose2 बनाया गया था। यदि आप खरोंच से शुरू कर रहे हैं, तो यह अनुशंसा की जाती है कि आप nose2 का उपयोग करें।

Nose2 के साथ आरंभ करने के लिए आपको इसे PyPl से इंस्टॉल करना होगा और इसे कमांड लाइन पर चलाना होगा। nose2 परीक्षण के साथ सभी परीक्षण लिपियों को खोजने की कोशिश करेगा। नाम में सभी test*.py और आपके वर्तमान निर्देशिका में unittest.TestCase से विरासत में प्राप्त सभी परीक्षण मामले:

 $ pip install nose2 $ python -m nose2 .F ====================================================================== FAIL: test_sum_tuple (__main__.TestSum) ---------------------------------------------------------------------- Traceback (most recent call last): File "test_sum_unittest.py", line 9, in test_sum_tuple self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") AssertionError: Should be 6 ---------------------------------------------------------------------- Ran 2 tests in 0.001s FAILED (failures=1)

यह है कि test_sum_unittest.py में बनाया गया परीक्षण नाक 2 परीक्षण धावक से test_sum_unittest.py किया गया है। नाक 2 निष्पादन योग्य परीक्षणों को छानने के लिए कई कमांड लाइन झंडे प्रदान करता है। अधिक जानकारी के लिए, नाक 2 प्रलेखन देखें ।

pytest

pytest unittest परीक्षण मामलों का समर्थन करता है। लेकिन पाइस्टेस्ट का असली फायदा इसके परीक्षण के मामले हैं। पायथेस्ट टेस्ट केस पायथन फ़ाइल में फ़ंक्शन की एक श्रृंखला है, जिसमें नाम की शुरुआत में test_ है।

इसमें अन्य उपयोगी विशेषताएं हैं:

विशेष सेल्फासर्ट * () विधियों का उपयोग करने के बजाय अंतर्निहित मुखर अभिव्यक्तियों का समर्थन;
परीक्षण मामलों को छानने के लिए समर्थन;
अंतिम विफल परीक्षण से पुनरारंभ करने की क्षमता;
सैकड़ों प्लगइन्स का एक पारिस्थितिकी तंत्र जो कार्यक्षमता का विस्तार करता है।

पाइस्टेस्ट के लिए एक उदाहरण टेस्टसम टेस्ट केस इस तरह दिखेगा:

 def test_sum(): assert sum([1, 2, 3]) == 6, "Should be 6" def test_sum_tuple(): assert sum((1, 2, 2)) == 6, "Should be 6"

आपको क्लास और कमांड लाइन प्रविष्टि बिंदुओं का उपयोग करके टेस्टकैसे से छुटकारा मिला।
अधिक जानकारी पाईस्ट डॉक्यूमेंटेशन साइट पर पाई जा सकती है।

पहला टेस्ट लिखना

उन सभी चीजों को मिलाएं जो हमने पहले से सीखा था, और अंतर्निहित sum() फ़ंक्शन के बजाय, हम समान आवश्यकताओं के साथ एक सरल कार्यान्वयन का परीक्षण करते हैं।

प्रोजेक्ट के लिए एक नया फ़ोल्डर बनाएँ, जिसके अंदर my_sum नामक एक नया फ़ोल्डर बनाएँ। My_sum के अंदर, एक खाली फ़ाइल बनाएं जिसका नाम _init_.py । इस फ़ाइल की उपस्थिति का अर्थ है कि my_sum फ़ोल्डर को मूल निर्देशिका से मॉड्यूल के रूप में आयात किया जा सकता है।

फ़ोल्डर संरचना इस तरह दिखाई देगी:

project/
│
└── my_sum/
└── __init__.py

my_sum/__init__.py खोलें और sum() नाम से एक नया फ़ंक्शन बनाएं, जो my_sum/__init__.py इनपुट्स (सूची, टपल, सेट) लेता है और मान जोड़ता है।

 def sum(arg): total = 0 for val in arg: total += val return total

यह उदाहरण एक चर बनाता है जिसे total कहा जाता है, arg में सभी मानों पर आधारित है और total जोड़ता है। फिर, पुनरावृत्ति पूरा होने पर, परिणाम वापस आ जाता है।

टेस्ट लिखने के लिए कहाँ

आप एक test.py फ़ाइल बनाकर एक परीक्षण लिखना शुरू कर सकते हैं जिसमें आपका पहला परीक्षण मामला होगा। परीक्षण के लिए, फ़ाइल को आपके एप्लिकेशन को आयात करने में सक्षम होना चाहिए, इसलिए पैकेज के ऊपर फ़ोल्डर में test.py । निर्देशिका पेड़ इस तरह दिखेगा:

project/
│
├── my_sum/
│ └── __init__.py
|
└── test.py

आप देखेंगे कि जैसे ही आप नए परीक्षण जोड़ते हैं, आपकी फ़ाइल अधिक बोझिल और बनाए रखना मुश्किल हो जाता है, इसलिए हम tests/ फ़ोल्डर बनाने और परीक्षणों को कई फ़ाइलों में विभाजित करने की सलाह देते हैं। सुनिश्चित करें कि सभी फ़ाइलों के नाम test_ शुरू test_ , ताकि परीक्षण test_ समझें कि पायथन फ़ाइलों में परीक्षण हैं जिन्हें चलाने की आवश्यकता है। बड़ी परियोजनाओं पर, परीक्षणों को उनके उद्देश्य या उपयोग के आधार पर कई निर्देशिकाओं में विभाजित किया जाता है।

नोट: और क्या आपके आवेदन एक एकल स्क्रिप्ट है?
आप किसी भी स्क्रिप्ट विशेषताओं को आयात कर सकते हैं: अंतर्निहित __import__() फ़ंक्शन का उपयोग करके कक्षाएं, फ़ंक्शन या चर। from my_sum import sum बजाय निम्नलिखित लिखें:

 target = __import__("my_sum.py") sum = target.sum

__import__() का उपयोग करते __import__() आपको प्रोजेक्ट फ़ोल्डर को पैकेज में बदलना नहीं पड़ता है, और आप फ़ाइल नाम निर्दिष्ट कर सकते हैं। यह उपयोगी है अगर फ़ाइल नाम मानक पैकेज पुस्तकालयों के नाम के साथ संघर्ष करता है। उदाहरण के लिए, यदि math.py गणित मॉड्यूल से math.py ।

कैसे एक सरल परीक्षण की संरचना करें

परीक्षण लिखने से पहले, आपको कुछ प्रश्नों को हल करने की आवश्यकता है:

आप क्या परीक्षण करना चाहते हैं?
क्या आप एक इकाई परीक्षण या एक एकीकरण परीक्षण लिख रहे हैं?

आप वर्तमान में sum() परीक्षण कर रहे हैं। आप इसके लिए विभिन्न व्यवहारों का परीक्षण कर सकते हैं, उदाहरण के लिए:

क्या पूर्णांकों की सूची को संक्षेप में प्रस्तुत करना संभव है?
क्या एक ट्यूल या सेट को संक्षेप में प्रस्तुत करना संभव है?
क्या मैं फ़्लोटिंग पॉइंट नंबरों की सूची संक्षेप में प्रस्तुत कर सकता हूँ?
यदि आप इनपुट को खराब मान देते हैं तो क्या होता है: एक पूर्णांक या एक स्ट्रिंग?
यदि मूल्यों में से एक नकारात्मक है तो क्या होगा?

परीक्षण करने का सबसे आसान तरीका पूर्णांकों की एक सूची है। निम्नलिखित कोड के साथ एक test.py फ़ाइल बनाएँ:

 import unittest from my_sum import sum class TestSum(unittest.TestCase): def test_list_int(self): """ Test that it can sum a list of integers """ data = [1, 2, 3] result = sum(data) self.assertEqual(result, 6) if __name__ == '__main__': unittest.main()

इस उदाहरण में कोड:

आपके द्वारा बनाए गए पैकेज my_sum() sum() से आयात sum() ;
एक नया टेस्ट केस क्लास परिभाषित करता है जिसे TestSum कहा जाता है जो कि unittest.TestCase इनहेरिट करता है;
पूर्णांक सूची के परीक्षण के लिए एक .test_list_int() विधि को परिभाषित करता है। .test_list_int() विधि निम्न कार्य करेगी

मूल्यों की सूची (1, 2, 3) साथ एक data चर घोषित करता है;
चर result my_sum.sum(data) मान my_sum.sum(data) ;
यह निर्धारित करता है कि परिणाम का मान। .assertEqual() वर्ग पर .assertEqual() पद्धति का उपयोग करके 6 है।

एक कमांड लाइन एंट्री पॉइंट को परिभाषित करता है जो कि .main() टेस्ट रनर को लॉन्च करता है।

यदि आप नहीं जानते कि स्व क्या है, या कैसे .assertEqual() परिभाषित है, तो आप पायथन 3 ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के अपने ज्ञान को ताज़ा कर सकते हैं।

स्टेटमेंट कैसे लिखें

परीक्षण लिखने में अंतिम चरण यह सत्यापित करना है कि आउटपुट ज्ञात मूल्यों से मेल खाता है। इसे अभिकथन कहते हैं। बयान लिखने के लिए कई सामान्य दिशानिर्देश हैं:

सत्यापित करें कि परीक्षण दोहराए जा रहे हैं और उन्हें सुनिश्चित करने के लिए कई बार चलाएं कि वे हर बार एक ही परिणाम देते हैं;
अपने इनपुट पर लागू होने वाले परिणामों की जांच करें और पुष्टि करें - यह सत्यापित करें कि परिणाम वास्तव में योग में मानों का sum() उदाहरण।

चरों के मूल्यों, प्रकारों और अस्तित्व की पुष्टि के लिए यूनीटेस्ट के पास कई तरीके हैं। यहाँ सबसे अधिक इस्तेमाल की जाने वाली विधियाँ हैं:

विधि	बराबर
.assertEqual (ए, बी)	a == बी
.assertTrue (x)	बूल (x) ट्रू है
.assertFalse (x)	बूल (x) गलत है
.assertIs (ए, बी)	ए बी है
.assertIsNone (x)	x कोई नहीं है
.assertIn (ए, बी)	बी में
.assertIsInstance (ए, बी)	आइंस्टीन (ए, बी)

.assertIs() , .assertIsNone() , .assertIn() , और .assertIsInstance() विपरीत तरीके हैं .assertIsNot() और इसी तरह।

साइड इफेक्ट

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

यदि आप पाते हैं कि कोड ब्लॉक के बहुत सारे साइड इफेक्ट हैं जिनका आप परीक्षण करना चाहते हैं, तो आप सोल रिस्पॉन्सिबिल एले का उल्लंघन कर रहे हैं। एकमात्र जिम्मेदारी सिद्धांत का उल्लंघन करने का मतलब है कि कोड का एक टुकड़ा बहुत सारी चीजें करता है और उसे फिर से तैयार करने की आवश्यकता होती है। एकमात्र जिम्मेदारी के सिद्धांत का पालन करना कोड डिजाइन करने का एक शानदार तरीका है जिसके लिए सरल, दोहराए जाने वाले यूनिट परीक्षणों को लिखना मुश्किल नहीं होगा, और अंततः, विश्वसनीय एप्लिकेशन बनाएं।

पहले टेस्ट का शुभारंभ

आपने पहला परीक्षण बनाया और अब आपको इसे चलाने की कोशिश करने की आवश्यकता है। यह स्पष्ट है कि इसे पारित किया जाएगा, लेकिन अधिक जटिल परीक्षण बनाने से पहले, आपको यह सुनिश्चित करने की आवश्यकता है कि ऐसे परीक्षण भी सफल हों।

रनिंग टेस्ट एक्ज़ीक्यूटर्स

टेस्ट एक्ज़ीक्यूटर - एक पायथन एप्लिकेशन जो टेस्ट कोड चलाता है, दावे को मान्य करता है, और कंसोल में परीक्षा परिणाम प्रदर्शित करता है। Test.py के अंत में इस छोटे से कोड को जोड़ा जाएगा:

 if __name__ == '__main__': unittest.main()

यह कमांड लाइन एंट्री पॉइंट है। यदि आप कमांड लाइन पर python test.py चलाकर इस स्क्रिप्ट को चलाते हैं, तो यह unittest.main() test.py । यह इस फ़ाइल में सभी वर्गों का पता लगाकर परीक्षण unittest.TestCase शुरू करता है जो कि unittest.TestCase से विरासत में मिला है।

यह सबसे आसान परीक्षण धावक को चलाने के कई तरीकों में से एक है। यदि आपके पास test.py नामक एक एकल परीक्षण फ़ाइल है, तो पायथन टेस्टोस्टोन को कॉल करना आरंभ करने का एक शानदार तरीका है।

एक और तरीका यह है कि आप यूनीटेस्ट कमांड लाइन का उपयोग करें। आइए कोशिश करते हैं:

 $ python -m unittest test

यह कमांड लाइन के माध्यम से एक ही परीक्षण मॉड्यूल ( test कहा जाता test ) को निष्पादित करेगा। आउटपुट बदलने के लिए आप अतिरिक्त पैरामीटर जोड़ सकते हैं। उनमें से एक क्रिया के लिए -v है। चलो निम्नलिखित प्रयास करें:

 $ python -m unittest -v test test_list_int (test.TestSum) ... ok ---------------------------------------------------------------------- Ran 1 tests in 0.000s

हमने एक परीक्षण test.py से चलाया और परिणामों को कंसोल में आउटपुट किया। वर्बोस मोड ने प्रदर्शन किए गए परीक्षणों के नाम और उनमें से प्रत्येक के परिणामों को सूचीबद्ध किया।

परीक्षण वाले मॉड्यूल का नाम प्रदान करने के बजाय, आप निम्नलिखित का उपयोग करके ऑटो-डिस्कवरी का अनुरोध कर सकते हैं:

 $ python -m unittest discover

यह कमांड test*.py लिए फ़ाइलों के लिए वर्तमान निर्देशिका में दिखेगा। test*.py टेस्ट करने के लिए उन्हें नाम में।

यदि आपके पास कई परीक्षण फाइलें हैं और आप test*.py नामकरण पैटर्न का पालन करते हैं, तो आप -s ध्वज और फ़ोल्डर नाम का उपयोग करके निर्देशिका नाम पारित कर सकते हैं।

 $ python -m unittest discover -s tests

unittest एक परीक्षण योजना में सभी परीक्षण चलाएगा और परिणाम तैयार करेगा।
अंत में, यदि आपका स्रोत कोड रूट डायरेक्टरी में नहीं है, लेकिन उपनिर्देशिका में, उदाहरण के लिए, src / नामक एक फ़ोल्डर में, आप unittest को बता सकते हैं कि मॉड्यूल को सही ढंग से आयात करने के लिए -t फ्लैग का उपयोग करके परीक्षण कहां चलाना है:

 $ python -m unittest discover -s tests -t src

unittest सभी test*.py फ़ाइलों को src/ निर्देशिका के अंदर tests में पाएगा, और फिर उन्हें निष्पादित करेगा।

परीक्षा परिणाम को समझना

यह एक बहुत ही सरल उदाहरण था, जहां सबकुछ ठीक हो गया, इसलिए आइए एक असफल परीक्षा के आउटपुट को समझने की कोशिश करें।

sum() संख्यात्मक प्रकार की अन्य सूचियों को स्वीकार करना चाहिए, उदाहरण के लिए अंश।

test.py में कोड की शुरुआत करने के लिए test.py मानक लाइब्रेरी के fractions मॉड्यूल से Fraction प्रकार आयात करने के लिए एक अभिव्यक्ति जोड़ें।

 from fractions import Fraction

अब एक बयान के साथ एक परीक्षण जोड़ें, एक गलत मूल्य की उम्मीद है। हमारे मामले में, हम उम्मीद करते हैं कि case, expect और expect का योग 1 के बराबर होगा:

 import unittest from my_sum import sum class TestSum(unittest.TestCase): def test_list_int(self): """ Test that it can sum a list of integers """ data = [1, 2, 3] result = sum(data) self.assertEqual(result, 6) def test_list_fraction(self): """ Test that it can sum a list of fractions """ data = [Fraction(1, 4), Fraction(1, 4), Fraction(2, 5)] result = sum(data) self.assertEqual(result, 1) if __name__ == '__main__': unittest.main()

यदि आप पायथन के साथ फिर से परीक्षण चलाते हैं, तो मैं एकतरफा परीक्षण करता हूँ, निम्नलिखित प्राप्त करें:

 $ python -m unittest test F. ====================================================================== FAIL: test_list_fraction (test.TestSum) ---------------------------------------------------------------------- Traceback (most recent call last): File "test.py", line 21, in test_list_fraction self.assertEqual(result, 1) AssertionError: Fraction(9, 10) != 1 ---------------------------------------------------------------------- Ran 2 tests in 0.001s FAILED (failures=1)

इस आउटपुट में, आप निम्नलिखित देखते हैं:

पहली पंक्ति सभी परीक्षणों के परिणामों को दिखाती है: एक असफल (एफ), एक पारित (;);
विफल परीक्षण के कुछ विवरण दिखाई देते हैं:

परीक्षण विधि का नाम ( test_list_fraction );
टेस्ट मॉड्यूल ( test ) और टेस्ट केस ( TestSum );
एक त्रुटि के साथ ट्रेसबैक तार;
अपेक्षित परिणाम (1) और वास्तविक परिणाम (अंश, 9, 10) के साथ विवरण का विवरण

याद रखें, आप python -m unittest में -v ध्वज का उपयोग करके परीक्षण आउटपुट में अतिरिक्त जानकारी जोड़ सकते हैं।

PyCharm से परीक्षण चल रहा है

यदि आप PyCharm IDE का उपयोग कर रहे हैं, तो आप इन चरणों का पालन करके बिना रुकावट या पाइस्टेस्ट चला सकते हैं:

प्रोजेक्ट टूल विंडो में, परीक्षण निर्देशिका का चयन करें।
संदर्भ मेनू में, unittest run कमांड का चयन करें। उदाहरण के लिए, 'मेरे टेस्ट में यूनीटैस्ट ...'।

यह परीक्षण विंडो में एकतरफा निष्पादन करेगा और PyCharm में परिणाम लौटाएगा:

अधिक जानकारी PyCharm वेबसाइट पर उपलब्ध है।

विजुअल स्टूडियो कोड से टेस्ट चलाना

यदि आप Microsoft Visual Studio कोड IDE का उपयोग करते हैं, तो unittest, nose और pytest का समर्थन पहले से ही Python प्लगइन में बनाया गया है।

यदि आपने इसे स्थापित किया है, तो आप Ctrl + Shift + P के साथ कमांड पैलेट खोलकर और "पायथन टेस्ट" लिखकर परीक्षण कॉन्फ़िगरेशन को कॉन्फ़िगर कर सकते हैं। आपको विकल्पों की एक सूची दिखाई देगी:

डीबग ऑल यूनिट टेस्ट का चयन करें, जिसके बाद VSCode परीक्षण ढांचे को कॉन्फ़िगर करने के लिए एक अनुरोध भेजेगा। टेस्ट रनर (यूनीटेस्ट) और होम डायरेक्टरी (।) का चयन करने के लिए गियर पर क्लिक करें।

सेटअप के पूरा होने पर, आपको स्क्रीन के नीचे परीक्षणों की स्थिति दिखाई देगी और आप जल्दी से परीक्षण लॉग का उपयोग कर सकते हैं और आइकन पर क्लिक करके परीक्षणों को पुनः आरंभ कर सकते हैं:

हम देखते हैं कि परीक्षण किए जा रहे हैं, लेकिन उनमें से कुछ विफल रहे हैं।

अंत

लेख के अगले भाग में, हम Django और फ्लास्क जैसे चौखटे के लिए परीक्षणों की जांच करेंगे।

हम यहां आपके प्रश्नों और टिप्पणियों की प्रतीक्षा कर रहे हैं और हमेशा की तरह, आप एक खुले दिन स्टैनिस्लाव जा सकते हैं।

दूसरा भाग

पायथन में परीक्षण के साथ परिचित। भाग 1

More articles: