हम यूनिट टेस्ट कैसे तेज चलाते हैं?


40

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

मेरा मानना ​​है कि यह समस्या इस तथ्य के कारण है कि समाधान 120 परियोजनाओं तक बढ़ गया है (हम आमतौर पर बहुत छोटी परियोजनाएं करते हैं और यह केवल दूसरी बार है जब हम टीडीडी को ठीक से करते हैं) और बिल्ड + परीक्षण का समय लगभग दो-तीन मिनट तक बढ़ गया है कम मशीनों पर।

हम परीक्षणों के रन समय को कम कैसे करते हैं? क्या तकनीकें हैं? और अधिक? कम कम? हो सकता है कि सभी परीक्षण चलाते समय बड़े एकीकरण परीक्षण स्वचालित रूप से न चलें?

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


8
बेहतर हार्डवेयर प्राप्त करें? प्रोग्रामर समय की तुलना में हार्डवेयर सस्ता है।
ब्रायन ओकले

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

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

13
धिक्कार है, काश हमारे टेस्ट केवल 2-3 मिनट के होते। हमारे सभी यूनिट परीक्षणों को चलाने के लिए, इसमें 25 मिनट लगते हैं - और हमारे पास अभी तक कोई एकीकरण परीक्षण नहीं है।
इज़काता

4
2 से 3 मिनट? चीज़। हमारा समय चल सकता है ...
फ्रोजन मटर की

जवाबों:


51

एक संभव समाधान विकास मशीनों से परीक्षण के भाग को एक निरंतर एकीकरण सेटअप ( उदाहरण के लिए जेनकिंस ) में स्थानांतरित करने के लिए होगा , कुछ स्वाद ( गिट , svn , आदि ...) के संस्करण नियंत्रण सॉफ्टवेयर का उपयोग करते हुए ।

जब नया कोड लिखना होगा तो दिए गए डेवलपर रिपॉजिटरी में जो कुछ भी कर रहे हैं उसके लिए एक शाखा बनाएंगे। इस शाखा में सभी कार्य किए जाएंगे और वे किसी भी समय कोड की मुख्य लाइन को गड़बड़ किए बिना शाखा में अपने परिवर्तन कर सकते हैं।

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

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

इस तरह के सेटअप को करने के एक तरीके के लिए एक महान मार्गदर्शक यहां पाया जा सकता है (git विशिष्ट लेकिन अन्य संस्करण नियंत्रण प्रणालियों के लिए काम करना चाहिए): http://nvie.com/posts/a-successful-git-branching-model/


15
यह। यदि डेवलपर्स "में चेक करने से पहले उन्हें (यूनिट परीक्षण) चलाने से परेशान करना बंद कर देते हैं, तो आप चाहते हैं कि आपका CI सेटअप चेक के बाद उन्हें चला रहा हो ।
कार्सन63000

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

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

मुझे टीएफएस के साथ काम करने का कोई व्यक्तिगत अनुभव नहीं है; हालाँकि, मैं Microsoft से इस गाइड पर आने में सक्षम था, जो पोस्ट में किसी एक को सिमेरिलर ब्रांचिंग की रणनीति दिखाता है: msdn.microsoft.com/en-us/magazine/gg598921.aspx
माइक

33

यूनिट टेस्ट के बहुमत प्रत्येक या तो 10 मिलीसेकंड के तहत लेना चाहिए। बीत रहा है 'लगभग एक हजार परीक्षण' है कुछ भी नहीं है और ले जाना चाहिए शायद चलाने के लिए कुछ ही सेकंड।

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


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

2
आपका सही है कि ये एकीकरण परीक्षण प्रतीत होते हैं।
टॉम स्क्वायर्स

9
यह उत्तर उत्पादक नहीं है। सबसे पहले, यह एक अनुचित अपेक्षा निर्धारित करता है। यूनिट टेस्टिंग फ्रेमवर्क में ही ओवरहेड्स होते हैं; प्रत्येक परीक्षण में एक मिलीसेकंड से कम का समय नहीं लगता है, एक हजार परीक्षण में कुछ सेकंड से कम समय लेना चाहिए। ओपी का पूरा परीक्षण 2-3 मिनट में पूरा करना एक बहुत अच्छा संकेत है, अधिकांश उपायों के द्वारा।
rwong

6
@rwong - माफ करना, मैं बुलबुल को फोन करता हूं। मुझे जो मीट्रिक मिली, वह मेरे लिए उपलब्ध दो अलग-अलग व्यावसायिक परियोजनाओं को चलाने से थी: एक ~ 300 परीक्षणों के साथ, एक ~ 30000 परीक्षणों के साथ और परीक्षण रनटाइम को देखते हुए। <1000 परीक्षणों के लिए 2-3 मिनट लगने वाला एक परीक्षण सूट अत्याचारी और एक संकेत है कि परीक्षण पर्याप्त रूप से पृथक नहीं हैं।
तैलस्टिन

2
@rwong Telastyn के समान नस में, यहां मेरा एक डेटा बिंदु है: यहां तक ​​कि कुछ बड़े-से-आदर्श परीक्षणों के साथ, परीक्षण रूपरेखा ( py.test) पृष्ठभूमि में जादू कर रही है, और सब कुछ शुद्ध पायथन कोड ("100x) है। C "की तुलना में धीमा), मेरा एक प्रोजेक्ट में लगभग 500 परीक्षण चल रहा है, कई साल पुरानी धीमी नेटबुक पर 6 सेकंड से भी कम समय लगता है। यह आंकड़ा परीक्षणों की संख्या में लगभग रैखिक है; जबकि कुछ स्टार्ट-अप ओवरहेड है, यह सभी परीक्षणों से अधिक परिशोधित है, और प्रति-परीक्षण ओवरहेड हे (1) है।

16

इसी तरह की समस्या को हल करने के लिए मैंने कई दृष्टिकोणों का उपयोग किया है:

  1. निष्पादन समय की जांच करें, और सभी सबसे धीमे परीक्षणों को ढूंढें और फिर विश्लेषण करें कि उन्हें निष्पादित करने में इतना समय क्यों लगता है
  2. आपके पास 100 परियोजनाएं हैं, क्या आपको हर बार उन्हें बनाने और परीक्षण करने की आवश्यकता नहीं होगी? क्या आप सभी एक रात में केवल एक ही समय पर निर्माण कर सकते हैं? दैनिक उपयोग के लिए कई 'फास्ट' बिल्ड कॉन्फ़िगरेशन बनाएं । CI सर्वर आपके वर्तमान विकास प्रक्रिया के 'हॉट' भागों से संबंधित केवल एकरहित परियोजनाओं का सीमित प्रदर्शन करेगा ।
  3. जब भी संभव हो मॉक और अलग करें , डिस्क / नेटवर्क I / O से बचें
  4. जब इस तरह के ऑपरेशन को अलग करना संभव नहीं है, तो क्या आपके पास एकीकरण परीक्षण हो सकते हैं? क्या आप केवल रात के निर्माण के लिए एकीकरण परीक्षण शेड्यूल कर सकते हैं ?
  5. सभी सामयिक सिंग्लेटों की जाँच करें, जो उदाहरणों / संसाधनों का संदर्भ रखते हैं और जो स्मृति का उपभोग करते हैं, इससे अन्य परीक्षण चलाते समय प्रदर्शन में गिरावट आ सकती है।

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

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

12

0. अपने प्रोग्रामर को सुनो।

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

1. अपने परीक्षणों को 100% विश्वसनीय बनाएं।

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

2. अपने सिस्टम को यह गारंटी देने के लिए बदलें कि सभी परीक्षण हर समय गुजरते हैं।

निरंतर एकीकरण प्रणाली का उपयोग यह सुनिश्चित करने के लिए करें कि केवल पासिंग कमिट मुख्य / आधिकारिक / रिलीज / जो भी शाखा में विलय हो जाए।

3. 100% पासिंग टेस्ट को महत्व देने के लिए अपनी संस्कृति को बदलें।

100% परीक्षण पास होने तक एक सबक सिखाएं जो "किया" नहीं गया है और इसे मुख्य / आधिकारिक / रिलीज / जो भी शाखा में विलय कर दिया गया है।

4. परीक्षण तेज करें।

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

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

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

परीक्षण तेज करना कठिन हो सकता है (यह वही है जो ओपी ने पूछा है, ठीक है!)। Decoupling कुंजी है। मोक्स / फेक ठीक हैं, लेकिन मुझे लगता है कि आप नकली / फेक को अनावश्यक बनाने के लिए बेहतर बना सकते हैं। देखें Arlo Belshee का ब्लॉग, http://arlobelshee.com/post/the-no-mocks-book से शुरू ।

5. परीक्षण उपयोगी बनाएं।

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


2
पूरी तरह से सहमत हैं, विशेष रूप से 3 और 1 बिंदु। यदि डेवलपर्स परीक्षण नहीं चला रहे हैं, तो परीक्षण टूट गए हैं, पर्यावरण टूट गया है, या दोनों। बिंदु 1 न्यूनतम है। लापता परीक्षण की तुलना में झूठी विफलताएं बदतर हैं। क्योंकि लोग असफल होना सीख जाते हैं। एक बार विफलता को सहन करने के बाद, यह फैलता है, और यह 100% पास होने और 100% पास होने के लिए वापस लाने के लिए एक शक्तिशाली प्रयास लेता है। इसे आज ही ठीक करना शुरू करें ।
बिल IV

और आप संभवतः # 5 से कैसे सहमत नहीं हो सकते? 1 और 3 के अलावा, या बिल्ली, 2 और 4, भी! वैसे भी, चारों ओर महान जवाब।
चारपश्चमी की रात

4

यूनिट परीक्षणों के लिए कुछ मिनट ठीक है। हालांकि, ध्यान रखें कि परीक्षण के 3 प्रमुख प्रकार हैं:

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

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

जाँच करने के लिए चीजें:

  • यह सुनिश्चित करना सुनिश्चित करें कि आपकी इकाई परीक्षण और एकीकरण परीक्षण अलग-अलग हैं। एकीकरण परीक्षण हमेशा धीमा रहेगा।

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

  • सुनिश्चित करें कि आपकी इकाई परीक्षण "निर्भरता मुक्त" हैं। उन्हें कभी भी डेटाबेस या फाइल सिस्टम का उपयोग नहीं करना चाहिए

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


3

अपने डेवलपर्स को पर्सनल सॉफ्टवेयर प्रोसेस (पीएसपी) पर प्रशिक्षित करें और अधिक अनुशासन का उपयोग करके उनके प्रदर्शन को समझने और बेहतर बनाने में मदद करें। लेखन कोड का कीबोर्ड पर अपनी उंगलियों को पटकने से कोई लेना-देना नहीं है और बाद में एक संकलन और बटन दबाएं।

PSP अतीत में बहुत लोकप्रिय हुआ करता था जब कोड संकलन एक ऐसी प्रक्रिया थी जो एक मेनफ्रेम पर बहुत समय (घंटे / दिन) लेती थी इसलिए हर किसी को संकलक को साझा करना पड़ता था)। लेकिन जब व्यक्तिगत कामकाज अधिक शक्तिशाली हो गए, तो हम सभी इस प्रक्रिया को स्वीकार करने आए:

  1. बिना सोचे समझे कुछ कोड टाइप करें
  2. हिट निर्माण / संकलन
  3. इसे संकलित करने के लिए अपना सिंटैक्स ठीक करें
  4. यह देखने के लिए परीक्षण चलाएं कि क्या आपने वास्तव में लिखा है

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


2
मैं आपकी सूची से बहुत सहमत हूं, लेकिन बिल्कुल नहीं "केवल दिन में दो बार चलने वाला निर्माण 50 बार से बेहतर है"।
डॉक्टर ब्राउन

3

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

इसके बजाय, आप प्रोजेक्ट A और Lib के साथ समाधान A बना सकते हैं और B और Lib परियोजनाओं के साथ समाधान B भी बना सकते हैं।


2

मैं एक वैसी ही स्थिति में हूँ। मेरे पास यूनिट परीक्षण हैं जो सर्वर के साथ संचार का परीक्षण करते हैं। वे टाइमआउट के साथ व्यवहार का परीक्षण कर रहे हैं, कनेक्शन रद्द कर रहे हैं आदि परीक्षणों का पूरा सेट 7 मिनट चलता है।

7 मिनट एक अपेक्षाकृत कम समय है, लेकिन यह ऐसा कुछ नहीं है जो आप हर प्रतिबद्ध से पहले करेंगे।

हमारे पास स्वचालित UI परीक्षणों का एक सेट भी है, उनके चलाने का समय 2 घंटे है। यह ऐसा कुछ नहीं है जिसे आप अपने कंप्यूटर पर हर दिन चलाना चाहते हैं।

इसलिए क्या करना है?

  1. परीक्षणों को बदलना आमतौर पर बहुत प्रभावी नहीं होता है।
  2. अपनी प्रतिबद्धता से पहले केवल प्रासंगिक परीक्षण चलाएं।
  3. एक बिल्ड सर्वर पर हर दिन (या कई बार एक दिन) अपने सभी परीक्षण चलाएं। यह आपको अच्छा कोड कवरेज और कोड विश्लेषण रिपोर्ट उत्पन्न करने की संभावना भी देगा।

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


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

@MichaelKohne मुझे पता था कि कोई इसे हाजिर करेगा। मुझे पता है कि वे बिल्कुल इकाई परीक्षण नहीं हैं, लेकिन वे एक ही उद्देश्य की सेवा करते हैं, यह केवल इस बारे में है कि आप उन्हें कैसे नाम देते हैं।
सुल्तान

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

1

यद्यपि समस्या का आपका वर्णन कोडबेस में पूरी तरह से जानकारी नहीं देता है, मुझे लगता है कि मैं सुरक्षित रूप से कह सकता हूं कि आपकी समस्या दो गुना है।

सही परीक्षण लिखना सीखें।

आप कहते हैं कि आपके पास लगभग एक हजार परीक्षण हैं, और आपके पास 120 परियोजनाएं हैं। यह मानते हुए कि उन परियोजनाओं में से अधिकांश में परीक्षण परियोजनाएं हैं, आपके पास 1000 उत्पादन से लेकर 60 उत्पादन कोड परियोजनाएं हैं। यह आपको लगभग 16-17 परीक्षण पीआर प्रदान करता है। परियोजना !!!

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

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

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

प्रोजेक्ट संरचना को प्रबंधित करना सीखें।

आपने समाधान को 120 परियोजनाओं में विभाजित किया है। यह मेरे मानकों द्वारा परियोजनाओं की एक चौंका देने वाली राशि है।

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

लेकिन अलग-अलग घटकों में एक परियोजना का निर्माण, संस्करण, और अलग से तैनात करने के लिए मेरे अनुभव की आवश्यकता है एक बहुत ही परिपक्व विकास टीम, एक टीम जो मुझे आपकी टीम है जो महसूस करने की तुलना में अधिक परिपक्व है।

लेकिन किसी भी दर पर, आपको परियोजना संरचना के बारे में कुछ करने की आवश्यकता है। या तो परियोजनाओं को अलग-अलग घटकों में विभाजित करें, या परियोजनाओं को विलय करना शुरू करें।

अपने आप से पूछें कि क्या आपको वास्तव में 120 परियोजनाओं की आवश्यकता है?

ps आप NCrunch को देखना चाहते हैं। यह एक विजुअल स्टूडियो प्लग-इन है जो पृष्ठभूमि में आपके परीक्षण को स्वचालित रूप से चलाता है।


0

JUnit परीक्षण आम तौर पर जल्दी होने के लिए होता है, लेकिन उनमें से कुछ को बस कुछ समय निकालना चाहिए।

उदाहरण के लिए, डेटाबेस परीक्षण आमतौर पर शुरू करने और खत्म करने में कुछ समय ले रहा है।

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

क्या किया जा सकता है:

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

2) निरंतर एकीकरण सर्वर तैयार करें, जो पृष्ठभूमि में सभी परीक्षण चलाएगा। यह आप पर निर्भर करता है कि आप हर घंटे का निर्माण करने का फैसला करते हैं या हर कमिटमेंट के बाद बनाने का (दूसरा केवल तभी समझ में आता है जब आप स्वचालित रूप से यह पता लगाना चाहते हैं कि किसकी वजह से परेशानी हुई है)।


0

जिन मुद्दों को मैंने देखा है:

a) परीक्षण तत्वों के निर्माण के लिए IOC का उपयोग करना। कंटेनर को हटाकर 70 सेकंड -> 7 सेकंड।

b) सभी वर्गों का मजाक नहीं उड़ाया। अपने यूनिट टेस्ट को किसी एक तत्व पर रखें। मैंने परीक्षण देखे हैं कि कुछ वर्गों के माध्यम से घूमता है। ये इकाई परीक्षण नहीं हैं और बहुत अधिक टूटने की संभावना है।

ग) क्या हो रहा था यह पता लगाने के लिए उन्हें प्रोफाइल करें। मैंने पाया कि कंस्ट्रक्टर सामान बना रहा था जिसकी मुझे जरूरत नहीं थी इसलिए मैंने इसे स्थानीय कर दिया और रन टाइम को कम कर दिया।

d) प्रोफाइल शायद कोड इतना अच्छा नहीं है और आप एक समीक्षा से कुछ दक्षता हासिल कर सकते हैं।

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


0

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

निर्माण के समय खाने वाली चीजें:

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

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

समस्याओं को ठीक करने के तरीके हैं:

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

जब आपके समाधान में 100 से अधिक प्रोजेक्ट होते हैं, तो आपके पास लाइब्रेरी कोड, टेस्ट और एप्लिकेशन कोड का एक संयोजन होता है। पुस्तकालयों में से प्रत्येक इसका संबद्ध परीक्षणों के साथ स्वयं का समाधान हो सकता है। Jet Brains Team City एक CI बिल्ड सर्वर है, जो Nuget सर्वर के रूप में दोगुना है - और मुझे यकीन है कि यह केवल एक ही नहीं है। यह आपको उन पुस्तकालयों को स्थानांतरित करने के लिए लचीलापन देता है जो संभवतः अपने स्वयं के समाधान / परियोजनाओं में अक्सर परिवर्तित नहीं होते हैं और अपने आवेदन कोड के लिए निर्भरता को हल करने के लिए Nuget का उपयोग करते हैं। छोटे समाधानों का मतलब है कि आप किसी भी उपद्रव के बिना जल्दी से पुस्तकालय में अपने परिवर्तन कर सकते हैं, और मुख्य समाधान में लाभों का आनंद ले सकते हैं।


-1

क्या आपके परीक्षण का वातावरण कहीं भी चल सकता है? यदि यह हो सकता है, तो परीक्षण चलाने के लिए क्लाउड कंप्यूटिंग का उपयोग करें। एन वर्चुअल मशीनों के बीच परीक्षणों को विभाजित करें। यदि किसी एकल मशीन पर परीक्षण चलाने का समय T1 सेकंड है, तो उन्हें चलाने का समय T2, T2 = T1 / N तक पहुंच सकता है। (प्रत्येक परीक्षण के मामले में समान समय लगता है।) और आपको केवल वीएम के लिए भुगतान करना होगा जब आप उनका उपयोग कर रहे हों। तो आपके पास 24/7 कहीं पर किसी प्रयोगशाला में बैठे परीक्षण मशीनों का एक गुच्छा नहीं है। (मैं यह करने में सक्षम होना चाहूँगा जहाँ मैं काम करता हूँ, लेकिन हम विशिष्ट हार्डवेयर से बंधे हैं। मेरे लिए कोई VM नहीं है।)

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