नकली या झुंड के साथ यूनिट परीक्षण?

Question

मैं अपने परीक्षण सूट लिखते समय अच्छे प्रथाओं का पालन करने की कोशिश कर रहा हूं। आधे रास्ते के माध्यम से मैं कि iam खर्च बहुत नकली वस्तुओं पर अपने समय के (सबसे) ... मेरे परीक्षण में से अधिकांश इस

public interface ITemplateRepository 
{ 
    string get GetGenericTemplate {get;} 
} 

public FakeTemplateRepository : ITemplateRepository 
{ 
    public string GetGenericTemplate() 
    { 
    return "<xml>Complex</xml>"; 
    } 
} 

[Test] 
public void CanGetGenericTemplate() 
{ 
    ITemplateRepository rep = new FakeTemplateRepository(); 
    Assert.IsNotNull(rep.GetGenericTemplate()); 
} 

की तरह कुछ करता है एहसास हुआ

[Test] 
public void GetGenericTemplateContains() 
{ 
ITemplateRepository rep = new FakeTemplateRepository(); 
Assert.IsTrue(rep.GetGenericTemplate().StartsWith("<xml>")); 
} 

मुझे वास्तव में खुद को FakeTemplateRepository पर बहुत समय व्यतीत हुआ, यह सुनिश्चित कर रहा था कि यह वास्तविक सामग्री को लौटाए जो मैं उम्मीद कर रहा था। क्या यह खराब चीज़ है?

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

यदि वास्तव में मैं जो कर रहा हूं वह एकीकरण टेस्ट हैं, तो मुझे अपने यूनिट परीक्षणों के लिए मैक्स का उपयोग कैसे करना चाहिए?

यह मुझे समझ में नहीं आता है (यदि मैक्स का उपयोग कर रहा है) कि मैं उम्मीद को सेट करता हूं ताकि यह विधि को कॉल करे और स्ट्रिंग लौटाए? क्या मुझे कुछ याद आ रहा है लेकिन मुझे वहां बहुत मूल्य नहीं दिख रहा है? यदि मैं एक अवैध विधि नाम सेट करता हूं तो कोड भी संकलित नहीं होगा!

मैं वास्तव में पूरी चीज के बारे में वास्तव में उलझन में हूं और यूनिट परीक्षण की मेरी धारणा अब इन सभी अवधारणाओं के साथ पूरी तरह धुंधली है।

क्या कोई भी सुपर सुपर सरल उदाहरण के साथ प्रदर्शित हो सकता है कि कैसे नकली और मोजे सूट में फिट होते हैं? उदाहरण के लिए यूनिट टेस्ट क्या होना चाहिए, एकीकरण परीक्षण क्या होना चाहिए?

धन्यवाद

Answer 1

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

सबसे पहले, मैं मार्टिन फाउलर के पेपर को पढ़ता हूं "Mocks Aren't Stubs"। यदि आप विशिष्ट तर्कों के लिए मूल्यों या सेटअप अपेक्षाओं को वापस करना चाहते हैं, तो रोल-अपने-अपने नकल पर एक मॉकिंग फ्रेमवर्क के लिए जाएं। आम तौर पर सहयोगियों को बाहर निकालने के लिए नकल का उपयोग किया जाता है ... जहां आप सहयोगी की परवाह नहीं करते हैं .. उदा। नेटवर्क या फाइल IO stub बाहर।
अगला this similar SO question और यह के जवाब ..

Answer 2

सबसे पहले पढ़ा है, एक अलग (मजाक) ढांचे, Moq या Rhino Mocks तरह सीखते हैं। यह आपको बहुत समय बचाएगा।

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

यह एक जटिल विषय है, और आपको कुछ पढ़ने की आवश्यकता होगी।ओशरोव का Art of Unit Testing अपने ई-बुक फॉर्म में सस्ता है, और यह समझाए जाने का एक अच्छा काम करता है। आप Dependency Injection पर भी पढ़ना चाहेंगे।

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

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

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

EDIT: अब मैं Growing Object-Oriented Software, Guided by Tests पढ़ रहा हूं और अपने "मोक्स से बचें" दृष्टिकोण पर सवाल उठा रहा हूं। यदि आपके पास ऐसी वस्तुएं हैं जो Tell, Don't Ask का पालन करती हैं तो राज्य परीक्षण कठिन हो सकता है।

Answer 3

आपके उदाहरण में, आप अपने नकली का परीक्षण कर रहे हैं। आप इससे समझ नहीं सकते हैं, क्योंकि यह समझ में नहीं आता है।

यहां एक उदाहरण है कि आपको नकली का उपयोग कैसे करना चाहिए। आप दस्तावेज़ जेनरेटर कक्षा का परीक्षण करना चाहते हैं। यह कक्षा एक ITemplateRepository की सेवाओं का उपयोग करने के लिए होता है। हालांकि, ठीक से यूनिट परीक्षण दस्तावेज़ जेनरेटर के लिए आप यह सुनिश्चित करना चाहते हैं कि यह किसी भी बाहरी सेवाओं पर निर्भर नहीं है। तो आप एक नकली ITemplateRepository के साथ DocumentGenerator प्रदान करते हैं जो डिब्बाबंद परिणाम वापस कर देगा।

यहां कोड कैसा दिखता है।

public class DocumentGenerator 
{ 
    ITemplateRepository _repo; 

    DocumentGenerator(ITemplateRepository repo) 
    { 
    _repo = repo; 
    } 

    Doc GenerateDoc() 
    { 
    .... 
    _repo.GetGenericTemplate(); 
    .... 
    } 
} 


[Test] 
public void GenerateDocTest() 
{ 
    ITemplateRepository rep = new FakeTemplateRepository(); 
    DocumentGenerator docGenerator = new DocumentGenerator(rep); 
    Assert.IsNotNull(docGenerator.GenerateDoc()); 
} 

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