agile-proxy 0.1.0

data/spec/unit/agile_proxy/handlers/handler_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe AgileProxy::Handler do
+  let(:handler) { Class.new { include AgileProxy::Handler }.new }
+  it '#handle_request raises an error if not overridden' do
+    expect(handler.call(nil)).to eql([500, {}, 'The handler has not overridden the handle_request method!'])
+  end
+end

data/spec/unit/agile_proxy/handlers/proxy_handler_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe AgileProxy::ProxyHandler do
+  subject { AgileProxy::ProxyHandler.new }
+  let(:request) do
+    ActionDispatch::Request.new to_rack_env(
+                                                method: 'post',
+                                                url: 'http://example.test:8080/index?some=param',
+                                                headers: { 'Accept-Encoding' => 'gzip',
+                                                           'Cache-Control' => 'no-cache' },
+                                                body: 'Some body'
+                                            )
+  end
+
+  def request_for_url(url)
+    ActionDispatch::Request.new to_rack_env(
+                                                method: 'post',
+                                                url: url,
+                                                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(AgileProxy.config).to receive(:non_whitelisted_requests_disabled).and_return(false)
+      end
+    end
+    context 'with non-whitelisted requests disabled' do
+      before do
+        expect(AgileProxy.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.send(:handles_request?, request)).to be_falsy
+      end
+
+      context 'a whitelisted host' do
+        context 'with a blacklisted path' do
+          before do
+            expect(AgileProxy.config).to receive(:path_blacklist) { ['/index'] }
+          end
+
+          it 'does not handle requests for blacklisted paths' do
+            req = request_for_url 'http://example.test:8080/index?some=param'
+            expect(subject.send(:handles_request?, req)).to be_falsy
+          end
+        end
+        context 'without a port' do
+          before do
+            expect(AgileProxy.config).to receive(:whitelist) { ['example.test'] }
+          end
+
+          it 'handles requests for the host without a port' do
+            req = request_for_url 'http://example.test'
+            expect(subject.send(:handles_request?, req)).to be_truthy
+          end
+
+          it 'handles requests for the host with a port' do
+            req = request_for_url 'http://example.test:8080'
+            expect(subject.send(:handles_request?, req)).to be_truthy
+          end
+        end
+
+        context 'with a port' do
+          before do
+            expect(AgileProxy.config).to receive(:whitelist) { ['example.test:8080'] }
+          end
+
+          it 'does not handle requests whitelisted for a specific port' do
+            req = request_for_url 'http://example.test'
+            expect(subject.send(:handles_request?, req)).to be_falsy
+          end
+
+          it 'handles requests for the host with a port' do
+            req = request_for_url 'http://example.test:8080'
+            expect(subject.send(:handles_request?, req)).to be_truthy
+          end
+        end
+      end
+    end
+  end
+
+  describe '#call' do
+    it 'returns nil if it does not handle the request' do
+      expect(subject).to receive(:handles_request?).and_return(false)
+      expect(subject.call(request.env)).to eql [404, {}, 'Not proxied']
+    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 'Should pass through a not allowed response' do
+        allow(response_header).to receive(:status).and_return(503)
+        expect(subject.call(request.env)).to eql [503, { 'Connection' => 'close' }, 'The response body']
+      end
+      it 'returns any error in the response' do
+        allow(em_request).to receive(:error).and_return('ERROR!')
+        expect(subject.call(request.env)).to eql([500, {}, "Request to #{request.url} failed with error: ERROR!"])
+      end
+
+      it 'returns a hashed response if the request succeeds' do
+        expect(subject.call(request.env)).to eql([200, { 'Connection' => 'close' }, '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.call(request.env)).to eql [404, {}, 'Not proxied']
+      end
+
+      it 'uses the timeouts defined in configuration' do
+        allow(AgileProxy.config).to receive(:proxied_request_inactivity_timeout).and_return(42)
+        allow(AgileProxy.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.call(request.env)
+      end
+    end
+  end
+end

data/spec/unit/agile_proxy/handlers/request_handler_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe AgileProxy::RequestHandler do
+  subject { AgileProxy::RequestHandler.new }
+
+  it 'implements Handler' do
+    expect(subject).to be_a AgileProxy::Handler
+  end
+
+  context 'with stubbed handlers' do
+    let(:env) { to_rack_env(url: 'http://dummy.host.com/index.html') }
+    let(:stub_handler) { Class.new }
+    let(:proxy_handler) { Class.new }
+    let(:application_class) { Class.new }
+    let(:recordings_class) { Class.new }
+    let(:application) { double('Application', record_requests: false, recordings: recordings_class) }
+
+    before do
+      stub_const 'AgileProxy::StubHandler', stub_handler
+      stub_const 'AgileProxy::ProxyHandler', proxy_handler
+      stub_const 'AgileProxy::Application', application_class
+      allow(application_class).to receive(:where).and_return [application]
+    end
+
+    describe '#call' do
+      it 'returns error 500 if no handlers handle the request' do
+        expect_any_instance_of(stub_handler).to receive(:call).and_return [404, {}, 'It didnt work']
+        expect_any_instance_of(proxy_handler).to receive(:call).and_return [404, {}, 'It didnt work']
+        expect(subject.call(env)).to start_with [500, {}]
+      end
+
+      it 'returns 200 immediately if the stub handler handles the request' do
+        expect_any_instance_of(stub_handler).to receive(:call).with(env).and_return [200, {}, 'Some data']
+        expect_any_instance_of(proxy_handler).to_not receive(:call)
+        expect(subject.call(env)).to eql [200, {}, 'Some data']
+      end
+
+      it 'returns true if the proxy handler handles the request' do
+        expect_any_instance_of(stub_handler).to receive(:call).with(env).and_return [404, {}, 'Irrelevant']
+        expect_any_instance_of(proxy_handler).to receive(:call).with(env).and_return [200, {}, 'Some data']
+        expect(subject.call(env)).to eql [200, {}, 'Some data']
+      end
+
+      it 'Calls application.recordings.create if record_requests is true' do
+        allow(application).to receive(:record_requests).and_return true
+        expect(application.recordings).to receive(:create)
+        expect_any_instance_of(stub_handler).to receive(:call).with(env).and_return [200, {}, 'Some data']
+        expect_any_instance_of(proxy_handler).to_not receive(:call)
+        expect(subject.call(env)).to eql [200, {}, 'Some data']
+      end
+
+    end
+
+  end
+end

data/spec/unit/agile_proxy/handlers/stub_handler_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe AgileProxy::StubHandler do
+  let(:route_not_found_response) { [404, { 'X-Cascade' => 'pass' }, ['Not Found']] }
+  let(:handler) { AgileProxy::StubHandler.new }
+  let(:request) do
+    request_for(
+        method: 'GET',
+        url: 'http://example.test:8080/index?some=param',
+        headers: { 'Accept-Encoding' => 'gzip',
+                   'Cache-Control' => 'no-cache' }
+    )
+  end
+  let(:application_class) { Class.new }
+  let(:request_spec_class) { Class.new }
+  let(:application) { application_class.new }
+
+  def request_for(options)
+    request = ActionDispatch::Request.new(to_rack_env(options))
+    request.params
+    request
+  end
+
+  before :each do
+    stub_const('AgileProxy::Application', application_class)
+    allow(application_class).to receive(:where).and_return application_class
+    allow(application_class).to receive(:first).and_return application
+    allow(application).to receive(:request_specs).and_return request_spec_class
+  end
+  describe 'With find_stub mocked' do
+
+    describe '#handle_request' do
+      it 'returns 404 if the request is not stubbed' do
+        stub = double('stub', http_method: 'GET', url: 'http://example.test:8080/index', conditions: {}, call: [404, {}, 'Not found'])
+        expect(request_spec_class).to receive(:where).and_return double('association', all: [stub])
+        expect(handler.call(to_rack_env(url: 'http://example.test:8080/index'))).to eql [404, {}, 'Not found']
+      end
+
+      it 'returns a response hash if the request is stubbed' do
+        stub = double('stub', http_method: 'GET', url: 'http://example.test:8080/index', conditions: {}, call: [200, { 'Content-Type' => 'application/json' }, 'Some content'])
+        expect(request_spec_class).to receive(:where).and_return double('association', all: [stub])
+        expect(handler.call(request.env)).to eql([200, { 'Content-Type' => 'application/json' }, 'Some content'])
+      end
+      it 'Passes on the correct parameters to the stub call method' do
+        stub = double('stub', http_method: 'GET', url: 'http://example.test:8080/index', conditions: {})
+        expect(request_spec_class).to receive(:where).and_return double('association', all: [stub])
+        body = request.body.read
+        request.body.rewind
+        expect(stub).to receive(:call).with({ some: 'param' }, { 'Accept-Encoding' => 'gzip', 'Cache-Control' => 'no-cache' }, body).and_return([200, { 'Content-Type' => 'application/json' }, 'Some Content'])
+        expect(handler.call(request.env)).to eql([200, { 'Content-Type' => 'application/json' }, 'Some Content'])
+
+      end
+      describe 'Routing patterns' do
+        describe 'With a simple GET match on the root of a domain' do
+          let(:request_stub) { double 'stub', url: 'http://example.com', http_method: 'GET', conditions: {} }
+          before :each do
+            allow(request_spec_class).to receive(:where).with('url LIKE ?', 'http://example.com%').and_return double('association', all: [request_stub])
+            allow(request_spec_class).to receive(:where).with('url LIKE ?', 'http://subdomain.example.com%').and_return double('association', all: [])
+            allow(request_stub).to receive(:call).and_return([200, {}, ''])
+          end
+          it 'Should match with a get on the same domain but not with a post or a different domain' do
+            expect(handler.call(request_for(url: 'http://example.com').env)).to eql([200, {}, ''])
+            expect(handler.call(request_for(url: 'http://example.com/').env)).to eql([200, {}, ''])
+            expect(handler.call(request_for(url: 'http://example.com/', method: 'POST').env)).to eql route_not_found_response
+            expect(handler.call(request_for(url: 'http://subdomain.example.com/').env)).to eql route_not_found_response
+          end
+
+        end
+        describe 'With a simple GET match inside a domain' do
+          let(:request_stub) { double 'stub for simple get inside a domain', url: 'http://example.com/index', http_method: 'GET', conditions: {} }
+          before :each do
+            allow(request_spec_class).to receive(:where).with('url LIKE ?', 'http://example.com%').and_return double('association', all: [request_stub])
+            allow(request_spec_class).to receive(:where).with('url LIKE ?', 'http://subdomain.example.com%').and_return double('association', all: [])
+            expect(request_stub).to receive(:call).and_return([200, {}, ''])
+          end
+          it 'Should match with a get on the same domain but not with a post or a different domain' do
+            expect(handler.call(request_for(url: 'http://example.com/index').env)).to eql([200, {}, ''])
+            expect(handler.call(request_for(method: 'POST', url: 'http://example.com/index').env)).to eql route_not_found_response
+            expect(handler.call(request_for(url: 'http://subdomain.example.com/index').env)).to eql route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/').env)).to eql route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com').env)).to eql route_not_found_response
+          end
+
+        end
+        describe 'With a simple POST match on the root of a domain' do
+          let(:request_stub) { double 'stub', url: 'http://example.com', http_method: 'POST', conditions: {} }
+          before :each do
+            allow(request_spec_class).to receive(:where).with('url LIKE ?', 'http://example.com%').and_return double('association', all: [request_stub])
+            allow(request_spec_class).to receive(:where).with('url LIKE ?', 'http://subdomain.example.com%').and_return double('association', all: [])
+            allow(request_stub).to receive(:call).and_return([200, {}, ''])
+          end
+          it 'Should match with a post on the same domain but not with a get or a post on a different domain' do
+            expect(handler.call(request_for(method: 'POST', url: 'http://example.com').env)).to eql([200, {}, ''])
+            expect(handler.call(request_for(method: 'POST', url: 'http://example.com/').env)).to eql([200, {}, ''])
+            expect(handler.call(request_for(url: 'http://example.com/').env)).to eql route_not_found_response
+            expect(handler.call(request_for(method: 'POST', url: 'http://subdomain.example.com/').env)).to eql route_not_found_response
+          end
+
+        end
+        describe 'With a more complex route with conditions inside a domain' do
+          let(:request_stub) { double 'stub for complex route inside a domain', url: 'http://example.com/users/:user_id/index', http_method: 'GET', conditions: { user_id: '1' }.to_json }
+          before :each do
+            allow(request_spec_class).to receive(:where).with('url LIKE ?', 'http://example.com%').and_return double('association', all: [request_stub])
+            expect(request_stub).to receive(:call).and_return([200, {}, ''])
+          end
+          it 'Should match with a get on the same domain but not with a post or a different domain' do
+            expect(handler.call(request_for(url: 'http://example.com/users/1/index').env)).to eql([200, {}, ''])
+            expect(handler.call(request_for(url: 'http://example.com/users/2/index').env)).to eql route_not_found_response
+            expect(handler.call(request_for(method: 'POST', url: 'http://example.com/users/1/index').env)).to eql route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/users/1/').env)).to eql route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/users/1').env)).to eql route_not_found_response
+          end
+        end
+        describe 'With a more complex route with conditions including query params inside a domain' do
+          let(:request_stub) { double 'stub for complex route inside a domain', url: 'http://example.com/users/:user_id/index', http_method: 'GET', conditions: { user_id: '1', extra_1: 'extra_1', extra_2: 'extra_2' }.to_json }
+          before :each do
+            allow(request_spec_class).to receive(:where).with('url LIKE ?', 'http://example.com%').and_return double('association', all: [request_stub])
+            allow(request_stub).to receive(:call).and_return([200, {}, ''])
+          end
+          it 'Should match with a get on the same domain but not with a post or a different domain' do
+            expect(handler.call(request_for(url: 'http://example.com/users/1/index?extra_1=extra_1&extra_2=extra_2').env)).to eql([200, {}, ''])
+            expect(handler.call(request_for(url: 'http://example.com/users/1/index?some_other=2&extra_1=extra_1&extra_2=extra_2').env)).to eql([200, {}, ''])
+            expect(handler.call(request_for(url: 'http://example.com/users/2/index').env)).to eql route_not_found_response
+            expect(handler.call(request_for(method: 'POST', url: 'http://example.com/users/1/index').env)).to eql route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/users/1/').env)).to eql route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/users/1').env)).to eql route_not_found_response
+          end
+        end
+
+        # it 'should match regexps' do
+        #   expect(AgileProxy::RequestSpec.new(:url => "http:\/\/.+\.com", :method => :post, :regex => true).
+        #              matches?('POST', 'http://example.com')).to be
+        #   expect(AgileProxy::RequestSpec.new(:url => "http:\/\/.+\.co\.uk", :method => :get, :regex => true).
+        #              matches?('GET', 'http://example.com')).to_not be
+        # end
+        #
+        # it 'should match up to but not including query strings' do
+        #   stub = AgileProxy::RequestSpec.new(:url => '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 be
+        # end
+        # it 'Should match routes using pattern matching' do
+        #   stub = AgileProxy::RequestSpec.new(:url => "http://example.com/users/:user_id/application/:application_id")
+        #   expect(stub.matches?('GET', 'http://example.com/users/user_id/application/application_id')).to be
+        #   expect(stub.matches?('GET', 'http://example.com/users/user_id/somethingelse/application_id')).not_to be
+        # end
+
+      end
+    end
+
+  end
+
+end

data/spec/unit/agile_proxy/model/request_spec_spec.rb

@@ -0,0 +1,45 @@
+require 'agile_proxy/model/request_spec'
+describe AgileProxy::RequestSpec do
+  let(:response_class) do
+    Class.new do
+      def initialize(config = {})
+        @config = config
+      end
+      attr_accessor :config
+
+    end
+  end
+  let(:mock_response) { response_class.new }
+  before :each do
+    stub_const('AgileProxy::Response', response_class)
+  end
+  it 'Should allow a nested response' do
+    subject.should accept_nested_attributes_for(:response)
+  end
+  it 'Should belong to a user' do
+    expect(subject).to belong_to(:user)
+  end
+  it 'Should belong to an application' do
+    expect(subject).to belong_to(:application)
+  end
+  it 'Should belong to a response' do
+    expect(subject).to belong_to(:response)
+  end
+
+  describe 'Interface for the stub handler' do
+    context '#call (without #and_return)' do
+      let(:subject) { AgileProxy::RequestSpec.new(url: 'url') }
+      it 'returns a 204 empty response' do
+        expect(subject).to receive(:response).and_return nil
+        expect(subject.call({}, {}, nil)).to eql [204, { 'Content-Type' => 'text/plain' }, '']
+      end
+    end
+    context '#call With conditions' do
+      let(:subject) { AgileProxy::RequestSpec.new(url: 'url', conditions: '{"a": 1, "b": 2}') }
+      it 'returns a the correct json' do
+        expect(subject.conditions_json).to eql('a' => 1, 'b' => 2)
+      end
+
+    end
+  end
+end

data/spec/unit/agile_proxy/model/response_spec.rb

@@ -0,0 +1,38 @@
+require 'em-synchrony'
+require 'spec_helper'
+describe AgileProxy::Response do
+  it 'Should have many requests ' do
+    expect(subject).to have_many(:request_specs)
+  end
+  it 'Should serialize the headers in json format' do
+    expect(subject).to serialize(:headers)
+  end
+  describe 'With a configured delay' do
+    before :each do
+      subject.delay = 0.5
+      subject.content = 'Test'
+      subject.content_type = 'text/plain'
+    end
+    it 'Should respond with a delay using the Em::Synchrony.sleep method' do
+      expect(EventMachine::Synchrony).to receive(:sleep).with(0.5)
+      expect(subject.to_rack({}, {}, '')).to eql([200, { 'Content-Type' => 'text/plain' }, 'Test'])
+    end
+
+  end
+  describe 'Using templates' do
+    describe 'Using text' do
+      before :each do
+        subject.is_template = true
+        subject.content = 'Hello {{name}}'
+        subject.content_type = 'text/plain'
+      end
+      it 'Should pass the params to the template and the output should be correct' do
+        expect(subject.to_rack({ name: 'World' }, {}, '')).to eql([200, { 'Content-Type' => 'text/plain' }, 'Hello World'])
+      end
+      it 'Should deal with if a parameter is missing' do
+        expect(subject.to_rack({}, {}, '')).to eql([500, { 'Content-Type' => 'text/plain' }, "Missing var or method 'name' in data."])
+      end
+    end
+  end
+
+end