रुपयेपेक

Question

के साथ मिडलवेयर परीक्षण करना मैंने कुछ रैक-मिडलवेयर लिखा है और अब मैं इसे रुपयेपेक के साथ परीक्षण करने की कोशिश कर रहा हूं। लेकिन सभी रैक-मिडलवेयर को 'ऐप' तर्क के साथ तुरंत चालू किया जाता है, जो रेल ऐप का प्रतिनिधित्व करता है। आप लोग इसेपेपेक में कैसे मजाक करते हैं?

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

describe MyMiddleWare do 
    let(:app) { # How do I mock a Rails app object here? } 
    subject { MyMiddleWare.new(app: app) } 

    it 'should blah blah blah' do 
     # a bunch of tests go here 
    end 
end 

Answer 1

आप की तरह मेरा परीक्षण किया

let(:app) { lambda {|env| [200, {'Content-Type' => 'text/plain'}, ['OK']]} } 

इसके अलावा, आपके मिडलवेयर के निर्माता अपनी पहली parame के रूप में एक एप्लिकेशन प्राप्त करना चाहिए: सिर्फ दुनिया का सबसे सरल रैक एप्लिकेशन की आवश्यकता है Ter नहीं तो यह पढ़ना चाहिए एक हैश:

subject { MyMiddleWare.new(app) } 

सभी संभावना में, हालांकि, अपने परीक्षण निर्धारित करने के लिए क्या प्रभाव मिडलवेयर अनुरोध पर किया गया है की जरूरत जा रहा है। तो आप अपने मिडलवेयर पर जासूसी करने के लिए थोड़ा और परिष्कृत रैक ऐप लिख सकते हैं।

class MockRackApp 

    attr_reader :request_body 

    def initialize 
    @request_headers = {} 
    end 

    def call(env) 
    @env = env 
    @request_body = env['rack.input'].read 
    [200, {'Content-Type' => 'text/plain'}, ['OK']] 
    end 

    def [](key) 
    @env[key] 
    end 

end 

और फिर आप वास्तव में अनुरोध भेजने के लिए रैक :: MockRequest का उपयोग करना चाहेंगे। कुछ ऐसा:

describe MyMiddleWare do 

    let(:app) { MockRackApp.new } 
    subject { described_class.new(app) } 

    context "when called with a POST request" do 
    let(:request) { Rack::MockRequest.new(subject) } 
    before(:each) do 
     request.post("/some/path", input: post_data, 'CONTENT_TYPE' => 'text/plain') 
    end 

    context "with some particular data" do 
     let(:post_data) { "String or IO post data" } 

     it "passes the request through unchanged" do 
     expect(app['CONTENT_TYPE']).to eq('text/plain') 
     expect(app['CONTENT_LENGTH'].to_i).to eq(post_data.length) 
     expect(app.request_body).to eq(post_data) 
     end 
    end 
    end 
end 

Answer 2

मेरा मानना ​​है कि आप एक HTTP अनुरोध अनुकरण अनुरोध चश्मा का उपयोग करना चाहिए (अपने मिडलवेयर में रेल मिडलवेयर ढेर शामिल किया जाना चाहिए)। Rspec अनुरोध चश्मा here पर अधिक जानकारी देखें।

युपीडी मुझे लगता है कि मैंने पाया कि वास्तव में क्या आप टेस्ट :: यूनिट के साथ की जरूरत है, है, लेकिन यह RSpec के लिए पुनर्लेखन के लिए आसान है: rack-ssl-enforcer

Answer 3

मैं इतना

describe Support::CharConverter do 

    let(:env_hash) do 
    { 
     "HTTP_REFERER" => "", 
     "PATH_INFO" => "foo", 
     "QUERY_STRING" => "bar", 
     "REQUEST_PATH" => "is", 
     "REQUEST_URI" => "here", 
    } 
    end 

    subject do 
    Support::CharConverter.new(env_hash) 
    end 

    context 'sanitize_env' do 

    it 'should keep key values the same if nothing to sanitize' do 
     sanitized_hash = subject.sanitize_env(env_hash) 
     # k = env_hash.keys[5] 
     # v = env_hash.values[5] 
     env_hash.each do |k, v| 
     sanitized_hash[k].encoding.name.should eq("US-ASCII") 
     sanitized_hash[k].should eq(v) 
     sanitized_hash[k].valid_encoding?.should eq(true) 
     end 
    end 
    end 
end