puffing-billy 0.4.1 → 0.5.0

data/spec/lib/billy/handlers/handler_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe Billy::Handler do
-  let(:handler) { Class.new{ include Billy::Handler }.new }
+  let(:handler) { Class.new { include Billy::Handler }.new }
   it '#handle_request raises an error if not overridden' do
-    expect(handler.handle_request(nil,nil,nil,nil)).to eql({ error: 'The handler has not overridden the handle_request method!' })
+    expect(handler.handle_request(nil, nil, nil, nil)).to eql(error: 'The handler has not overridden the handle_request method!')
   end
 
   it '#handles_request returns false by default' do
-    expect(handler.handles_request?(nil,nil,nil,nil)).to be false
+    expect(handler.handles_request?(nil, nil, nil, nil)).to be false
   end
 
   it 'responds to #reset' do

data/spec/lib/billy/handlers/proxy_handler_spec.rb

@@ -2,13 +2,15 @@ require 'spec_helper'
 
 describe Billy::ProxyHandler do
   subject { Billy::ProxyHandler.new }
-  let(:request) { {
+  let(:request) do
+    {
       method:   'post',
       url:      'http://example.test:8080/index?some=param',
-      headers:  {'Accept-Encoding'  => 'gzip',
-                 'Cache-Control'    => 'no-cache' },
+      headers:  { 'Accept-Encoding'  => 'gzip',
+                  'Cache-Control'    => 'no-cache' },
       body:     'Some body'
-  } }
+    }
+  end
 
   describe '#handles_request?' do
     context 'with non-whitelisted requests enabled' do
@@ -108,31 +110,31 @@ describe Billy::ProxyHandler do
         header
       end
 
-      let(:em_response)     { double("response") }
-      let(:em_request)      {
-        double("EM::HttpRequest", :error => nil, :response => em_response, :response_header => response_header)
-      }
+      let(:em_response)     { double('response') }
+      let(:em_request)      do
+        double('EM::HttpRequest', error: nil, response: em_response, response_header: response_header)
+      end
 
       before do
         allow(subject).to receive(:handles_request?).and_return(true)
-        allow(em_response).to receive(:force_encoding).and_return("The response body")
+        allow(em_response).to receive(:force_encoding).and_return('The response body')
         allow(EventMachine::HttpRequest).to receive(:new).and_return(em_request)
         expect(em_request).to receive(:post).and_return(em_request)
       end
 
       it 'returns any error in the response' do
-        allow(em_request).to receive(:error).and_return("ERROR!")
+        allow(em_request).to receive(:error).and_return('ERROR!')
         expect(subject.handle_request(request[:method],
                                       request[:url],
                                       request[:headers],
-                                      request[:body])).to eql({ :error => "Request to #{request[:url]} failed with error: ERROR!"})
+                                      request[:body])).to eql(error: "Request to #{request[:url]} failed with error: ERROR!")
       end
 
       it 'returns a hashed response if the request succeeds' do
         expect(subject.handle_request(request[:method],
                                       request[:url],
                                       request[:headers],
-                                      request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>"The response body"})
+                                      request[:body])).to eql(status: 200, headers: { 'Connection' => 'close' }, content: 'The response body')
       end
 
       it 'returns nil if both the error and response are for some reason nil' do
@@ -156,10 +158,10 @@ describe Billy::ProxyHandler do
         allow(Billy.config).to receive(:proxied_request_inactivity_timeout).and_return(42)
         allow(Billy.config).to receive(:proxied_request_connect_timeout).and_return(24)
 
-        expect(EventMachine::HttpRequest).to receive(:new).with(request[:url], {
-            inactivity_timeout: 42,
-            connect_timeout: 24
-        })
+        expect(EventMachine::HttpRequest).to receive(:new).with(request[:url],
+                                                                inactivity_timeout: 42,
+                                                                connect_timeout: 24
+        )
 
         subject.handle_request(request[:method],
                                request[:url],

data/spec/lib/billy/handlers/request_handler_spec.rb

@@ -22,15 +22,17 @@ describe Billy::RequestHandler do
   end
 
   context 'with stubbed handlers' do
-    let(:args) { ["get","url","headers","body"] }
-    let(:stub_handler) { double("StubHandler") }
-    let(:cache_handler) { double("CacheHandler") }
-    let(:proxy_handler) { double("ProxyHandler") }
-    let(:handlers) { {
-        :stubs => stub_handler,
-        :cache => cache_handler,
-        :proxy => proxy_handler
-    } }
+    let(:args) { %w(get url headers body) }
+    let(:stub_handler) { double('StubHandler') }
+    let(:cache_handler) { double('CacheHandler') }
+    let(:proxy_handler) { double('ProxyHandler') }
+    let(:handlers) do
+      {
+        stubs: stub_handler,
+        cache: cache_handler,
+        proxy: proxy_handler
+      }
+    end
 
     before do
       allow(subject).to receive(:handlers).and_return(handlers)
@@ -38,82 +40,82 @@ describe Billy::RequestHandler do
 
     describe '#handles_request?' do
       it 'returns false if no handlers handle the request' do
-        handlers.each do |key,handler|
+        handlers.each do |_key, handler|
           expect(handler).to receive(:handles_request?).with(*args).and_return(false)
         end
         expect(subject.handles_request?(*args)).to be false
       end
 
       it 'returns true immediately if the stub handler handles the request' do
-        expect(stub_handler).to       receive(:handles_request?).with(*args).and_return(true)
-        expect(cache_handler).to_not  receive(:handles_request?)
-        expect(proxy_handler).to_not  receive(:handles_request?)
+        expect(stub_handler).to receive(:handles_request?).with(*args).and_return(true)
+        expect(cache_handler).to_not receive(:handles_request?)
+        expect(proxy_handler).to_not receive(:handles_request?)
         expect(subject.handles_request?(*args)).to be true
       end
 
       it 'returns true if the cache handler handles the request' do
-        expect(stub_handler).to       receive(:handles_request?).with(*args).and_return(false)
-        expect(cache_handler).to      receive(:handles_request?).with(*args).and_return(true)
-        expect(proxy_handler).to_not  receive(:handles_request?)
+        expect(stub_handler).to receive(:handles_request?).with(*args).and_return(false)
+        expect(cache_handler).to receive(:handles_request?).with(*args).and_return(true)
+        expect(proxy_handler).to_not receive(:handles_request?)
         expect(subject.handles_request?(*args)).to be true
       end
 
       it 'returns true if the proxy handler handles the request' do
-        expect(stub_handler).to   receive(:handles_request?).with(*args).and_return(false)
-        expect(cache_handler).to  receive(:handles_request?).with(*args).and_return(false)
-        expect(proxy_handler).to  receive(:handles_request?).with(*args).and_return(true)
+        expect(stub_handler).to receive(:handles_request?).with(*args).and_return(false)
+        expect(cache_handler).to receive(:handles_request?).with(*args).and_return(false)
+        expect(proxy_handler).to receive(:handles_request?).with(*args).and_return(true)
         expect(subject.handles_request?(*args)).to be true
       end
     end
 
     describe '#handle_request' do
       it 'returns stubbed responses' do
-        expect(stub_handler).to       receive(:handle_request).with(*args).and_return("foo")
-        expect(cache_handler).to_not  receive(:handle_request)
-        expect(proxy_handler).to_not  receive(:handle_request)
-        expect(subject.handle_request(*args)).to eql "foo"
+        expect(stub_handler).to receive(:handle_request).with(*args).and_return('foo')
+        expect(cache_handler).to_not receive(:handle_request)
+        expect(proxy_handler).to_not receive(:handle_request)
+        expect(subject.handle_request(*args)).to eql 'foo'
       end
 
       it 'returns cached responses' do
-        expect(stub_handler).to       receive(:handle_request).with(*args)
-        expect(cache_handler).to      receive(:handle_request).with(*args).and_return("bar")
-        expect(proxy_handler).to_not  receive(:handle_request)
-        expect(subject.handle_request(*args)).to eql "bar"
+        expect(stub_handler).to receive(:handle_request).with(*args)
+        expect(cache_handler).to receive(:handle_request).with(*args).and_return('bar')
+        expect(proxy_handler).to_not receive(:handle_request)
+        expect(subject.handle_request(*args)).to eql 'bar'
       end
 
       it 'returns proxied responses' do
-        expect(stub_handler).to       receive(:handle_request).with(*args)
-        expect(cache_handler).to      receive(:handle_request).with(*args)
-        expect(proxy_handler).to      receive(:handle_request).with(*args).and_return("baz")
-        expect(subject.handle_request(*args)).to eql "baz"
+        expect(stub_handler).to receive(:handle_request).with(*args)
+        expect(cache_handler).to receive(:handle_request).with(*args)
+        expect(proxy_handler).to receive(:handle_request).with(*args).and_return('baz')
+        expect(subject.handle_request(*args)).to eql 'baz'
       end
 
       it 'returns an error hash if request is not handled' do
-        expect(stub_handler).to       receive(:handle_request).with(*args)
-        expect(cache_handler).to      receive(:handle_request).with(*args)
-        expect(proxy_handler).to      receive(:handle_request).with(*args)
-        expect(subject.handle_request(*args)).to eql({ :error => "Connection to url not cached and new http connections are disabled" })
+        expect(stub_handler).to receive(:handle_request).with(*args)
+        expect(cache_handler).to receive(:handle_request).with(*args)
+        expect(proxy_handler).to receive(:handle_request).with(*args)
+        expect(subject.handle_request(*args)).to eql(error: 'Connection to url not cached and new http connections are disabled')
       end
 
       it 'returns an error hash with body message if POST request is not handled' do
         args[0] = 'post'
-        expect(stub_handler).to       receive(:handle_request).with(*args)
-        expect(cache_handler).to      receive(:handle_request).with(*args)
-        expect(proxy_handler).to      receive(:handle_request).with(*args)
-        expect(subject.handle_request(*args)).to eql({ :error => "Connection to url with body 'body' not cached and new http connections are disabled" })
+        expect(stub_handler).to receive(:handle_request).with(*args)
+        expect(cache_handler).to receive(:handle_request).with(*args)
+        expect(proxy_handler).to receive(:handle_request).with(*args)
+        expect(subject.handle_request(*args)).to eql(error: "Connection to url with body 'body' not cached and new http connections are disabled")
       end
     end
 
     describe '#stub' do
       it 'delegates to the stub_handler' do
-        expect(stub_handler).to receive(:stub).with("some args")
-        subject.stub("some args")
+        expect(stub_handler).to receive(:stub).with('some args')
+        subject.stub('some args')
       end
     end
 
     describe '#reset' do
       it 'resets all of the handlers' do
-        handlers.each do |key,handler|
+        handlers.each do |_key, handler|
           expect(handler).to receive(:reset)
         end
         subject.reset

data/spec/lib/billy/handlers/stub_handler_spec.rb

@@ -2,42 +2,44 @@ require 'spec_helper'
 
 describe Billy::StubHandler do
   let(:handler) { Billy::StubHandler.new }
-  let(:request) { {
+  let(:request) do
+    {
       method:   'GET',
       url:      'http://example.test:8080/index?some=param',
-      headers:  {'Accept-Encoding'  => 'gzip',
-                 'Cache-Control'    => 'no-cache' },
+      headers:  { 'Accept-Encoding'  => 'gzip',
+                  'Cache-Control'    => 'no-cache' },
       body:     'Some body'
-  } }
+    }
+  end
 
   describe '#handles_request?' do
     it 'handles the request if it is stubbed' do
-      expect(handler).to receive(:find_stub).and_return("a stub")
-      expect(handler.handles_request?(nil,nil,nil,nil)).to be true
+      expect(handler).to receive(:find_stub).and_return('a stub')
+      expect(handler.handles_request?(nil, nil, nil, nil)).to be true
     end
 
     it 'does not handle the request if it is not stubbed' do
       expect(handler).to receive(:find_stub).and_return(nil)
-      expect(handler.handles_request?(nil,nil,nil,nil)).to be false
+      expect(handler.handles_request?(nil, nil, nil, nil)).to be false
     end
   end
 
   describe '#handle_request' do
     it 'returns nil if the request is not stubbed' do
       expect(handler).to receive(:handles_request?).and_return(false)
-      expect(handler.handle_request(nil,nil,nil,nil)).to be nil
+      expect(handler.handle_request(nil, nil, nil, nil)).to be nil
     end
 
     it 'returns a response hash if the request is stubbed' do
-      stub = double("stub", :call => [200, {'Content-Type' => 'application/json'}, "Some content"])
+      stub = double('stub', call: [200, { 'Content-Type' => 'application/json' }, 'Some content'])
       expect(handler).to receive(:handles_request?).and_return(true)
       expect(handler).to receive(:find_stub).and_return(stub)
       expect(handler.handle_request('GET',
                                     request[:url],
                                     request[:headers],
-                                    request[:body])).to eql({:status => 200,
-                                                             :headers => {'Content-Type' => 'application/json'},
-                                                             :content => "Some content"})
+                                    request[:body])).to eql(status: 200,
+                                                            headers: { 'Content-Type' => 'application/json' },
+                                                            content: 'Some content')
     end
   end
 

data/spec/lib/billy/proxy_request_stub_spec.rb

@@ -3,27 +3,27 @@ require 'spec_helper'
 describe Billy::ProxyRequestStub do
   context '#matches?' do
     it 'should match urls and methods' do
-      expect(Billy::ProxyRequestStub.new('http://example.com').
-        matches?('GET', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://example.com').
-        matches?('POST', 'http://example.com')).to_not be
-
-      expect(Billy::ProxyRequestStub.new('http://example.com', :method => :get).
-        matches?('GET', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://example.com', :method => :post).
-        matches?('GET', 'http://example.com')).to_not be
-
-      expect(Billy::ProxyRequestStub.new('http://example.com', :method => :post).
-        matches?('POST', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new('http://fooxample.com', :method => :post).
-        matches?('POST', 'http://example.com')).to_not be
+      expect(Billy::ProxyRequestStub.new('http://example.com')
+        .matches?('GET', 'http://example.com')).to be
+      expect(Billy::ProxyRequestStub.new('http://example.com')
+        .matches?('POST', 'http://example.com')).to_not be
+
+      expect(Billy::ProxyRequestStub.new('http://example.com', method: :get)
+        .matches?('GET', 'http://example.com')).to be
+      expect(Billy::ProxyRequestStub.new('http://example.com', method: :post)
+        .matches?('GET', 'http://example.com')).to_not be
+
+      expect(Billy::ProxyRequestStub.new('http://example.com', method: :post)
+        .matches?('POST', 'http://example.com')).to be
+      expect(Billy::ProxyRequestStub.new('http://fooxample.com', method: :post)
+        .matches?('POST', 'http://example.com')).to_not be
     end
 
     it 'should match regexps' do
-      expect(Billy::ProxyRequestStub.new(/http:\/\/.+\.com/, :method => :post).
-        matches?('POST', 'http://example.com')).to be
-      expect(Billy::ProxyRequestStub.new(/http:\/\/.+\.co\.uk/, :method => :get).
-        matches?('GET', 'http://example.com')).to_not be
+      expect(Billy::ProxyRequestStub.new(/http:\/\/.+\.com/, method: :post)
+        .matches?('POST', 'http://example.com')).to be
+      expect(Billy::ProxyRequestStub.new(/http:\/\/.+\.co\.uk/, method: :get)
+        .matches?('GET', 'http://example.com')).to_not be
     end
 
     it 'should match up to but not including query strings' do
@@ -34,11 +34,24 @@ describe Billy::ProxyRequestStub do
     end
   end
 
-  context "#call (without #and_return)" do
+  context "#matches? (with strip_query_params false in config)" do
+    before do
+      Billy.config.strip_query_params = false
+    end
+
+    it 'should not match up to request with query strings' do
+      stub = Billy::ProxyRequestStub.new('http://example.com/foo/bar/')
+      expect(stub.matches?('GET', 'http://example.com/foo/')).to_not be
+      expect(stub.matches?('GET', 'http://example.com/foo/bar/')).to be
+      expect(stub.matches?('GET', 'http://example.com/foo/bar/?baz=bap')).to_not be
+    end
+  end
+
+  context '#call (without #and_return)' do
     let(:subject) { Billy::ProxyRequestStub.new('url') }
 
-    it "returns a 204 empty response" do
-      expect(subject.call({}, {}, nil)).to eql [204, {"Content-Type" => "text/plain"}, ""]
+    it 'returns a 204 empty response' do
+      expect(subject.call({}, {}, nil)).to eql [204, { 'Content-Type' => 'text/plain' }, '']
     end
   end
 
@@ -46,7 +59,7 @@ describe Billy::ProxyRequestStub do
     let(:subject) { Billy::ProxyRequestStub.new('url') }
 
     it 'should generate bare responses' do
-      subject.and_return :body => 'baz foo bar'
+      subject.and_return body: 'baz foo bar'
       expect(subject.call({}, {}, nil)).to eql [
         200,
         {},
@@ -55,75 +68,75 @@ describe Billy::ProxyRequestStub do
     end
 
     it 'should generate text responses' do
-      subject.and_return :text => 'foo bar baz'
+      subject.and_return text: 'foo bar baz'
       expect(subject.call({}, {}, nil)).to eql [
         200,
-        {'Content-Type' => 'text/plain'},
+        { 'Content-Type' => 'text/plain' },
         'foo bar baz'
       ]
     end
 
     it 'should generate JSON responses' do
-      subject.and_return :json => { :foo => 'bar' }
+      subject.and_return json: { foo: 'bar' }
       expect(subject.call({}, {}, nil)).to eql [
         200,
-        {'Content-Type' => 'application/json'},
+        { 'Content-Type' => 'application/json' },
         '{"foo":"bar"}'
       ]
     end
 
     context 'JSONP' do
       it 'should generate JSONP responses' do
-        subject.and_return :jsonp => { :foo => 'bar' }
+        subject.and_return jsonp: { foo: 'bar' }
         expect(subject.call({ 'callback' => ['baz'] }, {}, nil)).to eql [
           200,
-          {'Content-Type' => 'application/javascript'},
+          { 'Content-Type' => 'application/javascript' },
           'baz({"foo":"bar"})'
         ]
       end
 
       it 'should generate JSONP responses with custom callback parameter' do
-        subject.and_return :jsonp => { :foo => 'bar' }, :callback_param => 'cb'
+        subject.and_return jsonp: { foo: 'bar' }, callback_param: 'cb'
         expect(subject.call({ 'cb' => ['bap'] }, {}, nil)).to eql [
           200,
-          {'Content-Type' => 'application/javascript'},
+          { 'Content-Type' => 'application/javascript' },
           'bap({"foo":"bar"})'
         ]
       end
 
       it 'should generate JSONP responses with custom callback name' do
-        subject.and_return :jsonp => { :foo => 'bar' }, :callback => 'cb'
+        subject.and_return jsonp: { foo: 'bar' }, callback: 'cb'
         expect(subject.call({}, {}, nil)).to eql [
           200,
-          {'Content-Type' => 'application/javascript'},
+          { 'Content-Type' => 'application/javascript' },
           'cb({"foo":"bar"})'
         ]
       end
     end
 
     it 'should generate redirection responses' do
-      subject.and_return :redirect_to => 'http://example.com'
+      subject.and_return redirect_to: 'http://example.com'
       expect(subject.call({}, {}, nil)).to eql [
         302,
-        {'Location' => 'http://example.com'},
+        { 'Location' => 'http://example.com' },
         nil
       ]
     end
 
     it 'should set headers' do
-      subject.and_return :text => 'foo', :headers => {'HTTP-X-Foo' => 'bar'}
+      subject.and_return text: 'foo', headers: { 'HTTP-X-Foo' => 'bar' }
       expect(subject.call({}, {}, nil)).to eql [
         200,
-        {'Content-Type' => 'text/plain', 'HTTP-X-Foo' => 'bar'},
+        { 'Content-Type' => 'text/plain', 'HTTP-X-Foo' => 'bar' },
         'foo'
       ]
     end
 
     it 'should set status codes' do
-      subject.and_return :text => 'baz', :code => 410
+      subject.and_return text: 'baz', code: 410
       expect(subject.call({}, {}, nil)).to eql [
         410,
-        {'Content-Type' => 'text/plain'},
+        { 'Content-Type' => 'text/plain' },
         'baz'
       ]
     end
@@ -133,15 +146,15 @@ describe Billy::ProxyRequestStub do
       expected_headers = { 'header1' => 'three', 'header2' => 'four' }
       expected_body = 'body text'
 
-      subject.and_return(Proc.new { |params, headers, body|
+      subject.and_return(proc do |params, headers, body|
         expect(params).to eql expected_params
         expect(headers).to eql expected_headers
         expect(body).to eql 'body text'
-        {:code => 418, :text => 'success'}
-      })
+        { code: 418, text: 'success' }
+      end)
       expect(subject.call(expected_params, expected_headers, expected_body)).to eql [
         418,
-        {'Content-Type' => 'text/plain'},
+        { 'Content-Type' => 'text/plain' },
         'success'
       ]
     end