puffing-billy 3.0.0 → 3.0.1

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

@@ -1,258 +0,0 @@
-require 'spec_helper'
-
-describe Billy::ProxyHandler do
-  subject { Billy::ProxyHandler.new }
-  let(:request) do
-    {
-      method:   'post',
-      url:      'http://usern:pw@example.test:8080/index?some=param',
-      headers:  { 'Accept-Encoding'  => 'gzip',
-                  'Cache-Control'    => 'no-cache' },
-      body:     'Some body'
-    }
-  end
-
-  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 'as a regex' do
-          before do
-            expect(Billy.config).to receive(:whitelist) { [%r{example\.test\/a}] }
-          end
-
-          it 'handles requests for the host without a port' do
-            expect(subject.handles_request?(request[:method],
-                                            'http://example.test/a',
-                                            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/a',
-                                            request[:headers],
-                                            request[:body])).to be true
-          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)      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(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 'does NOT cache the response if the host is whitelisted but not cache_whitelisted' do
-        uri = Addressable::URI.parse(request[:url])
-
-        expect(subject).to receive(:allowed_response_code?).and_return(true)
-        expect(Billy.config).to receive(:whitelist).and_return([uri.host])
-        expect(Billy.config).to receive(:cache_whitelist).and_return([])
-
-        expect(Billy::Cache.instance).not_to receive(:store)
-        subject.handle_request(request[:method],
-                               request[:url],
-                               request[:headers],
-                               request[:body])
-      end
-
-      it 'caches the response if the host is whitelisted AND cache_whitelisted' do
-        uri = Addressable::URI.parse(request[:url])
-
-        expect(subject).to receive(:allowed_response_code?).and_return(true)
-        expect(Billy.config).to receive(:whitelist).and_return([uri.host])
-        expect(Billy.config).to receive(:cache_whitelist).and_return([uri.host])
-
-        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
-
-      it 'uses the internal proxy settings defined in configuration' do
-        allow(Billy.config).to receive(:proxied_request_host).and_return('10.10.10.10')
-        allow(Billy.config).to receive(:proxied_request_port).and_return('2080')
-
-        expect(EventMachine::HttpRequest).to receive(:new).with(request[:url],
-                                                                {
-                                                                  inactivity_timeout: 10,
-                                                                  connect_timeout: 5,
-                                                                  proxy: { host: '10.10.10.10', port: '2080' }
-                                                                }
-        )
-
-        subject.handle_request(request[:method],
-                               request[:url],
-                               request[:headers],
-                               request[:body])
-      end
-    end
-  end
-
-  describe '#build_request_options' do
-    it 'creates authorization header when URL has basic auth' do
-      request_options = subject.send(:build_request_options, request[:url],
-                                                             request[:headers],
-                                                             request[:body])
-      expect(request_options[:head]).to have_key 'authorization'
-    end
-
-    it 'does not include authorization header without basic auth' do
-      request_options = subject.send(:build_request_options, request[:url].gsub('usern:pw@',''),
-                                                             request[:headers],
-                                                             request[:body])
-      expect(request_options[:head]).not_to have_key 'authorization'
-    end
-  end
-end

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

@@ -1,200 +0,0 @@
-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) { %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)
-    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
-      before do
-        allow(Billy::config).to receive(:record_requests).and_return(true)
-      end
-
-      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(subject.requests).to eql([{status: :complete, handler: :stubs, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-      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(subject.requests).to eql([{status: :complete, handler: :cache, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-      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(subject.requests).to eql([{status: :complete, handler: :proxy, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-      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(subject.requests).to eql([{status: :complete, handler: :error, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-      end
-
-      it 'returns an error hash with body message if request cached based on body is not handled' do
-        args[0] = Billy.config.cache_request_body_methods[0]
-        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(subject.requests).to eql([{status: :complete, handler: :error, method: 'post', url: 'url', headers: 'headers', body: 'body'}])
-      end
-
-      it 'returns an error hash on unhandled exceptions' do
-        # Allow handling requests initially
-        allow(stub_handler).to receive(:handle_request)
-        allow(cache_handler).to receive(:handle_request)
-
-        allow(proxy_handler).to receive(:handle_request).and_raise("Any Proxy Error")
-        expect(subject.handle_request(*args)).to eql(error: "Any Proxy Error")
-
-        allow(cache_handler).to receive(:handle_request).and_raise("Any Cache Error")
-        expect(subject.handle_request(*args)).to eql(error: "Any Cache Error")
-
-        allow(stub_handler).to receive(:handle_request).and_raise("Any Stub Error")
-        expect(subject.handle_request(*args)).to eql(error: "Any Stub Error")
-      end
-
-      context 'before_handle_request activated' do
-        before do
-          handle_request = proc { |method, url, headers, body|
-            [method, url, headers, "#{body}_modified"]
-          }
-          allow(Billy::config).to receive(:before_handle_request).and_return(handle_request)
-        end
-
-        after do
-          allow(Billy::config).to receive(:before_handle_request).and_call_original
-        end
-
-        it 'modify request before handling' do
-          new_args = %w(get url headers body_modified)
-          expect(stub_handler).to receive(:handle_request).with(*new_args)
-          expect(cache_handler).to receive(:handle_request).with(*new_args).and_return('bar')
-          expect(proxy_handler).to_not receive(:handle_request)
-          expect(subject.handle_request(*args)).to eql 'bar'
-          expect(subject.requests).to eql([{status: :complete, handler: :cache, method: 'get', url: 'url', headers: 'headers', body: 'body'}])
-        end
-      end
-    end
-
-    describe '#stubs' do
-      it 'delegates to the stub_handler' do
-        expect(stub_handler).to receive(:stubs)
-        subject.stubs
-      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
-        expect(subject.request_log).to receive(:reset)
-        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

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

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe Billy::RequestLog do
-  let(:request_log) { Billy::RequestLog.new }
-
-  describe '#record' do
-    it 'returns the request details if record_requests is enabled' do
-      allow(Billy::config).to receive(:record_requests).and_return(true)
-      expected_request = {
-        status: :inflight,
-        handler: nil,
-        method: :method,
-        url: :url,
-        headers: :headers,
-        body: :body
-      }
-      expect(request_log.record(:method, :url, :headers, :body)).to eql(expected_request)
-    end
-
-    it 'returns nil if record_requests is disabled' do
-      allow(Billy::config).to receive(:record_requests).and_return(false)
-      expect(request_log.record(:method, :url, :headers, :body)).to be_nil
-    end
-  end
-
-  describe '#complete' do
-    it 'marks the request as complete if record_requests is enabled' do
-      allow(Billy::config).to receive(:record_requests).and_return(true)
-
-      request = request_log.record(:method, :url, :headers, :body)
-      expected_request = {
-        status: :complete,
-        handler: :handler,
-        method: :method,
-        url: :url,
-        headers: :headers,
-        body: :body
-      }
-      expect(request_log.complete(request, :handler)).to eql(expected_request)
-    end
-
-    it 'marks the request as complete if record_requests is disabled' do
-      allow(Billy::config).to receive(:record_requests).and_return(false)
-      expect(request_log.complete(nil, :handler)).to be_nil
-    end
-  end
-
-  describe '#requests' do
-    it 'returns an empty array when there are no requests' do
-      expect(request_log.requests).to be_empty
-    end
-
-    it 'returns the currently known requests' do
-      allow(Billy::config).to receive(:record_requests).and_return(true)
-
-      request1 = request_log.record(:method, :url, :headers, :body)
-      request2 = request_log.record(:method, :url, :headers, :body)
-      expect(request_log.requests).to eql([request1, request2])
-    end
-  end
-
-  describe '#reset' do
-    it 'resets known requests' do
-      allow(Billy::config).to receive(:record_requests).and_return(true)
-
-      request1 = request_log.record(:method, :url, :headers, :body)
-      request2 = request_log.record(:method, :url, :headers, :body)
-      expect(request_log.requests).to eql([request1, request2])
-
-      request_log.reset
-      expect(request_log.requests).to be_empty
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-require 'spec_helper'
-
-describe Billy::StubHandler do
-  let(:handler) { Billy::StubHandler.new }
-  let(:request) do
-    {
-      method:   'GET',
-      url:      'http://example.test:8080/index?some=param',
-      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
-    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
-    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
-    end
-
-    it 'returns a response hash if the request is stubbed' do
-      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')
-    end
-  end
-
-  describe '#reset' do
-    it 'resets the stubs' do
-      # Can't use request params when creating the stub.
-      # See https://github.com/oesmith/puffing-billy/issues/21
-      stub = handler.stub('http://example.test:8080/index')
-
-      expect(handler.stubs).to eql([stub])
-      expect(handler.handles_request?('GET',
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to be true
-      handler.reset
-      expect(handler.stubs).to be_empty
-      expect(handler.handles_request?('GET',
-                                      request[:url],
-                                      request[:headers],
-                                      request[:body])).to be false
-    end
-  end
-
-  describe '#unstub' do
-    let!(:get_stub) { handler.stub('http://example.get/') }
-    let!(:post_stub) { handler.stub('http://example.post/', method: :post) }
-
-    it 'removes a single stub' do
-      expect(handler.handles_request?('GET',
-                                      'http://example.get/',
-                                      request[:headers],
-                                      request[:body])).to be true
-      expect(handler.handles_request?('POST',
-                                      'http://example.post/',
-                                      request[:headers],
-                                      request[:body])).to be true
-
-      handler.unstub get_stub
-
-      expect(handler.handles_request?('GET',
-                                      'http://example.get/',
-                                      request[:headers],
-                                      request[:body])).to be false
-      expect(handler.handles_request?('POST',
-                                      'http://example.post/',
-                                      request[:headers],
-                                      request[:body])).to be true
-    end
-
-    it 'does not raise errors for not existing stub' do
-      expect { handler.unstub 'http://example.option/' }.not_to raise_error
-    end
-  end
-
-  it '#stubs requests' do
-    handler.stub('http://example.test:8080/index')
-    expect(handler.handles_request?('GET',
-                                    request[:url],
-                                    request[:headers],
-                                    request[:body])).to be true
-  end
-
-  describe '#stubs' do
-    it 'is empty by default' do
-      expect(handler.stubs).to be_empty
-    end
-
-    it 'keeps track of created stubs' do
-      stub1 = handler.stub('http://example.test:8080/index')
-      stub2 = handler.stub('http://example.test:8080/index')
-
-      expect(handler.stubs).to eql([stub2, stub1])
-    end
-  end
-end

data/spec/lib/billy/proxy_connection_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Billy::ProxyConnection do
-  context '#prepare_response_headers_for_evma_httpserver' do
-    let(:subject) { Billy::ProxyConnection.new('') }
-    
-    it 'should remove duplicated headers fields' do
-        provided_headers = {
-            'transfer-encoding' => '',
-            'content-length' => '',
-            'content-encoding' => '',
-            'key' => 'value'
-        }
-        expected_headers = { 'key' => 'value' }
-        headers = subject.send(:prepare_response_headers_for_evma_httpserver, provided_headers)
-
-        expect(headers).to eql expected_headers
-    end
-  end
-end