क्या इकाई परीक्षण सफलतापूर्वक एक मौजूदा उत्पादन परियोजना में जोड़ा जा सकता है? यदि हां, तो यह कैसे और इसके लायक है?


140

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

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

क्या ऐसी कोई प्रक्रिया / कदम हैं जिनका पालन किया जाना चाहिए ताकि यह सुनिश्चित हो सके कि एक मौजूदा समाधान ठीक से परीक्षण की गई इकाई है या नहीं? मैं यह कैसे सुनिश्चित कर सकता हूं कि परीक्षण एक अच्छी गुणवत्ता के हैं और किसी भी परीक्षा का सिर्फ एक मामला नहीं परीक्षणों से बेहतर है

तो मुझे लगता है कि मैं जो पूछ रहा हूं वह भी है;

  • क्या यह उत्पादन में मौजूद मौजूदा समाधान के प्रयास के लायक है?
  • क्या इस परियोजना के लिए परीक्षण को अनदेखा करना और इसे भविष्य के संभावित पुन: लिखना में जोड़ना बेहतर होगा?
  • क्या अधिक लाभकारी होगा; कुछ हफ़्ते जोड़ने परीक्षण या कुछ हफ़्ते जोड़ने कार्यक्षमता खर्च कर रहे हैं?

(स्पष्ट रूप से तीसरे बिंदु का उत्तर पूरी तरह से इस बात पर निर्भर करता है कि आप प्रबंधन या डेवलपर से बात कर रहे हैं)


बाउंटी का कारण

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

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


11
इस विषय पर माइकल
फ़ेबर्स

1
@ मर्क - धन्यवाद, यह मेरे द्वारा दिए गए लिंक में है। मैं एक और पुस्तक खरीदने के बिना एक सभ्य जवाब पाने की उम्मीद कर रहा था ... हालांकि आपके पास कभी भी बहुत अधिक किताबें नहीं हो सकती हैं (जब तक कि आप ऐसा काम नहीं करना चाहते हैं)।
djdd87

1
आपको वास्तव में इस पुस्तक को पढ़ने की आवश्यकता है :) यह मेरे पसंदीदा में से एक है और वास्तव में रिफैक्टिंग और स्वचालित-परीक्षण के बीच तनाव को समझने में मदद करता है।
मैनुएल अलदाना

जवाबों:


177

मैंने यूनिट परीक्षणों को कोड बेस के लिए पेश किया है जो पहले नहीं था। आखिरी बड़ी परियोजना जिसमें मैं शामिल था, जहां मैंने ऐसा किया था, जब मैं टीम में आया तो उत्पाद पहले से ही शून्य इकाई परीक्षणों के साथ उत्पादन में था। जब मैंने छोड़ा - 2 साल बाद - हमारे पास 4500+ या तो परीक्षण थे जो 230 बेस + प्रोडक्शन एलओसी (रियल टाइम फाइनेंशियल विन-फॉर्म एप्लीकेशन) के साथ कोड बेस में 33% कोड कवरेज के लिए उपज थे। यह कम लग सकता है, लेकिन परिणाम कोड गुणवत्ता और दोष दर में एक महत्वपूर्ण सुधार था - साथ ही मनोबल और लाभप्रदता में सुधार हुआ।

यह तब किया जा सकता है जब आपके पास शामिल दलों से सटीक समझ और प्रतिबद्धता दोनों होती है।

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

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

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

अब, अपनी टिप्पणियों और सवालों के लिए:

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

संक्षिप्त उत्तर: हां, आप परीक्षण से चूक जाएंगे और हाँ वे शुरू में यह नहीं देख सकते हैं कि उनके पास हरे क्षेत्र की स्थिति में क्या होगा।

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

अब, यहाँ की पंक्तियों के बीच में पढ़ने से मुझे यह आभास होता है कि यह "कार्रवाई न करने के बहाने के रूप में पूर्णता" की मानसिकता से आ रही है। एक बेहतर मानसिकता आत्म विश्वास पर ध्यान केंद्रित करना है। तो जैसा कि आप जानते हैं कि यह कैसे करना है, यह अभी तक पता नहीं चलेगा कि आप कैसे जाते हैं और रिक्त स्थान को भरते हैं। इसलिए, चिंता करने का कोई कारण नहीं है।

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

अच्छी खबर यह है कि जैसे-जैसे महीने (और यहां तक ​​कि साल) बीतते हैं, आपका कोड धीरे-धीरे "उचित" अच्छी तरह से फैक्टरेड और अच्छी तरह से जांचा जाने वाला कोड बनने लगेगा।

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

क्या ऐसी कोई प्रक्रिया / कदम हैं जिनका पालन किया जाना चाहिए ताकि यह सुनिश्चित किया जा सके कि एक मौजूदा समाधान ठीक से परीक्षण की गई इकाई है या नहीं?

जब तक आपके पास पहले से ही है, एक बिल्ड सर्वर सेट करें और एक निरंतर एकीकरण बिल्ड सेट करें जो कोड कवरेज के साथ सभी यूनिट परीक्षणों सहित हर चेकइन पर चलता है।

अपने लोगों को प्रशिक्षित करें।

कहीं से शुरू करें और ग्राहक के दृष्टिकोण से प्रगति करते हुए परीक्षण जोड़ना शुरू करें (नीचे देखें)।

कोड कवरेज का उपयोग इस बात के मार्गदर्शक संदर्भ के रूप में करें कि आपके उत्पादन कोड का कितना आधार परीक्षण के तहत है।

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

निरीक्षण और अनुकूलन।

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

आपका अपना निर्णय वास्तविकता का आपका प्राथमिक स्रोत होना चाहिए। कोई मीट्रिक नहीं है जो कौशल को बदल सकती है।

यदि आपके पास वह अनुभव या निर्णय नहीं है, तो किसी ऐसे व्यक्ति को अनुबंधित करने पर विचार करें।

दो मोटे माध्यमिक संकेतक कुल कोड कवरेज और बिल्ड गति हैं।

क्या यह एक मौजूदा समाधान के लिए प्रयास के लायक है जो उत्पादन में है?

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

क्या इस परियोजना के लिए परीक्षण को अनदेखा करना और इसे भविष्य के संभावित पुन: लिखना में जोड़ना बेहतर होगा?

आपको न केवल लोगों और कौशल में निवेश, बल्कि सबसे महत्वपूर्ण स्वामित्व की कुल लागत और सिस्टम के अपेक्षित जीवन समय को ध्यान में रखना होगा।

मेरा व्यक्तिगत जवाब अधिकांश मामलों में "हां हां" होगा, क्योंकि मुझे पता है कि यह सिर्फ इतना बेहतर है, लेकिन मैं मानता हूं कि कुछ अपवाद हो सकते हैं।

क्या अधिक लाभकारी होगा; कुछ हफ़्ते जोड़ने परीक्षण या कुछ हफ़्ते जोड़ने कार्यक्षमता खर्च कर रहे हैं?

न तो। आपका दृष्टिकोण आपके कोड आधार पर परीक्षण जोड़ने का होना चाहिए जब आप कार्यक्षमता के मामले में प्रगति कर रहे हों।

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

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

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

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

उम्मीद है की वो मदद करदे


मेरे जैसी ही मानसिकता को दर्शाता है। वर्तमान में मैं एक बड़े JAVA एप्लिकेशन में परीक्षण मामलों को पेश करने के लिए इस सटीक प्रक्रिया / विधि को दिखाने की प्रक्रिया में हूं। :)
दर्शन जोशी

3
यह किसी भी विषय पर सबसे अच्छा व्यक्त किया गया उत्तर है जो मैंने कभी स्टाकेवरफ्लो पर पढ़ा है। बहुत बढ़िया! यदि आपने ऐसा नहीं किया है, तो मैं आपसे अंतिम प्रश्न के उत्तर पर एक पुस्तक लिखने पर विचार करने का आग्रह करूंगा।
योर्मो लैमर्स

शुक्रिया यारमो। मुझे यकीन नहीं है कि मेरे पास किताब लिखने का समय है। लेकिन शायद मैं एक ब्लॉग लेख या दो लिख सकता था। बस अपना नया ब्लॉग शुरू कर रहा हूं, इसलिए थोड़ी देर हो सकती है।
माहोल

2
यह दोस्तों यूनिट परीक्षण सलाह सामान्य जीवन सलाह है। गंभीरता से।
Wjdavis5

24
  • क्या यह एक मौजूदा समाधान के लिए प्रयास के लायक है जो उत्पादन में है?

हाँ!

  • क्या इस परियोजना के लिए परीक्षण को अनदेखा करना और इसे भविष्य के संभावित पुन: लिखना में जोड़ना बेहतर होगा?

नहीं!

  • क्या अधिक लाभकारी होगा; कुछ हफ़्ते जोड़ने परीक्षण या कुछ हफ़्ते जोड़ने कार्यक्षमता खर्च कर रहे हैं?

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

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

फिर अपने बग डेटाबेस में प्रत्येक मौजूदा बग के लिए एक परीक्षण में रखें जो बग को ठीक से प्रेरित करता है और जो बग तय होने पर पास होगा। फिर उन कीड़े को ठीक करें! :-)

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


विस्तृत प्रतिक्रिया के लिए धन्यवाद। मुझे जो महसूस हो रहा था, उसकी पुष्टि की। देखेंगे कि मेरे वोट डालने से पहले और क्या जवाब मिलते हैं, हालांकि स्वीकार करते हैं।
djdd87

15

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

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


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

13

मैं इस बात से सहमत हूं कि बाकी सभी ने क्या कहा है। मौजूदा कोड में परीक्षण जोड़ना मूल्यवान है। मैं उस बिंदु से कभी असहमत नहीं होऊंगा, लेकिन मैं एक चेतावनी जोड़ना चाहूंगा।

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

  • आपको उस सभी कोड को परीक्षण के तहत रखने में कितना समय लगेगा? दिन? सप्ताह? महीने? वर्षों?
  • आप इस कोड को किसके लिए लिख रहे हैं? ग्राहकों का भुगतान? एक प्राध्यापक? एक खुला स्रोत परियोजना?
  • आपका कार्यक्रम की तरह का है? क्या आपके पास कठिन समय सीमाएं हैं जिन्हें आपको पूरा करना चाहिए? क्या आपके पास कोई समय सीमा है?

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

  • आपके द्वारा लिखा गया कोई भी नया कोड पूरी तरह से यूनिट टेस्ट के तहत होना चाहिए
  • कोई भी पुराना कोड जिसे आप टच करना चाहते हैं (बग फिक्स, एक्सटेंशन आदि) को यूनिट टेस्ट के तहत रखा जाना चाहिए

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

संपादित करें:

मैं इस सवाल को बाद में पेशेवरों और प्रयासों के साथ लिखने का प्रयास कर रहा हूं और प्रबंधन को दिखाने के लिए कि यह उत्पाद के भविष्य के विकास को TDD पर ले जाने में आदमी के घंटे खर्च करने लायक है।

यह पूछने की तरह है "स्रोत नियंत्रण का उपयोग करने के लिए पेशेवरों और विपक्ष क्या हैं?" या "लोगों को काम पर रखने से पहले उनका साक्षात्कार करने के लिए क्या पेशेवरों और विपक्ष हैं?" या "सांस लेने के लिए पेशेवरों और विपक्ष क्या हैं?"

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


9

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

पहले चीजों में से एक हमने (एक निरंतर बिल्ड सर्वर स्थापित करने के बाद) प्रतिगमन परीक्षण जोड़ना था। ये एंड-टू-एंड टेस्ट थे।

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

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

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

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

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


8

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

यदि आप ऐसे परीक्षण लिखते हैं जो आपके द्वारा जोड़ी जा रही कार्यक्षमता को संशोधित या संशोधित करते हैं, तो आपको तत्काल लाभ मिलेगा। यदि आप फिर से लिखने की प्रतीक्षा करते हैं, तो आपके पास कभी भी स्वचालित परीक्षण नहीं हो सकते हैं।

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


6

मैं अपनी आवाज जोड़ूंगा और हां कहूंगा, यह हमेशा उपयोगी है!

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

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

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

छोटी इकाइयों के ब्लैक-बॉक्स और यूनिट परीक्षण भी उपयोगी होते हैं, लेकिन यदि आपका समय सीमित है, तो उन्हें जल्दी जोड़ना बेहतर है। जब तक आप शिपिंग कर रहे होते हैं, तब तक आप आमतौर पर किनारे के मामलों और समस्याओं के अधिकांश (कठिन तरीके से) मिल जाते हैं जो इन परीक्षणों को मिला होगा।

दूसरों की तरह, मैं भी आपको TDD के बारे में दो सबसे महत्वपूर्ण बातें याद दिलाऊंगा:

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

4

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

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

आपके तीसरे प्रश्न के लिए मेरा उत्तर पहले जैसा है: यह आपकी परियोजना के संदर्भ पर निर्भर करता है।

आपके पोस्ट के भीतर एंबेडेड यह सुनिश्चित करने के बारे में एक और सवाल है कि किसी भी रेट्रो-फिटेड परीक्षण को ठीक से किया गया है । यह सुनिश्चित करने के लिए महत्वपूर्ण बात यह है कि इकाई परीक्षण वास्तव में इकाई परीक्षण हैं, और यह (अधिक बार नहीं) का मतलब है कि रेट्रोफिटिंग परीक्षणों को आपकी परतों / घटकों (cf. निर्भरता इंजेक्शन) को नियंत्रित करने की अनुमति देने के लिए मौजूदा कोड को फिर से भरना आवश्यक है; नियंत्रण का उलटा; मजाक)। यदि आप इसे लागू करने में विफल रहते हैं तो आपके परीक्षण एकीकरण परीक्षण बन जाते हैं, जो कि उपयोगी इकाई परीक्षणों की तुलना में उपयोगी, लेकिन कम लक्षित और अधिक भंगुर होते हैं।


4

आप कार्यान्वयन भाषा का उल्लेख नहीं करते हैं, लेकिन यदि जावा में है तो आप इस दृष्टिकोण की कोशिश कर सकते हैं:

  1. सेपरेट सोर्स ट्री बिल्ड रिग्रेशन या 'स्मोक' परीक्षणों में, उन्हें उत्पन्न करने के लिए एक उपकरण का उपयोग करते हुए, जो आपको 80% कवरेज के करीब मिल सकता है। ये परीक्षण सभी कोड लॉजिक पथ निष्पादित करते हैं, और उस बिंदु से सत्यापित करते हैं कि कोड अभी भी वही करता है जो वर्तमान में करता है (भले ही बग मौजूद हो)। यह आपको अनजाने में बदलते व्यवहार के खिलाफ एक सुरक्षा जाल देता है जब हाथ से कोड को आसानी से परीक्षण योग्य बनाने के लिए आवश्यक रीफैक्टरिंग करता है।

    • उत्पाद का सुझाव - मैं मुफ्त वेब आधारित उत्पाद जूनिट फैक्टरी का उपयोग करता था, लेकिन दुख की बात है कि यह अब बंद हो गया है। हालाँकि उत्पाद http://www.agitar.com/solutions/products/automated_junit_generation.html पर व्यावसायिक रूप से लाइसेंस प्राप्त AgitarOne JUnit जेनरेटर में रहता है
  2. प्रत्येक बग जिसे आप ठीक करते हैं, या आप अभी से जोड़ते हैं, के लिए TDD दृष्टिकोण का उपयोग करके यह सुनिश्चित करें कि नया कोड परीक्षण योग्य बनाया गया है और इन परीक्षणों को सामान्य परीक्षण स्रोत ट्री में रखें।

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

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

  5. जब फिक्सिंग बग एक असफल इकाई परीक्षण लिखते हैं जो पहले बग को उजागर करता है।


3

मैं यह कहकर इस उत्तर को शुरू करना चाहूंगा कि इकाई परीक्षण वास्तव में महत्वपूर्ण है क्योंकि इससे आपको उत्पादन में रेंगने से पहले बग को गिरफ्तार करने में मदद मिलेगी।

उन क्षेत्रों परियोजनाओं / मॉड्यूल की पहचान करें जहां बग्स को फिर से पेश किया गया है। परीक्षण लिखने के लिए उन परियोजनाओं के साथ शुरू करें। यह पूरी तरह से नई कार्यक्षमता के लिए और बग फिक्स के लिए परीक्षण लिखने के लिए समझ में आता है।

क्या यह एक मौजूदा समाधान के लिए प्रयास के लायक है जो उत्पादन में है?

हाँ। आपको बग्स का प्रभाव कम होता जाएगा और रखरखाव आसान हो जाएगा

क्या इस परियोजना के लिए परीक्षण को अनदेखा करना और इसे भविष्य के संभावित पुन: लिखना में जोड़ना बेहतर होगा?

मैं अगर अभी से शुरू करने की सलाह दूंगा।

क्या अधिक लाभकारी होगा; कुछ हफ़्ते जोड़ने परीक्षण या कुछ हफ़्ते जोड़ने कार्यक्षमता खर्च कर रहे हैं?

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


3

मैं Refactor के बहुत शौक़ीन हूँ , कम-लटकने वाले फलों को इस सवाल के जवाब के रूप में कि जहाँ से रिफैक्टरिंग शुरू करना है। यह एक बेहतर तरीका है कि आप जितना चबा सकते हैं उससे ज्यादा काटे बिना बेहतर डिजाइन में ढील दें।

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


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

2

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

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


2

क्या यह एक मौजूदा समाधान के लिए प्रयास के लायक है जो उत्पादन में है?
हाँ। लेकिन आपको आरंभ करने के लिए सभी इकाई परीक्षणों को लिखने की आवश्यकता नहीं है। बस उन्हें एक-एक करके जोड़ना है।

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

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


2

अपडेट करें

मूल उत्तर के 6 साल बाद, मुझे थोड़ा अलग लेना है।

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

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

पहले जवाब दो

Im यहाँ कुछ भौहें बढ़ाने जा रहा है :)

सबसे पहले आपकी परियोजना क्या है - यदि यह एक संकलक या एक भाषा या एक रूपरेखा या कुछ और है जो लंबे समय तक कार्यात्मक रूप से बदलने नहीं जा रहा है, तो मुझे लगता है कि इकाई परीक्षणों को जोड़ने के लिए इसका बिल्कुल शानदार है।

हालाँकि, यदि आप एक ऐसे अनुप्रयोग पर काम कर रहे हैं जो संभवतः कार्यक्षमता में परिवर्तन की आवश्यकता है (बदलती आवश्यकताओं के कारण) तो उस अतिरिक्त प्रयास को लेने का कोई मतलब नहीं है।

क्यों?

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

  2. यूनिट परीक्षण लागत समय! अब मैं जहां से आता हूं, वह एक कीमती वस्तु है - और व्यापार आम तौर पर एक पूर्ण परीक्षण सूट पर बेहतर कार्यक्षमता रखता है।

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

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

क्या अधिक लाभकारी होगा; कुछ हफ़्ते जोड़ने परीक्षण या कुछ हफ़्ते जोड़ने कार्यक्षमता खर्च कर रहे हैं? - बहुत सारी चीजें हैं जो आप परीक्षण लिखने से बेहतर कर सकते हैं - नई कार्यक्षमता लिखें, प्रदर्शन में सुधार करें, प्रयोज्यता में सुधार करें, बेहतर सहायता मैनुअल लिखें, लंबित कीड़े को हल करें, आदि आदि।

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


और मैं आपसे इसे पढ़ने का आग्रह करता हूं - joelonsoftware.com/items/2009/01/31.html
रूपेश शेनॉय

क्या आप 'लंबित बग' को ठीक करना पसंद करेंगे या उन्हें उत्पन्न होने से रोकेंगे? बग फिक्सिंग पर खर्च किए गए समय की मात्रा को कम करके उचित इकाई परीक्षण समय की बचत करता है।
इहर कहारलिचेंको

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

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

1

इसकी संभावना नहीं है कि आपके पास कभी महत्वपूर्ण परीक्षण कवरेज होगा, इसलिए आप जहाँ आप परीक्षण जोड़ते हैं, उसके बारे में आपको ज़रूर रणनीति होनी चाहिए:

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

OTOH, यह कोड के चारों ओर केवल परीक्षण लिखने के लायक नहीं है, जिससे लोग खुश हैं - खासकर अगर कोई इसे संशोधित करने वाला नहीं है। यह सिर्फ मूल्य नहीं जोड़ता (सिवाय सिस्टम के व्यवहार को समझने के)।

सौभाग्य!



1

यदि मैं आपकी जगह पर होता, तो शायद मैं पूरे सिस्टम को एक्सरसाइज करने वाले फंक्शनल टेस्ट्स से शुरू होकर एक आउट-इन एप्रोच लेता। मैं RSDec जैसी BDD विनिर्देश भाषा का उपयोग करके सिस्टम की आवश्यकताओं को फिर से दस्तावेज करने की कोशिश करूंगा, और फिर उपयोगकर्ता इंटरफ़ेस को स्वचालित करके उन आवश्यकताओं को सत्यापित करने के लिए परीक्षण लिखूंगा।

फिर मैं नए खोजे गए बगों के लिए संचालित विकास को दोष दूंगा, समस्याओं को पुन: पेश करने के लिए इकाई परीक्षण लिख रहा हूं और परीक्षण पास होने तक बग पर काम कर रहा हूं।

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

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


1

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

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

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

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

वहां से, मुझे आपके बिल्ड सर्वर या आपके पास जो भी स्वचालन है, वह कोड कवरेज टूल के साथ कॉन्फ़िगर किया गया है। वे बड़े लाल क्षेत्रों के साथ बुरा बार ग्राफ बनाते हैं जहां आपके पास खराब कवरेज है। अब 100% कवरेज आपका लक्ष्य नहीं है, न ही 100% कवरेज का मतलब यह होगा कि आपका कोड बुलेटप्रूफ है, लेकिन लाल बार निश्चित रूप से मेरे पास खाली समय होने पर मुझे प्रेरित करता है। :)


1

बहुत सारे अच्छे जवाब हैं इसलिए मैं उनकी सामग्री को नहीं दोहराऊंगा। मैंने आपकी प्रोफ़ाइल की जाँच की और ऐसा लगता है कि आप C # .NET डेवलपर हैं। उसके कारण मैं Microsoft PEX और मोल्स प्रोजेक्ट का संदर्भ जोड़ रहा हूं जो आपको विरासत कोड के लिए ऑटोगेनेरेटिंग यूनिट परीक्षणों में मदद कर सकता है। मुझे पता है कि ऑटोजेनरेशन सबसे अच्छा तरीका नहीं है, लेकिन कम से कम यह शुरुआत करने का तरीका है। विरासत कोड के लिए PEX का उपयोग करने के बारे में MSDN पत्रिका के इस बहुत ही दिलचस्प लेख की जाँच करें ।


1

मेरा सुझाव है कि एक TopTal Engineer द्वारा एक शानदार लेख को पढ़ना , जो बताता है कि कहाँ है परीक्षण से शुरू करना है: इसमें बहुत सारे गणित शामिल हैं, लेकिन मूल विचार यह है:

1) अपने कोड के प्रतिरूप युग्मन (CA) को मापें ( एक वर्ग का अन्य वर्गों द्वारा कितना उपयोग किया जाता है, इसका अर्थ है कि इसे तोड़ने से व्यापक नुकसान होगा)

2) अपने कोड के साइक्लोमैटिक जटिलता (CC) (उच्च जटिलता = ब्रेकिंग का उच्च परिवर्तन ) को मापें

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

क्यों? क्योंकि एक उच्च सीए लेकिन बहुत कम सीसी कक्षाएं बहुत महत्वपूर्ण हैं लेकिन टूटने की संभावना नहीं है। दूसरी ओर, कम सीए लेकिन उच्च सीसी के टूटने की संभावना है, लेकिन कम नुकसान होगा। इसलिए आप संतुलन चाहते हैं।


0

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


-2

हाँ। नहीं, परीक्षण जोड़ना।

अधिक टीडीडी दृष्टिकोण की ओर जाने से वास्तव में नई कार्यक्षमता जोड़ने और प्रतिगमन परीक्षण को बहुत आसान बनाने के आपके प्रयासों को बेहतर ढंग से सूचित किया जा सकेगा। इसकी जांच - पड़ताल करें!

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.