puffing-billy 0.2.3 → 0.3.0

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

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Billy::CacheHandler do
+  let(:handler) { Billy::CacheHandler.new }
+  let(:request) { {
+      method:   'post',
+      url:      'http://example.test:8080/index?some=param&callback=dynamicCallback5678',
+      headers:  {'Accept-Encoding'  => 'gzip',
+                 'Cache-Control'    => 'no-cache' },
+      body:     'Some body'
+  } }
+
+  it 'delegates #reset to the cache' do
+    expect(Billy::Cache.instance).to receive(:reset).at_least(:once)
+    handler.reset
+  end
+
+  it 'delegates #cached? to the cache' do
+    expect(Billy::Cache.instance).to receive :cached?
+    handler.cached?
+  end
+
+  describe '#handles_request?' do
+    it 'handles the request if it is cached' do
+      expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
+      expect(handler.handles_request?(nil,nil,nil,nil)).to be true
+    end
+
+    it 'does not handle the request if it is not cached' do
+      expect(Billy::Cache.instance).to receive(:cached?).and_return(false)
+      expect(handler.handles_request?(nil,nil,nil,nil)).to be false
+    end
+  end
+
+  describe '#handle_request' do
+    it 'returns nil if the request cannot be handled' do
+      expect(Billy::Cache.instance).to receive(:cached?).and_return(false)
+      expect(handler.handle_request(request[:method],
+                                    request[:url],
+                                    request[:headers],
+                                    request[:body])).to be nil
+    end
+
+    it 'returns a cached response if the request can be handled' do
+      expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
+      expect(Billy::Cache.instance).to receive(:fetch).and_return({:status=>200, :headers=>{"Connection"=>"close"}, :content=>"The response body"})
+      expect(handler.handle_request(request[:method],
+                                    request[:url],
+                                    request[:headers],
+                                    request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>"The response body"})
+    end
+
+    context 'updating jsonp callback names enabled' do
+      before do
+        Billy.config.dynamic_jsonp = true
+      end
+
+      it 'updates the cached response if the callback is dynamic' do
+        expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
+        expect(Billy::Cache.instance).to receive(:fetch).and_return({:status=>200, :headers=>{"Connection"=>"close"}, :content=> 'dynamicCallback1234({"yolo":"kitten"})'})
+        expect(handler.handle_request(request[:method],
+                                      request[:url],
+                                      request[:headers],
+                                      request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>'dynamicCallback5678({"yolo":"kitten"})'})
+      end
+
+      it 'is flexible about the format of the response body' do
+        expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
+        expect(Billy::Cache.instance).to receive(:fetch).and_return({:status=>200, :headers=>{"Connection"=>"close"}, :content=> "/**/ dynamicCallback1234(\n{\"yolo\":\"kitten\"})"})
+        expect(handler.handle_request(request[:method],
+                                      request[:url],
+                                      request[:headers],
+                                      request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>"/**/ dynamicCallback5678(\n{\"yolo\":\"kitten\"})"})
+      end
+
+      it 'does not interfere with non-jsonp requests' do
+        jsonp_request = request
+        other_request = {
+          method:  'get',
+          url:     'http://example.test:8080/index?hanukkah=latkes',
+          headers: {'Accept-Encoding'=>'gzip', 'Cache-Control'=>'no-cache' },
+          body:    'no jsonp'
+        }
+
+        allow(Billy::Cache.instance).to receive(:cached?).and_return(true)
+        allow(Billy::Cache.instance).to receive(:fetch).with(jsonp_request[:method], jsonp_request[:url], jsonp_request[:body]).and_return({:status=>200,
+                      :headers=>{"Connection"=>"close"},
+                      :content=> 'dynamicCallback1234({"yolo":"kitten"})'})
+        allow(Billy::Cache.instance).to receive(:fetch).with(other_request[:method], other_request[:url], other_request[:body]).and_return({:status=>200,
+                      :headers=>{"Connection"=>"close"},
+                      :content=> 'no jsonp but has parentheses()'})
+
+        expect(handler.handle_request(other_request[:method],
+          other_request[:url],
+          other_request[:headers],
+          other_request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>'no jsonp but has parentheses()'})
+      end
+    end
+
+    context 'updating jsonp callback names disabled' do
+      before do
+        Billy.config.dynamic_jsonp = false
+      end
+
+      it 'does not change the response' do
+        expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
+        expect(Billy::Cache.instance).to receive(:fetch).and_return({:status=>200, :headers=>{"Connection"=>"close"}, :content=> 'dynamicCallback1234({"yolo":"kitten"})'})
+        expect(handler.handle_request(request[:method],
+                                      request[:url],
+                                      request[:headers],
+                                      request[:body])).to eql({:status=>200, :headers=>{"Connection"=>"close"}, :content=>'dynamicCallback1234({"yolo":"kitten"})'})
+      end
+    end
+
+    it 'returns nil if the Cache fails to handle the response for some reason' do
+      expect(Billy::Cache.instance).to receive(:cached?).and_return(true)
+      expect(Billy::Cache.instance).to receive(:fetch).and_return(nil)
+      expect(handler.handle_request(request[:method],
+                                    request[:url],
+                                    request[:headers],
+                                    request[:body])).to be nil
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Billy::Handler do
+  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!' })
+  end
+
+  it '#handles_request returns false by default' do
+    expect(handler.handles_request?(nil,nil,nil,nil)).to be false
+  end
+
+  it 'responds to #reset' do
+    expect(handler).to respond_to :reset
+  end
+end

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

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe Billy::ProxyHandler do
+  subject { Billy::ProxyHandler.new }
+  let(:request) { {
+      method:   'post',
+      url:      'http://example.test:8080/index?some=param',
+      headers:  {'Accept-Encoding'  => 'gzip',
+                 'Cache-Control'    => 'no-cache' },
+      body:     'Some body'
+  } }
+
+  describe '#handles_request?' do
+    context 'with non-whitelisted requests enabled' do
+      before do
+        expect(Billy.config).to receive(:non_whitelisted_requests_disabled).and_return(false)
+      end
+
+      it 'handles all requests' do
+        expect(subject.handles_request?(request[:method],
+                                        request[:url],
+                                        request[:headers],
+                                        request[:body])).to be true
+      end
+    end
+    context 'with non-whitelisted requests disabled' do
+      before do
+        expect(Billy.config).to receive(:non_whitelisted_requests_disabled).and_return(true)
+      end
+
+      it 'does not handle requests that are not white or black listed' do
+        expect(subject.handles_request?(request[:method],
+                                        request[:url],
+                                        request[:headers],
+                                        request[:body])).to be false
+      end
+
+      context 'a whitelisted host' do
+        context 'with a blacklisted path' do
+          before do
+            expect(Billy.config).to receive(:path_blacklist) { ['/index'] }
+          end
+
+          it 'does not handle requests for blacklisted paths' do
+            expect(subject.handles_request?(request[:method],
+                                            'http://example.test:8080/index?some=param',
+                                            request[:headers],
+                                            request[:body])).to be false
+          end
+        end
+        context 'without a port' do
+          before do
+            expect(Billy.config).to receive(:whitelist) { ['example.test'] }
+          end
+
+          it 'handles requests for the host without a port' do
+            expect(subject.handles_request?(request[:method],
+                                            'http://example.test',
+                                            request[:headers],
+                                            request[:body])).to be true
+          end
+
+          it 'handles requests for the host with a port' do
+            expect(subject.handles_request?(request[:method],
+                                            'http://example.test:8080',
+                                            request[:headers],
+                                            request[:body])).to be true
+          end
+        end
+
+        context 'with a port' do
+          before do
+            expect(Billy.config).to receive(:whitelist) { ['example.test:8080'] }
+          end
+
+          it 'does not handle requests whitelisted for a specific port' do
+            expect(subject.handles_request?(request[:method],
+                                            'http://example.test',
+                                            request[:headers],
+                                            request[:body])).to be false
+          end
+
+          it 'handles requests for the host with a port' do
+            expect(subject.handles_request?(request[:method],
+                                            'http://example.test:8080',
+                                            request[:headers],
+                                            request[:body])).to be true
+          end
+        end
+      end
+    end
+  end
+
+  describe '#handle_request' do
+    it 'returns nil if it does not handle the request' do
+      expect(subject).to receive(:handles_request?).and_return(false)
+      expect(subject.handle_request(request[:method],
+                                    request[:url],
+                                    request[:headers],
+                                    request[:body])).to be nil
+    end
+
+    context 'with a handled request' do
+      let(:response_header) do
+        header = Struct.new(:status, :raw).new
+        header.status = 200
+        header.raw = {}
+        header
+      end
+
+      let(:em_response)     { double("response") }
+      let(:em_request)      {
+        double("EM::HttpRequest", :error => nil, :response => em_response, :response_header => response_header)
+      }
+
+      before do
+        allow(subject).to receive(:handles_request?).and_return(true)
+        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!")
+        expect(subject.handle_request(request[:method],
+                                      request[:url],
+                                      request[:headers],
+                                      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"})
+      end
+
+      it 'returns nil if both the error and response are for some reason nil' do
+        allow(em_request).to receive(:response).and_return(nil)
+        expect(subject.handle_request(request[:method],
+                                      request[:url],
+                                      request[:headers],
+                                      request[:body])).to be nil
+      end
+
+      it 'caches the response if cacheable' do
+        expect(subject).to receive(:allowed_response_code?).and_return(true)
+        expect(Billy::Cache.instance).to receive(:store)
+        subject.handle_request(request[:method],
+                               request[:url],
+                               request[:headers],
+                               request[:body])
+      end
+
+      it 'uses the timeouts defined in configuration' 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
+        })
+
+        subject.handle_request(request[:method],
+                               request[:url],
+                               request[:headers],
+                               request[:body])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Billy::RequestHandler do
+  subject { Billy::RequestHandler.new }
+
+  it 'implements Handler' do
+    expect(subject).to be_a Billy::Handler
+  end
+
+  describe '#handlers' do
+    it 'has a stub handler' do
+      expect(subject.handlers[:stubs]).to be_a Billy::StubHandler
+    end
+
+    it 'has a cache handler' do
+      expect(subject.handlers[:cache]).to be_a Billy::CacheHandler
+    end
+
+    it 'has a proxy handler' do
+      expect(subject.handlers[:proxy]).to be_a Billy::ProxyHandler
+    end
+  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
+    } }
+
+    before do
+      allow(subject).to receive(:handlers).and_return(handlers)
+    end
+
+    describe '#handles_request?' do
+      it 'returns false if no handlers handle the request' do
+        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(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(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(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"
+      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"
+      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"
+      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" })
+      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" })
+      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")
+      end
+    end
+
+    describe '#reset' do
+      it 'resets all of the handlers' do
+        handlers.each do |key,handler|
+          expect(handler).to receive(:reset)
+        end
+        subject.reset
+      end
+    end
+
+    describe '#reset_stubs' do
+      it 'resets the stub handler' do
+        expect(stub_handler).to receive(:reset)
+        subject.reset_stubs
+      end
+    end
+
+    describe '#reset_cache' do
+      it 'resets the cache handler' do
+        expect(cache_handler).to receive(:reset)
+        subject.reset_cache
+      end
+    end
+
+    describe '#restore_cache' do
+      it 'resets the cache handler' do
+        expect(cache_handler).to receive(:reset)
+        subject.reset_cache
+      end
+    end
+  end
+end