RSpec Mocks का उपयोग कैसे करें (स्टेप-बाय-स्टेप ट्यूटोरियल)

RSpec में नकली क्या है?

(या सामान्य रूप से एक नकली, क्योंकि यह RSpec के लिए अद्वितीय अवधारणा नहीं है।)

नकली परीक्षण के लिए उपयोग की जाने वाली वस्तु है ।

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

उदाहरण के लिए :

आप एक एपीआई लिख रहे हैं जो छवियों को फ़्लिप करता है।

अपना स्वयं का छवि-हेरफेर कोड लिखने के बजाय आप mini_magick . जैसे रत्न का उपयोग करते हैं ।

आप अपने कोड और इस बाहरी निर्भरता . के बीच बातचीत का परीक्षण करना चाहते हैं ... तो आप एक मॉक लिखते हैं जो ImageProcessor . पर सही तरीकों को बुलाए जाने की अपेक्षा करता है कक्षा।

इसका मतलब है कि हर बार जब आप अपने परीक्षण चलाते हैं तो आप छवियों को फ़्लिप नहीं करेंगे (धीमी गति से संचालन)।

यह कैसे काम करता है?

मोक्स मूल वस्तु को बदल देता है, इसलिए वास्तविक तरीकों को नहीं कहा जाएगा।

कुछ कोड उदाहरणों के लिए समय!

आरएसपीसी मॉक उदाहरण

यह रहा ImageFlipper परीक्षण:

RSpec.describe "ImageFlipper" क्या यह "सही तर्कों के साथ फ्लिप विधि को कॉल करता है" नकली =डबल ("मिनी_मैजिक") उम्मीद (नकली)। प्राप्त करने के लिए (:फ्लिप)। साथ ("रूबी। जेपीजी") img =ImageFlipper.new(mock) img.flip("ruby.jpg") endend

इस परीक्षण से हम TDD का उपयोग करके अपना कोड लिख सकते हैं।

पहले :

हमें एक ImageFlipper लिखना होगा कक्षा।

इसे पसंद करें :

क्लास इमेजफ्लिपर डीईएफ़ इनिशियलाइज़ (इमेज_प्रोसेसर) @image_processor =इमेज_प्रोसेसर एंडएंड

हमें एक flip भी चाहिए विधि:

डिफ फ्लिप(file_name)end

अब हमें यह प्रतिक्रिया RSpec से मिलती है:

विफलताएं:1) ImageFlipper फ्लिप विधि को सही तर्कों के साथ कॉल करता है विफलता/त्रुटि:उम्मीद (नकली)। प्राप्त करने के लिए (:flip).with("ruby.jpg") (डबल "mini_magick").flip(" ruby.jpg") अपेक्षित:तर्कों के साथ 1 बार:("ruby.jpg") प्राप्त हुआ:0 गुना # ./rspec-mocks.rb:6:in `ब्लॉक (2 स्तर) में <शीर्ष (आवश्यक)>'

यह कह रहा है कि flip मेथड को 0 बार कॉल किया गया था, लेकिन इसे 1 बार कॉल किए जाने की उम्मीद थी।

आप इस परीक्षा को वह देकर पास कर सकते हैं जो वह चाहता है :

डिफ फ्लिप(file_name) @image_processor.flip(file_name)end

और वहां आप जाते हैं, हमारे पास एक उत्तीर्ण परीक्षा है :

.0.00751 सेकंड में समाप्त (फ़ाइलों को लोड होने में 0.11157 सेकंड का समय लगा)1 उदाहरण, 0 विफलताएं

आइए समीक्षा करें:हमने यहां क्या किया है?

हमने एक ImageFlipper बनाया है वह वर्ग जो image_processor लेता है ।

यह प्रोसेसर flip का जवाब देता है विधि।

हम यह परीक्षण करने के लिए एक नकली का उपयोग करते हैं कि क्या इस विधि को एक बार तर्क के साथ बुलाया गया था।

मुझे पता है।

यह उदाहरण सरल है।

लेकिन आप ImageFlipper . के पूर्ण कार्यान्वयन की कल्पना कर सकते हैं यह जांचता है कि फ़ाइल मौजूद है या नहीं, अगर यह एक वैध छवि है, आदि।

नकली और मूल्य परीक्षण के बीच अंतर

एक नियमित परीक्षण में आप किसी विधि का वापसी मान check की जांच करते हैं :

"क्या इस विधि ने फ़्लिप की गई छवि लौटा दी?"

नकली का उपयोग करते समय आप व्यवहार का परीक्षण कर रहे हैं :

"क्या हमने सही जानकारी के साथ दूसरों को सही काम करने के लिए कहा था, और ठीक उसी समय की सही मात्रा में, जिसकी हमें आवश्यकता है?"

मॉक्स बनाम स्टब्स

एक और भ्रम की स्थिति है मॉक और स्टब्स की तुलना करना।

क्या अंतर है?

• ठूंठ केवल डिब्बाबंद प्रतिक्रिया वाली एक विधि है, यह व्यवहार की परवाह नहीं करता है।
• एक नकली तरीकों को बुलाए जाने की अपेक्षा करता है, अगर उन्हें नहीं कहा जाता है तो परीक्षण विफल हो जाएगा।

यहां RSpec में एक आधार है :

stub =double("json")allow(stub).to get(:response) do {"blog"=>"rubyguides.com", "rating"=>"5/5"}.to_jsonend

allow विधि ही इसे एक आधार बनाती है।

हम अपने परीक्षण ऑब्जेक्ट को अनुमति दे रहे हैं double("json") इस पद्धति को प्राप्त करने और उसका जवाब देने के लिए, लेकिन हम जांच नहीं कर रहे हैं कि क्या इसे कहा जा रहा है ।

यही अंतर है!

सत्यापित डबल्स का उपयोग कैसे करें

मॉक और स्टब्स के नुकसान में से एक यह है कि आप एक ऐसी विधि का उपयोग कर सकते हैं जो आपके प्रोडक्शन कोड में मौजूद नहीं है।

क्योंकि विधि का नाम बदल गया है... या हो सकता है कि आपने कोई गलती कर दी हो!

मिलिए सत्यापित युगल ।

एक सत्यापित डबल का उपयोग या तो एक स्टब के रूप में किया जा सकता है (allow ) या नकली (expect ) और यह जाँच करेगा कि इस नाम की कोई विधि मौजूद है।

उदाहरण :

मॉक =इंस्टेंस_डबल (इमेजप्रोसेसर)

यदि विधि मौजूद नहीं है तो यह एक त्रुटि उत्पन्न करेगा:

1) ImageFlipper फ्लिप विधि को सही तर्कों के साथ कॉल करता है। /पूर्व> 

 लेकिन अगर यह तरीका मौजूद है तो यह सही तरीके से काम करेगा।
 
मॉक्स रिटर्निंग वैल्यू
 

 चलिए वापस मज़ाक पर चलते हैं।
 

 पिछले उदाहरण . में हमारे पास यह था:
 
उम्मीद (नकली)। प्राप्त करने के लिए(:flip).with("ruby.jpg")
 

 जब आपका कोड flip calls पर कॉल करता है , नकली वापस आ जाएगा nil ।
 

 यदि कोड शून्य के अलावा किसी अन्य मूल्य की अपेक्षा कर रहा है तो इसके परिणामस्वरूप एक त्रुटि होगी।
 

 आप मॉक रिटर्न को परिणाम बनाकर इसे ठीक कर सकते हैं।
 

 इसे पसंद करें :
 
उम्मीद (नकली)। प्राप्त करने के लिए(:flip).with("ruby.jpg").and_return("ruby-flipped.jpg")
 
इंस्टेंस मेथड्स का मॉक कैसे करें
 

 मान लें कि आपके पास इस तरह का कोड है:
 
क्लास नंबर जेनरेटर यादृच्छिक "ए" * रैंड (1..10) एंडेंड को परिभाषित करता है
 

 यादृच्छिकता के कारण इस विधि का परीक्षण करना कठिन है।
 

 RSpec आपको rand . का उपहास करने या ठूंठ देने की अनुमति देता है ।
 

 इसे पसंद करें :
 
यह "एक यादृच्छिक संख्या उत्पन्न करता है" जनरेटर =NumberGenerator.new allow(generator).to get(:rand).and_return(5) Expect(generator.random).to eq("AAAAA")end
 

 अब :
 

 rand एक निश्चित मान देता है ताकि आप इसका उपयोग अपने तरीके के परिणाम के परीक्षण के लिए कर सकें।
 

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

 लेकिन कभी-कभी केवल विधि को आधार बनाना अधिक सुविधाजनक होता है।
 
मॉक्स का उपयोग कब करें?
 

 अब बड़े प्रश्न के लिए…
 

 आपको मॉक का उपयोग कब करना चाहिए?
 

 सॉफ्टवेयर विकास एक जटिल विषय है।
 

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

 आप बाहरी दुनिया के साथ बातचीत के लिए मॉकिंग आरक्षित करना चाहते हैं ।
 

 दूसरे शब्दों में…
 

 अपने स्वयं के एप्लिकेशन की कक्षाओं का मज़ाक उड़ाने से बचें!
 

 क्यों?
 

 क्योंकि यह आपके परीक्षणों को कार्यान्वयन विवरण के साथ जोड़ने को बढ़ावा देता है और यह आपके कोड को बदलना कठिन बना देता है ।
 

 एकमात्र अपवाद उन वर्गों के लिए है जो तृतीय पक्ष कोड के लिए रैपर हैं।
 

 अधिक जानने के लिए यह वीडियो देखें :
 
सारांश
 

 आपने RSpec के मॉक, स्टब्स और सत्यापित डबल्स के बारे में जान लिया है!
 

 कृपया इस लेख को साझा करें ताकि अधिक से अधिक लोग इस सामग्री का आनंद उठा सकें और इसका लाभ उठा सकें।
 

 पढ़ने के लिए धन्यवाद