कोड के लिए परीक्षण क्यों लिखें कि मैं रिफ्लेक्टर करूंगा?

Question

मैं एक विशाल विरासत कोड कक्षा को फिर से बना रहा हूं। Refactoring (मुझे लगता है) यह वकालत करता है:

1. विरासत वर्ग के लिए परीक्षण लिखें
2. रिफ्लेक्टर को वर्ग से बाहर निकाल देना

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

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

क्या रिफ्लेक्टर से पहले परीक्षण लिखने का असली कारण है - मुझे बेहतर कोड समझने में मदद करने के लिए? वहाँ एक और कारण हो गया है!

कृपया समझाएँ!

ध्यान दें:

यह पोस्ट है: क्या यह विरासत कोड के लिए परीक्षण लिखने के लिए समझ में आता है जब कोई पूर्ण रीफैक्टरिंग का समय नहीं है? लेकिन यह कहता है कि "रिफ्लेक्टर से पहले परीक्षण लिखें", लेकिन "क्यों" नहीं कहते हैं, या क्या करें यदि "लेखन परीक्षण" ऐसा लगता है कि "व्यस्त काम जल्द ही नष्ट हो जाएगा"

Comments

आपका आधार गलत है। आप अपने परीक्षण नहीं बदलेंगे। आप नए परीक्षण लिखेंगे। चरण 3 "किसी भी परीक्षण को नष्ट कर देगा जो अब दोषपूर्ण है।"

— पीडीआर

चरण 3 तब "नए परीक्षण लिखें। हटाए गए परीक्षण हटाएं" पढ़ सकते हैं। मुझे लगता है कि यह अभी भी मूल काम को नष्ट करने की मात्रा है

— डेनिस

नहीं, आप चरण 2 के दौरान नए परीक्षण लिखना चाहते हैं और हाँ, चरण 1 नष्ट हो गया है। लेकिन क्या यह समय की बर्बादी थी? नहीं, क्योंकि यह आपको एक टन आश्वासन देता है कि आप चरण 2 के दौरान कुछ भी नहीं तोड़ रहे हैं। आपके नए परीक्षण नहीं हैं।

— पीडीआर

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

— डीएक्सएम

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

— नील

Answer 1

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

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

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

बड़े पैमाने पर परिवर्तन करते समय यह अधिक कठिन होता है, जैसे कई कोडपेंडेंट भागों को नया स्वरूप देना। लेकिन किसी प्रकार की सीमा होगी, और उस सीमा पर आप परीक्षण लिख सकेंगे।

Comments

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

— david.pfx

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

— डेनिस

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

— डेनिस

@ डेनिस वास्तव में, मैं अनजाने में एक वैज्ञानिक रूप से सही प्रयोग का वर्णन कर रहा था: हम यह नहीं बता सकते हैं कि कौन सा पैरामीटर वास्तव में परिणाम को प्रभावित करता है जब एक से अधिक पैरा बदलते हैं। याद रखें कि परीक्षण कोड हैं, और हर कोड में बग होते हैं। क्या आप कोड को छूने से पहले परीक्षण नहीं चलाने के लिए प्रोग्रामर नरक में जाएंगे? निश्चित रूप से नहीं: परीक्षण चलाने के दौरान आदर्श होगा, यह आपका पेशेवर निर्णय है कि क्या आवश्यक है। आगे ध्यान दें कि यदि यह संकलन नहीं किया गया है, तो एक परीक्षा विफल हो गई है, और यह कि मेरा उत्तर डायनेमिक भाषाओं पर भी लागू होता है, न कि किसी लिंकर के साथ स्थैतिक भाषाओं पर।

— अमोन

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

— डेनिस

Answer 2

आह, विरासत प्रणालियों को बनाए रखना।

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

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

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

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

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

इसके अलावा, विरासत प्रणाली के ज्ञान को "अस्थायी ज्ञान" के रूप में मानना ​​अच्छा नहीं है। यह जानना कि यह पहले कैसे हुआ था जब यह विरासत प्रणालियों की बात आती है तो यह महत्वपूर्ण है। "क्यों नरक ऐसा करता है?"

Comments

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

— डेनिस

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

— फिलिप

Answer 3

मेरा अपना उत्तर / बोध:

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

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

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

अपडेट करें

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

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

Comments

अधिक लगता है जैसे आपने रीफैक्टरिंग के साथ एप्लिकेशन को फिर से डिज़ाइन किया।

— जेएफओ

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

— डेनिस

Answer 4

अपना कोड चलाने के लिए अपने परीक्षणों का उपयोग करें जैसा कि आप करते हैं। विरासत कोड में इसका मतलब उस कोड के लिए परीक्षण लिखना है जिसे आप बदलने जा रहे हैं। इस तरह वे एक अलग कलाकृति नहीं हैं। टेस्ट के बारे में होना चाहिए कि कोड को प्राप्त करने की आवश्यकता है और इसके बारे में नहीं कि यह कैसे करता है।

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

पुराने परीक्षणों को अद्यतन करने, नई परीक्षाएँ लिखने, पुराने परीक्षणों को हटाने आदि की निष्ठा के लिए मैं आधुनिक व्यावसायिक सॉफ्टवेयर विकास की लागत के हिस्से के रूप में देखता हूँ।

Comments

आपका पहला पैराग्राफ चरण 1 को अनदेखा करने और उसके जाते ही परीक्षण लिखने की वकालत करता प्रतीत होता है; आपका दूसरा पैराग्राफ इसके विपरीत प्रतीत होता है।

— पीडीआर

मेरे उत्तर को अपडेट किया।

— माइकल डुरंट

Answer 5

आपके विशिष्ट मामले में सुधार करने का लक्ष्य क्या है?

मेरे जवाब के साथ रखने के प्रयोजनों के लिए मान लें कि हम सभी (कुछ हद तक) TDD (टेस्ट-प्रेरित विकास) में विश्वास करते हैं।

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

• परीक्षण आपको यह सुनिश्चित करने में मदद करेंगे कि आपका नया काम वास्तव में काम करता है।

• परीक्षण शायद उन मामलों को भी उजागर करेंगे जहां मूल काम नहीं करता है।

लेकिन आप कुछ हद तक व्यवहार को प्रभावित किए बिना वास्तव में कोई महत्वपूर्ण रीफैक्टरिंग कैसे करते हैं ?

यहाँ कुछ चीजों की एक छोटी सूची है जो कि रिफैक्टरिंग के दौरान हो सकती हैं:

• नाम बदलें चर
• नाम बदलें समारोह
• फ़ंक्शन जोड़ें
• फ़ंक्शन हटाएं
• दो या अधिक कार्यों में विभाजित समारोह
• दो या अधिक फ़ंक्शन को एक फ़ंक्शन में संयोजित करें
• विभाजित वर्ग
• कक्षाओं को मिलाएं
• नाम बदलें वर्ग

मैं तर्क देने वाला हूं कि उन सूचीबद्ध गतिविधियों में से हर एक में किसी न किसी तरह से व्यवहार में बदलाव होता है।

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

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

इस परिदृश्य के बारे में कैसे:

• मान लो तुम्हारे पास है function bar()

• function foo() को फोन करता है bar()

• function flee() कार्य करने के लिए एक कॉल भी करता है bar()

• बस विविधता के लिए, flam()एक कॉल करता हैfoo()

• सब कुछ शानदार ढंग से (जाहिरा तौर पर, कम से कम) काम करता है।

• आप रिफ्लेक्टर ...

• bar() का नाम बदल दिया गया है barista()

• flee() कॉल करने के लिए बदल दिया गया है barista()

• foo()है नहीं कॉल करने के लिए बदलbarista()

जाहिर है, दोनों के लिए आपके परीक्षण foo()और flam()अब विफल।

हो सकता है कि आपको पहली बार में foo()बुलाया bar()गया हो। आपको निश्चित रूप से एहसास नहीं था कि flam()किस bar()तरह से निर्भर था foo()।

जो कुछ। मुद्दा यह है कि अपने परीक्षण दोनों के नव टूट व्यवहार को उजागर करेंगे foo()और flam(), अपने रिफैक्टरिंग काम के दौरान एक वृद्धिशील फैशन में।

परीक्षण अंत में आप रिफ्लेक्टर को अच्छी तरह से मदद करते हैं।

जब तक आपके पास कोई परीक्षण नहीं है।

यह एक मामूली उदाहरण है। ऐसे लोग हैं जो तर्क देते हैं कि यदि bar()विराम बदलते हैं foo(), तो foo()शुरू करने के लिए बहुत जटिल था और टूट जाना चाहिए। लेकिन प्रक्रियाएं एक कारण से अन्य प्रक्रियाओं को कॉल करने में सक्षम हैं और सभी जटिलता को समाप्त करना असंभव है , है ना? हमारा काम जटिलता को अच्छी तरह से प्रबंधित करना है।

दूसरे परिदृश्य पर विचार करें।

आप एक भवन का निर्माण कर रहे हैं।

आप यह सुनिश्चित करने में मदद करने के लिए मचान का निर्माण करते हैं कि भवन सही ढंग से बनाया गया है।

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

सादृश्य कठिन है, लेकिन मुद्दा यह है कि उत्पाद बनाने में आपकी सहायता करने के लिए उपकरण का निर्माण करना अनसुना नहीं है। यहां तक ​​कि अगर उपकरण स्थायी नहीं हैं, तो वे उपयोगी हैं (आवश्यक भी)। बढ़ई हर समय जिग्स बनाते हैं, कभी-कभी केवल एक नौकरी के लिए। फिर वे जिग्स को फाड़ देते हैं, कभी-कभी अन्य नौकरियों के लिए अन्य जिग्स बनाने के लिए भागों का उपयोग करते हैं, कभी-कभी नहीं। लेकिन यह जिग्स को बेकार या बेकार प्रयास नहीं करता है।