sitehub 0.4.3 → 0.4.6

data/spec/sitehub/middleware/forward_proxies_spec.rb

@@ -0,0 +1,105 @@
+require 'sitehub/middleware/forward_proxies'
+
+class SiteHub
+  module Middleware
+    describe ForwardProxies do
+      let(:base_url) { 'http://google.com' }
+      let(:application_root) { '/application_url' }
+      let(:forward_proxy_builder) do
+        ForwardProxyBuilder.new(mapped_path: application_root).tap do |builder|
+          builder.split url: base_url, label: :current, percentage: 100
+        end
+      end
+
+      subject do
+        described_class.new.tap do |route_set|
+          route_set << forward_proxy_builder
+        end
+      end
+
+      before do
+        subject.init
+      end
+
+      describe '#init' do
+        it 'builds all of the forward_proxies' do
+          expect(subject.forward_proxies[application_root]).to receive(:build).and_call_original
+          subject.init
+        end
+      end
+
+      describe '#mapped_route' do
+        let(:request) { Rack::Request.new({}) }
+        let(:more_specific_proxy_builder) do
+          ForwardProxyBuilder.new(url: "#{base_url}/sub_url", mapped_path: "#{application_root}/sub_url")
+        end
+
+        context 'regex match on path' do
+          let(:fuzzy_matcher) do
+            ForwardProxyBuilder.new(url: "#{base_url}/$1/view", mapped_path: %r{#{application_root}/(.*)/view})
+          end
+          subject do
+            described_class.new.tap do |route_set|
+              route_set << fuzzy_matcher
+            end
+          end
+
+          it 'matches and subsitutes the captured group' do
+            mapped_endpoint = subject.mapped_proxy(path: "#{application_root}/123/view", request: request)
+            expected_endpoint = fuzzy_matcher.resolve(env: {})
+            expect(mapped_endpoint).to eq(expected_endpoint)
+          end
+        end
+
+        context 'exact match on path' do
+          it 'proxies to the requested path' do
+            mapped_endpoint = subject.mapped_proxy(path: application_root, request: request)
+            expected_endpoint = forward_proxy_builder.resolve(env: {})
+            expect(mapped_endpoint).to eq(expected_endpoint)
+          end
+        end
+
+        context 'when more specific route is configured first' do
+          subject do
+            described_class.new.tap do |route_set|
+              route_set << more_specific_proxy_builder
+              route_set << forward_proxy_builder
+            end
+          end
+
+          it 'matches the first endpoint' do
+            expected_endpoint = more_specific_proxy_builder.resolve(env: {})
+            mapped_endpoint = subject.mapped_proxy(path: "#{application_root}/sub_url", request: request)
+            expect(mapped_endpoint).to eq(expected_endpoint)
+          end
+        end
+      end
+
+      describe '#call' do
+        context 'mapped_route not found' do
+          let(:app) do
+            subject
+          end
+
+          it 'returns a 404' do
+            expect(get('/missing').status).to eq(404)
+          end
+        end
+
+        context 'mapped_route found' do
+          let(:app) do
+            subject
+          end
+
+          it 'uses the forward proxy' do
+            subject
+            expect(forward_proxy_builder.endpoints[:current]).to receive(:call) do
+              [200, {}, []]
+            end
+            expect(get(application_root).status).to eq(200)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/middleware/logging/access_logger_spec.rb

@@ -0,0 +1,51 @@
+require 'sitehub/constants'
+require 'sitehub/middleware/logging/access_logger'
+require 'stringio'
+
+class SiteHub
+  module Middleware
+    module Logging
+      describe AccessLogger do
+        include_context :rack_request
+
+        let(:logger) { StringIO.new }
+
+        let(:env) { env_for(path: '/') }
+
+        subject do
+          described_class.new(app, logger)
+        end
+
+        describe '#initialize' do
+          context 'logger supplied' do
+            it 'sets logger to that logger' do
+              expect(described_class.new(:app, :custom_logger).logger).to eq(LogWrapper.new(:custom_logger))
+            end
+          end
+
+          context 'logger not supplied' do
+            it 'sets the logger to go to STDERR' do
+              expect(::Logger).to receive(:new).with(STDOUT).and_return(:logging)
+              expect(described_class.new(:app).logger).to eq(LogWrapper.new(:logging))
+            end
+          end
+        end
+
+        describe '#call' do
+          let(:expected_response) { Response.new([], 200, {}) }
+
+          let(:app) do
+            proc { expected_response }
+          end
+
+          it 'logs the request / response details' do
+            expected_request = Request.new(env: env)
+
+            subject.call(env)
+            expect(logger.string).to eq(RequestLog.new(expected_request, expected_response).to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/middleware/logging/error_logger_spec.rb

@@ -0,0 +1,84 @@
+require 'sitehub/middleware/logging/error_logger'
+
+class SiteHub
+  module Middleware
+    module Logging
+      describe ErrorLogger do
+        let(:app) { proc { [200, {}, []] } }
+        subject { described_class.new(app) }
+
+        describe '#initialize' do
+          context 'logger supplied' do
+            it 'sets logger to that logger' do
+              expect(described_class.new(:app, :custom_logger).logger).to eq(LogWrapper.new(:custom_logger))
+            end
+          end
+
+          context 'logger not supplied' do
+            it 'sets the logger to go to STDERR' do
+              expect(::Logger).to receive(:new).with(STDERR).and_return(:logging)
+              expect(described_class.new(:app).logger).to eq(LogWrapper.new(:logging))
+            end
+          end
+        end
+
+        describe '#before_call' do
+          it 'adds a collection hold errors' do
+            env = {}
+            subject.call(env)
+            expect(env[ERRORS]).to eq([])
+          end
+        end
+
+        describe '#call' do
+          let(:output) { StringIO.new }
+          let(:logger) { Logger.new(output) }
+          let(:error_message) { 'error' }
+          let(:errors) do
+            Logging::LogStash.new.tap do |stash|
+              stash << error_message
+            end
+          end
+          subject { described_class.new(app, logger) }
+
+          context 'errors have occurred' do
+            it 'logs errors' do
+              log_message = subject.log_message(error: error_message, transaction_id: :transaction_id)
+              subject.call(ERRORS => errors, Constants::RackHttpHeaderKeys::TRANSACTION_ID => :transaction_id)
+              expect(output.string).to eq(log_message)
+            end
+          end
+
+          context 'no errors have occured' do
+            it 'does not log anything' do
+              expect(logger).to_not receive(:write)
+              subject.call(ERRORS => [])
+            end
+          end
+        end
+
+        describe '#log_message' do
+          let(:error) { 'error' }
+
+          it 'contains the time and date' do
+            now = Time.now
+            expect(Time).to receive(:now).and_return(now)
+            log_message = subject.log_message(error: error, transaction_id: :transaction_id)
+            expected_time = now.strftime('%d/%b/%Y:%H:%M:%S %z')
+            expect(log_message).to start_with("[#{expected_time}]")
+          end
+
+          it 'logs statements made against blah' do
+            log_message = subject.log_message(error: error, transaction_id: :transaction_id)
+            expect(log_message).to match(/ERROR: .* -  ?#{error}$/)
+          end
+
+          it 'contains the transation id of the request' do
+            log_message = subject.log_message(error: error, transaction_id: :transaction_id)
+            expect(log_message).to include('ERROR: transaction_id')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/middleware/logging/log_entry_spec.rb

@@ -0,0 +1,33 @@
+require 'sitehub/middleware/logging/log_entry'
+class SiteHub
+  module Middleware
+    module Logging
+      describe LogEntry do
+        describe '#initialize' do
+          let(:time) { Time.now }
+          subject do
+            described_class.new(:message, time)
+          end
+
+          it 'sets the message' do
+            expect(subject.message).to be(:message)
+          end
+
+          it 'sets the time' do
+            expect(subject.time).to be(time)
+          end
+
+          context 'time not supplied' do
+            subject do
+              described_class.new(:message)
+            end
+            it 'defaults the time' do
+              expect(Time).to receive(:now).and_return(:current_time)
+              expect(subject.time).to be(:current_time)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/middleware/logging/log_stash_spec.rb

@@ -0,0 +1,21 @@
+require 'sitehub/middleware/logging/log_stash'
+
+class SiteHub
+  module Middleware
+    module Logging
+      describe LogStash do
+        it 'inherits Array' do
+          expect(subject).to be_a_kind_of(Array)
+        end
+
+        describe '#<<' do
+          it 'adds a LogEntry' do
+            allow(Time).to receive(:now).and_return(:current_time)
+            subject << :message
+            expect(subject).to eq([LogEntry.new(:message)])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/middleware/logging/log_wrapper_spec.rb

@@ -0,0 +1,31 @@
+require 'sitehub/middleware/logging/log_wrapper'
+class SiteHub
+  module Middleware
+    module Logging
+      describe LogWrapper do
+        describe '#write' do
+          let(:logger) { double('logger') }
+          subject do
+            described_class.new(logger)
+          end
+
+          context 'logger responds to <<' do
+            it 'calls << when writing out the log' do
+              message = 'message'
+              expect(logger).to receive(:<<).with(message)
+              subject.write(message)
+            end
+          end
+
+          context 'logger responds to write' do
+            it 'calls << when writing out the log' do
+              message = 'message'
+              expect(logger).to receive(:write).with(message)
+              subject.write(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/middleware/logging/request_log_spec.rb

@@ -0,0 +1,108 @@
+require 'sitehub/middleware/logging/request_log'
+
+class SiteHub
+  module Middleware
+    module Logging
+      describe RequestLog do
+        include_context :rack_request
+
+        let(:rack_http_header_keys) { Constants::RackHttpHeaderKeys }
+
+        let(:response_headers) do
+          env = { rack_http_header_keys::QUERY_STRING => '',
+                  rack_http_header_keys::TRANSACTION_ID => :transaction_id,
+                  rack_http_header_keys::HTTP_VERSION => '1.1' }
+          HttpHeaders.from_rack_env(env)
+        end
+
+        let(:request_headers) do
+          {}
+        end
+
+        let(:query_string) { '' }
+
+        let(:request) do
+          env = env_for(path: "/#{query_string}", env: request_headers)
+          Request.new(env: env).tap do |request|
+            request.map :mapped_path.to_s, :mapped_url.to_s
+          end
+        end
+
+        let(:response) do
+          headers = env_for(path: '/', env: response_headers)
+          Response.new([], 200, headers)
+        end
+
+        subject do
+          described_class.new(request, response)
+        end
+
+        describe '#to_s' do
+          context 'query string' do
+            let(:query_string) { rack_http_header_keys::QUERY_STRING }
+            context 'present' do
+              let(:query_string) { '?query' }
+              it 'logs it' do
+                expect(subject.to_s).to include(query_string)
+              end
+            end
+
+            context 'not present' do
+              let(:query_string) { '' }
+              it 'is not logged' do
+                expect(subject.to_s).to include(query_string)
+              end
+            end
+          end
+
+          it 'logs the transaction id' do
+            request_headers[rack_http_header_keys::TRANSACTION_ID] = :transaction_id
+            expect(subject.to_s).to include('transaction_id:transaction_id')
+          end
+
+          it 'logs the response status' do
+            expect(subject.to_s).to include(response.status.to_s)
+          end
+
+          it 'logs the downstream url that was proxied to' do
+            expect(subject.to_s).to include("#{request.path} => mapped_url")
+          end
+
+          context '404 returned, i.e. no downstream call made' do
+            let(:request) do
+              env = env_for(path: "/#{query_string}", env: request_headers)
+              Request.new(env: env)
+            end
+            it 'does not log the down stream url' do
+              expect(subject.to_s).to include("=> #{EMPTY_STRING} #{request.http_version}")
+            end
+          end
+        end
+
+        describe '#extract_content_length' do
+          context 'content length header not present' do
+            it 'returns -' do
+              expect(subject.extract_content_length).to eq('-')
+            end
+          end
+
+          context 'content length header not present' do
+            context 'it is 0' do
+              it 'returns -' do
+                response_headers[Constants::HttpHeaderKeys::CONTENT_LENGTH] = 0
+                expect(subject.extract_content_length).to eq('-')
+              end
+            end
+
+            context 'it is set to a number other than 0' do
+              it 'returns the number' do
+                response_headers[Constants::HttpHeaderKeys::CONTENT_LENGTH] = 5
+                expect(subject.extract_content_length).to eq(5)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/middleware/reverse_proxy_spec.rb

@@ -0,0 +1,113 @@
+class SiteHub
+  module Middleware
+    describe ReverseProxy do
+      include_context :rack_request
+      include_context :middleware_test
+      HttpHeaderKeys = Constants::HttpHeaderKeys
+
+      let(:mapped_path) { '/orders' }
+      let(:user_facing_app_url) { "http://example.org#{mapped_path}" }
+
+      let(:downstream_mapping) { 'https://downstream.com/app1/orders' }
+      let(:downstream_location) { "#{downstream_mapping}/123/confirmation" }
+
+      let(:env) { env_for(path: mapped_path) }
+
+      let(:request) do
+        Request.new(env: env).tap do |request|
+          request.map mapped_path, downstream_mapping
+        end
+      end
+      let(:request_mapping) { request.mapping }
+
+      let(:app) do
+        proc { downstream_response }
+      end
+
+      let(:downstream_response) { Rack::Response.new('downstream', 200, 'header1' => 'header1') }
+
+      subject(:reverse_proxy) { described_class.new(app, []) }
+
+      before do
+        env[REQUEST] = request
+      end
+
+      describe '#call' do
+        subject(:response) do
+          status, headers, body = reverse_proxy.call(env).to_a
+          Rack::Response.new(body, status, headers)
+        end
+
+        it 'copies the downstream body in to the response' do
+          expect(response.body).to eq(downstream_response.body)
+        end
+
+        it 'copies the downstream headers in to the response' do
+          expect(response.headers).to eq(downstream_response.headers)
+        end
+
+        it 'copies the downstream status in to the response' do
+          expect(response.status).to eq(downstream_response.status)
+        end
+
+        context 'cookies' do
+          context 'downstream response contains a cookie' do
+            it 'rewrites it to use the upstream domain' do
+              downstream_response.set_cookie('downstream.cookie', domain: '.downstream.com', value: 'value')
+
+              expect(reverse_proxy)
+                .to receive(:rewrite_cookies)
+                .with(downstream_response.headers, substitute_domain: URI(request.mapping.source_url).host)
+
+              reverse_proxy.call(env)
+            end
+          end
+
+          context 'downstream response does not contain a cookie' do
+            it 'does not attempt to rewrite the cookies' do
+              downstream_headers = downstream_response.headers
+              downstream_headers[HttpHeaderKeys::LOCATION_HEADER] = downstream_location
+              expect(reverse_proxy).not_to receive(:rewrite_cookies)
+              reverse_proxy.call(env)
+            end
+          end
+        end
+
+        context 'location header' do
+          context 'reverse proxy defined' do
+            subject(:reverse_proxy) do
+              directive = { downstream_mapping => '/rewritten' }
+              described_class.new(app, directive)
+            end
+            # Location, Content-Location and URI
+            it 'rewrites the header' do
+              downstream_response.headers[HttpHeaderKeys::LOCATION_HEADER] = downstream_mapping
+              reverse_proxy.call(env)
+              # TODO: come up with better way for getting source request address and reuse the test suite
+              expect(downstream_response.headers[HttpHeaderKeys::LOCATION_HEADER]).to eq('http://example.org/rewritten')
+            end
+          end
+        end
+
+        context 'response' do
+          include_context :http_proxy_rules
+
+          let(:downstream_response) do
+            Rack::Response.new('', 200, prohibited_headers.merge(permitted_header => 'value'))
+          end
+
+          subject(:app) do
+            app = proc { downstream_response }
+            described_class.new(app, [])
+          end
+
+          it_behaves_like 'prohibited_header_filter' do
+            let(:subject) do
+              get('/', {}, REQUEST => request).headers
+            end
+          end
+        end
+      end
+    end
+  end
+end