agile-proxy-jruby 0.1.25-jruby

data/spec/unit/agile_proxy/api/request_specs_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+require_relative 'common_helper'
+require 'rack/test'
+
+describe AgileProxy::Api::RequestSpecs, api_test: true do
+  include Rack::Test::Methods
+  include AgileProxy::Test::Api::Common
+  let(:applications_assoc_class) do
+    Class.new do
+    end
+  end
+  let(:request_spec_assoc_class) do
+    Class.new do
+      def self.destroy_all
+      end
+    end
+  end
+  let(:application_instance) { applications_assoc_class.new }
+  before :each do
+    expect(current_user).to receive(:applications).at_least(:once).and_return(applications_assoc_class)
+    expect(applications_assoc_class).to receive(:where).with(id: '1').at_least(:once).and_return applications_assoc_class
+    expect(applications_assoc_class).to receive(:first).at_least(:once).and_return application_instance
+    expect(application_instance).to receive(:request_specs).and_return request_spec_assoc_class
+  end
+  let(:default_json_spec) { { include: { response: { except: [:created_at, :updated_at] } } } }
+
+  # def mock_collection_data
+  #   @__all_request_specs ||= [double('HttpFlexiblePrAgileProxy', :id => 1),double('AgileProxy::ReAgileProxy=> 2),double('AgileProxy::RequestSpAgileProxyeach do |d|
+  #     allow(d).to receive(:as_json).with(default_json_spec).and_return({:spec => "Spec #{d.id}"}.as_json)
+  #   end
+  # end
+  # def mock_collection_association
+  #   return @__mock_collection_association if @__mock_collection_association.present?
+  #   @__mock_collection_association = double('Mock Association')
+  #   @__mock_collection_association.tap do |o|
+  #     allow(o).to receive(:total_count).and_return 3
+  #     allow(o).to receive(:num_pages).and_return 1
+  #     allow(o).to receive(:current_page).and_return 1
+  #     allow(o).to receive(:next_page).and_return nil
+  #     allow(o).to receive(:prev_page).and_return nil
+  #     allow(o).to receive(:page).and_return o
+  #     allow(o).to receive(:per).and_return o
+  #     allow(o).to receive(:padding).and_return o
+  #   end
+  #   allow(@__mock_collection_association).to receive(:as_json).with(default_json_spec).and_return(mock_collection_data.as_json(default_json_spec))
+  #   allow(@__mock_collection_association).to receive(:count).and_return 3
+  #   allow(@__mock_collection_association).to receive(:where) do |options|
+  #     if options.key?(:id)
+  #       mock_collection_data.select{|r| r.id.to_s == options[:id]}
+  #     else
+  #       throw "mock_collection_association called with an unknown where clause of #{where.to_json}"
+  #     end
+  #   end
+  #   @__mock_collection_association
+  # end
+  # def created_member(attrs)
+  #   double("AgileProxy::RequestSpec", attrs.merge({:as_json => {"spec" => attrs[:spec]}}))
+  # end
+  describe 'GET /users/1/applications/1/request_specs' do
+    let(:request_specs_result) do
+      [{ 'spec' => 'Spec 1' }, { 'spec' => 'Spec 2' }, { 'spec' => 'Spec 3' }]
+    end
+    before :each do
+      expect(request_spec_assoc_class).to receive(:page).and_return request_spec_assoc_class
+      expect(request_spec_assoc_class).to receive(:per).and_return request_spec_assoc_class
+      expect(request_spec_assoc_class).to receive(:padding).and_return request_spec_assoc_class
+      expect(request_spec_assoc_class).to receive(:total_count).and_return 3
+      expect(request_spec_assoc_class).to receive(:num_pages).and_return 1
+      expect(request_spec_assoc_class).to receive(:current_page).and_return 1
+      expect(request_spec_assoc_class).to receive(:next_page).and_return 1
+      expect(request_spec_assoc_class).to receive(:prev_page).and_return 1
+      expect(request_spec_assoc_class).to receive(:count).and_return 3
+      expect(request_spec_assoc_class).to receive(:as_json).with(default_json_spec).and_return request_specs_result
+    end
+    it 'returns a populated array of request specs' do
+      get '/v1/users/1/applications/1/request_specs'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)).to eq('request_specs' => [{ 'spec' => 'Spec 1' }, { 'spec' => 'Spec 2' }, { 'spec' => 'Spec 3' }], 'total' => 3)
+    end
+    it 'Should not list items from a different application'
+    it 'Should not list items that belong to a different user'
+  end
+  describe '/users/1/applications/1/request_specs/2' do
+    let(:request_spec_instance) { request_spec_assoc_class.new }
+    let(:persisted_attributes) { { user_id: 1, application_id: 1, url: 'http://www.test.com', http_method: 'GET' } }
+    before :each do
+      expect(request_spec_assoc_class).to receive(:where).with(id: '2').and_return request_spec_assoc_class
+      expect(request_spec_assoc_class).to receive(:first).and_return request_spec_instance
+      expect(request_spec_instance).to receive(:as_json).with(default_json_spec).and_return persisted_attributes
+    end
+    describe 'GET' do
+      it 'returns a single item in json format' do
+        get '/v1/users/1/applications/1/request_specs/2'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)
+      end
+      it 'Should not find a request spec which does not belong to the application specified'
+      it 'Should not find a request spec which does not belong to the user specified'
+    end
+    describe 'PUT' do
+      it 'Should update an existing item with the attributes given' do
+        expect(current_user).to receive(:id).and_return(1)
+        expect(application_instance).to receive(:id).and_return(1)
+        expect(request_spec_instance).to receive(:update_attributes).with(spec: 'Renamed Spec 2', user_id: 1, application_id: 1).and_return true
+        put '/v1/users/1/applications/1/request_specs/2', { spec: 'Renamed Spec 2' }.to_json, 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq 200
+        expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)  # Note that the mocked update_attributes doesnt actually update so the original json is expected
+      end
+    end
+    describe 'DELETE' do
+      it 'Should delete the existing item and return it in json form' do
+        expect(request_spec_instance).to receive(:destroy)
+        delete '/v1/users/1/applications/1/request_specs/2'
+        expect(last_response.status).to eq 200
+        expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)
+      end
+      it 'Should not allow deleting of other peoples request specs'
+    end
+  end
+  describe 'POST /users/1/applications/1/request_specs' do
+    let(:request_spec_instance) { request_spec_assoc_class.new }
+    let(:persisted_attributes) { { user_id: 1, application_id: 1, url: 'http://www.test.com', http_method: 'GET', record_requests: true } }
+    before :each do
+      expect(request_spec_instance).to receive(:as_json).with(default_json_spec).and_return(persisted_attributes)
+      expect(current_user).to receive(:id).and_return(1)
+      expect(application_instance).to receive(:id).and_return(1)
+    end
+    it 'Should create a new item with the correct attributes set' do
+      expect(request_spec_assoc_class).to receive(:create).with(spec: 'Spec 4', user_id: 1, application_id: 1).and_return request_spec_instance
+      post '/v1/users/1/applications/1/request_specs', { spec: 'Spec 4' }.to_json, 'CONTENT_TYPE' => 'application/json'
+      expect([200, 201]).to include(last_response.status)
+      expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)
+    end
+    it 'Should allow creating of a response object also' do
+      response_attributes = { name: 'Test Response', content: '<h1>Hello World</h1>', content_type: 'text/html', status_code: 200, headers: '{}', is_template: false }
+      expect(request_spec_assoc_class).to receive(:create).with(spec: 'Spec 4', user_id: 1, application_id: 1, response_attributes: Hashie::Mash.new(response_attributes)).and_return request_spec_instance
+      post '/v1/users/1/applications/1/request_specs', { spec: 'Spec 4', response: response_attributes }.to_json, 'CONTENT_TYPE' => 'application/json'
+      expect([200, 201]).to include(last_response.status)
+      expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)
+    end
+    it 'Should inform the router of the new entry'
+    it 'Should not allow the user to specify the user_id to prevent creating for a different user'
+    it 'Should not allow setting of an application_id which doesnt belong to the current user'
+  end
+  describe 'DELETE /users/1/applications/1/request_specs' do
+    before :each do
+      expect(request_spec_assoc_class).to receive(:destroy_all)
+    end
+    it 'Should delete all request specs for the users application' do
+      delete '/v1/users/1/applications/1/request_specs'
+      expect(JSON.parse(last_response.body).symbolize_keys).to eq(request_specs: [], total: 0)
+
+    end
+  end
+  it 'Should not find other peoples request specs to update'
+  it 'Should not allow updates of the user_id to prevent changing ownership'
+  it 'Should not allow updates of the application_id to prevent changing ownership via the application'
+  it 'Should inform the router of the update if the spec or response has changed'
+end

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', 'Cache-Control' => 'max-age=3600' }, ['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', 'Cache-Control' => 'max-age=3600' }, ['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,76 @@
+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').merge('agile_proxy.request_spec' => mock_request_spec) }
+    let(:stub_handler) { Class.new }
+    let(:proxy_handler) { Class.new }
+    let(:application_class) { Class.new }
+    let(:recordings_class) { Class.new }
+    let(:rack_builder_class) {Class.new}
+    let(:get_only_cache_class) {Class.new}
+    let(:application) { double('Application', record_requests: false, recordings: recordings_class) }
+    let(:mock_request_spec) {double('RequestSpec', id: 8, record_requests: false)}
+
+    before do
+      stub_const 'AgileProxy::StubHandler', stub_handler
+      stub_const 'AgileProxy::ProxyHandler', proxy_handler
+      stub_const 'AgileProxy::Application', application_class
+      stub_const '::Rack::Builder', rack_builder_class
+      stub_const 'AgileProxy::Rack::GetOnlyCache', get_only_cache_class
+      allow(application_class).to receive(:where).and_return [application]
+      #Make the rack builder just pass through whatever is passed to 'run' - to avoid the caching middleware etc..
+      rack_builder_instance = rack_builder_class.new
+      allow(rack_builder_class).to receive(:new) do |&blk|
+        rack_builder_instance.instance_eval(&blk)
+      end
+      allow(rack_builder_instance).to receive(:use).with(get_only_cache_class)
+      allow(rack_builder_instance).to receive(:run) do |app|
+        app
+      end
+    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 with a reference to the stub if record_requests is true on the application' do
+        allow(application).to receive(:record_requests).and_return true
+        expect(application.recordings).to receive(:create).with(a_hash_including request_spec_id: 8)
+        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 'Calls application.recordings.create with a reference to the stub if record_requests is true on the request spec' do
+        allow(mock_request_spec).to receive(:record_requests).and_return true
+        expect(application.recordings).to receive(:create).with(a_hash_including request_spec_id: 8)
+        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,177 @@
+require 'spec_helper'
+
+describe AgileProxy::StubHandler do
+  #Mock the content length middleware as we are not testing if that works
+  let(:rack_content_length_class) do
+    Class.new do
+      def initialize(app)
+        @app = app
+      end
+      def call(env)
+        @app.call(env)
+      end
+    end
+  end
+  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)
+    stub_const('Rack::ContentLength', rack_content_length_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_json: {}, call: [404, {}, 'Not found'], id: 5)
+        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_json: {}, call: [200, { 'Content-Type' => 'application/json' }, 'Some content'], id: 5)
+        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_json: {}, id: 5)
+        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
+      it 'should store the id of the request spec in the rack environment when call is called' do
+        stub = double('stub', http_method: 'GET', url: 'http://example.test:8080/index', conditions_json: {}, id: 5)
+        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'])
+        expect(request.env).to include('agile_proxy.request_spec' => stub)
+
+      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_json: {}, id: 5 }
+          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 contain_exactly *route_not_found_response
+            expect(handler.call(request_for(url: 'http://subdomain.example.com/').env)).to contain_exactly *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_json: {}, id: 5 }
+          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 contain_exactly *route_not_found_response
+            expect(handler.call(request_for(url: 'http://subdomain.example.com/index').env)).to contain_exactly *route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/').env)).to contain_exactly *route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com').env)).to contain_exactly *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_json: {}, id: 5 }
+          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(method: 'POST', url: 'http://example.com/', headers: {'Content-Type' => 'text/plain'}, body: "a=1\nb=2\nc=3").env)).to eql([200, {}, ''])
+            expect(handler.call(request_for(url: 'http://example.com/').env)).to contain_exactly *route_not_found_response
+            expect(handler.call(request_for(method: 'POST', url: 'http://subdomain.example.com/').env)).to contain_exactly *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_json: { user_id: '1' }, id: 5 }
+          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 contain_exactly *route_not_found_response
+            expect(handler.call(request_for(method: 'POST', url: 'http://example.com/users/1/index').env)).to contain_exactly *route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/users/1/').env)).to contain_exactly *route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/users/1').env)).to contain_exactly *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_json: { user_id: '1', extra_1: 'extra_1', extra_2: 'extra_2' }, id: 5 }
+          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 contain_exactly *route_not_found_response
+            expect(handler.call(request_for(method: 'POST', url: 'http://example.com/users/1/index').env)).to contain_exactly *route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/users/1/').env)).to contain_exactly *route_not_found_response
+            expect(handler.call(request_for(url: 'http://example.com/users/1').env)).to contain_exactly *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