RSpec let () का उपयोग कब करें?

Question

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

... मेमो हेल्पर पद्धति को परिभाषित करना। मान को एक ही उदाहरण में कई कॉल में कैश किया जाएगा, लेकिन उदाहरणों में नहीं।

यह ब्लॉक से पहले उदाहरण चर का उपयोग करने से अलग कैसे है? और भी आपको कब let()बनाम का उपयोग करना चाहिए before()?

Comments

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

— नेशा जोरिक

पहले के हुक में उदाहरण चर सेट करना अच्छा नहीं है। Check out betterspecs.org

— Allison

Answer 1

मैं हमेशा letकुछ कारणों से एक उदाहरण चर के लिए पसंद करते हैं :

• उदाहरण के लिए जब अस्तित्व में चर चरता है। इसका मतलब यह है कि यदि आप उदाहरण चर की वर्तनी उंगली करते हैं, तो एक नया बनाया जाएगा और इसे प्रारंभिक रूप दिया जाएगा nil, जिससे सूक्ष्म कीड़े और झूठे सकारात्मक हो सकते हैं। चूंकि letएक विधि बनाता है, आप एक मिल जाएगाNameError बनती है, इसलिए जब आप इसे मिस करते हैं , जो मुझे बेहतर लगता है। इससे रिफ्लेक्टर स्पेक्स को भी आसान बनाया जा सकता है।
• before(:each)प्रत्येक उदाहरण से पहले एक हुक चलेगा, भले ही उदाहरण हुक में परिभाषित किसी भी उदाहरण चर का उपयोग न करे। यह आम तौर पर एक बड़ी बात नहीं है, लेकिन अगर उदाहरण चर की स्थापना में लंबा समय लगता है, तो आप चक्र बर्बाद कर रहे हैं। द्वारा परिभाषित विधि के लिए let, इनिशियलाइज़ेशन कोड केवल तभी चलता है जब उदाहरण इसे कहता है।
• आप उदाहरण में संदर्भित वाक्यविन्यास को बदलने के बिना एक उदाहरण में एक स्थानीय चर से सीधे रिफ्लेक्टर कर सकते हैं। यदि आप एक उदाहरण चर के लिए रिफ्लेक्टर करते हैं, तो आपको यह बदलना होगा कि आप ऑब्जेक्ट को उदाहरण में कैसे संदर्भित करते हैं (उदाहरण के लिए a जोड़ें@ )।
• यह थोड़ा व्यक्तिपरक है, लेकिन जैसा कि माइक लुईस ने बताया है, मुझे लगता है कि यह पढ़ना आसान बनाता है। मुझे अपने सभी आश्रित वस्तुओं को परिभाषित करने letऔर अपने itब्लॉक को अच्छा और छोटा रखने का संगठन पसंद है ।

एक संबंधित लिंक यहां पाया जा सकता है: http://www.betterspecs.org/#let

Comments

मैं वास्तव में आपके द्वारा उल्लिखित पहला लाभ पसंद करता हूं, लेकिन क्या आप तीसरे के बारे में कुछ और बता सकते हैं? अब तक मैंने जो उदाहरण देखे हैं (मोंगॉयड स्पेक्स: github.com/mongoid/mongoid/blob/master/spec/functional/mongoid/… ) सिंगल लाइन ब्लॉक्स का उपयोग करते हैं और मैं नहीं देखता कि कैसे "" बनाता है। पढ़ने में आसान।

— भेजा-हिल

जैसा कि मैंने कहा, यह थोड़ा व्यक्तिपरक है, लेकिन मुझे letसभी आश्रित वस्तुओं को परिभाषित करने के लिए, और before(:each)आवश्यक कॉन्फ़िगरेशन या सेटअप के लिए उपयोग करने के लिए उपयोग करने में मदद मिलती है । मैं हुक से पहले एक बड़े से इस सब युक्त पसंद करते हैं। इसके अलावा, let(:foo) { Foo.new }कम शोर है (और इस बिंदु तक अधिक) तब before(:each) { @foo = Foo.new }। मैं इसका उपयोग कैसे करता हूं इसका एक उदाहरण यहां दिया गया है: github.com/myronmarston/vcr/blob/v1.7.0/spec/vcr/util/…

— Myron Marston

उदाहरण के लिए धन्यवाद, कि वास्तव में मदद की।

— भेजा-हिल

एंड्रयू ग्रिम: सच है, लेकिन चेतावनियां शोर उत्पन्न कर सकती हैं (यानी आपके द्वारा रत्नों का उपयोग जो चेतावनी-मुक्त नहीं चलते हैं)। इसके अलावा, मैं NoMethodErrorएक चेतावनी प्राप्त करना पसंद करता हूं , लेकिन YMMV।

— मिरॉन मैरस्टन

@ Jwan622: आप एक उदाहरण लिखकर शुरू कर सकते हैं, जिसमें बाद की तर्ज पर foo = Foo.new(...)उपयोगकर्ता fooहैं। बाद में, आप उसी उदाहरण समूह में एक नया उदाहरण लिखते हैं जिसमें भी Fooउसी तरह एक त्वरित की आवश्यकता होती है। इस बिंदु पर, आप दोहराव को खत्म करने के लिए रिफलेक्टर करना चाहते हैं। आप foo = Foo.new(...)अपने उदाहरणों से लाइनों को हटा सकते हैं और इसे let(:foo) { Foo.new(...) }w / o के साथ बदल सकते हैं कि उदाहरण कैसे उपयोग करते हैं foo। लेकिन अगर आप के लिए रिफ्लेक्टर before { @foo = Foo.new(...) }भी उदाहरण के लिए से संदर्भ में अद्यतन fooकरने के लिए है @foo।

— मायरोन मैरस्टन

Answer 2

उदाहरणों चर और का उपयोग कर के बीच अंतर let()यह है कि let()है आलसी से मूल्यांकन किया । इसका मतलब है कि इसका let()मूल्यांकन तब तक नहीं किया जाता है जब तक कि इसे परिभाषित करने वाली विधि पहली बार नहीं चलती है।

के बीच का अंतर beforeऔर letवह यह है कि let()आप एक 'व्यापक' शैली में चरों के एक समूह को परिभाषित करने का एक अच्छा तरीका देता है। ऐसा करने से, कोड को सरल बनाकर चश्मा थोड़ा बेहतर दिखता है।

Comments

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

— भेजा- hil

आईएमओ को पढ़ना आसान है, और पठनीयता प्रोग्रामिंग भाषाओं का एक बड़ा कारक है।

— माइक लुईस

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

— डेविड चेलिमस्की

तो क्या इसका मतलब यह है कि letअगर आपको हर बार मूल्यांकन करने के लिए किसी चीज की आवश्यकता है तो आपको इसका उपयोग नहीं करना चाहिए ? उदाहरण के लिए मुझे मूल मॉडल पर कुछ व्यवहार शुरू होने से पहले डेटाबेस में एक बच्चे के मॉडल की आवश्यकता होती है। मैं जरूरी नहीं कि परीक्षण में उस बच्चे के मॉडल का उल्लेख कर रहा हूं, क्योंकि मैं मूल मॉडल व्यवहार का परीक्षण कर रहा हूं। फिलहाल मैं let!इसके बजाय विधि का उपयोग कर रहा हूं , लेकिन शायद यह उस सेटअप को लगाने के लिए अधिक स्पष्ट होगा before(:each)?

— गर

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

— हरमून

Answer 3

मैंने अपने rspec परीक्षणों में इंस्टेंस चर के सभी उपयोगों को पूरी तरह से बदल दिया है। मैंने एक दोस्त के लिए एक क्विक उदाहरण लिखा है, जिसने इसका इस्तेमाल एक छोटी Rspec क्लास को पढ़ाने के लिए किया: http://ruby-lambda.blogspot.com/2011/02/agile-rspec-with-let.html

जैसा कि यहां कुछ अन्य उत्तर कहते हैं, चलो () का आलसी मूल्यांकन किया गया है, इसलिए यह केवल उन लोगों को लोड करेगा जिन्हें लोड करने की आवश्यकता होती है। यह कल्पना को पूरा करता है और इसे और अधिक पठनीय बनाता है। मैं वास्तव में विरासत नियंत्रक_श्रेणी मणि की शैली में अपने नियंत्रकों में उपयोग करने के लिए Rspec let () कोड को पोर्ट किया गया हूं। http://ruby-lambda.blogspot.com/2010/06/stealing-let-from-rspec.html

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

मेरे द्वारा उपयोग की जाने वाली रणनीति फ़ैक्टरी-सब कुछ है (माचिनिस्ट + फोर्जरी / फ़ेकर के माध्यम से)। हालांकि, पहले के साथ संयोजन में इसका उपयोग करना संभव है: (प्रत्येक) उदाहरण समूहों के एक पूरे सेट के लिए कारखानों को लोड करने के लिए ब्लॉक करता है, जिससे चश्मा तेजी से चल सकता है: http://makandra.com/notes/770-taking- नुकसान के- rspec-s-जाने में पहले-ब्लॉक

Comments

हे हो-शेंग, मैंने वास्तव में इस प्रश्न को पूछने से पहले आपके कई ब्लॉग पोस्ट पढ़े। अपने उदाहरण # spec/friendship_spec.rbऔर # spec/comment_spec.rbउदाहरण के बारे में , क्या आपको नहीं लगता कि वे इसे कम पठनीय बनाते हैं? मुझे नहीं पता कि कहां से usersआया और गहरी खुदाई करने की आवश्यकता होगी।

— भेजा-हिल

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

— हो-शेंग ह्सियाओ

मेरे द्वारा चलाए गए सबसे बड़े गोच गलती से ({विषय) {} विषय के बजाय {} का उपयोग कर रहे हैं। सब्जेक्ट () को लेट (: सब्जेक्ट) से अलग सेट किया गया है, लेकिन लेट (: सब्जेक्ट) इसे ओवरराइड करेगा।

— हो-शेंग ह्सियाओ

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

— हो-शेंग ह्सियाओ

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

— भेजा-हिल

Answer 4

यह ध्यान में रखना महत्वपूर्ण है कि देना है आलसी मूल्यांकन किया है और डाल नहीं उस में पक्ष प्रभाव तरीकों अन्यथा आप नहीं से बदलने के लिए सक्षम हो जाएगा देना करने के लिए : (प्रत्येक) से पहले आसानी से। आप का उपयोग कर सकते हैं ! के बजाय जाने इतना है कि यह प्रत्येक परिदृश्य से पहले मूल्यांकन किया जाता है।

Answer 5

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

मैंने यह भी पाया है कि let()सभी परिस्थितियों में कैश नहीं लगता है! मैंने इसे अपने ब्लॉग में लिखा है: http://technicaldebt.com/?p=1242

शायद यह सिर्फ मैं ही हूं?

Comments

letहमेशा एकल उदाहरण की अवधि के लिए मान को याद करता है। यह कई उदाहरणों में मूल्य को याद नहीं करता है। before(:all), इसके विपरीत, आप कई उदाहरणों में एक प्रारंभिक चर का फिर से उपयोग करने की अनुमति देता है।

— म्योरॉन मैरस्टन

यदि आप लेट (जैसा कि अब सबसे अच्छा अभ्यास माना जाता है) का उपयोग करना चाहते हैं, लेकिन तुरंत एक विशेष चर की आवश्यकता है, यही वह है जिसके let!लिए डिज़ाइन किया गया है। relishapp.com/rspec/rspec-core/v/2-6/docs/helper-methods/…

— जैकब

Answer 6

चलो कार्यात्मक रूप से अनिवार्य रूप से एक प्रोक है। साथ ही इसकी कैश्ड भी।

एक गेचा मुझे ठीक से जाने दिया गया ... एक विशेष ब्लॉक में जो एक बदलाव का मूल्यांकन कर रहा है।

let(:object) {FactoryGirl.create :object}

expect {
  post :destroy, id: review.id
}.to change(Object, :count).by(-1)

आपको letअपने अपेक्षित ब्लॉक के बाहर कॉल करना सुनिश्चित करना होगा । यानी आप FactoryGirl.createअपने लेट ब्लॉक में कॉल कर रहे हैं । मैं आम तौर पर इस बात को सत्यापित करने के द्वारा करता हूं कि वस्तु बनी हुई है।

object.persisted?.should eq true

अन्यथा जब letब्लॉक को पहली बार कहा जाता है तो डेटाबेस में बदलाव वास्तव में आलसी तात्कालिकता के कारण होगा।

अपडेट करें

सिर्फ एक नोट जोड़ना। इस जवाब के साथ कोड गोल्फ खेलने के मामले में या rspec गोल्फ से सावधान रहें ।

इस मामले में, मुझे बस कुछ विधि को कॉल करना होगा, जिस पर ऑब्जेक्ट प्रतिक्रिया करता है। इसलिए मैं _.persisted?वस्तु पर उसके सत्य के रूप में _ विधि का आह्वान करता हूं । मैं जो कुछ करने की कोशिश कर रहा हूं, वह वस्तु को तुरंत करना है। आप खाली कह सकते हैं? या नील? भी। बिंदु परीक्षण नहीं है, लेकिन वस्तु ओटी जीवन को बुलाकर ला रहा है।

तो आप रिफ्लेक्टर नहीं कर सकते

object.persisted?.should eq true

होने के लिए

object.should be_persisted 

के रूप में वस्तु तात्कालिक नहीं किया गया है ... अपनी आलसी। :)

अपडेट २

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

इसके अलावा कुछ उदाहरणों में आप वास्तव में विषय के सिंटैक्स का लाभ उठाना चाह सकते हैं क्योंकि यह आपको अतिरिक्त विकल्प दे सकता है।

subject(:object) {FactoryGirl.create :object}

Answer 7

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

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

context "foo" do
  let(:params) do
     { :foo => foo,  :bar => "bar" }
  end
  let(:foo) { "foo" }
  it "is set to foo" do
    params[:foo].should eq("foo")
  end
  context "when foo is bar" do
    let(:foo) { "bar" }
    # NOTE we didn't have to redefine params entirely!
    it "is set to bar" do
      params[:foo].should eq("bar")
    end
  end
end

Comments

+1 से पहले (: सभी) बग हमारे डेवलपर्स समय के कई दिनों को बर्बाद कर चुके हैं।

— माइकल ड्यूरेंट

Answer 8

"पहले" डिफ़ॉल्ट रूप से तात्पर्य है before(:each)। रीस्पेक बुक, कॉपीराइट २०१०, पृष्ठ २२ R पर जाएँ।

before(scope = :each, options={}, &block)

मैं " before(:each)उदाहरण let" ब्लॉक में डेटा बनाने के लिए विधि को कॉल किए बिना प्रत्येक उदाहरण समूह के लिए कुछ डेटा बीज करने के लिए उपयोग करता हूं । इस मामले में "इट" ब्लॉक में कम कोड।

मैं उपयोग करता हूं letअगर मुझे कुछ उदाहरणों में कुछ डेटा चाहिए लेकिन दूसरों को नहीं।

पहले और दोनों "इसे" ब्लॉक को DRYing के लिए महान हैं।

किसी भी भ्रम से बचने के लिए, "लेट" समान नहीं है before(:all)। "प्रत्येक उदाहरण (" यह ") के लिए इसकी विधि और मूल्य का पुनर्मूल्यांकन करते हैं, लेकिन एक ही उदाहरण में कई कॉल पर मूल्य को कैश करता है। आप इसके बारे में और अधिक यहाँ पढ़ सकते हैं: https://www.relishapp.com/rspec/rspec-core/v/2-6/docs/helper-methods/let-and-let

Answer 9

यहां आवाज का भंग होना: 5 साल की rspec के बाद मुझे letबहुत पसंद नहीं है।

1. आलसी मूल्यांकन अक्सर परीक्षण सेटअप को भ्रामक बनाता है

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

अंत में, निराशा किसी से बाहर बस में परिवर्तन letकरने के लिए let!ताकि उनकी कल्पना काम कर प्राप्त करने के लिए (आलसी मूल्यांकन के बिना एक ही बात)। यदि यह उनके लिए काम करता है, तो एक नई आदत पैदा होती है: जब एक पुराने सूट में एक नया चश्मा जोड़ा जाता है और यह काम नहीं करता है, तो पहली चीज जो लेखक कोशिश करता है वह है यादृच्छिक letकॉल में बैंग्स जोड़ना ।

बहुत जल्द सभी प्रदर्शन लाभ चले गए हैं।

2. विशेष वाक्यविन्यास गैर-rspec उपयोगकर्ताओं के लिए असामान्य है

मैं बल्कि रूबी को अपनी टीम को rspec के गुर सिखाऊंगा। इस प्रोजेक्ट और अन्य जगहों पर इंस्टेंस वैरिएबल या मेथड कॉल उपयोगी हैं, letसिंटैक्स केवल rspec में उपयोगी होगा।

3. "लाभ" हमें अच्छे डिजाइन परिवर्तनों को आसानी से अनदेखा करने की अनुमति देता है

let()महंगी निर्भरता के लिए अच्छा है जिसे हम बार-बार नहीं बनाना चाहते हैं। यह अच्छी तरह से जोड़े के साथ subject, आपको बहु-तर्क विधियों में बार-बार कॉल को सूखने की अनुमति देता है

महंगी निर्भरताएँ कई बार दोहराई जाती हैं, और बड़े हस्ताक्षर वाले तरीके दोनों ही ऐसे बिंदु हैं जहाँ हम कोड को बेहतर बना सकते हैं:

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

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

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

Answer 10

मैं letसंदर्भों का उपयोग करके अपने एपीआई चश्मे में अपनी HTTP 404 प्रतिक्रियाओं का परीक्षण करने के लिए उपयोग करता हूं।

संसाधन बनाने के लिए, मैं उपयोग करता हूं let!। लेकिन संसाधन पहचानकर्ता को संग्रहीत करने के लिए, मैं उपयोग करता हूं let। एक नज़र डालें कि यह कैसा दिखता है:

let!(:country)   { create(:country) }
let(:country_id) { country.id }
before           { get "api/countries/#{country_id}" }

it 'responds with HTTP 200' { should respond_with(200) }

context 'when the country does not exist' do
  let(:country_id) { -1 }
  it 'responds with HTTP 404' { should respond_with(404) }
end

यह चश्मा साफ और पठनीय रखता है।