क्या संस्करण नियंत्रण हुक में इकाई परीक्षण चलाना एक अच्छा अभ्यास है?


43

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

मेरा प्रश्न है - क्या बिल्ड पाइपलाइन में यूनिट टेस्ट रखना बेहतर है (इस प्रकार, रेपो को टूटे हुए कमिट्स को पेश करना) या यह बेहतर है कि "खराब" होने की अनुमति न दें।

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


जवाबों:


35

नहीं, यह दो कारणों से नहीं है:

गति

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

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

सबसे बुरी बात यह है कि इसे तेज करने के लिए बहुत कुछ नहीं है। छोटी पायथन परियोजनाएं, जो कहती हैं, सौ यूनिट परीक्षण, एक औसत सर्वर पर चलाने के लिए कम से कम एक सेकंड लेते हैं, लेकिन अक्सर बहुत लंबा होता है। C # एप्लिकेशन के लिए, संकलन समय के कारण, यह औसतन चार-पाँच सेकंड का होगा।

उस बिंदु से, आप बेहतर सर्वर के लिए अतिरिक्त $ 10 000 का भुगतान कर सकते हैं जो समय कम करेगा, लेकिन बहुत अधिक नहीं, या कई सर्वरों पर परीक्षण चलाएगा, जो केवल चीजों को धीमा कर देगा।

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

इसके बजाय, आप क्या कर सकते हैं:

  • डेवलपर्स को प्रतिबद्ध करने के लिए स्थानीय स्तर पर संशोधित कोड से संबंधित परीक्षणों को दृढ़ता से चलाने के लिए प्रोत्साहित करें। वे संभवतः हजारों यूनिट परीक्षण नहीं चला सकते, लेकिन वे उनमें से पांच-दस चला सकते हैं।

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

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

  • अपने निरंतर एकीकरण सर्वर पर यूनिट परीक्षण चलाएं।

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

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

  • सुनिश्चित करें कि डेवलपर्स समझते हैं कि बिल्ड को तोड़ना (या प्रतिगमन परीक्षणों को विफल करना) ठीक नहीं है, और जैसे ही ऐसा होता है, उनकी सर्वोच्च प्राथमिकता इसे ठीक करना है। इससे कोई फर्क नहीं पड़ता कि वे एक उच्च प्राथमिकता वाले फीचर पर काम कर रहे हैं जो उनके मालिक ने कल के लिए जहाज करने के लिए कहा: वे निर्माण में विफल रहे, उन्हें इसे ठीक करना चाहिए।

सुरक्षा

सर्वर जो रिपॉजिटरी को होस्ट करता है उसे कस्टम कोड नहीं चलाना चाहिए, जैसे कि यूनिट परीक्षण, विशेष रूप से सुरक्षा कारणों से। GitLab के एक ही सर्वर पर CI धावक में उन कारणों को पहले ही समझाया गया था ?

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


4
मैं सहमत हूं, यह वह है जो एक बिल्ड सर्वर के लिए है। आपका स्रोत नियंत्रण स्रोत कोड के प्रबंधन के लिए है, आपके आवेदन कार्यों को सुनिश्चित नहीं करता है।
मैथ्यू

4
चरम मामलों में, बिल्ड को तोड़ते समय प्रतिशोध एक आवश्यक सूचना उपकरण हो सकता है।

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

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

10
@ थोमस: यह व्याकुलता के बारे में नहीं है, बल्कि झुंझलाहट के बारे में है। उसी तरह, 100 एम.एस. किसी व्यक्ति द्वारा किसी वेबसाइट का उपयोग करने पर "एक औसत दर्जे का प्रभाव पड़ता है" । यहां एक ही पैटर्न: 100 एमएस। उस समय की तुलना में कुछ भी नहीं है, जब आप YouTube वीडियो देखते हैं या अपना PC शुरू करते हैं: होशपूर्वक , आप 600 ms के बीच अंतर नहीं देखेंगे। और 700 मि। देरी। लेकिन अनजाने में, यह आपके व्यवहार पर प्रभाव डालता है। उसी तरह, थोड़ा धीमा आपको जल्दी और बार-बार करने से हतोत्साहित करता है।
आर्सेनी मौरज़ेंको

41

मुझे अपने साथी उत्तरदाताओं से असहमत होने के लिए एक होना चाहिए।

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

मेरे अनुभव में, गेटेड चेक-इन सफल इकाई परीक्षण के लिए सबसे महत्वपूर्ण प्रक्रियाओं में से एक है - और विस्तार से, सॉफ्टवेयर गुणवत्ता।

क्यों?

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

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

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


3
+1 मैं जोड़ना चाहता हूं, कि कई ओपन सोर्स प्रोजेक्ट्स में योगदान और कमिटिंग के बीच स्पष्ट अंतर है। इसके कारण बहुत हद तक समान हैं कि gated check-ins क्यों मौजूद है।
जेन्सजी

गेटेड चेक-इन के साथ एक महत्वपूर्ण समस्या यह है कि यह मुश्किल कोड की सहयोगात्मक समस्या को रोकता है। वितरित टीमों के साथ यह और भी महत्वपूर्ण है।
क्यूरियस रैबिट

2
@CuriousRabbit - आप कैसे आंकते हैं? लोग शायद ही कभी प्रतिबद्ध सहयोगी रूप से भले ही वे काम सहयोगी रूप से। अन्यथा अलमारियों या अछूता कार्य शाखाएं इसके लिए अच्छी तरह से काम करती हैं जबकि बाकी टीम में बाधा नहीं डालती हैं।
तेलस्टिन

@ Telastyn- अलमारियाँ मेरे लिए एक नया शब्द है। मैं इकट्ठा करता हूं कि यह एक एमएस वीएस विकल्प है, जो कि बड़ी संख्या में परियोजनाओं के लिए कोई विकल्प नहीं है। मोबाइल एप्लिकेशन विकास के क्षेत्र में, वीएस एक गैर-खिलाड़ी है।
क्यूरियसबिट

3
@CuriousRabbit - वास्तव में? 17 घंटे से अधिक बांटी गई टीम को एक टूटी हुई निर्माण की संभावना की तुलना में 10 मिनट तक प्रतीक्षा करने के बारे में अधिक परवाह है जबकि अपमानजनक पार्टी सो रही है? ऐसा लगता है ... इष्टतम से कम।
तेलस्टीन

40

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

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

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

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

संबंधित: क्या मुझे ज्ञात दोषों के लिए यूनिट परीक्षण करना चाहिए? और असफल इकाई परीक्षणों में जाँच का क्या मूल्य है?


2
Commits should run fast.इसके क्या लाभ हैं? मैं उत्सुक हूं क्योंकि हम वर्तमान में gated चेकइन का उपयोग करते हैं। आमतौर पर मेरे चेकइन एक घंटे या काम का एक संचयन होते हैं, इसलिए 5 मिनट इंतजार एक बड़ी बात नहीं है। वास्तव में मैंने पाया अपने सामान्य रूप से बार है कि जब मैं कर रहा हूँ कि मान्यता का निर्माण मूर्खतापूर्ण गलतियों को पकड़ने के लिए सबसे उपयोगी है जल्दी में (भागने की वजह से)
जस्टिन

1
@ जस्टिन पांच मिनट प्रतीक्षा पांच मिनट की प्रतीक्षा है, चाहे वह कहीं भी हो। एक नहीं होना चाहिए हर बार जब आप एक प्रतिबद्ध है nerf तलवारें बाहर तोड़ की जरूरत है। और मेरे लिए एक या एक से अधिक कामों को एक-दूसरे को तोड़ना असामान्य नहीं है, जो कि एक-दूसरे की वैचारिक इकाइयाँ हैं - "सेवा करने वाले ग्राहक पृष्ठ के लिए कोड" के बाद "बाकी सेवा कोड करें" दो अलग-अलग तरीके से करें (एक और कमिट के रूप में सीएसएस ट्वीक का उल्लेख नहीं करना है)। यदि इनमें से प्रत्येक को दौड़ने में 5 मिनट का समय लगता है, तो मेरा 1/6 वां समय परीक्षणों के इंतजार में बीतता है। इससे बड़े रोलअप कमिट होंगे जो बग्स को ट्रैक करने के लिए कठिन हैं।

इकाई परीक्षण चलाने के लिए 5 मिनट प्रतीक्षा करें? मुझे लगता है कि आप जिन परियोजनाओं पर काम कर रहे हैं उन्हें छोटे घटकों में तोड़ दिया जाना चाहिए।
user441521

@ जस्टिन catching silly mistakes (as a result of rushing)बिल्कुल। सॉफ्टवेयर इंजीनियरिंग में सामान्य रूप से भागना एक बुरा व्यवहार है। रॉबर्ट सी। मार्टिन ने सर्जरी की तरह कोड लिखने की सिफारिश की youtube.com/watch?v=p0O1VVqRSK0
जेरी जोसेफ

10

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

हालाँकि, प्रतिबद्ध हुक का विशेष समाधान एक अच्छी योजना नहीं है।

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

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

@ ब्रायन, मैं कुल समझौते में हूं, आप यह काम कर सकते हैं। लेकिन, प्रतिबद्ध हुक सर्वर-साइड को ब्लॉक करके काम करने की कोशिश नहीं की जा रही है।
विंस्टन इर्वर्ट

अच्छे अंक। Breaking the build is simply too costly in terms of lost time for all engineers on the projectमैं सुझाव दूंगा कि किसी भी प्रकार के निर्माण अधिसूचना उपकरण का उपयोग करने से बचने के लिए सभी इंजीनियर प्रत्येक टूटे हुए निर्माण पर समय समाप्त होने से बचें
जैरी जोसेफ

3

नहीं, आपको नहीं करना चाहिए क्योंकि अन्य उत्तर बताए गए हैं।

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


2

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

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

  • एक मंचन शाखा है जिसमें आप केवल अपनी देव शाखाओं और मुख्य शाखा के बीच विलय कर सकते हैं

  • एक हुक की स्थापना करें जो स्टेजिंग शाखा पर किए गए कमिट पर एक निर्माण और परीक्षण शुरू करता है या करता है, लेकिन यह कमिट प्रतीक्षा नहीं करता है

  • सफल निर्माण और परीक्षणों पर, मुख्य शाखा को स्वचालित रूप से आगे बढ़ाएं यदि यह अद्यतित है

    नोट: स्वचालित रूप से मुख्य शाखा में विलय नहीं होता है , क्योंकि परीक्षण किया गया विलय, यदि मुख्य शाखा के दृष्टिकोण से आगे विलय नहीं होता है, तो बीच में आने वाली मुख्य शाखा में विलय होने पर विफल हो सकता है

एक परिणाम के रूप में:

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

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

  • आपको इनमें से चुनना होगा:

    • एक एकल स्टेजिंग शाखा, जो अन्यथा सफल विलय कर देगी वास्तव में विफल हो जाती है यदि पिछले अभी तक निर्माण नहीं किया गया है और परीक्षण योग्य मर्ज विफल नहीं है

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

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

    • एकाधिक स्टेजिंग शाखाएं, जो गैर-परस्पर विरोधी सफल विलय को मुख्य शाखा में लाने की अनुमति देंगी

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

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

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

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


लेकिन एक कार्यशील शाखा होने की बात यह नहीं है (आमतौर पर) यह सुनिश्चित करने के लिए कि आपके पास एक स्थिर रिलीज है, लेकिन एक ही कोड में एक साथ काम करने वाले डेवलपर्स के कारण होने वाले थ्रैशिंग पर कटौती करना।
तेलेस्टिन

नहीं अगर आपके पास बड़े, विश्व स्तर पर वितरित टीमों के साथ एक विशाल रेपो है। उदाहरण के लिए, Microsoft विंडोज के साथ एक समान, अधिक स्तरित दृष्टिकोण का उपयोग करता है।
16

2

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

आपको एक बिल्ड फ्रेमवर्क की आवश्यकता होगी जो कि आर्टिफैक्ट्स को कैश करता है।

आपको एक परीक्षण ढाँचे की आवश्यकता होगी जो किसी भी दिए गए आर्टिफैक्ट (ओं) के साथ (सफल) टेस्ट रन से टेस्ट स्टेटस को कैश करता है।

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


1

मैं कहूंगा कि यह परियोजना और "प्रतिबद्ध" पर चलने वाले स्वचालित परीक्षणों के दायरे पर निर्भर करता है।

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

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

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

मैं इस तरह के ऑपरेशन के लिए "प्रतीक्षा करते समय आपके देवों को पहेली नहीं बना सकता" पर अन्य उत्तरों से सहमत हो सकता हूं।


1

टूटे हुए कमों को ट्रंक पर नहीं जाने देना चाहिए , क्योंकि ट्रंक वह है जो उत्पादन में जा सकता है। इसलिए आपको यह सुनिश्चित करने की आवश्यकता है कि ट्रंक पर होने से पहले उन्हें प्रवेश द्वार की आवश्यकता है । हालांकि, टूटे हुए कॉमोट रेपो में पूरी तरह से ठीक हो सकते हैं जब तक कि यह ट्रंक पर न हो।

दूसरी ओर, रिपॉजिटरी में बदलाव को आगे बढ़ाने से पहले डेवलपर्स को मुद्दों की प्रतीक्षा करने / ठीक करने की आवश्यकता होती है।

कुछ उदाहरण:

  • TDD में, फीचर को लागू करने से पहले नई सुविधाओं के लिए असफल परीक्षणों को करना और धक्का देना आम है
  • असफल होने और परीक्षण को विफल करने के द्वारा बग की रिपोर्टिंग के लिए वही जाता है
  • अपूर्ण कोड को पुश करने से 2 या अधिक लोगों को समानांतर में एक सुविधा पर आसानी से काम करने की अनुमति मिलती है
  • आपके CI इंफ्रास्ट्रक्चर में समय की पुष्टि हो सकती है, लेकिन डेवलपर को इंतजार नहीं करना होगा
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.