फ़ेकिंग, मॉकिंग और स्टबिंग में क्या अंतर है?

Question

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

यहां बताया गया है कि मैं उनका उपयोग कैसे करता हूं:

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

मॉक : एक वर्ग जो एक इंटरफ़ेस को लागू करता है और विशेष तरीकों से फेंकने के लिए मानों को वापस लौटने / अपवादों को गतिशील रूप से सेट करने की अनुमति देता है और यह जांचने की क्षमता प्रदान करता है कि क्या विशेष तरीकों को बुलाया गया है / नहीं बुलाया गया है।

ठूंठ : एक नकली वर्ग की तरह, सिवाय इसके कि यह सत्यापित करने की क्षमता प्रदान नहीं करता कि विधियों को बुलाया गया है / नहीं कहा जाता है।

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

Comments

वैसे आपने मूल रूप से यह सब अपने "प्रश्न" में कहा है :) मुझे लगता है कि वे उन शर्तों की बहुत अच्छी तरह से स्वीकार की गई परिभाषाएं हैं

— एरन गैपरिन

फेक की विकिपीडिया परिभाषा इस से भिन्न है, यह कहते हुए कि एक फेक "का उपयोग एक सरल कार्यान्वयन के रूप में किया जाता है, उदाहरण के लिए असली डेटाबेस एक्सेस करने के बजाय परीक्षणों में इन-मेमोरी डेटाबेस का उपयोग करते हुए)" en.wikipedia.org/wiki/stest_double

— zumalifeguard

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

— एरिक

परीक्षण .googleblog.com/2013/07/… (एक छोटा-पृष्ठ सारांश)।

— श्रीवत्सआर

यहाँ मेरी व्याख्या करने के लिए है कि: टेस्ट डबल्स: नकली, स्टब्स और मोज़े (उदाहरण के साथ ब्लॉग पोस्ट)

— michal-lipski

Answer 1

आप कुछ जानकारी प्राप्त कर सकते हैं:

से नकली और स्टब के बारे में मार्टिन Fowler

नकली वस्तुओं में वास्तव में काम करने वाले कार्यान्वयन होते हैं, लेकिन आमतौर पर कुछ शॉर्टकट होते हैं जो उन्हें उत्पादन के लिए उपयुक्त नहीं बनाते हैं

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

मोक्स वे हैं जिनके बारे में हम यहां बात कर रहे हैं: ऑब्जेक्ट्स पूर्व-अपेक्षाओं के साथ प्रोग्राम किए जाते हैं जो उन कॉलों का एक विनिर्देश बनाते हैं जो उन्हें प्राप्त होने की उम्मीद है।

से xunitpattern :

नकली : हम उसी कार्यक्षमता का बहुत हल्का कार्यान्वयन प्राप्त करते हैं या उसका निर्माण करते हैं जैसा कि एक घटक द्वारा प्रदान किया जाता है जो SUT निर्भर करता है और SUT को वास्तविक के बजाय इसका उपयोग करने का निर्देश देता है।

स्टब : यह कार्यान्वयन SUT के उन मूल्यों (या अपवादों) से कॉल करने के लिए प्रतिक्रिया करने के लिए कॉन्फ़िगर किया गया है जो SUT के भीतर अनटाइटेड कोड (पेज X पर उत्पादन कीड़े देखें) का प्रयोग करेंगे। टेस्ट स्टब का उपयोग करने के लिए एक महत्वपूर्ण संकेत SUT के अप्रत्यक्ष इनपुट को नियंत्रित करने में असमर्थता के कारण अनटाइटेड कोड हो रहा है

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

व्यक्तिगत रूप से

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

Comments

मुझे लगता है कि स्टब और फेक की परिभाषाएँ मार्टिन फाउलर के उद्धरण की तुलना में xUnitPattern उद्धरण में उलट हैं। इसके अलावा, कि स्टॉन और फेक की मार्टिन फाउलर की परिभाषाएं टवानफॉसन के मूल प्रश्न की परिभाषाओं की तुलना में उलट हैं। वास्तव में क्या उन दो शब्दों की कोई आम तौर पर स्वीकृत परिभाषा है या यह सिर्फ इस बात पर निर्भर करता है कि आप किससे बात कर रहे हैं?

— साइमन तवेसी

+1 के लिए "मैं उपयोग करके सरल बनाने का प्रयास करता हूं: मॉक और स्टब"। बढ़िया विचार है!

— ब्रैड कपिट

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

— हेक्टर ऑर्डोनेज़

मैं एमएफ की परिभाषा में नकली और नकली के बीच का अंतर नहीं देख सकता।

— IdontCareAboutReputationPoints

@MusuNaji: एमएफ की परिभाषा में, फेक के लिए बातचीत के संबंध में कोई "अपेक्षाएं" नहीं हैं, इसके अलावा इसके इंटरफ़ेस के लिए कार्यान्वयन है। दूसरी ओर मॉक को चुनौती दी जाएगी (क्या इसे विधि कहा जाता है?)।

— दलबाकिरेव

Answer 2

स्टब - एक ऑब्जेक्ट जो विधि कॉल को पूर्वनिर्धारित उत्तर प्रदान करता है।

मॉक - एक ऐसी वस्तु जिस पर आप उम्मीदें लगाते हैं।

नकली - सीमित क्षमताओं के साथ एक वस्तु (परीक्षण के प्रयोजनों के लिए), उदाहरण के लिए एक नकली वेब सेवा।

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

Comments

क्या कोई मुझे समझा और परिभाषित कर सकता है कि इस संदर्भ में "डिब्बाबंद जवाब" क्या है?

— MasterMastic

गणना के मूल्य के बजाय एक स्पष्ट मूल्य।

— माइक

आखिरकार! कुछ परिभाषाएँ मैं समझ सकता हूँ! इन परिभाषाओं के आधार पर, तब, googletest (gtest) / googlemock (gmock) नकली वस्तुओं को भी स्टब्स बनाने की अनुमति देता है, जैसा कि आप EXPECT_CALL()एक नकली विधि पर बना सकते हैं जो कुछ इनपुट के आधार पर कुछ आउटपुट को मजबूर करती है, .WillOnce(Invoke(my_func_or_lambda_func))(या .WillRepeatedly()) प्रकार का उपयोग करके वाक्य रचना एक से जुड़ी EXPECT_CALL()। उपयोग करने के कुछ उदाहरणों को Invoke()मेरे लंबे उत्तर के तल पर एक अलग संदर्भ में देखा जा सकता है: stackoverflow.com/a/60905880/4561887 ।

— गेब्रियल स्टेपल्स

Gmock प्रलेखन Invoke()यहाँ पर है: github.com/google/googletest/blob/master/googlemock/docs […] । वैसे भी, निष्कर्ष यह है: Google मॉक (gmock) किसी को आसानी से मोक्स और स्टब्स दोनों बनाने की अनुमति देता है , हालांकि अधिकांश मॉक्स स्टब्स नहीं हैं।

— गेब्रियल स्टेपल्स

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

— ल्यूक

Answer 3

मुझे आश्चर्य है कि यह सवाल इतने लंबे समय से है और किसी ने भी रॉय ओशेरोव के "द आर्ट ऑफ यूनिट टेस्टिंग" के आधार पर जवाब नहीं दिया है ।

"3.1 परिचय स्टब्स" में एक स्टब को परिभाषित किया गया है:

एक स्टब सिस्टम में मौजूदा निर्भरता (या सहयोगी) के लिए एक नियंत्रणीय प्रतिस्थापन है। एक स्टब का उपयोग करके, आप सीधे निर्भरता से निपटने के बिना अपने कोड का परीक्षण कर सकते हैं।

और स्टब्स और मोक्स के बीच के अंतर को परिभाषित करता है:

मॉक बनाम स्टब्स के बारे में याद रखने वाली मुख्य बात यह है कि मॉक्स स्टब्स की तरह ही होते हैं, लेकिन आप मॉक ऑब्जेक्ट के खिलाफ जोर देते हैं, जबकि आप स्टब के खिलाफ जोर नहीं देते।

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

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

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

एक परीक्षण का उदाहरण जहां कक्षा FakeX को स्टब के रूप में उपयोग किया जाता है:

const pleaseReturn5 = 5;
var fake = new FakeX(pleaseReturn5);
var cut = new ClassUnderTest(fake);

cut.SquareIt;

Assert.AreEqual(25, cut.SomeProperty);

fakeक्योंकि उदाहरण के एक ठूंठ के रूप में प्रयोग किया जाता है Assertका उपयोग नहीं करता fakeसब पर।

एक परीक्षण का उदाहरण जहां परीक्षण कक्षा X का उपयोग मॉक के रूप में किया जाता है:

const pleaseReturn5 = 5;
var fake = new FakeX(pleaseReturn5);
var cut = new ClassUnderTest(fake);

cut.SquareIt;

Assert.AreEqual(25, fake.SomeProperty);

इस मामले में उस नकली को नकली बनाते Assertहुए एक मूल्य पर जांच की जाती है fake।

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

मैं ओशेरोव के साथ सहमत हूँ

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

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

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

मज़ेदार पढ़ने के लिए क्यों आपको यहाँ परिभाषित मॉक से बचना चाहिए, "फाउलर मॉकिस्ट क्लासिकिस्ट" के लिए गूगल। आपको राय का ढेर मिल जाएगा।

Answer 4

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

ये चीजें अलग कैसे हैं, इस पर ध्यान केंद्रित करने के बजाय , मुझे लगता है कि यह अलग-अलग अवधारणाएं क्यों हैं, इस पर ध्यान केंद्रित करना अधिक ज्ञानवर्धक है । प्रत्येक एक अलग उद्देश्य के लिए मौजूद है।

नकली

एक नकली एक कार्यान्वयन है जो "स्वाभाविक रूप से" व्यवहार करता है, लेकिन "वास्तविक" नहीं है। ये फ़ज़ी कॉन्सेप्ट हैं और इसलिए अलग-अलग लोगों की अलग-अलग समझ होती है कि कौन सी चीज़ नकली है।

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

एक अन्य उदाहरण के रूप में, शायद आप उत्पादन में किसी प्रकार के ऑब्जेक्ट स्टोर (जैसे अमेज़ॅन एस 3) का उपयोग करते हैं, लेकिन एक परीक्षण में आप बस डिस्क पर फ़ाइलों को ऑब्जेक्ट्स को बचा सकते हैं; तब आपका "डिस्क टू सेव" कार्यान्वयन एक नकली होगा। (या आप इन-मेमरी फाइल सिस्टम के बजाय "डिस्क टू सेव" ऑपरेशन को नकली बना सकते हैं।)

तीसरे उदाहरण के रूप में, एक ऑब्जेक्ट की कल्पना करें जो कैश एपीआई प्रदान करता है; एक ऐसी वस्तु जो सही इंटरफ़ेस को लागू करती है, लेकिन यह केवल कोई कैशिंग नहीं करती है, लेकिन हमेशा कैशे मिस करती है, एक तरह का नकली होगा।

एक नकली का उद्देश्य परीक्षण के तहत प्रणाली के व्यवहार को प्रभावित करना नहीं है , बल्कि परीक्षण के कार्यान्वयन को सरल करना है (अनावश्यक या भारी निर्भरता को हटाकर)।

स्टब्स

एक स्टब एक कार्यान्वयन है जो "अस्वाभाविक" व्यवहार करता है। यह विशिष्ट आउटपुट के साथ विशिष्ट आदानों का जवाब देने के लिए पूर्व-निर्धारित (आमतौर पर परीक्षण सेट-अप) है।

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

एक स्टब आमतौर पर केवल उन सटीक अंतःक्रियाओं पर प्रतिक्रिया करने के लिए कार्यान्वित किया जाता है, जिनके बारे में आपने उसे बताया है। लेकिन प्रमुख विशेषता यह है कि कुछ को एक स्टब बनाता है उद्देश्य है : एक स्टब आपके परीक्षण के मामले को स्थापित करने के बारे में है।

mocks

एक मॉक एक स्टब के समान है, लेकिन सत्यापन के साथ जोड़ा गया है। एक मॉक का उद्देश्य इस बात पर जोर देना है कि परीक्षण के तहत आपकी प्रणाली निर्भरता के साथ कैसे इंटरैक्ट करती है। ।

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

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

टेस्ट डबल्स

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

Answer 5

स्टब्स और मोक्स के उपयोग को स्पष्ट करने के लिए, मैं रॉय ओशेरोव के " द आर्ट ऑफ़ यूनिट टेस्टिंग " पर आधारित एक उदाहरण भी शामिल करना चाहूंगा ।

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

यहाँ तर्क है कि हम LogAnalyzer के अंदर परीक्षण करना चाहते हैं:

if(fileName.Length<8)
{
 try
  {
    service.LogError("Filename too short:" + fileName);
  }
 catch (Exception e)
  {
    email.SendEmail("a","subject",e.Message);
  }
}

जब वेब सेवा अपवाद छोड़ती है तो आप कैसे परीक्षण करते हैं कि LogAnalyzer ईमेल सेवा को सही ढंग से कॉल करता है? यहां वे प्रश्न हैं जिनका हम सामना कर रहे हैं:

• हम वेब सेवा को कैसे बदल सकते हैं?

• हम वेब सेवा से एक अपवाद का अनुकरण कैसे कर सकते हैं ताकि हम ईमेल सेवा पर कॉल का परीक्षण कर सकें?

• हमें कैसे पता चलेगा कि ईमेल सेवा को सही तरीके से या बिल्कुल भी कहा गया था?

हम वेब सेवा के लिए स्टब का उपयोग करके पहले दो प्रश्नों से निपट सकते हैं । तीसरी समस्या को हल करने के लिए, हम कर सकते हैं ईमेल सेवा के लिए एक नकली वस्तु का उपयोग हैं ।

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

[TestFixture]
public class LogAnalyzer2Tests
{
[Test]
 public void Analyze_WebServiceThrows_SendsEmail()
 {
   StubService stubService = new StubService();
   stubService.ToThrow= new Exception("fake exception");
   MockEmailService mockEmail = new MockEmailService();

   LogAnalyzer2 log = new LogAnalyzer2();
   log.Service = stubService
   log.Email=mockEmail;
   string tooShortFileName="abc.ext";
   log.Analyze(tooShortFileName);

   Assert.AreEqual("a",mockEmail.To); //MOCKING USED
   Assert.AreEqual("fake exception",mockEmail.Body); //MOCKING USED
   Assert.AreEqual("subject",mockEmail.Subject);
 }
}

Answer 6

वह चीज जो आप उस पर मुखर करते हैं, एक मॉक ऑब्जेक्ट कहलाती है और बाकी सब जो सिर्फ टेस्ट रन में मदद करता है, एक स्टब है ।

Comments

जबकि अन्य उत्तरों में बहुत विस्तार है और वास्तव में अच्छे हैं। यह अंतर स्पष्ट करने के लिए इतना स्पष्ट और आसान बनाता है, यह मुश्किल नहीं है। जी जे!

— मारियो गार्सिया

Answer 7

यह परीक्षणों को अभिव्यंजक बनाने की बात है। अगर मैं चाहता हूं कि परीक्षण दो वस्तुओं के बीच संबंध का वर्णन करने के लिए एक मॉक पर उम्मीद लगाए। यदि मैं परीक्षण में दिलचस्प व्यवहार करने के लिए मुझे समर्थन ऑब्जेक्ट सेट कर रहा हूं, तो मैं रिटर्न मानों को रोक देता हूं।

Answer 8

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

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

Answer 9

स्टब, फेक और मोक्स के अलग-अलग स्रोतों में अलग-अलग अर्थ हैं। मेरा सुझाव है कि आप अपनी टीम को आंतरिक शब्दों से परिचित कराएँ और उनके अर्थ पर सहमत हों।

मुझे लगता है कि दो दृष्टिकोणों के बीच अंतर करना महत्वपूर्ण है: - व्यवहार सत्यापन (व्यवहार प्रतिस्थापन का अर्थ है) - अंत-राज्य सत्यापन (व्यवहार व्यवहार का अर्थ है)

त्रुटि के मामले में ईमेल भेजने पर विचार करें। व्यवहार सत्यापन करते समय - आप एक बार निष्पादित Sendकी IEmailSenderगई विधि की जाँच करते हैं । और आपको इस विधि के रिटर्न परिणाम का अनुकरण करने की आवश्यकता है, भेजे गए संदेश की ईद वापस करें। तो आप कहते हैं: "मुझे उम्मीद है कि Sendइसे बुलाया जाएगा। और मैं बस किसी भी कॉल के लिए डमी (या यादृच्छिक) आईडी वापस करूंगा" । यह व्यवहार मान्यता है: emailSender.Expect(es=>es.Send(anyThing)).Return((subject,body) => "dummyId")

राज्य सत्यापन करते समय आपको TestEmailSenderउस कार्यान्वयन को बनाने की आवश्यकता होगी IEmailSender। और Sendविधि को लागू करें - कुछ डेटा संरचना में इनपुट की बचत करके जिसका उपयोग भविष्य के राज्य सत्यापन के लिए किया जाएगा जैसे कि कुछ वस्तुओं की सरणी SentEmailsऔर फिर यह परीक्षण करता है कि आप जांच करेंगे कि SentEmailsअपेक्षित ईमेल शामिल है। यह राज्य मान्यता है: Assert.AreEqual(1, emailSender.SentEmails.Count)

मेरे पढ़ने से मुझे समझ में आया कि व्यवहार सत्यापन को आमतौर पर मोक्स कहा जाता है । और राज्य सत्यापन को आमतौर पर स्टब्स या कहा जाता है फेक ।

Comments

वास्तव में अच्छी तरह से विस्तृत और कुरकुरा रक्षा।

— श्याम सुंदर सिंह tomar

Answer 10

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

public class MyUnitTest {

 @Test
 public void testConcatenate() {
  StubDependency stubDependency = new StubDependency();
  int result = stubDependency.toNumber("one", "two");
  assertEquals("onetwo", result);
 }
}

public class StubDependency() {
 public int toNumber(string param) {
  if (param == “one”) {
   return 1;
  }
  if (param == “two”) {
   return 2;
  }
 }
}

नकली और स्टब्स से एक कदम ऊपर एक मॉक है। मोज़े स्टब के समान कार्यक्षमता प्रदान करते हैं लेकिन अधिक जटिल होते हैं। उनके पास उनके लिए परिभाषित नियम हो सकते हैं जो उनके एपीआई पर किस क्रम के तरीकों को निर्धारित करते हैं। अधिकांश मॉक ट्रैक कर सकते हैं कि कितनी बार एक विधि को बुलाया गया था और उस जानकारी के आधार पर प्रतिक्रिया कर सकते हैं। मोक्स आमतौर पर प्रत्येक कॉल के संदर्भ को जानते हैं और विभिन्न स्थितियों में अलग-अलग प्रतिक्रिया कर सकते हैं। इस वजह से, मॉक को क्लास के कुछ ज्ञान की आवश्यकता होती है जो वे मॉकिंग करते हैं। एक स्टब आम तौर पर ट्रैक नहीं कर सकता है कि कितनी बार एक विधि को बुलाया गया था या किस क्रम में तरीकों का एक क्रम कहा गया था। एक नकली की तरह लग रहा है:

public class MockADependency {

 private int ShouldCallTwice;
 private boolean ShouldCallAtEnd;
 private boolean ShouldCallFirst;

 public int StringToInteger(String s) {
  if (s == "abc") {
   return 1;
  }
  if (s == "xyz") {
   return 2;
  }
  return 0;
 }

 public void ShouldCallFirst() {
  if ((ShouldCallTwice > 0) || ShouldCallAtEnd)
   throw new AssertionException("ShouldCallFirst not first thod called");
  ShouldCallFirst = true;
 }

 public int ShouldCallTwice(string s) {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallTwice called before ShouldCallFirst");
  if (ShouldCallAtEnd)
   throw new AssertionException("ShouldCallTwice called after ShouldCallAtEnd");
  if (ShouldCallTwice >= 2)
   throw new AssertionException("ShouldCallTwice called more than twice");
  ShouldCallTwice++;
  return StringToInteger(s);
 }

 public void ShouldCallAtEnd() {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallAtEnd called before ShouldCallFirst");
  if (ShouldCallTwice != 2) throw new AssertionException("ShouldCallTwice not called twice");
  ShouldCallAtEnd = true;
 }

}

Answer 11

fake object- इंटरफेस (प्रोटोकॉल) का एक वास्तविक कार्यान्वयन या एक विरासत या अन्य तरीकों जो बनाने के लिए इस्तेमाल किया जा सकता का उपयोग कर का विस्तार है है निर्भरता। आमतौर पर इसे डेवलपर द्वारा कुछ निर्भरता को बदलने के लिए सबसे सरल समाधान के रूप में बनाया जाता है

stub objectलौटे हुए मूल्यों को परिभाषित करने के लिए अतिरिक्त और पूर्वनिर्धारित (डेवलपर द्वारा) स्थिति के साथ एक नंगे ऑब्जेक्ट (तर्क के बिना शून्य और तरीके) है । आमतौर पर इसे फ्रेमवर्क द्वारा बनाया जाता है

mock objectकुछ ऐसा ही होता है, stub objectलेकिन यदि कुछ हुआ है तो जाँच करने के लिए प्रोग्राम निष्पादन के दौरान अतिरिक्त स्थिति बदल दी जाती है।