मॉक मॉड्यूल: परीक्षण में डमी मॉकअप

अंग्रेजी में मॉक का अर्थ है "नकल," "नकली।" इस नाम के साथ एक मॉड्यूल पाइथन में यूनिट परीक्षणों को सरल बनाने में बहुत मदद करता है।

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

यह व्यवहार अब inflatable रॉकेट लांचर नहीं है, लेकिन एक पूरी inflatable भूमि जिसके चारों ओर परीक्षण रॉकेट और विमान उड़ सकते हैं।





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

पैकेज 1 मेगाबाइट से कम का होता है और बहुत ही सरलता से स्थापित होता है:

$ pip install mock
या
$ easy_install mock

और अब इसका उपयोग किया जा सकता है।

समारोह ओवरराइड

मान लें कि हमारा कार्य कुछ मानता है, और बहुत लंबे समय के लिए:

 from itertools import permutations def real(name): if len(name) < 10: raise ValueError('String too short to calculate statistics.') y = 0 for i in permutations(xrange(len(name)), 10): y += i print y 

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

कोड को फिर से लिखने के बजाय, हम कॉल की अवधि के लिए क्रमपरिवर्तन फ़ंक्शन को केवल "पैच" कर सकते हैं, केवल एक विशिष्ट आउटपुट सेट कर सकते हैं और कुछ कोड कॉल कर सकते हैं:

 from mock import patch import itertools # :   ,    name = '  ' >>> with patch('itertools.permutations') as perm_mock: ... perm_mock.return_value = xrange(3) ... real(name) 1 3 6 

नोट: 42 के बजाय प्रिंट कहा जाता है ! / (42 - 10)! केवल 3 बार, यानी चक्र xrange (3) के माध्यम से चला, जिसे हमने प्रतिस्थापित किया।

इसके अलावा, संदर्भ के साथ बाहर निकलने के बाद, itertools.permutations फ़ंक्शन अपनी सामान्य स्थिति में लौट आया।

डिबग जानकारी

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

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



मॉक ऑब्जेक्ट में कॉल जानकारी के साथ कई विशेषताएं हैं:

• कहा जाता है - क्या वस्तु को बुलाया गया था
• call_count - कॉल की संख्या
• call_args - अंतिम कॉल के तर्क
• call_args_list - सभी तर्कों की सूची
• method_calls - नेस्टेड विधियों और विशेषताओं को कॉल करने के लिए तर्क (नीचे देखें)
• mock_calls - एक ही चीज़, लेकिन एक साथ वस्तु के लिए और नेस्टेड के लिए

ऊपर हमारे उदाहरण में, आप यह सत्यापित कर सकते हैं कि वास्तविक () फ़ंक्शन क्रमचय को सही ढंग से कॉल करता है। अधिक सटीक रूप से जांचने के लिए, उदाहरण के लिए, स्वचालित परीक्षणों में, आप assert_ * विधियों में से एक को कॉल कर सकते हैं:

 perm_mock.assert_called_with(xrange(len(name)), 10) 

सिंथेटिक चीनी

Django में इकाई परीक्षणों के लिए, पैच एक डेकोरेटर के रूप में काम करता है:

 @patch('itertools.permutations') def test(ip): ip.return_value = range(5) print list(itertools.permutations(xrange(10), 10)) >>> test() [0, 1, 2, 3, 4] 

विशेषता और चेन मॉकअप कॉल करें

कभी-कभी Django में आपको फ़ाइलों के साथ कुछ करने की आवश्यकता होती है, और उन्हें डिस्क या अन्य संग्रहण पर सहेजे बिना करना बेहतर होता है। सामान्य तरीके से, हम फ़ाइल वर्ग से विरासत में लेंगे और कुछ गुणों को अधिलेखित करेंगे, जो बोझिल होगा। लेकिन मॉक में, आप तुरंत दोनों विशेषताओं और कॉल श्रृंखलाओं का वर्णन कर सकते हैं:

 mock_file = Mock() mock_file.name = 'my_filename.doc' mock_file.__iter__.return_value = [' 1', ' 2', ' 3'] stat = mock_file.stat.return_value stat.size, stat.access_time = 1000, datetime(2012, 1, 1) 

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

 >>> mock_a = Mock(name=' ') >>> mock_a <Mock name=' ' id='169542476'> 

ये विशेषता श्रृंखलाएं कैसे काम करती हैं?

 >>> m = Mock() >>> m <Mock id='167387660'> >>> m.any_attribute <Mock name='mock.any_attribute' id='167387436'> >>> m.any_attribute <Mock name='mock.any_attribute' id='167387436'> >>> m.another_attribute <Mock name='mock.another_attribute' id='167185324'> 

जैसा कि आप देख सकते हैं, विशेषता को एक्सेस करना मॉक क्लास का एक और उदाहरण देता है, और उसी विशेषता को फिर से एक्सेस करना एक ही उदाहरण देता है। एक फ़ंक्शन सहित एक विशेषता कुछ भी हो सकती है। अंत में, किसी भी लेआउट को बुलाया जा सकता है (कहें, एक वर्ग के बजाय):

 >>> m() <Mock name='mock()' id='167186284'> >>> m() is m False 

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

यदि हम विशेषता के लिए एक मान प्रदान करते हैं, तो कोई आश्चर्य की बात नहीं है: अगली कॉल पर हमें वास्तव में यह मूल्य मिलता है:

 >>> m.any_attribute <Mock name='mock.any_attribute' id='167387436'> >>> m.any_attribute = 5 >>> m.any_attribute 5 

नाम के टकराव से बचने के लिए इसमें कौन सी विशेषताएँ हैं, यह कक्षा के प्रलेखन में पढ़ना उपयोगी है।

लेआउट के लचीलेपन को कैसे सीमित करें

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

 class Tanchik(object): model = 'T80' def shoot(self, target): print '!' def tank_sugar(target): print '%s ' % tank.model tank.shoot(target) return tank ================== import tanks @patch('tanks.Tanchik', spec=tanks.Tanchik) # <<==   spec def test_tank(tank_mock): assert isinstance(tank_sugar(tank_mock), tanks.Tanchik) 

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

लेआउट को कैसे स्मार्ट बनाया जाए

खैर, मान लें कि मॉक आवश्यक वस्तुओं को अनावश्यक के साथ बदल सकता है और आउटपुट को बदल सकता है। क्या मान (रिटर्न_वेल्यू) की तुलना में फ़ंक्शन को कुछ अधिक जटिल से बदलना संभव है? 2 तरीके हैं:

• यदि आपको उदाहरण या वर्ग पर कई विधियों को ओवरराइड करने की आवश्यकता है, तो मॉक वर्ग से विरासत में मिला
• यदि आपको केवल एक कॉल (विधि या स्वयं कक्षा) को बदलने की आवश्यकता है, तो side_effect का उपयोग करें ।

 def simple_function(args): do_something_useful() with patch('module.BigHeavyClass', side_effect=simple_function) as mock_class: another_class.take(mock_class) 

वैसे, आपको simple_function में परीक्षण आउटपुट लिखने की आवश्यकता नहीं है, क्योंकि, जैसा कि ऊपर बताया गया है, mock_class ऑब्जेक्ट में कोड के अंत में आप method_calls पढ़ सकते हैं।

अंतर्निहित कार्यों का प्रतिस्थापन

मॉक स्वयं भाषा (लेन, इटेर) में निर्मित कार्यों को प्रतिस्थापित नहीं कर सकता है, लेकिन यह आवश्यक "जादू" कार्यों के साथ एक लेआउट बना सकता है । उदाहरण के लिए, यहाँ हम एक फ़ाइल लेआउट बना रहे हैं:

 >>> mock = Mock() >>> mock_bz2module.open.return_value.__enter__ = Mock(return_value='foo') >>> mock_bz2module.open.return_value.__exit__ = Mock(return_value=False) >>> with mock_bz2module.open('test.bz2') as m: ... assert m == 'foo' 

ऐसे कई मामलों के लिए, जब आप एक मानक ऑब्जेक्ट (सूची, फ़ाइल, संख्या) का अनुकरण करना चाहते हैं, तो परीक्षणों के लिए उपयुक्त मूल्यों के एक सेट के साथ एक मैजिकमॉक क्लास है।

जहां नकली काम नहीं करता है

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

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

मेरे व्यक्तिगत अनुभव में, मॉक डिबगर्स के साथ संघर्ष कर सकता है, उदाहरण के लिए, PuDB में, अनंत पुनरावृत्ति हुई। IPDB ने ठीक काम किया, इसलिए हमने IPDB के साथ प्रोजेक्ट परीक्षण चलाया, और PuDB पर सिर्फ कोड।

निष्कर्ष

मॉक लेआउट को कहीं भी और कभी भी प्रतिस्थापित किया जा सकता है। आपके कोड को परीक्षण के लिए तैयार नहीं होना है, जिसका अर्थ है तेज विकास, और, संभवतः, तेज प्रोटोटाइप।

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

लेआउट सेटिंग्स जहां आपको हार्ड (युक्ति) की आवश्यकता होती है, जहां आपको लचीलेपन की आवश्यकता होती है, और पैच कोई निशान नहीं छोड़ते हैं।

संदर्भ

• प्रोजेक्ट मुखपृष्ठ
• मॉक के साथ परीक्षण , मॉड्यूल लेखक माइकल फोरड ने इसके बारे में PyCon 2011 में बात की।