पायथन यूनिट टेस्ट: त्वरित शुरुआत

विशेष रूप से पायथन क्यूए इंजीनियर पाठ्यक्रम के छात्रों के लिए लेख का अनुवाद तैयार किया गया था।

---

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

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

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

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

इस के लिए कोड यहाँ है ( Calculator.py ):

 #A simple calculator class Calculator: #empty constructor def __init__(self): pass #add method - given two numbers, return the addition def add(self, x1, x2): return x1 + x2 #multiply method - given two numbers, return the #multiplication of the two def multiply(self, x1, x2): return x1 * x2 #subtract method - given two numbers, return the value #of first value minus the second def subtract(self, x1, x2): return x1 - x2 #divide method - given two numbers, return the value #of first value divided by the second def divide(self, x1, x2): if x2 != 0: return x1/x2 

अब मैं यह समझने के लिए एक इकाई परीक्षण चलाना चाहता हूं कि उपरोक्त वर्ग में कार्यक्षमता नियोजित है।

पायथन आमतौर पर सबसे unittest पैकेज के साथ आता है। यदि यह आपके सिस्टम पर नहीं है, तो इसे स्थापित करने के लिए पाइप का उपयोग करें।

इकाई परीक्षण में निम्नलिखित संरचना है:



tearDown() setUp() और tearDown() मानक विधियाँ हैं, जो कि tearDown() फ्रेमवर्क के साथ आती हैं (वे unittest.TestCase क्लास में परिभाषित हैं)। आपके परीक्षण के मामले के आधार पर, आप डिफ़ॉल्ट रूप से इन दो विधियों को ओवरराइड या ओवरराइड कर सकते हैं।

यह परीक्षण मामले के कोड को देखने का समय है। यहाँ फ़ाइल TestCalculator.py ।

 import unittest from Calculator import Calculator #Test cases to test Calulator methods #You always create a child class derived from unittest.TestCase class TestCalculator(unittest.TestCase): #setUp method is overridden from the parent class TestCase def setUp(self): self.calculator = Calculator() #Each test method starts with the keyword test_ def test_add(self): self.assertEqual(self.calculator.add(4,7), 11) def test_subtract(self): self.assertEqual(self.calculator.subtract(10,5), 5) def test_multiply(self): self.assertEqual(self.calculator.multiply(3,7), 21) def test_divide(self): self.assertEqual(self.calculator.divide(10,2), 5) # Executing the tests in the above test case class if __name__ == "__main__": unittest.main() 

हालांकि यह आवश्यक नहीं है, लेकिन एक नियम के रूप में मैं उपसर्ग परीक्षण (हमारे मामले में TestCalculator) के साथ परीक्षण वर्ग को बुलाता हूं। इस वर्ग में एक प्रमुख आवश्यकता है unittest.TestCase की उपस्थिति।

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

अभी के लिए, आप सभी करेंगे कैलकुलेटर क्लास में प्रत्येक विधि का परीक्षण करने के लिए test_xxx विधियाँ लिखेंगे। कृपया ध्यान दें कि सभी परीक्षण विधियाँ उपसर्ग test_ शुरू test_ । यह अजगर को एकतरफा ढांचे का उपयोग करके बताता है कि ये परीक्षण विधियां हैं।

परीक्षण विधियों में से प्रत्येक में, मैंने यह जांचने के लिए अंतर्निहित assertEqual पद्धति का उपयोग किया है कि क्या कैलकुलेटर के तरीके अपेक्षित मूल्य वापस करते हैं। यदि वापसी मूल्य अपेक्षित मूल्य के बराबर है, तो परीक्षण सफल होता है, अन्यथा यह विफल हो जाता है।

कई अंतर्निहित तरीके हैं जो हम बाद में बात करेंगे।

ऊपर दिए गए कोड में अंतिम पंक्ति TestCalculator परीक्षण मामले को लॉन्च करती है। यह कक्षा के अंदर परिभाषित प्रत्येक परीक्षण विधि को निष्पादित करता है और परिणाम देता है।

 python TestCalculator.py -v 

आपको निम्नलिखित के समान निष्कर्ष दिखाई देगा:

 test_add (__main__.TestCalculator) ... ok test_divide (__main__.TestCalculator) ... ok test_multiply (__main__.TestCalculator) ... ok test_subtract (__main__.TestCalculator) ... ok -------------------------------------------------------------------- Ran 4 tests in 0.000s OK 

क्या होगा अगर कुछ उम्मीद के मुताबिक काम नहीं करता है? आइए 5 से 6 तक test_divide के अपेक्षित मान को test_divide (5 सही मूल्य है, अब हम देखेंगे कि क्या हुआ अगर यह विफल हो जाता है। यह स्रोत कोड में कोई त्रुटि नहीं है, लेकिन परीक्षण सूट में एक त्रुटि है, आपको परीक्षण सूट में भी त्रुटियां हो सकती हैं, इसलिए हमेशा जांचें। त्रुटियों के लिए परीक्षण स्क्रिप्ट!)

 import unittest from Calculator import Calculator #Test cases to test Calulator methods #You always create a child class derived from unittest.TestCase class class TestCalculator(unittest.TestCase): #setUp method overridden from the parent class TestCase def setUp(self): self.calculator = Calculator() ... def test_divide(self): self.assertEqual(self.calculator.divide(10,2), 6) # Executing the tests in the above test case class if __name__ == "__main__": unittest.main() 

जब आप इस परीक्षण मामले को चलाते हैं, तो आपको निम्न परिणाम प्राप्त होंगे:

 test_add (__main__.TestCalculator) ... ok test_divide (__main__.TestCalculator) ... FAIL test_multiply (__main__.TestCalculator) ... ok test_subtract (__main__.TestCalculator) ... ok ==================================================================== FAIL: test_divide (__main__.TestCalculator) -------------------------------------------------------------------- Traceback (most recent call last): File "TestCalculator.py", line 23, in test_divide self.assertEqual(self.calculator.divide(10,2), 6) AssertionError: 5.0 != 6 -------------------------------------------------------------------- Ran 4 tests in 0.001s FAILED (failures=1) 

यह यहां कहता है कि 4 में से 3 परीक्षण सफल रहे, लेकिन एक असफल रहा। एक वास्तविक परिदृश्य में, यह माना जाता है कि आपका परीक्षण मामला सही है, अर्थात इस प्रकार यह एक ऐसे कार्य की पहचान करने में मदद करता है जो ठीक से लागू नहीं होता है।