क्या इस मामले में प्रति परीक्षण मूर्खता की निरंतरता का पालन करना है?

Question

मेरे पास एक वर्ग है जो मैं परीक्षण कर रहा हूं। कक्षा में एक समारोह है:apply(List<IRule> rules, List<ITarget> targets);

एक परीक्षण में मैं यह सुनिश्चित करना चाहता हूं कि प्रत्येक लक्ष्य को एक नियम, एक ला में पारित किया गया है:

rule1.AssertWasCalled(fnord => fnord.Test(target1));
rule1.AssertWasCalled(fnord => fnord.Test(target2));
rule1.AssertWasCalled(fnord => fnord.Test(target3));

यह मुझे लगता है कि एक ही कथन के लिए खुद को सीमित करना काफी शौकीन होगा । क्या मैं इस धारणा में सही हूं, या क्या कोई और तरीका है जिससे मैं यह दावा कर सकता हूं कि प्रत्येक लक्ष्य का वास्तव में परीक्षण किया गया था?

Comments

मैं fnords देख सकते हैं!

— रॉस पैटरसन

Answer 1

तीन मुखर सार एक परीक्षण में हैं। आप एक संग्रह पर एक विधि के व्यवहार का परीक्षण कर रहे हैं, यह सुनिश्चित करने के लिए कि प्रत्येक आइटम एक विशिष्ट कॉल के लिए एक पैरामीटर है (यानी प्रत्येक आइटम को ठीक से संसाधित किया गया है)।

डेटा को तीन बार और तीन अलग-अलग तरीकों से सेट करना कई जोर देने के विकल्प की तुलना में बेकार और कम पठनीय है।

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

Comments

वास्तव में: नियम प्रति यूनिट टेस्ट एक से अधिक तार्किक अभिकथन है। आप उन लोगों को एक उच्च स्तर में वर्गीकृत कर सकते हैं जिन्हें आप विभिन्न परीक्षणों में पुन: उपयोग कर सकते हैं।

— लॉरेंट बोर्गुल्ट-रॉय

Answer 2

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

आपके मामले में, मुझे लगता है कि तीन बार जोर देना ठीक है। यदि आप अपने कोड को अधिक पठनीय बनाना चाहते हैं, तो आप उन तीन आवेषणों को नाम विधि में निकाल सकते हैं assertWasCalledOnTargets(...)।

Answer 3

अपने विशेष उदाहरण के लिए, यदि आप कुछ ऐसा करते हैं, तो आप "एक" कथन के साथ भाग सकते हैं:

foreach target in targets
{
     rule1.AssertWasCalled(fnord => fnord.Test(target))
}

यह वही है जो मैं एक परीक्षण में कई जोर देने के बारे में दोषी महसूस करने से बचने के लिए करता हूं।

Comments

मैंने पहले भी ऐसा किया है। जाने का बुरा तरीका नहीं। यह पढ़ना आसान है, और आप इसकी प्रकृति को समझ सकते हैं कि यह क्या कर रहा है।

— कोकोबो

Answer 4

मैंने इस एक के साथ भी संघर्ष किया है।

शुद्धतावादी (मुझ में) प्रति परीक्षण एक जोर पर जोर देता है तो मुझे पता चलेगा कि वास्तव में * जहां चीजें उड़ गईं।

और फिर मैं खुद को एक ही, अनावश्यक परीक्षण सेटअप कोड को काटने / चिपकाने के लिए पाता हूं। इस की तीसरी या चौथी परत के बाद, आप कहना शुरू करते हैं "ओए! बस!"

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

Comments

आपको जांच करनी चाहिए Assume। मैंने आज ही इसके बारे में जाना।

— वेन वर्नर

Answer 5

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

यदि प्रत्येक लक्ष्य के लिए सेटअप कोड अनिवार्य रूप से समान है, तो आपके परीक्षण को कई अलग-अलग परीक्षणों में विभाजित करना संभवतः ओवरकिल है।

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