sitehub 0.4.1

data/spec/sitehub/forward_proxy_spec.rb

@@ -0,0 +1,138 @@
+require 'sitehub/forward_proxy'
+
+class SiteHub
+  describe ForwardProxy do
+
+    let(:current_version_url) { 'http://does.not.exist.com' }
+    let(:mapped_path) { '/path' }
+
+    subject do
+      described_class.new(id: :id, url: current_version_url, mapped_path: mapped_path,sitehub_cookie_name: :cookie_name)
+    end
+
+    let(:app) do
+      subject
+    end
+
+    it 'includes Resolver' do
+      expect(subject).to be_a(Resolver)
+    end
+
+    it 'includes Rules' do
+      expect(subject).to be_a(Rules)
+    end
+
+    describe '#call' do
+      before do
+        WebMock.enable!
+        stub_request(:get, current_version_url).to_return(:body => 'body')
+      end
+
+      context 'recorded routes cookie' do
+        it 'drops a cookie using the name of the sitehub_cookie_name containing the id' do
+          get(mapped_path, {})
+          expect(last_response.cookies[:cookie_name.to_s]).to eq(value: :id.to_s, path: subject.mapped_path)
+        end
+
+        context 'recorded_routes_cookie_path not set' do
+          it 'sets the path to be the request path' do
+            get(mapped_path, {})
+            expect(last_response.cookies[:cookie_name.to_s][:path]).to eq(mapped_path)
+          end
+        end
+
+        context 'recorded_routes_cookie_path set' do
+
+          let(:expected_path){'/expected_path'}
+
+          subject do
+            described_class.new(id: :id,
+                                url: current_version_url,
+                                mapped_path: mapped_path,
+                                sitehub_cookie_path: expected_path,
+                                sitehub_cookie_name: :cookie_name)
+          end
+
+          it 'is set as the path' do
+            get(mapped_path, {})
+            expect(last_response.cookies[:cookie_name.to_s][:path]).to eq(expected_path)
+          end
+        end
+      end
+
+
+
+      it 'passes request mapping information in to the environment hash' do
+        get(mapped_path, {})
+        expect(last_request.env[REQUEST_MAPPING]).to eq(RequestMapping.new(source_url: "http://example.org#{mapped_path}", mapped_url: current_version_url, mapped_path: mapped_path))
+      end
+
+      context 'downstream call' do
+        context 'it fails' do
+          before do
+            WebMock.disable!
+          end
+          it 'adds an error to be logged' do
+            env = {ERRORS.to_s => []}
+            get(mapped_path, {}, env)
+            expect(last_request.env[ERRORS]).to eq(["unable to resolve server address"])
+          end
+
+          describe 'parameters to callback' do
+            it 'calls the callback with an error response' do
+              expect(described_class::ERROR_RESPONSE).to receive(:dup).and_return(described_class::ERROR_RESPONSE)
+              env = {ERRORS.to_s => []}
+              get(mapped_path, {}, env)
+
+              expect(last_response.body).to eq(described_class::ERROR_RESPONSE.body.join)
+              expect(last_response.headers).to eq(described_class::ERROR_RESPONSE.headers)
+              expect(last_response.status).to eq(described_class::ERROR_RESPONSE.status)
+            end
+
+            it 'passes the request mapping' do
+              env = { ERRORS.to_s => []}
+              get(mapped_path, {}, env)
+              expect(last_request.env[REQUEST_MAPPING]).to eq(RequestMapping.new(source_url: "http://example.org#{mapped_path}", mapped_url: current_version_url, mapped_path: mapped_path))
+            end
+          end
+        end
+
+
+        it 'translates the header names back in to the http compatible names' do
+          get(mapped_path, {})
+          expect(last_response.headers).to include('Content-Length')
+          expect(last_response.headers).to_not include('CONTENT_LENGTH')
+        end
+
+        context 'adding http_x_forwarded_host header' do
+          context 'when not present in the original request' do
+            it 'appends original request url with port' do
+              get(mapped_path, {})
+              assert_requested :get, current_version_url, headers: {'X-FORWARDED-HOST' => 'example.org:80'}
+            end
+          end
+
+          context 'when present in the original request' do
+            it 'appends original request url without port' do
+              get(mapped_path, {}, 'HTTP_X_FORWARDED_HOST' => 'staging.com')
+              assert_requested :get, current_version_url, headers: {'X-FORWARDED-HOST' => 'staging.com,staging.com'}
+            end
+          end
+
+          it 'preserves the body when forwarding request' do
+            body = {"key" => "value"}
+            stub_request(:put, current_version_url).with(:body => body)
+
+            put(mapped_path, body)
+          end
+
+          it 'preserves the headers when forwarding request' do
+            get(mapped_path, '', 'HTTP_HEADER' => 'value')
+            assert_requested :get, current_version_url, headers: {'Header' => 'value'}
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/sitehub/http_headers_spec.rb

@@ -0,0 +1,71 @@
+ require 'sitehub/http_headers'
+class SiteHub
+  describe HttpHeaders do
+
+    subject do
+      Object.new.tap do |o|
+        o.extend(described_class)
+      end
+    end
+
+    let(:headers_underscored) do
+      {'CONNECTION' => 'close',
+       'KEEP_ALIVE' => 'something',
+       'PROXY_AUTHENTICATE' => 'something',
+       'PROXY_AUTHORIZATION' => 'something',
+       'TE' => 'something',
+       'TRAILERS' => 'something',
+       'TRANSFER_ENCODING' => 'something',
+       'CONTENT_ENCODING' => 'something',
+       'PROXY_CONNECTION' => 'something'}
+    end
+
+    let(:headers_hyphonised) do
+      Hash.new.tap do |hash|
+        headers_underscored.each do |key, value|
+          hash[key.gsub('_', '-')] = value
+        end
+      end
+    end
+
+    describe '#sanitise_headers' do
+
+      context 'port 80 present in url' do
+        it 'removes the port' do
+          headers_hyphonised['location'] = 'http://mysite.com:80/redirect_endpoint'
+          expect(subject.sanitise_headers(headers_hyphonised)['location']).to eq('http://mysite.com/redirect_endpoint')
+        end
+      end
+
+      context 'port 443 present in url' do
+        it 'removes the port' do
+          headers_hyphonised['location'] = 'http://mysite.com:443/redirect_endpoint'
+          expect(subject.sanitise_headers(headers_hyphonised)['location']).to eq('http://mysite.com/redirect_endpoint')
+        end
+      end
+
+      describe 'treatment of headers according to RFC2616: 13.5.1 and RFC2616: 14.10' do
+        context 'prohibitted headers hyphonised' do
+          it 'filters them out' do
+            sanatised_headers = subject.sanitise_headers(headers_hyphonised)
+            expect(sanatised_headers.empty?).to eq(true)
+          end
+        end
+
+        context 'prohibitted headers underscored' do
+          it 'filters them out' do
+            sanatised_headers = subject.sanitise_headers(headers_underscored)
+            expect(sanatised_headers.empty?).to eq(true)
+          end
+        end
+
+        it 'filters out connections' do
+          headers = subject.sanitise_headers('connection' => 'a, b', 'a' => 'value_a', 'b' => 'value_b', 'c' => 'value_c')
+          expect(headers).to eq('c' => 'value_c')
+        end
+      end
+    end
+
+
+  end
+end

data/spec/sitehub/integration_spec.rb

@@ -0,0 +1,21 @@
+describe 'proxying calls' do
+  include_context :site_hub
+  include_context :async
+
+  describe 'supported HTTP verbs' do
+
+    before do
+      WebMock.enable!
+    end
+
+    let(:app){async_middleware.new(rack_application)}
+
+    %i(get post put delete).each do |verb|
+      it "forwards the downstream" do
+        stub_request(verb, downstream_url).to_return(:body => 'hello')
+        send(verb, '/endpoint')
+        expect(app.last_response.body).to eq(['hello'])
+      end
+    end
+  end
+end

data/spec/sitehub/logging/access_logger_spec.rb

@@ -0,0 +1,127 @@
+require 'sitehub/logging/access_logger'
+require 'stringio'
+
+class SiteHub
+  module Logging
+    describe AccessLogger do
+
+      let(:logger) do
+        StringIO.new
+      end
+
+      let(:app) do
+        proc{[200, {}, []]}
+      end
+
+      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 '#before_call' do
+      #  it 'saves the time' do
+      #    now = Time.now
+      #    allow(Time).to receive(:now).and_return(now)
+      #    subject.before_call(:env)
+      #    expect(subject.start_time).to eq(now)
+      #  end
+      #end
+
+      describe '#call' do
+        let(:env) do
+          {
+              REQUEST_MAPPING => request_mapping,
+              described_class::QUERY_STRING => '',
+              described_class::PATH_INFO => 'path_info',
+              Constants::RackHttpHeaderKeys::TRANSACTION_ID => :transaction_id
+          }
+
+        end
+        let(:request_mapping) { RequestMapping.new(source_url: :source_url, mapped_url: :mapped_url.to_s, mapped_path: :mapped_path.to_s) }
+        before { subject.call(env) }
+
+        let(:args) { {request_mapping: request_mapping, downstream_response: Rack::Response.new} }
+        it 'logs the request / response details in the required format' do
+          expect(subject).to receive(:log_template).and_return(:template.to_s)
+          expect(logger).to receive(:write).with(:template.to_s)
+
+          subject.call(env)
+        end
+
+        context 'query string' do
+          let(:query_string) { described_class::QUERY_STRING }
+          context 'present' do
+            it 'logs it' do
+              env[query_string] = 'query'
+              subject.call(env)
+              expect(logger.string).to include("?query")
+            end
+          end
+
+          context 'not present' do
+            it 'is not logged' do
+              subject.call(env)
+              expect(logger.string).to_not include("?")
+            end
+          end
+        end
+
+        it 'logs the transaction id' do
+          subject.call(env)
+
+          expect(logger.string).to include("transaction_id:#{:transaction_id}")
+        end
+
+        it 'logs the response status' do
+          subject.call(env)
+
+          expect(logger.string).to include(args[:downstream_response].status.to_s)
+        end
+
+
+        it 'logs the downstream url that was proxied to' do
+          subject.call(env)
+
+          expect(logger.string).to include("#{env[described_class::PATH_INFO]} => #{:mapped_url}")
+        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
+          let(:content_length) { described_class::CONTENT_LENGTH }
+          context 'it is 0' do
+            it 'returns -' do
+              expect(subject.extract_content_length({content_length => 0})).to eq('-')
+            end
+          end
+          context 'it is set to a number other than 0'
+          it 'returns the number' do
+            expect(subject.extract_content_length({content_length => 5})).to eq(5)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/sitehub/logging/error_logger_spec.rb

@@ -0,0 +1,80 @@
+require 'sitehub/logging/error_logger'
+
+class SiteHub
+  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)
+          expected_time = now.strftime("%d/%b/%Y:%H:%M:%S %z")
+          expect(subject.log_message(error: error, transaction_id: :transaction_id)).to start_with("[#{expected_time}]")
+        end
+
+        it 'logs statements made against blah' do
+
+          expect(subject.log_message(error: error, transaction_id: :transaction_id)).to match(/ERROR: .* -  ?#{error}$/)
+        end
+
+        it 'contains the transation id of the request' do
+          expect(subject.log_message(error: error, transaction_id: :transaction_id)).to include("ERROR: #{:transaction_id}")
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/logging/log_entry_spec.rb

@@ -0,0 +1,34 @@
+require 'sitehub/logging/log_entry'
+class SiteHub
+  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