unit-testing - vbg - यूनिट टेस्ट क्या है




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

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

हाँ!

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

नहीं!

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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

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

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


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

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

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

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


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


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


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

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

2) अपने कोड की चक्रवात जटिलता (सीसी) को मापें (उच्च जटिलता = तोड़ने का उच्च परिवर्तन)

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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


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

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


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

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


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

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


अद्यतन करें

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

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

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

पहले जवाब

मैं यहाँ कुछ भौहें उठाने जा रहा हूँ :)

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

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

क्यूं कर?

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

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

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

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

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

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


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

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

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


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






tdd