agile-proxy-jruby 0.1.25-jruby

data/lib/agile_proxy/servers/api.rb

@@ -0,0 +1,40 @@
+require 'rack'
+require 'grape'
+require 'goliath/api'
+require 'goliath/runner'
+require 'agile_proxy/api/root'
+
+module AgileProxy
+  module Servers
+    #
+    # The API Server
+    #
+    # This server is a RACK server responsible for providing access to the system
+    # using REST requests.
+    # This allows remote programming of the proxy using either a client adapter or the built in user interface
+    module Api
+      ROOT = File.expand_path '../../../', File.dirname(__FILE__)
+      class << self
+        #
+        # Starts the webserver on the given host and port
+        # @param webserver_host [String] The host for the server to run on
+        # @param webserver_port [Integer] The port for the server to run on
+        def start(webserver_host, webserver_port)
+          #
+          # The API runner
+          runner = ::Goliath::Runner.new([], nil)
+          runner.address = webserver_host
+          runner.port = webserver_port
+          runner.app = ::Goliath::Rack::Builder.app do
+            use ::Rack::Static, root: File.join(ROOT, 'assets'), urls: ['/ui'], index: 'index.html'
+            map '/api' do
+              run ::AgileProxy::Api::Root.new
+            end
+          end
+          runner.run
+
+        end
+      end
+    end
+  end
+end

data/lib/agile_proxy/servers/request_spec.rb

@@ -0,0 +1,40 @@
+require 'eventmachine'
+require 'goliath/api'
+require 'goliath/proxy'
+module AgileProxy
+  module Servers
+    #
+    # The 'Request Spec' server
+    # This server is responsible for handling or passing through a request, depending
+    # on if it has a matching 'Request Specification'
+    class RequestSpec
+
+      # Starts the server
+      def self.start(options = {})
+        new(options).start
+      end
+      def initialize(options = {})
+        @request_handler = AgileProxy::RequestHandler.new enable_cache: options[:enable_cache]
+      end
+      # Starts the server
+      def start
+        #
+        # The API runner
+        runner = ::Goliath::Proxy::Runner.new([], nil)
+        runner.address = '127.0.0.1'
+        runner.port = AgileProxy.config.proxy_port
+        app = @request_handler
+        runner.app = app
+        runner.run
+        self
+
+      end
+      # The port the server is running on
+      # @return [Integer] The port the server is running on
+      def port
+        return AgileProxy.config.proxy_port
+      end
+      private
+    end
+  end
+end

data/lib/agile_proxy/servers/request_spec_direct.rb

@@ -0,0 +1,35 @@
+require 'rack'
+require 'goliath/api'
+require 'goliath/runner'
+module AgileProxy
+  module Servers
+    #
+    # The API Server
+    #
+    # This server is a RACK server responsible for providing access to the system
+    # using REST requests.
+    # This allows remote programming of the proxy using either a client adapter or the built in user interface
+    module RequestSpecDirect
+      ROOT = Dir.pwd
+      class << self
+        #
+        # Starts the server on the given host and port
+        # @param server_host [String] The host for the server to run on
+        # @param server_port [Integer] The port for the server to run on
+        def start(server_host, server_port, static_dirs = [])
+
+          runner = ::Goliath::Runner.new([], nil)
+          runner.address = server_host
+          runner.port = server_port
+          notFoundApp = -> {[404, {}, 'Not Found']}
+          runner.app = ::Goliath::Rack::Builder.app do
+            map '/' do
+              run ::Rack::Cascade.new([::Rack::Static.new(notFoundApp, root: ROOT, urls: ['']), ::AgileProxy::StubHandler.new])
+            end
+          end
+          runner.run
+        end
+      end
+    end
+  end
+end

data/lib/agile_proxy/version.rb

@@ -0,0 +1,6 @@
+# Agile Proxy
+#
+# The Agile Proxy module is a common namespace for all classes / sub modules.
+module AgileProxy
+  VERSION = '0.1.25'
+end

data/load_proxy.js

@@ -0,0 +1,39 @@
+var proxy, contracts;
+proxy = require('flexible_proxy_client');
+debugger;
+contracts = [];
+for (i=0; i< 100; i=i+1) {
+    contracts.push({
+        "created_at": "2014-10-21T09:30:45.217Z",
+        "customer_company_id": "1",
+        "customer_contact_id": "1",
+        "daily_rate_currency": "GBP",
+        "daily_rate_pennies": 10000,
+        "duration": 2678400,
+        "end_date": "2013-01-31T00:00:00.000Z",
+        "fq_name": "My First Contract",
+        "id": "544627c51fedb0383c0000" + i,
+        "name": "My Contract No " + (i + 1),
+        "owner_company_id": "1",
+        "owner_id": "544627c51fedb0383c000092",
+        "start_date": "2013-01-01T00:00:00.000Z",
+        "status": "accepted",
+        "supplier_company_id": "1",
+        "updated_at": "2014-10-21T09:30:45.217Z",
+        "value_currency": "GBP",
+        "value_pennies": 100000,
+        "notes": [
+
+        ]
+    });
+}
+proxy.define([
+    proxy.stub('http://localhost:9000/api/v1/contracts.json').andReturn({json: {
+        "contracts": contracts,
+        "total": contracts.length,
+        "success": true
+    }}),
+    proxy.stub('http://localhost:35729/livereload.js').andReturn({
+        json: {}
+    })
+], function () {console.log("YEP")});

data/spec/common_helper.rb

@@ -0,0 +1,32 @@
+module AgileProxy
+  module Test
+    # Common helpers for the test suite
+    module Common
+      def to_rack_env(opts = {})
+        fake_input_buffer = StringIO.new(opts[:body] || '')
+        fake_error_buffer = StringIO.new
+        url_parsed = URI.parse(opts[:url])
+        env = {
+          'rack.input' => ::Rack::Lint::InputWrapper.new(fake_input_buffer),
+          'rack.errors' => ::Rack::Lint::ErrorWrapper.new(fake_error_buffer),
+          'REQUEST_METHOD' => (opts[:method] || 'GET').upcase,
+          'REQUEST_PATH' => url_parsed.path,
+          'PATH_INFO' => url_parsed.path,
+          'QUERY_STRING' => url_parsed.query || '',
+          'REQUEST_URI' => url_parsed.path + (url_parsed.query.nil? ? '' : url_parsed.query),
+          'rack.url_scheme' => url_parsed.scheme,
+          'CONTENT_LENGTH' => (opts[:body] || '').length,
+          'SERVER_NAME' => url_parsed.host,
+          'SERVER_PORT' => url_parsed.port
+        }
+        (opts[:headers] || {}).each do |name, value|
+          converted_name = 'HTTP_' + (name.gsub(/-/, '_').upcase)
+          env[converted_name] = value
+        end
+        env['CONTENT_TYPE'] = env.delete('HTTP_CONTENT_TYPE') if env.key?('HTTP_CONTENT_TYPE')
+        env['CONTENT_LENGTH'] = env.delete('HTTP_CONTENT_LENGTH') if env.key?('HTTP_CONTENT_LENGTH')
+        env
+      end
+    end
+  end
+end

data/spec/fixtures/example_static_file.html

@@ -0,0 +1 @@
+Hello World

data/spec/fixtures/test-server.crt

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICazCCAdQCCQD9MxXmqmRKtTANBgkqhkiG9w0BAQUFADB6MQswCQYDVQQGEwJV
+UzELMAkGA1UECBMCQ0ExITAfBgNVBAoTGEludGVybmV0IFdpZGdpdHMgUHR5IEx0
+ZDEWMBQGA1UEAxMNUHVmZmluZyBCaWxseTEjMCEGCSqGSIb3DQEJARYUb2xseS5z
+bWl0aEBnbWFpbC5jb20wHhcNMTIxMDA0MDgwNzMxWhcNMTIxMTAzMDgwNzMxWjB6
+MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExITAfBgNVBAoTGEludGVybmV0IFdp
+ZGdpdHMgUHR5IEx0ZDEWMBQGA1UEAxMNUHVmZmluZyBCaWxseTEjMCEGCSqGSIb3
+DQEJARYUb2xseS5zbWl0aEBnbWFpbC5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0A
+MIGJAoGBAKsUa8bzUeTfC05JFwjBXnD+nBlil5aVTDOB719WJkiq1eDY5WWBaMhk
+OqlZkNhl1rg7LmG/0NhBBUdICYTblNRXzhEfaejqOIGQ3FZMR3W/b87cBp4S+8b/
+q9xJPSUgFvQUzX4v+2+//wdiO8qPioinDdRG9RhxwNvS34bqJqpfAgMBAAEwDQYJ
+KoZIhvcNAQEFBQADgYEADnHq4MP+LgTdp4+ycyearUZh4uhAPzxYXTGDirkkFFQ4
+YA2QT0zXgPq1JmrZwV5Wo1wKoIq8LtfeYoDou0VDKtZ6Up13c98R+1yuQE2kgNoG
+9VGn/2la4mvLpj+9Zt8wfNxibFi+ajZ7/zsebI7UM+pW0a3SDowDeU0nVPAmDRM=
+-----END CERTIFICATE-----

data/spec/fixtures/test-server.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQCrFGvG81Hk3wtOSRcIwV5w/pwZYpeWlUwzge9fViZIqtXg2OVl
+gWjIZDqpWZDYZda4Oy5hv9DYQQVHSAmE25TUV84RH2no6jiBkNxWTEd1v2/O3Aae
+EvvG/6vcST0lIBb0FM1+L/tvv/8HYjvKj4qIpw3URvUYccDb0t+G6iaqXwIDAQAB
+AoGBAJccJ4KIYzqUZGkWmBjsq92Elx64/gpM/wyz5VpBPvmKo/XBvwWkg4gVN9dj
+vFPXyAvcgkBm7DJHZEEs+PN3/IEMyLHWVA+C+C3AHisR/E2yl/AyD9oX8F0KDu+Q
+8bnsL1rFL5zP1saw+QiyofQ13HKtCOj8zjhAUCyZl1NBdiqxAkEA2PNxBHFBSnPU
+L6+PiCvDOJcbqrHQa5kYcS312SNqX/VQ9BtIJfIQ7QA/ueKIUd40OfNBc/jiOC1x
+mlSwlsLnFwJBAMnfWagBvlinIwXw4yhAgsqt012gOzPIHCM7FWipJPbCm9LtJykE
+dGuA06TRE2ZKQq+Oh2yomNni4/LfPVQ6Y/kCQHkej/4W7IiQWem1bcBsDjVNx1ho
+pR8s/YRSUGrFZuHjpyphAMqOdfyaovk4CzsJfsbLk8MXM9SBKmcq2NuSPEkCQQCM
+MvTmTIewtCsLtjdcvijXsA9KR7y2ArUf9qmwrUABrDhiLdfzkad0/dx+68FIWiyk
+Fh2RZin5sKzVARtrwr2pAkEAgIDCCl3YC7Jk5GOm1xVjb999hZSyasOasiVsAafa
+4UzoA4HlDjTWEROObX8ijbsWRU16/yotbWXDa9XXxnDV3A==
+-----END RSA PRIVATE KEY-----

data/spec/integration/helpers/request_spec_helper.rb

@@ -0,0 +1,84 @@
+require 'rest_client'
+module AgileProxy
+  module Test
+    module Integration
+      # A helper for 'request spec' integration tests
+      module RequestSpecHelper
+        class Spec
+          attr_accessor :url, :name, :body
+          def self.for(url, name, body)
+            obj = new
+            obj.url=url + '/'
+            obj.name = name
+            obj.body = body
+            obj.body = obj.body.with_indifferent_access if obj.body.is_a? Hash
+            obj
+          end
+        end
+
+        def load_small_set_of_request_specs(options = {})
+          let(:recordings_resource) { RestClient::Resource.new "http://localhost:#{api_port}/api/v1/users/1/applications/#{@recording_application_id}/recordings", headers: { content_type: 'application/json' } }
+          before :context do
+            @stubs_with_recordings = []
+            def configure_applications
+              application_resource.delete  # Delete all applications
+              @non_recording_application_id = JSON.parse(application_resource.post user_id: 1, name: 'Non recording app', username: 'anonymous', password: 'password')['id']
+              @recording_application_id = JSON.parse(application_resource.post user_id: 1, name: 'Recording app', username: 'recording', password: 'password', record_requests: true)['id']
+              @direct_application_id = JSON.parse(application_resource.post user_id: 1, name: 'Direct app', username: nil, password: nil, record_requests: false)['id']
+            end
+
+            def application_resource
+              @__application_resource ||= RestClient::Resource.new "http://localhost:#{api_port}/api/v1/users/1/applications", headers: { content_type: 'application/json' }
+            end
+
+            def create_request_spec(attrs)
+              non_recording_resource.post ActiveSupport::JSON.encode attrs
+              recording_response = JSON.parse recording_resource.post(ActiveSupport::JSON.encode attrs).body
+              direct_resource.post ActiveSupport::JSON.encode attrs
+              recording_response
+            end
+
+            def non_recording_resource
+              @__non_recording_resource ||= RestClient::Resource.new "http://localhost:#{api_port}/api/v1/users/1/applications/#{@non_recording_application_id}/request_specs", headers: { content_type: 'application/json' }
+            end
+
+            def recording_resource
+              @__recording_resource ||= RestClient::Resource.new "http://localhost:#{api_port}/api/v1/users/1/applications/#{@recording_application_id}/request_specs", headers: { content_type: 'application/json' }
+            end
+
+            def direct_resource
+              @__direct_resource ||= RestClient::Resource.new "http://localhost:#{api_port}/api/v1/users/1/applications/#{@direct_application_id}/request_specs", headers: { content_type: 'application/json' }
+            end
+
+
+            # Delete all first
+            configure_applications
+            # Now, add some stubs via the REST interface
+            [@http_url, @https_url, @http_url_no_proxy, @https_url_no_proxy].each do |url|
+              @stubs_with_recordings.push Spec.for url, 'index_old', create_request_spec(url: "#{url}/index.html", response: { content_type: 'text/html', content: '<html><body>This Is An Older Mock</body></html>' }) #This is intentional - the system should always use the latest
+              @stubs_with_recordings.push Spec.for url, 'index', create_request_spec(url: "#{url}/index.html", response: { content_type: 'text/html', content: '<html><body>Mocked Content</body></html>' })
+              @stubs_with_recordings.push Spec.for url, 'index_recording', create_request_spec(url: "#{url}/indexRecording.html", response: { content_type: 'text/html', content: '<html><body>Mocked Content</body></html>' })
+              @stubs_with_recordings.push Spec.for url, 'api_forums', create_request_spec(url: "#{url}/api/forums", response: { content_type: 'application/json', content: JSON.pretty_generate(forums: [], total: 0) })
+              @stubs_with_recordings.push Spec.for url, 'api_forums_post', create_request_spec(url: "#{url}/api/forums", http_method: 'POST', response: { content_type: 'application/json', content: '{"created": true}' })
+              @stubs_with_recordings.push Spec.for url, 'api_forum_post', create_request_spec(url: "#{url}/api/forums/:forum_id/:post_id", response: { content_type: 'text/html', content: '<html><body><h1>Sorted By: {{sort}}</h1><h2>{{forum_id}}</h2><h3>{{post_id}}</h3></body></html>', is_template: true })
+              @stubs_with_recordings.push Spec.for url, 'api_forum_post_put', create_request_spec(url: "#{url}/api/forums/:forum_id/:post_id", http_method: 'PUT', response: { content_type: 'application/json', content: '{"updated": true}' })
+              @stubs_with_recordings.push Spec.for url, 'api_forum_post_delete', create_request_spec(url: "#{url}/api/forums/:forum_id/:post_id", http_method: 'DELETE', response: { content_type: 'application/json', content: '{"deleted": true}' })
+              @stubs_with_recordings.push Spec.for url, 'api_forum_post_special', create_request_spec(url: "#{url}/api/forums/:forum_id/:post_id", conditions: '{"post_id": "special"}', response: { content_type: 'text/html', content: '<html><body><h1>Sorted By: {{sort}}</h1><h2>{{forum_id}}</h2><h3>{{post_id}}</h3><p>This is a special response</p></body></html>', is_template: true })
+              @stubs_with_recordings.push Spec.for url, 'api_forum_post_ever_so_special', create_request_spec(url: "#{url}/api/forums/:forum_id/:post_id", conditions: '{"post_id": "special", "sort": "eversospecial"}', response: { content_type: 'text/html', content: '<html><body><h1>Sorted By: {{sort}}</h1><h2>{{forum_id}}</h2><h3>{{post_id}}</h3><p>This is an ever so special response</p></body></html>', is_template: true })
+              @stubs_with_recordings.push Spec.for url, 'api_forum_update', create_request_spec(url: "#{url}/api/forums/:forum_id", http_method: 'POST',response: { content_type: 'text/html', content: '<html><body><h1></h1><h2>WRONG RESULT</h2><h3>{{forum_id}}</h3><p>This is an incorrect result probably because the conditions are being ignored ?</p></body></html>'})
+              @stubs_with_recordings.push Spec.for url, 'api_forum_update_special', create_request_spec(url: "#{url}/api/forums/:forum_id", http_method: 'POST', conditions: '{"posted_var":"special_value"}', response: { content_type: 'text/html', content: '<html><body><h1></h1><h2>{{posted_var}}</h2><h3>{{forum_id}}</h3><p>This should get data from the POSTed data</p></body></html>', is_template: true })
+              @stubs_with_recordings.push Spec.for url, 'api_forums_post', create_request_spec(url: "#{url}/api/forums/:forum_id/posts", response: { content_type: 'application/json', content: JSON.pretty_generate(posts: [
+                   { forum_id: '{{forum_id}}', subject: 'My first post' },
+                   { forum_id: '{{forum_id}}', subject: 'My second post' },
+                   { forum_id: '{{forum_id}}', subject: 'My third post' }
+               ], total: 3), is_template: true })
+            end
+          end
+          before :each do
+            recordings_resource.delete if options.key?(:recording) && options[:recording]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/specs/lib/server_spec.rb

@@ -0,0 +1,474 @@
+require 'integration_spec_helper'
+
+# require 'spec_helper'
+require 'agile_proxy'
+require 'resolv'
+require 'rest_client'
+
+shared_examples_for 'a proxy server' do |options = {}|
+  if options.key?(:recording) && options[:recording]
+    after :each do
+      expect(JSON.parse(recordings_resource.get)['total']).to eql(1)
+    end
+  end
+  it 'should proxy GET requests' do
+    expect(http.get('/echo').body).to eql 'GET /echo'
+  end
+
+  it 'should proxy POST requests' do
+    expect(http.post('/echo', foo: 'bar').body).to eql "POST /echo\nfoo=bar"
+  end
+
+  it 'should proxy PUT requests' do
+    expect(http.post('/echo', foo: 'bar').body).to eql "POST /echo\nfoo=bar"
+  end
+
+  it 'should proxy HEAD requests' do
+    expect(http.head('/echo').headers['HTTP-X-EchoServer']).to eql 'HEAD /echo'
+  end
+
+  it 'should proxy DELETE requests' do
+    expect(http.delete('/echo').body).to eql 'DELETE /echo'
+  end
+end
+
+shared_examples_for 'a request stub' do |options = {}|
+  recording = false
+  if options.key?(:recording) && options[:recording]
+    recording = true
+    after :each do
+      data = recordings_resource.get
+      count = JSON.parse(data)['total']
+      expect(count).to eql(1)
+    end
+  end
+  def find_stub(client, name)
+    @stubs_with_recordings.select { |stub| stub.url == client.url_prefix.to_s && stub.name == name}.first
+  end
+  def rest_client_for_stub(stub)
+    RestClient::Resource.new("http://localhost:#{api_port}/api/v1/users/1/applications/#{@recording_application_id}/request_specs/#{stub.body[:id]}/recordings", content_type: :json )
+  end
+  def recordings_for(name)
+    stub = find_stub(http, name)
+    JSON.parse(rest_client_for_stub(stub).get).with_indifferent_access
+  end
+  def recordings_matcher_for(name, path)
+    stub = find_stub(http, name)
+    {recordings: a_collection_containing_exactly(a_hash_including request_body: '', request_url: "#{http.url_prefix}#{path.gsub(/^\//, '')}", request_method: 'GET', request_spec_id: stub.body[:id])}
+  end
+
+  it 'should stub GET requests' do
+    response = http.get('/index.html')
+    expect(response.body).to eql '<html><body>Mocked Content</body></html>'
+    expect(response.headers).to include('content-length' => "40")
+    expect(recordings_for 'index').to include(recordings_matcher_for('index', '/index.html')) if recording
+  end
+
+  it 'should stub GET response statuses' do
+    response = http.get('/index.html')
+    expect(response.status).to eql 200
+  end
+
+  #TODO When time allows, work out how to easily test this as the stubs are not recorded for anything but recorded tests
+  #the lookup table would need to contain all stubs and we would need a way of indexing them to allow the test to find
+  # the correct one.
+  xit 'Should record a stub if specified in the stub irrespective of whether app is recording or not' do
+    expect(http.get('/indexRecording.html').status).to eql 200
+    expect(recordings_for('index_recording')).to include(recordings_matcher_for('index_recording', '/indexRecording.html'))
+  end
+
+  it 'Should stub a different get request with json response' do
+    resp = http.get('/api/forums')
+    expect(ActiveSupport::JSON.decode(resp.body).symbolize_keys).to eql forums: [], total: 0
+    expect(resp.status).to eql 200
+    expect(resp.headers).to include('content-type' => 'application/json', 'content-length' => resp.body.length.to_s)
+    expect(recordings_for 'api_forums').to include(recordings_matcher_for('api_forums', '/api/forums')) if recording
+  end
+
+  it 'Should get the mocked content with parameter substitution for the /api/forums/:forum_id/posts url' do
+    resp = http.get '/api/forums/my_forum/posts'
+    expect(ActiveSupport::JSON.decode(resp.body)).to eql 'posts' => [{ 'forum_id' => 'my_forum', 'subject' => 'My first post' }, { 'forum_id' => 'my_forum', 'subject' => 'My second post' }, { 'forum_id' => 'my_forum', 'subject' => 'My third post' }], 'total' => 3
+    expect(resp.status).to eql 200
+    expect(resp.headers).to include('content-type' => 'application/json', 'content-length' => resp.body.length.to_s)
+  end
+
+  it 'Should get the mocked content for api/forums/:forum_id/:post_id with parameter substitution including query parameters' do
+    resp = http.get '/api/forums/my_forum/my_post?sort=id'
+    expect(resp.body).to eql '<html><body><h1>Sorted By: id</h1><h2>my_forum</h2><h3>my_post</h3></body></html>'
+    expect(resp.status).to eql 200
+    expect(resp.headers).to include('content-type' => 'text/html', 'content-length' => resp.body.length.to_s)
+  end
+  it 'Should get the mocked content for api/forums/:forum_id/:post_id.html with parameter substitution including query parameters' do
+    resp = http.get '/api/forums/my_forum/my_post.html?sort=id'
+    expect(resp.body).to eql '<html><body><h1>Sorted By: id</h1><h2>my_forum</h2><h3>my_post</h3></body></html>'
+    expect(resp.status).to eql 200
+    expect(resp.headers).to include('content-type' => 'text/html', 'content-length' => resp.body.length.to_s)
+  end
+  it 'Should respond with an error for api/forums/:forum_id/:post_id.html with parameter substitution with a missing query parameter' do
+    resp = http.get '/api/forums/my_forum/my_post.html'
+    expect(resp.body).to eql '<html><body><h1>Sorted By: </h1><h2>my_forum</h2><h3>my_post</h3></body></html>'
+    expect(resp.headers).to include('content-type' => 'text/html', 'content-length' => resp.body.length.to_s)
+    expect(resp.status).to eql 200
+  end
+  it 'Should match the route by posted json data and the posted data can be output via the template' do
+    resp = http.post '/api/forums/my_forum', '{"posted_var": "special_value"}', 'Content-Type' => 'application/json'
+    expect(resp.body).to eql '<html><body><h1></h1><h2>special_value</h2><h3>my_forum</h3><p>This should get data from the POSTed data</p></body></html>'
+    expect(resp.status).to eql 200
+    expect(resp.headers).to include('content-type' => 'text/html', 'content-length' => resp.body.length.to_s)
+  end
+  it 'Should match the route by posted plain text data and the posted data can be output via the template' do
+    resp = http.post '/api/forums/my_forum', "posted_var=special_value\n", 'Content-Type' => 'text/plain'
+    expect(resp.body).to eql '<html><body><h1></h1><h2>special_value</h2><h3>my_forum</h3><p>This should get data from the POSTed data</p></body></html>'
+    expect(resp.status).to eql 200
+    expect(resp.headers).to include('content-type' => 'text/html', 'content-length' => resp.body.length.to_s)
+  end
+  it 'Should match the route by posted plain text data and the posted data can be output via the template' do
+    resp = http.post '/api/forums/my_forum', "dummy=\nposted_var=special_value\n", 'Content-Type' => 'text/plain'
+    expect(resp.body).to eql '<html><body><h1></h1><h2>special_value</h2><h3>my_forum</h3><p>This should get data from the POSTed data</p></body></html>'
+    expect(resp.status).to eql 200
+    expect(resp.headers).to include('content-type' => 'text/html', 'content-length' => resp.body.length.to_s)
+  end
+  # it 'Should match the route by posted xml data and the posted data can be output via the template' do
+  #   resp = http.post "/api/forums/my_forum", '<posted_var>special_value</posted_var>', {'Content-Type' => 'application/xml'}
+  #   expect(resp.body).to eql '<html><body><h1></h1><h2>special_value</h2><h3>my_forum</h3><p>This should get data from the POSTed data</p></body></html>'
+  #   expect(resp.status).to eql 200
+  # end
+  it 'Should match the route by posted url encoded data and the posted data can be output via the template' do
+    resp = http.post '/api/forums/my_forum', 'posted_var=special_value', 'Content-Type' => 'application/x-www-form-urlencoded'
+    expect(resp.body).to eql '<html><body><h1></h1><h2>special_value</h2><h3>my_forum</h3><p>This should get data from the POSTed data</p></body></html>'
+    expect(resp.headers).to include('content-type' => 'text/html', 'content-length' => resp.body.length.to_s)
+    expect(resp.status).to eql 200
+  end
+  it 'Should match the route by posted multipart encoded data and the posted data can be output via the template' do
+    resp = http.post '/api/forums/my_forum', 'posted_var=special_value', 'Content-Type' => 'multipart/form-data'
+    expect(resp.body).to eql '<html><body><h1></h1><h2>special_value</h2><h3>my_forum</h3><p>This should get data from the POSTed data</p></body></html>'
+    expect(resp.headers).to include('content-type' => 'text/html', 'content-length' => resp.body.length.to_s)
+    expect(resp.status).to eql 200
+  end
+
+  it 'should stub POST requests' do
+    resp = http.post('/api/forums', foo: :bar)
+    expect(resp.body).to eql '{"created": true}'
+    expect(resp.headers).to include('content-type' => 'application/json', 'content-length' => resp.body.length.to_s)
+
+  end
+
+  it 'should stub PUT requests' do
+    resp = http.put('/api/forums/forum_1/my_post', foo: :bar)
+    expect(resp.body).to eql '{"updated": true}'
+    expect(resp.headers).to include('content-type' => 'application/json', 'content-length' => resp.body.length.to_s)
+  end
+
+  it 'should stub DELETE requests' do
+    resp = http.delete('/api/forums/forum_1/my_post')
+    expect(resp.body).to eql '{"deleted": true}'
+    expect(resp.headers).to include('content-type' => 'application/json', 'content-length' => resp.body.length.to_s)
+  end
+end
+
+shared_examples_for 'a cache' do
+
+  context 'whitelisted GET requests' do
+    it 'should not be cached' do
+      assert_noncached_url
+    end
+
+    context 'with ports' do
+      before do
+        rack_app_url = URI(http.url_prefix)
+        AgileProxy.config.whitelist = ["#{rack_app_url.host}:#{rack_app_url.port}"]
+      end
+
+      it 'should not be cached ' do
+        assert_noncached_url
+      end
+    end
+  end
+
+  context 'non-whitelisted GET requests' do
+    before do
+      AgileProxy.config.whitelist = []
+    end
+
+    it 'should be cached' do
+      assert_cached_url
+    end
+
+    context 'with ports' do
+      before do
+        rack_app_url = URI(http.url_prefix)
+        AgileProxy.config.whitelist = ["#{rack_app_url.host}:#{rack_app_url.port + 1}"]
+      end
+
+      it 'should be cached' do
+        assert_cached_url
+      end
+    end
+  end
+
+  context 'ignore_params GET requests' do
+    before do
+      AgileProxy.config.ignore_params = ['/analytics']
+    end
+
+    it 'should be cached' do
+      r = http.get('/analytics?some_param=5')
+      expect(r.body).to eql 'GET /analytics'
+      expect do
+        expect do
+          r = http.get('/analytics?some_param=20')
+        end.to change { r.headers['HTTP-X-EchoCount'].to_i }.by(1)
+      end.to_not change { r.body }
+    end
+  end
+
+  context 'path_blacklist GET requests' do
+    before do
+      AgileProxy.config.path_blacklist = ['/api']
+    end
+
+    it 'should be cached' do
+      assert_cached_url('/api')
+    end
+  end
+
+  context 'cache persistence' do
+    let(:cached_key) { proxy.cache.key('get', "#{url}/foo", '') }
+    let(:cached_file) do
+      f = cached_key + '.yml'
+      File.join(AgileProxy.config.cache_path, f)
+    end
+
+    before { AgileProxy.config.whitelist = [] }
+
+    after do
+      File.delete(cached_file) if File.exist?(cached_file)
+    end
+
+    context 'enabled' do
+      before { AgileProxy.config.persist_cache = true }
+
+      it 'should persist' do
+        http.get('/foo')
+        expect(File.exist?(cached_file)).to be_true
+      end
+
+      it 'should be read initially from persistent cache' do
+        File.open(cached_file, 'w') do |f|
+          cached = {
+            headers: {},
+            content: 'GET /foo cached'
+          }
+          f.write(cached.to_yaml(Encoding: :Utf8))
+        end
+
+        r = http.get('/foo')
+        expect(r.body).to eql 'GET /foo cached'
+      end
+
+      context 'cache_request_headers requests' do
+        it 'should not be cached by default' do
+          http.get('/foo')
+          saved_cache = AgileProxy.proxy.cache.fetch_from_persistence(cached_key)
+          expect(saved_cache.keys).not_to include :request_headers
+        end
+
+        context 'when enabled' do
+          before do
+            AgileProxy.config.cache_request_headers = true
+          end
+
+          it 'should be cached' do
+            http.get('/foo')
+            saved_cache = AgileProxy.proxy.cache.fetch_from_persistence(cached_key)
+            expect(saved_cache.keys).to include :request_headers
+          end
+        end
+      end
+
+      context 'ignore_cache_port requests' do
+        it 'should be cached without port' do
+          r   = http.get('/foo')
+          url = URI(r.env[:url])
+          saved_cache = AgileProxy.proxy.cache.fetch_from_persistence(cached_key)
+
+          expect(saved_cache[:url]).to_not eql(url.to_s)
+          expect(saved_cache[:url]).to eql(url.to_s.gsub(":#{url.port}", ''))
+        end
+      end
+
+      context 'non_whitelisted_requests_disabled requests' do
+        before { AgileProxy.config.non_whitelisted_requests_disabled = true }
+
+        it 'should raise error when disabled' do
+          # TODO: Suppress stderr output: https://gist.github.com/adamstegman/926858
+          expect { http.get('/foo') }.to raise_error(Faraday::Error::ConnectionFailed, 'end of file reached')
+        end
+      end
+
+      context 'non_successful_cache_disabled requests' do
+        before do
+          rack_app_url = URI(http_error.url_prefix)
+          AgileProxy.config.whitelist = ["#{rack_app_url.host}:#{rack_app_url.port}"]
+          AgileProxy.config.non_successful_cache_disabled = true
+        end
+
+        it 'should not cache non-successful response when enabled' do
+          http_error.get('/foo')
+          expect(File.exist?(cached_file)).to be_false
+        end
+
+        it 'should cache successful response when enabled' do
+          assert_cached_url
+        end
+      end
+
+      context 'non_successful_error_level requests' do
+        before do
+          rack_app_url = URI(http_error.url_prefix)
+          AgileProxy.config.whitelist = ["#{rack_app_url.host}:#{rack_app_url.port}"]
+          AgileProxy.config.non_successful_error_level = :error
+        end
+
+        it 'should raise error for non-successful responses when :error' do
+          # When this config setting is set, the EventMachine running the test servers is killed upon error raising
+          # The `raise` is required to bubble up the error to the test running it
+          # The Faraday error is raised upon `close_connection` so this can be non-pending if we can do one of the following:
+          # 1) Remove the `raise error_message` conditionally for this test
+          # 2) Restart the test servers if they aren't running
+          # 3) Change the test servers to start/stop for each test instead of before all
+          # 4) Remove the test server completely and rely on the server instantiated by the app
+          pending 'Unable to test this without affecting the running test servers'
+          expect { http_error.get('/foo') }.to raise_error(Faraday::Error::ConnectionFailed)
+        end
+      end
+    end
+    context 'disabled' do
+      before { AgileProxy.config.persist_cache = false }
+
+      it 'shouldnt persist' do
+        http.get('/foo')
+        expect(File.exist?(cached_file)).to be_false
+      end
+    end
+  end
+
+  def assert_noncached_url(url = '/foo')
+    r = http.get(url)
+    expect(r.body).to eql "GET #{url}"
+    expect do
+      expect do
+        r = http.get(url)
+      end.to change { r.headers['HTTP-X-EchoCount'].to_i }.by(1)
+    end.to_not change { r.body }
+  end
+
+  def assert_cached_url(url = '/foo')
+    r = http.get(url)
+    expect(r.body).to eql "GET #{url}"
+    expect do
+      expect do
+        r = http.get(url)
+      end.to_not change { r.headers['HTTP-X-EchoCount'] }
+    end.to_not change { r.body }
+  end
+end
+
+shared_examples_for 'a static server' do
+  it 'Should serve a file from the current directory' do
+    expect(http.get('/spec/fixtures/example_static_file.html').body).to eql 'Hello World'
+  end
+end
+describe AgileProxy::Server, :type => :integration do
+  extend AgileProxy::Test::Integration::RequestSpecHelper
+  describe 'Without recording' do
+    load_small_set_of_request_specs
+    before do
+      # Adding non-valid Faraday options throw an error: https://github.com/arsduo/koala/pull/311
+      # Valid options: :request, :proxy, :ssl, :builder, :url, :parallel_manager, :params, :headers, :builder_class
+      faraday_options = {
+          request: {timeout: 10.0}
+      }
+      faraday_options_with_proxy = faraday_options.merge({
+        proxy: { uri: "http://anonymous:password@localhost:#{proxy_port}" }
+      })
+      @http       = Faraday.new @http_url,  faraday_options_with_proxy
+      @https      = Faraday.new @https_url, faraday_options_with_proxy.merge(ssl: { verify: false })
+      @http_no_proxy       = Faraday.new @http_url_no_proxy,  faraday_options
+      @https_no_proxy      = Faraday.new @https_url_no_proxy, faraday_options.merge(ssl: { verify: false })
+      @http_error = Faraday.new @error_url, faraday_options_with_proxy
+      @http_error_no_proxy = Faraday.new @error_url, faraday_options_with_proxy
+    end
+    context 'proxying' do
+      context 'HTTP' do
+        let!(:http) { @http }
+        it_should_behave_like 'a proxy server'
+      end
+      context 'HTTPS' do
+        let!(:http) { @https }
+        it_should_behave_like 'a proxy server'
+      end
+    end
+    context 'stubbing' do
+      context 'In Proxy Mode' do
+        context 'HTTP' do
+          let!(:url)  { @http_url }
+          let!(:http) { @http }
+          it_should_behave_like 'a request stub'
+        end
+
+        context 'HTTPS' do
+          let!(:url)  { @https_url }
+          let!(:http) { @https }
+          it_should_behave_like 'a request stub'
+        end
+      end
+      #Server mode only supports http - no real point for https at the moment
+      context 'In Server Mode' do
+        context 'HTTP' do
+          let!(:url)  { @http_url_no_proxy }
+          let!(:http) { @http_no_proxy }
+          it_should_behave_like 'a request stub'
+          it_should_behave_like 'a static server'
+        end
+      end
+    end
+  end
+  describe 'With recording' do
+    load_small_set_of_request_specs recording: true
+    before do
+      # Adding non-valid Faraday options throw an error: https://github.com/arsduo/koala/pull/311
+      # Valid options: :request, :proxy, :ssl, :builder, :url, :parallel_manager, :params, :headers, :builder_class
+      faraday_options = {
+        proxy: { uri: 'http://recording:password@localhost:3101' },
+        request: { timeout: 10.0 }
+      }
+
+      @http       = Faraday.new @http_url,  faraday_options
+      @https      = Faraday.new @https_url, faraday_options.merge(ssl: { verify: false })
+      @http_error = Faraday.new @error_url, faraday_options
+    end
+    context 'proxying' do
+      context 'HTTP' do
+        let!(:http) { @http }
+        it_should_behave_like 'a proxy server', recording: true
+      end
+      context 'HTTPS' do
+        let!(:http) { @https }
+        it_should_behave_like 'a proxy server', recording: true
+      end
+    end
+    context 'stubbing' do
+      context 'HTTP' do
+        let!(:url)  { @http_url }
+        let!(:http) { @http }
+        it_should_behave_like 'a request stub', recording: true
+      end
+      context 'HTTPS' do
+        let!(:url)  { @https_url }
+        let!(:http) { @https }
+        it_should_behave_like 'a request stub', recording: true
+      end
+    end
+  end
+end