ruby on rails - आरएसपीसी का उपयोग कब करें()?




ruby-on-rails tdd (6)

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

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

ब्लॉक से पहले आवृत्ति चर का उपयोग करने से यह अलग कैसे है? और आपको कब let() बनाम before() बनाते हैं?


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

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


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

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

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

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


डिफ़ॉल्ट रूप से "पहले" से before(:each) तात्पर्य है। आरपीईसी बुक, कॉपीराइट 2010, पृष्ठ 228 रेफरी करें।

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

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

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

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

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


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

संसाधन बनाने के लिए, मैं उपयोग 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

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


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


यूसुफ को ध्यान दें - यदि आप before(:all) डेटाबेस डेटाबेस बना रहे हैं 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






bdd