agile-proxy 0.1.0

data/lib/agile_proxy/server.rb

@@ -0,0 +1,85 @@
+require 'active_record'
+require 'yaml'
+require 'cgi'
+require 'uri'
+require 'eventmachine'
+require 'thin'
+require 'grape'
+require 'agile_proxy/api/root'
+require 'agile_proxy/servers/api'
+require 'agile_proxy/servers/request_spec'
+
+module AgileProxy
+  #
+  # This class is responsible for controlling the underlying proxy and web servers
+  #
+  class Server
+    ROOT = File.expand_path '../../', File.dirname(__FILE__)
+    extend Forwardable
+    attr_reader :request_handler
+
+    def_delegators :request_handler, :reset_cache, :restore_cache, :handle_request
+
+    def initialize
+      environment = AgileProxy.config.environment
+      dbconfig    = YAML.load(File.read(AgileProxy.config.database_config_file)).with_indifferent_access
+      ActiveRecord::Base.configurations = dbconfig
+      ActiveRecord::Base.establish_connection dbconfig[environment.to_s]
+    end
+
+    # Starts the proxy and web servers
+    def start
+      main_loop
+    end
+
+    # The url that the proxy server is running on
+    # @return [String] The URL
+    def url
+      "http://#{host}:#{port}"
+    end
+
+    # The url that the web server can be accessed from
+    # @return [String] The URL
+    def webserver_url
+      "http://#{webserver_host}:#{webserver_port}"
+    end
+
+    # The host that the proxy server is running on
+    # @return [String] The host
+    def host
+      'localhost'
+    end
+
+    # The port that the proxy server is running on
+    # @return [String] The port
+    def port
+      @request_spec_server.port
+    end
+
+    # The host that the webserver is running on
+    # @return [String] The host
+    def webserver_host
+      AgileProxy.config.webserver_host
+    end
+
+    # The port that the webserver is running on
+    # @return [String] The port
+    def webserver_port
+      AgileProxy.config.webserver_port
+    end
+
+    protected
+
+    def main_loop
+      EM.run do
+        EM.error_handler do |e|
+          puts e.class.name, e
+          puts e.backtrace.join("\n")
+        end
+        AgileProxy::Servers::Api.start(webserver_host, webserver_port)
+        @request_spec_server = AgileProxy::Servers::RequestSpec.start
+        AgileProxy.log(:info, "agile-proxy: Proxy listening on #{url} and webserver listening on #{webserver_url}")
+      end
+    end
+  end
+end

data/lib/agile_proxy/servers/api.rb

@@ -0,0 +1,41 @@
+require 'rack'
+require 'thin'
+require 'grape'
+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 sinatra web server
+          dispatch = 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
+          # Start the web server.
+          ::Rack::Server.start(
+              app: dispatch,
+              server: 'thin',
+              Host: webserver_host,
+              Port: webserver_port,
+              signals: false
+          )
+        end
+      end
+    end
+  end
+end

data/lib/agile_proxy/servers/request_spec.rb

@@ -0,0 +1,30 @@
+require 'eventmachine'
+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
+        new.start
+      end
+      def initialize
+        @request_handler = AgileProxy::RequestHandler.new
+      end
+      # Starts the server
+      def start
+        @signature = EM.start_server('127.0.0.1', AgileProxy.config.proxy_port, ProxyConnection) do |p|
+          p.handler = @request_handler
+        end
+        self
+      end
+      # The port the server is running on
+      # @return [Integer] The port the server is running on
+      def port
+        Socket.unpack_sockaddr_in(EM.get_sockname(@signature)).first
+      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.0'
+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/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,60 @@
+module AgileProxy
+  module Test
+    module Integration
+      # A helper for 'request spec' integration tests
+      module RequestSpecHelper
+        def load_small_set_of_request_specs(options = {})
+          let(:recordings_resource) { RestClient::Resource.new "http://localhost:3020/api/v1/users/1/applications/#{@recording_application_id}/recordings", headers: { content_type: 'application/json' } }
+          before :context do
+
+            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']
+            end
+
+            def application_resource
+              @__application_resource ||= RestClient::Resource.new 'http://localhost:3020/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_resource.post ActiveSupport::JSON.encode attrs
+            end
+
+            def non_recording_resource
+              @__non_recording_resource ||= RestClient::Resource.new "http://localhost:3020/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:3020/api/v1/users/1/applications/#{@recording_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].each do |url|
+              create_request_spec url: "#{url}/index.html", response: { content_type: 'text/html', content: '<html><body>Mocked Content</body></html>' }
+              create_request_spec url: "#{url}/api/forums", response: { content_type: 'application/json', content: JSON.pretty_generate(forums: [], total: 0) }
+              create_request_spec url: "#{url}/api/forums", http_method: 'POST', response: { content_type: 'application/json', content: '{"created": true}' }
+              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 }
+              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 }
+              create_request_spec url: "#{url}/api/forums/:forum_id/:post_id", http_method: 'PUT', response: { content_type: 'application/json', content: '{"updated": true}' }
+              create_request_spec url: "#{url}/api/forums/:forum_id/:post_id", http_method: 'DELETE', response: { content_type: 'application/json', content: '{"deleted": true}' }
+              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 }
+              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 }
+              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 }
+            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,407 @@
+require 'integration_spec_helper'
+
+# require 'spec_helper'
+require 'agile_proxy'
+require 'resolv'
+
+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 = {}|
+  if options.key?(:recording) && options[:recording]
+    after :each do
+      data = recordings_resource.get
+      count = JSON.parse(data)['total']
+      expect(count).to eql(1)
+    end
+  end
+  it 'should stub GET requests' do
+    expect(http.get('/index.html').body).to eql '<html><body>Mocked Content</body></html>'
+  end
+
+  it 'should stub GET response statuses' do
+    expect(http.get('/index.html').status).to eql 200
+  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['Content-Type']).to eql 'application/json'
+  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['Content-Type']).to eql 'application/json'
+  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['Content-Type']).to eql 'text/html'
+  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['Content-Type']).to eql 'text/html'
+  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 "Missing var or method 'sort' in data."
+    expect(resp.status).to eql 500
+  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['Content-Type']).to eql 'text/html'
+  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.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.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['Content-Type']).to eql 'application/json'
+
+  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['Content-Type']).to eql 'application/json'
+  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['Content-Type']).to eql 'application/json'
+  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
+describe AgileProxy::Server 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 = {
+        proxy: { uri: 'http://anonymous:password@localhost:3100' },
+        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'
+      end
+      context 'HTTPS' do
+        let!(:http) { @https }
+        it_should_behave_like 'a proxy server'
+      end
+    end
+    context 'stubbing' 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
+  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:3100' },
+        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