sitehub 0.4.2 → 0.4.3

data/spec/sitehub/error_handling_spec.rb

@@ -2,13 +2,12 @@ describe 'error handling' do
   include_context :site_hub
   include_context :async
 
-
   before do
     WebMock.enable!
   end
   context 'connectivity error' do
     def app
-      @app||= async_middleware.new(rack_application)
+      @app ||= Async::Middleware.new(rack_application)
     ensure
       WebMock.disable!
     end
@@ -18,4 +17,4 @@ describe 'error handling' do
       expect(last_response.status).to eq(500)
     end
   end
-end
+end

data/spec/sitehub/forward_proxies_spec.rb

@@ -2,7 +2,6 @@ require 'sitehub/forward_proxies'
 
 class SiteHub
   describe ForwardProxies do
-
     let(:base_url) { 'http://google.com' }
     let(:application_root) { '/application_url' }
     let(:forward_proxy_builder) do
@@ -29,27 +28,33 @@ class SiteHub
     end
 
     describe '#mapped_route' do
-
       let(:request) { Rack::Request.new({}) }
-      let(:more_specific_proxy_builder) {ForwardProxyBuilder.new(url: "#{base_url}/sub_url", mapped_path: "#{application_root}/sub_url")}
+      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){ ForwardProxyBuilder.new(url: "#{base_url}/$1/view", mapped_path: %r{#{application_root}/(.*)/view})}
+        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
-          expect(subject.mapped_route(path: "#{application_root}/123/view", request: request)).to eq(fuzzy_matcher.resolve(env:{}))
+          mapped_endpoint = subject.mapped_route(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
-          expect(subject.mapped_route(path: application_root, request: request)).to eq(forward_proxy_builder.resolve(env:{}))
+          mapped_endpoint = subject.mapped_route(path: application_root, request: request)
+          expected_endpoint = forward_proxy_builder.resolve(env: {})
+          expect(mapped_endpoint).to eq(expected_endpoint)
         end
       end
 
@@ -62,14 +67,14 @@ class SiteHub
         end
 
         it 'matches the first endpoint' do
-          expect(subject.mapped_route(path: "#{application_root}/sub_url", request: request)).to eq(more_specific_proxy_builder.resolve(env:{}))
+          expected_endpoint = more_specific_proxy_builder.resolve(env: {})
+          mapped_endpoint = subject.mapped_route(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
@@ -94,6 +99,5 @@ class SiteHub
         end
       end
     end
-
   end
-end
+end

data/spec/sitehub/forward_proxy_builder_spec.rb

@@ -1,9 +1,8 @@
+# rubocop:disable Metrics/ClassLength
 require 'sitehub/forward_proxy_builder'
 
 class SiteHub
-
   describe ForwardProxyBuilder do
-
     include_context :middleware_test
 
     subject do
@@ -58,30 +57,65 @@ class SiteHub
           end
         end
       end
-
     end
 
     describe '#split' do
       context 'duplicate label used' do
         it 'raises an error' do
           subject.split percentage: 10, url: :url, label: :label
-          expect { subject.split percentage: 10, url: :url, label: :label }.to raise_exception(Collection::DuplicateVersionException, 'supply unique labels')
+
+          expect { subject.split percentage: 10, url: :url, label: :label }
+            .to raise_exception(Collection::DuplicateVersionException, 'supply unique labels')
         end
       end
 
-
       context 'split supplied' do
-        it 'stores a split for the version' do
-          subject.split url: :url, label: :label, percentage: 50
-          expected = Collection::SplitRouteCollection.new(ForwardProxy.new(url: :url, id: :label,sitehub_cookie_name: :cookie_name) => 50)
-          expect(subject.endpoints).to eq(expected)
+        context 'block supplied' do
+          it 'stores a forward proxy builder' do
+            proc = proc do
+              default url: :url
+            end
+
+            subject.split(percentage: 50, &proc)
+
+            expected_builder = described_class.new(mapped_path: subject.mapped_path, &proc)
+            expected_split = SiteHub::Collection::SplitRouteCollection::Split.new(0, 50, expected_builder)
+            expect(subject.endpoints.values).to eq([expected_split])
+          end
+        end
+
+        context 'block not supplied' do
+          it 'stores a split for the version' do
+            subject.split url: :url, label: :label, percentage: 50
+
+            expected_proxy = { ForwardProxy.new(url: :url, id: :label, sitehub_cookie_name: :cookie_name) => 50 }
+            expected = Collection::SplitRouteCollection.new(expected_proxy)
+
+            expect(subject.endpoints).to eq(expected)
+          end
+
+          context 'label not supplied' do
+            it 'raises an error' do
+              expect { subject.split(url: :url, percentage: 50) }
+                .to raise_error(ForwardProxyBuilder::InvalidDefinitionException)
+            end
+          end
+
+          context 'url not supplied' do
+            it 'raises an error' do
+              expect { subject.split(label: :label, percentage: 50) }
+                .to raise_error(ForwardProxyBuilder::InvalidDefinitionException)
+            end
+          end
         end
       end
 
       context 'routes defined' do
         it 'throws and error' do
           subject.route url: :url, label: :label
-          expect { subject.split(url: :url, label: :label, percentage: 50) }.to raise_error(ForwardProxyBuilder::InvalidDefinitionException)
+
+          expect { subject.split(url: :url, label: :label, percentage: 50) }
+            .to raise_error(ForwardProxyBuilder::InvalidDefinitionException)
         end
       end
     end
@@ -90,26 +124,27 @@ class SiteHub
       it 'accepts a rule' do
         subject.route url: :url, label: :current, rule: :rule
         expected_route = ForwardProxy.new(url: :url, id: :current, rule: :rule, sitehub_cookie_name: :cookie_name)
-        expect(subject.endpoints).to eq({expected_route.id => expected_route})
+        expect(subject.endpoints).to eq(expected_route.id => expected_route)
       end
 
       context 'block supplied' do
         context 'rule not supplied' do
           it 'raise an error' do
-            expect { subject.route {} }.to raise_exception described_class::InvalidDefinitionException, 'rule must be specified when supplying a block'
+            expected_message = described_class::INVALID_ROUTE_DEF_MSG
+            expect { subject.route {} }.to raise_exception described_class::InvalidDefinitionException, expected_message
           end
         end
 
-        it 'allows further splits or routes to be defined' do
+        it 'stores a proxy builder' do
           rule = proc { true }
-          subject.route rule: rule do
+          proc = proc do
             route url: :url, label: :label1
           end
 
-          subject.build
+          subject.route(rule: rule, &proc)
 
-          expected_route = ForwardProxy.new(url: :url, id: :label1, sitehub_cookie_name: :cookie_name)
-          expect(subject.resolve(env: {})).to eq(expected_route)
+          expected_builder = described_class.new(mapped_path: subject.mapped_path, &proc)
+          expect(subject.endpoints.values).to eq([expected_builder])
         end
 
         context 'invalid definitions inside block' do
@@ -125,9 +160,7 @@ class SiteHub
       end
     end
 
-
     describe '#build' do
-
       let(:rule) { proc {} }
 
       context 'middleware not specified' do
@@ -144,12 +177,10 @@ class SiteHub
           subject.route url: :url, label: :current, rule: rule
           expect(subject.endpoints[:current]).to_not receive(:extend).with(Resolver)
           subject.build
-
         end
       end
 
       context 'middleware specified' do
-
         before do
           subject.use middleware
           subject.route url: :url, label: :current, rule: rule
@@ -162,7 +193,6 @@ class SiteHub
           proxy_after_build = subject.endpoints[:current]
           expect(proxy_after_build).to be_a(middleware)
           expect(proxy_after_build.app).to be(proxy_before_build)
-
         end
 
         it 'extends the middleware with Resolver' do
@@ -192,10 +222,8 @@ class SiteHub
           expect(default_proxy_after_build.app).to be(default_proxy_before_build)
         end
       end
-
     end
     describe '#resolve' do
-
       subject { described_class.new(mapped_path: '/') }
 
       context 'routes defined' do
@@ -239,12 +267,9 @@ class SiteHub
             expect { subject.endpoints(:collection2) }.to raise_exception described_class::InvalidDefinitionException
           end
         end
-
       end
 
-
       context 'version selected' do
-
         context 'version applies to a route' do
           before do
             subject.split percentage: 50, url: :url1, label: :new
@@ -270,7 +295,6 @@ class SiteHub
             end
           end
         end
-
       end
     end
 
@@ -291,5 +315,4 @@ class SiteHub
       end
     end
   end
-
-end
+end

data/spec/sitehub/forward_proxy_spec.rb

@@ -1,13 +1,22 @@
+# rubocop:disable Metrics/ClassLength
 require 'sitehub/forward_proxy'
 
 class SiteHub
   describe ForwardProxy do
-
-    let(:current_version_url) { 'http://does.not.exist.com' }
+    let(:current_version_url) { 'http://127.0.0.1:10111' }
     let(:mapped_path) { '/path' }
 
+    let(:expected_mapping) do
+      RequestMapping.new(source_url: "http://example.org#{mapped_path}",
+                         mapped_url: current_version_url,
+                         mapped_path: mapped_path)
+    end
+
     subject do
-      described_class.new(id: :id, url: current_version_url, mapped_path: mapped_path,sitehub_cookie_name: :cookie_name)
+      described_class.new(id: :id,
+                          url: current_version_url,
+                          mapped_path: mapped_path,
+                          sitehub_cookie_name: :cookie_name)
     end
 
     let(:app) do
@@ -25,7 +34,7 @@ class SiteHub
     describe '#call' do
       before do
         WebMock.enable!
-        stub_request(:get, current_version_url).to_return(:body => 'body')
+        stub_request(:get, current_version_url).to_return(body: 'body')
       end
 
       context 'recorded routes cookie' do
@@ -42,8 +51,7 @@ class SiteHub
         end
 
         context 'recorded_routes_cookie_path set' do
-
-          let(:expected_path){'/expected_path'}
+          let(:expected_path) { '/expected_path' }
 
           subject do
             described_class.new(id: :id,
@@ -60,11 +68,9 @@ class SiteHub
         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))
+        expect(last_request.env[REQUEST_MAPPING]).to eq(expected_mapping)
       end
 
       context 'downstream call' do
@@ -73,15 +79,15 @@ class SiteHub
             WebMock.disable!
           end
           it 'adds an error to be logged' do
-            env = {ERRORS.to_s => []}
+            env = { ERRORS.to_s => [] }
             get(mapped_path, {}, env)
-            expect(last_request.env[ERRORS]).to eq(["unable to resolve server address"])
+            expect(last_request.env[ERRORS]).to_not be_empty
           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 => []}
+              env = { ERRORS.to_s => [] }
               get(mapped_path, {}, env)
 
               expect(last_response.body).to eq(described_class::ERROR_RESPONSE.body.join)
@@ -90,14 +96,13 @@ class SiteHub
             end
 
             it 'passes the request mapping' do
-              env = { ERRORS.to_s => []}
+              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))
+              expect(last_request.env[REQUEST_MAPPING]).to eq(expected_mapping)
             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')
@@ -108,31 +113,30 @@ class SiteHub
           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'}
+              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'}
+              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)
+            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'}
+            assert_requested :get, current_version_url, headers: { 'Header' => 'value' }
           end
         end
-
       end
     end
   end
-end
+end

data/spec/sitehub/http_headers_spec.rb

@@ -1,7 +1,6 @@
- require 'sitehub/http_headers'
+require 'sitehub/http_headers'
 class SiteHub
   describe HttpHeaders do
-
     subject do
       Object.new.tap do |o|
         o.extend(described_class)
@@ -9,27 +8,26 @@ class SiteHub
     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'}
+      { '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|
+      {}.tap do |hash|
         headers_underscored.each do |key, value|
-          hash[key.gsub('_', '-')] = value
+          hash[key.tr('_', '-')] = 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'
@@ -60,12 +58,13 @@ class SiteHub
         end
 
         it 'filters out connections' do
-          headers = subject.sanitise_headers('connection' => 'a, b', 'a' => 'value_a', 'b' => 'value_b', 'c' => 'value_c')
+          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
+end

data/spec/sitehub/integration_spec.rb

@@ -3,19 +3,18 @@ describe 'proxying calls' do
   include_context :async
 
   describe 'supported HTTP verbs' do
-
     before do
       WebMock.enable!
     end
 
-    let(:app){async_middleware.new(rack_application)}
+    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')
+      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
+end

data/spec/sitehub/logging/access_logger_spec.rb

@@ -1,16 +1,19 @@
+require 'sitehub/constants'
 require 'sitehub/logging/access_logger'
 require 'stringio'
 
 class SiteHub
   module Logging
     describe AccessLogger do
+      RackHttpHeaderKeys = Constants::RackHttpHeaderKeys
+      HttpHeaderKeys = Constants::HttpHeaderKeys
 
       let(:logger) do
         StringIO.new
       end
 
       let(:app) do
-        proc{[200, {}, []]}
+        proc { [200, {}, []] }
       end
 
       subject do
@@ -18,7 +21,6 @@ class SiteHub
       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))
@@ -35,19 +37,20 @@ class SiteHub
 
       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,
-              described_class::HTTP_VERSION => '1.1'
-          }
+          { REQUEST_MAPPING => request_mapping,
+            RackHttpHeaderKeys::QUERY_STRING => '',
+            RackHttpHeaderKeys::PATH_INFO => 'path_info',
+            RackHttpHeaderKeys::TRANSACTION_ID => :transaction_id,
+            RackHttpHeaderKeys::HTTP_VERSION => '1.1' }
+        end
 
+        let(:request_mapping) do
+          RequestMapping.new(source_url: :source_url, mapped_url: :mapped_url.to_s, mapped_path: :mapped_path.to_s)
         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} }
+        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)
@@ -56,19 +59,19 @@ class SiteHub
         end
 
         context 'query string' do
-          let(:query_string) { described_class::QUERY_STRING }
+          let(:query_string) { RackHttpHeaderKeys::QUERY_STRING }
           context 'present' do
             it 'logs it' do
               env[query_string] = 'query'
               subject.call(env)
-              expect(logger.string).to include("?query")
+              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("?")
+              expect(logger.string).to_not include('?')
             end
           end
         end
@@ -76,7 +79,7 @@ class SiteHub
         it 'logs the transaction id' do
           subject.call(env)
 
-          expect(logger.string).to include("transaction_id:#{:transaction_id}")
+          expect(logger.string).to include('transaction_id:transaction_id')
         end
 
         it 'logs the response status' do
@@ -85,22 +88,21 @@ class SiteHub
           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}")
+          expect(logger.string).to include("#{env[RackHttpHeaderKeys::PATH_INFO]} => mapped_url")
         end
 
         context '404 returned, i.e. no downstream call made' do
           let(:request_mapping) { nil }
           it 'does not log the down stream url' do
             subject.call(env)
-            expect(logger.string).to include("=> #{EMPTY_STRING} #{env[described_class::HTTP_VERSION]}")
+            expect(logger.string).to include("=> #{EMPTY_STRING} #{env[RackHttpHeaderKeys::HTTP_VERSION]}")
           end
         end
-
       end
+
       describe '#extract_content_length' do
         context 'content length header not present' do
           it 'returns -' do
@@ -109,19 +111,18 @@ class SiteHub
         end
 
         context 'content length header not present' do
-          let(:content_length) { described_class::CONTENT_LENGTH }
+          let(:content_length) { HttpHeaderKeys::CONTENT_LENGTH }
           context 'it is 0' do
             it 'returns -' do
-              expect(subject.extract_content_length({content_length => 0})).to eq('-')
+              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)
+            expect(subject.extract_content_length(content_length => 5)).to eq(5)
           end
         end
-
       end
     end
   end
-end
+end