sitehub 0.4.1

data/spec/sitehub/collection_spec.rb

@@ -0,0 +1,40 @@
+require 'sitehub/collection'
+
+class SiteHub
+  describe Collection do
+    describe '#valid?' do
+      it 'must be overiden and raises an exception by default' do
+        expect { subject.valid? }.to raise_exception "implement me"
+      end
+    end
+
+    describe '#resolve' do
+      it 'must be overiden and raises an exception by default' do
+        expect { subject.resolve }.to raise_exception "implement me"
+      end
+    end
+
+    describe '.inherited' do
+      describe '#add' do
+        context 'duplicate ids added' do
+          subject do
+            inheritor = Class.new(described_class) do
+              def add id, value, *args
+                self[id] = value
+              end
+            end
+
+            inheritor.new
+          end
+          it 'raises an error' do
+            duplicate = Struct.new(:id).new(1)
+            subject.add(duplicate.id, duplicate)
+            expect{subject.add(duplicate.id, duplicate)}.to raise_exception described_class::DuplicateVersionException, 'supply unique labels'
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/spec/sitehub/cookie/attribute_spec.rb

@@ -0,0 +1,37 @@
+class SiteHub
+  class Cookie
+    describe Attribute do
+      let(:attribute_name){'domain'}
+      let(:attribute_value){'value'}
+      subject do
+        described_class.new(attribute_name, attribute_value)
+      end
+      describe '#initialize' do
+        it 'stores the attribute name and its value' do
+          expect(subject.name).to eq(attribute_name.to_sym)
+          expect(subject.value).to eq(attribute_value)
+        end
+
+        it 'sanitises the string parameter' do
+          expect(described_class.new("#{attribute_name} \n", attribute_value).name).to eq(attribute_name.to_sym)
+        end
+
+        context 'value is nil' do
+          subject do
+            described_class.new(attribute_name, nil)
+          end
+
+          it 'default to empty string' do
+            expect(subject.value).to eq('')
+          end
+        end
+      end
+
+      describe '#to_s' do
+        it 'contains the attribute name and value' do
+          expect(subject.to_s).to eq("#{attribute_name}=#{attribute_value}")
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/cookie/flag_spec.rb

@@ -0,0 +1,27 @@
+class SiteHub
+  class Cookie
+    describe Flag do
+      let(:name) { 'flag' }
+      let(:string_sanitiser){Object.new.tap{|o|o.extend(StringSanitiser)}}
+      subject do
+        described_class.new(name)
+      end
+
+      describe '#initialize' do
+        it 'stores the value as a symbol' do
+          expect(subject.name).to eq(name.to_sym)
+        end
+
+        it 'sanitises the string parameter' do
+          expect(described_class.new("#{name} \n").name).to eq(name.to_sym)
+        end
+      end
+
+      describe '#to_s' do
+        it 'returns the name' do
+          expect(subject.to_s).to eq(name)
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/cookie_rewriting_spec.rb

@@ -0,0 +1,67 @@
+require 'sitehub/cookie_rewriting'
+
+class SiteHub
+  describe CookieRewriting do
+    let(:downstream_domain){'.downstream_domain.com'}
+    let(:request_mapping){RequestMapping.new(source_url: 'http://example.org', mapped_url: "http://#{downstream_domain}", mapped_path: '/map')}
+    let(:substitute_domain){URI(request_mapping.source_url).host}
+    let(:substitute_path){'/path'}
+    let(:downstream_response){Rack::Response.new}
+    let(:downstream_domain_cookie_name){'downstream.cookie'}
+
+    subject do
+      Object.new.tap do |o|
+        o.extend(described_class)
+      end
+    end
+
+    before do
+      downstream_response.set_cookie(downstream_domain_cookie_name, domain: downstream_domain, value: 'value')
+      downstream_response.set_cookie('downstream.cookie2', domain: downstream_domain, value: 'value2', httponly: true)
+    end
+
+    describe '#cookies_string_as_hash' do
+      it 'returns the string as a hash' do
+        cookie_header = downstream_response.headers['Set-Cookie']
+
+        cookie_strings = cookie_header.lines
+        cookie1 = SiteHub::Cookie.new(cookie_strings[0])
+        cookie2 = SiteHub::Cookie.new(cookie_strings[1])
+        expected = {
+            cookie1.name => cookie1,
+            cookie2.name => cookie2
+        }
+        result = subject.cookies_string_as_hash(cookie_header)
+        expect(result).to eq(expected)
+      end
+    end
+
+    describe '#cookies_hash_to_string' do
+      it 'returns the hash as a correctly formatted string' do
+        cookies_hash = subject.cookies_string_as_hash(downstream_response.headers['Set-Cookie'])
+        expect(subject.cookies_hash_to_string(cookies_hash)).to eq(downstream_response.headers['Set-Cookie'])
+      end
+    end
+
+    describe '#rewrite_cookies' do
+
+      context 'subdomain character present' do
+        it 'substitues the domain for the mapped domain' do
+          downstream_response.set_cookie(downstream_domain_cookie_name, domain: downstream_domain, value: 'value')
+          subject.rewrite_cookies(downstream_response.headers, substitute_domain: substitute_domain)
+          expect(downstream_response.cookies[downstream_domain_cookie_name][:domain]).to eq('.example.org')
+        end
+      end
+
+      context 'subdomain not character present' do
+        it 'substitues the domain for the mapped domain' do
+          downstream_response.set_cookie(downstream_domain_cookie_name, domain: 'downstream.com', value: 'value')
+          subject.rewrite_cookies(downstream_response.headers, substitute_domain: substitute_domain)
+          expect(downstream_response.cookies[downstream_domain_cookie_name][:domain]).to eq('example.org')
+        end
+      end
+    end
+
+  end
+
+end

data/spec/sitehub/cookie_spec.rb

@@ -0,0 +1,61 @@
+require 'sitehub/cookie'
+
+class SiteHub
+  describe Cookie do
+    let(:attribute_class){described_class::Attribute}
+    let(:flag_class){described_class::Flag}
+    let(:domain_attribute){attribute_class.new(:domain.to_s, 'example.com')}
+    let(:name){'sitehub.recorded_route'}
+    let(:value){'new'}
+    let(:cookie_string){ "#{name}=#{value}; HttpOnly; #{domain_attribute}"}
+
+    subject do
+      described_class.new cookie_string
+    end
+
+    describe '#initialize' do
+      it 'parse a cookie string in to attributes and flags' do
+        expect(subject.attributes_and_flags).to eq([flag_class.new('HttpOnly'), domain_attribute])
+      end
+
+      it 'extracts name as a symbol' do
+        expect(subject.name).to eq('sitehub.recorded_route'.to_sym)
+      end
+
+      it 'extracts the value' do
+        expect(subject.value).to eq('new')
+      end
+    end
+
+
+    describe '#find' do
+
+      context 'entry found' do
+        it 'returns the entry with the given name' do
+          expect(subject.find(:domain)).to eq(domain_attribute)
+        end
+      end
+
+      context 'entry not found' do
+        it 'returns nil' do
+          expect(subject.find(:missing)).to eq(nil)
+        end
+      end
+
+    end
+
+    describe '#delete' do
+      it 'removes the entry' do
+        subject.delete(:domain)
+        expect(subject.find(:domain)).to eq(nil)
+      end
+    end
+
+    describe '#to_s' do
+      it 'prints the attributes and flags' do
+        expect(subject.to_s).to eq(cookie_string)
+      end
+    end
+
+  end
+end

data/spec/sitehub/error_handling_spec.rb

@@ -0,0 +1,21 @@
+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)
+    ensure
+      WebMock.disable!
+    end
+
+    it 'shows the error page when an exception occurs' do
+      get('/endpoint')
+      expect(last_response.status).to eq(500)
+    end
+  end
+end

data/spec/sitehub/forward_proxies_spec.rb

@@ -0,0 +1,99 @@
+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
+      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) {ForwardProxyBuilder.new(url: "#{base_url}/sub_url", mapped_path: "#{application_root}/sub_url")}
+
+      context 'regex match on path' do
+        let(:fuzzy_matcher){ ForwardProxyBuilder.new(url: "#{base_url}/$1/view", mapped_path: %r{#{application_root}/(.*)/view})}
+        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:{}))
+        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:{}))
+        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
+          expect(subject.mapped_route(path: "#{application_root}/sub_url", request: request)).to eq(more_specific_proxy_builder.resolve(env:{}))
+        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

data/spec/sitehub/forward_proxy_builder_spec.rb

@@ -0,0 +1,295 @@
+require 'sitehub/forward_proxy_builder'
+
+class SiteHub
+
+  describe ForwardProxyBuilder do
+
+    include_context :middleware_test
+
+    subject do
+      described_class.new(mapped_path: '/path')
+    end
+
+    it 'supports middleware' do
+      expect(described_class).to include(Middleware)
+    end
+
+    describe '#initialize' do
+      context 'with a block' do
+        it 'evaluates the block in the context of the instance' do
+          self_inside_block = nil
+          instance = described_class.new(url: '/app1', mapped_path: '/path') { self_inside_block = self }
+          expect(self_inside_block).to eq(instance)
+        end
+      end
+    end
+
+    describe 'valid?' do
+      context 'default defined' do
+        context 'splits add up to 100' do
+          it 'returns true' do
+            subject.split(percentage: 100, label: :old, url: :url)
+            expect(subject.valid?).to eq(true)
+          end
+        end
+
+        context 'splits do not add up to 100' do
+          it 'returns true' do
+            subject.split(percentage: 10, label: :old, url: :url)
+            subject.default(url: :url)
+            expect(subject.valid?).to eq(true)
+          end
+        end
+      end
+
+      context 'default not defined' do
+        context 'splits add up to 100' do
+          it 'returns true' do
+            subject.default(url: :url)
+            expect(subject.valid?).to eq(true)
+          end
+        end
+
+        context 'splits do not add up to 100' do
+          it 'returns false' do
+            subject.split(percentage: 10, label: :old, url: :url)
+            subject.split(percentage: 10, label: :new, url: :url)
+            expect(subject).to_not be_valid
+          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')
+        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)
+        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)
+        end
+      end
+    end
+
+    describe 'route' do
+      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})
+      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'
+          end
+        end
+
+        it 'allows further splits or routes to be defined' do
+          rule = proc { true }
+          subject.route rule: rule do
+            route url: :url, label: :label1
+          end
+
+          subject.build
+
+          expected_route = ForwardProxy.new(url: :url, id: :label1, sitehub_cookie_name: :cookie_name)
+          expect(subject.resolve(env: {})).to eq(expected_route)
+        end
+
+        context 'invalid definitions inside block' do
+          it 'raises an error' do
+            rule = proc { true }
+            expect do
+              subject.route rule: rule do
+                split percentage: 20, url: :url, label: :label1
+              end
+            end.to raise_exception described_class::InvalidDefinitionException
+          end
+        end
+      end
+    end
+
+
+    describe '#build' do
+
+      let(:rule) { proc {} }
+
+      context 'middleware not specified' do
+        it 'leaves it the proxies alone' do
+          subject.route url: :url, label: :current, rule: rule
+          proxy_before_build = subject.endpoints[:current]
+          subject.build
+          proxy_after_build = subject.endpoints[:current]
+          expect(proxy_after_build).to be(proxy_before_build)
+          expect(proxy_after_build.rule).to be(rule)
+        end
+
+        it 'does not extend the endpoint with Resolver' do
+          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
+        end
+
+        it 'wraps the forward proxies in the middleware' do
+          proxy_before_build = subject.endpoints[:current]
+
+          subject.build
+          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
+          subject.build
+          expect(subject.endpoints[:current]).to be_a(Resolver)
+        end
+
+        it 'extends the middleware with Rules' do
+          subject.build
+          expect(subject.endpoints[:current]).to be_a(Rules)
+        end
+
+        context 'rule on route' do
+          it 'adds it to the rule to the middleware object' do
+            subject.build
+            expect(subject.endpoints[:current].rule).to eq(rule)
+          end
+        end
+
+        it 'wraps the default in the middleware' do
+          subject.default url: :url
+          default_proxy_before_build = subject.default_proxy
+
+          subject.build
+          default_proxy_after_build = subject.default_proxy
+          expect(default_proxy_after_build).to be_a(middleware)
+          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
+        it 'returns that route' do
+          subject.route url: :url, label: :current
+          expect(subject.resolve(env: {})).to eq(subject.endpoints.values.first)
+        end
+
+        it 'passes the env to the when resolving the correct route' do
+          expect_any_instance_of(subject.routes.class).to receive(:resolve).with(env: :env).and_call_original
+          subject.resolve(env: :env)
+        end
+      end
+
+      context 'splits defined' do
+        it 'serves an entry from the routes' do
+          subject.split(percentage: 100, url: :url, label: :label)
+          expect(subject.endpoints).to receive(:resolve).and_return(:pick)
+          expect(subject.resolve(env: {})).to eq(:pick)
+        end
+
+        context 'splits not defined' do
+          it 'returns the default' do
+            subject.default url: :url
+            expect(subject.resolve(env: {})).to eq(subject.default_proxy)
+          end
+        end
+      end
+
+      context 'endpoints' do
+        context 'called with a collection' do
+          it 'sets endpoints to be that collection' do
+            subject.endpoints(:collection)
+            expect(subject.endpoints).to eq(:collection)
+          end
+        end
+
+        context 'already set with a different collection' do
+          it 'raise an error' do
+            subject.endpoints(:collection1)
+            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
+            subject.split percentage: 50, url: :url2, label: :old
+          end
+
+          let(:application_version1) do
+            subject.endpoints.values.find do |pick|
+              pick.value.id == :new
+            end.value
+          end
+
+          context 'string supplied' do
+            it 'redirects to that version' do
+              expect(subject.resolve(id: :new.to_s, env: {})).to eq(application_version1)
+            end
+          end
+
+          context 'symbol supplied' do
+            it 'redirects to that version' do
+              expect(subject).to_not receive(:auto_resolve)
+              expect(subject.resolve(id: :new, env: {})).to eq(application_version1)
+            end
+          end
+        end
+
+      end
+    end
+
+    describe '#forward_proxy' do
+      subject do
+        described_class.new(mapped_path: '/path', sitehub_cookie_name: :expected_cookie_name)
+      end
+
+      it 'sets the sitehub_cookie_path' do
+        subject.sitehub_cookie_path :cookie_path
+        proxy = subject.forward_proxy(label: :label, url: :url)
+        expect(proxy.sitehub_cookie_path).to eq(:cookie_path)
+      end
+
+      it 'sets the sitehub_cookie_name' do
+        proxy = subject.forward_proxy(label: :label, url: :url)
+        expect(proxy.sitehub_cookie_name).to eq(:expected_cookie_name)
+      end
+    end
+  end
+
+end