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




क्या निजी/संरक्षित तरीके इकाई परीक्षण के तहत होनी चाहिए? (8)

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

अब मेरा प्रश्न निजी और संरक्षित तरीकों के बारे में है जो मुझे इंटरफ़ेस द्वारा प्रकट विधियों / गुणों के समर्थन में मेरी कक्षा में लिखना पड़ सकता है:

  • क्या कक्षा में निजी तरीकों का अपना यूनिट परीक्षण होना चाहिए?

  • क्या कक्षा में संरक्षित तरीकों का अपना यूनिट परीक्षण होना चाहिए?

मेरे विचार:

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

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

  • यदि मेरा कोड-कवरेज यह नहीं दिखाता है कि संरक्षित / निजी तरीकों को हिट किया जा रहा है, तो मेरे पास सही यूनिट-टेस्ट नहीं हैं या मेरे पास कोड है जिसका उपयोग नहीं किया जा रहा है और इसे हटाया जाना चाहिए।


आप ने लिखा:

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

कृपया मुझे BDD भाषा में इसे BDD :

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

* एक वास्तविक Interface या कक्षा के बस सुलभ एपीआई हो सकता है, उदाहरण के लिए: रूबी में इंटरफेस नहीं है।

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

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

उम्मीद है की यह मदद करेगा!


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

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


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

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


नहीं! केवल इंटरफेस का परीक्षण करें।

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


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

इसलिए इन निजी तरीकों का परीक्षण उन परीक्षणों द्वारा किया जाता है जो आपके सार्वजनिक इंटरफेस के व्यवहार पर जोर देते हैं।

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


परीक्षण लिखने के दो कारण हैं:

  1. अपेक्षित व्यवहार का दावा करना
  2. व्यवहार के प्रतिगमन को रोकना

(1) अपेक्षित व्यवहार का दावा करना:

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

  • क्या मैंने अभी लिखा है काम करता है?
  • क्या यह पाश वास्तव में खत्म होता है?
  • क्या यह मुझे लगता है कि यह आदेश में लूपिंग है?
  • क्या यह एक शून्य इनपुट के लिए काम करेगा?

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

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

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

लेना (2) व्यवहार के प्रतिगमन को रोकना:

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

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

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

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

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

इसका क्या करें?

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

हां और ना।

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

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

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


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

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

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

आशा करता हूँ की ये काम करेगा!


मैं हर किसी के साथ सहमत हूं: आपके प्रश्न का उत्तर 'नहीं' है।

वास्तव में आप अपने दृष्टिकोण और अपने विचारों, विशेष रूप से कोड कवरेज के बारे में पूरी तरह से सही हैं।

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

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

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






tdd