sitehub 0.4.10 → 0.5.0.alpha2

data/spec/sitehub/forward_proxy_spec.rb

@@ -7,9 +7,7 @@ class SiteHub
     include_context :rack_request
 
     subject(:app) do
-      described_class.new(sitehub_cookie_name: :cookie_name,
-                          id: :id,
-                          mapped_path: mapped_path,
+      described_class.new(mapped_path: mapped_path,
                           mapped_url: mapped_url)
     end
 
@@ -17,14 +15,6 @@ class SiteHub
       stub_request(:get, mapped_url).to_return(body: 'body')
     end
 
-    it 'includes Resolver' do
-      expect(app).to be_a(Resolver)
-    end
-
-    it 'includes Rules' do
-      expect(app).to be_a(Rules)
-    end
-
     describe '#call' do
       let(:rack_headers) { {} }
       let(:request) { Request.new(env: env_for(path: mapped_path, env: rack_headers)) }
@@ -42,42 +32,6 @@ class SiteHub
         expect(request.mapped_path).to eq(mapped_path)
         expect(request.mapped_url).to eq(mapped_url)
       end
-
-      context 'recorded routes cookie' do
-        it 'drops a cookie using the name of the sitehub_cookie_name containing the id' do
-          expect(last_response.cookies[:cookie_name.to_s]).to eq(value: :id.to_s, path: mapped_path)
-        end
-
-        context 'cookie already set' do
-          let(:rack_headers) { { 'HTTP_COOKIE' => 'cookie_name=existing_value' } }
-
-          it 'replaces the value as this is the proxy it should stick with' do
-            expect(last_response.cookies[:cookie_name.to_s]).to eq(value: :id.to_s, path: mapped_path)
-          end
-        end
-
-        context 'recorded_routes_cookie_path not set' do
-          it 'sets the path to be the request path' do
-            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(:app) do
-            described_class.new(id: :id,
-                                sitehub_cookie_path: expected_path,
-                                sitehub_cookie_name: :cookie_name,
-                                mapped_path: mapped_path,
-                                mapped_url: mapped_url)
-          end
-
-          it 'is set as the path' do
-            expect(last_response.cookies[:cookie_name.to_s][:path]).to eq(expected_path)
-          end
-        end
-      end
     end
   end
 end

data/spec/sitehub/middleware/config_loader_spec.rb

@@ -0,0 +1,64 @@
+class SiteHub
+  module Middleware
+    describe ConfigLoader do
+      let(:server_url) { 'http://www.server.url' }
+
+      let(:config) do
+        {
+          proxies: [
+            {
+              path: '/route_1',
+              sitehub_cookie_name: 'sitehub.recorded_route',
+
+              splits: {},
+              routes: [
+                {
+                  label: :label_1,
+                  url: 'http://lvl-up.uk/'
+                }
+              ]
+            }
+          ]
+        }
+      end
+
+      before do
+        stub_request(:get, server_url).to_return(body: config.to_json)
+      end
+
+      subject do
+        described_class.new(:app, server_url)
+      end
+
+      describe '#load_config' do
+        it 'loads config' do
+          expect(subject.app).to be_nil
+          subject.load_config
+
+          expected_core = Core.new do
+            sitehub_cookie_name 'sitehub.recorded_route'
+            proxy '/route_1' do
+              route label: :label_1, url: 'http://lvl-up.uk/'
+            end
+          end.build
+
+          expect(subject.app).to eq(expected_core)
+        end
+      end
+
+      describe '#call' do
+        it 'calls the loaded_app' do
+          response = [200, {}, []]
+
+          app = proc do |env|
+            expect(env).to eq(:env)
+            response
+          end
+          expect(Core).to receive(:from_hash).and_return(double(build: app))
+
+          expect(subject.call(:env)).to eq(response)
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/middleware/route_spec.rb

@@ -0,0 +1,53 @@
+# 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
+
+# context 'recorded routes cookie' do
+#   it 'drops a cookie using the name of the sitehub_cookie_name containing the id' do
+#     expect(last_response.cookies[:cookie_name.to_s]).to eq(value: :id.to_s, path: mapped_path)
+#   end
+#
+#   context 'cookie already set' do
+#     let(:rack_headers) { { 'HTTP_COOKIE' => 'cookie_name=existing_value' } }
+#
+#     it 'replaces the value as this is the proxy it should stick with' do
+#       expect(last_response.cookies[:cookie_name.to_s]).to eq(value: :id.to_s, path: mapped_path)
+#     end
+#   end
+#
+#   context 'recorded_routes_cookie_path not set' do
+#     it 'sets the path to be the request path' do
+#       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(:app) do
+#       described_class.new(id: :id,
+#                           sitehub_cookie_path: expected_path,
+#                           sitehub_cookie_name: :cookie_name,
+#                           mapped_path: mapped_path,
+#                           mapped_url: mapped_url)
+#     end
+#
+#     it 'is set as the path' do
+#       expect(last_response.cookies[:cookie_name.to_s][:path]).to eq(expected_path)
+#     end
+#   end
+# end

data/spec/sitehub/middleware/{forward_proxies_spec.rb → routes_spec.rb}

@@ -1,10 +1,11 @@
-require 'sitehub/middleware/forward_proxies'
+require 'sitehub/middleware/routes'
 
 class SiteHub
   module Middleware
-    describe ForwardProxies do
+    describe Routes do
       let(:base_url) { 'http://google.com' }
-      let(:application_root) { '/application_url' }
+      let(:mapped_path) { '/app' }
+      let(:mapped_path) { '/application_url' }
 
       let(:forward_proxy_builder) do
         subject.values.first
@@ -12,20 +13,73 @@ class SiteHub
 
       subject do
         base_url = base_url()
-        described_class.new(:cookie_name).tap do |route_set|
-          route_set.add_proxy(mapped_path: application_root) do |builder|
+        described_class.new.tap do |route_set|
+          route_set.add_route(mapped_path: mapped_path) do |builder|
             builder.split url: base_url, label: :current, percentage: 100
           end
-        end
+        end.init
       end
 
       before do
         subject.init
       end
 
+      describe '#add_proxy' do
+        def route(app, id:)
+          Route.new(app,
+                    id: id,
+                    sitehub_cookie_name: RECORDED_ROUTES_COOKIE,
+                    sitehub_cookie_path: nil)
+        end
+
+        context 'RouteBuilder as parameter' do
+          it 'sets it' do
+            another_mapping = '/mapping'
+            route = RouteBuilder.new(sitehub_cookie_name: :sitehub_cookie_name, mapped_path: another_mapping)
+            subject.add_route route_builder: route
+            expect(subject[another_mapping]).to be(route)
+          end
+        end
+
+        context 'no version explicitly defined' do
+          let(:expected_route) do
+            proxy = ForwardProxy.new(mapped_path: mapped_path, mapped_url: :url)
+            route(proxy, id: :default)
+          end
+
+          it 'adds a default proxy for the given mapping' do
+            subject.add_route(url: :url, mapped_path: mapped_path)
+            route = subject[mapped_path]
+            expect(route.default_proxy).to eq(expected_route)
+          end
+        end
+      end
+
+      describe '#call' do
+        let(:app) do
+          subject
+        end
+
+        context 'mapped_route not found' do
+          it 'returns a 404' do
+            expect(get('/missing').status).to eq(404)
+          end
+        end
+
+        context 'mapped_route found' do
+          it 'uses the forward proxy' do
+            subject
+            expect(forward_proxy_builder.endpoints[:current]).to receive(:call) do
+              [200, {}, []]
+            end
+            expect(get(mapped_path).status).to eq(200)
+          end
+        end
+      end
+
       describe '#init' do
         it 'builds all of the forward_proxies' do
-          expect(subject[application_root]).to receive(:build).and_call_original
+          expect(subject[mapped_path]).to receive(:build).and_call_original
           subject.init
         end
       end
@@ -34,9 +88,10 @@ class SiteHub
         let(:request) { Rack::Request.new({}) }
 
         it 'uses the id in the sitehub_cookie to resolve the correct route' do
+          subject.sitehub_cookie_name :cookie_name
           request.cookies[:cookie_name] = :preset_id
           expect(forward_proxy_builder).to receive(:resolve).with(id: :preset_id, env: request.env).and_call_original
-          subject.mapped_proxy(path: application_root, request: request)
+          subject.mapped_proxy(path: mapped_path, request: request)
         end
 
         context 'regex match on path' do
@@ -45,13 +100,13 @@ class SiteHub
           end
 
           subject do
-            described_class.new(:cookie_name).tap do |route_set|
-              route_set.add_proxy url: "#{base_url}/$1/view", mapped_path: %r{#{application_root}/(.*)/view}
+            described_class.new.tap do |route_set|
+              route_set.add_route url: "#{base_url}/$1/view", mapped_path: %r{#{mapped_path}/(.*)/view}
             end
           end
 
           it 'matches and subsitutes the captured group' do
-            mapped_endpoint = subject.mapped_proxy(path: "#{application_root}/123/view", request: request)
+            mapped_endpoint = subject.mapped_proxy(path: "#{mapped_path}/123/view", request: request)
             expected_endpoint = fuzzy_matcher.resolve(env: {})
             expect(mapped_endpoint).to eq(expected_endpoint)
           end
@@ -59,7 +114,7 @@ class SiteHub
 
         context 'exact match on path' do
           it 'proxies to the requested path' do
-            mapped_endpoint = subject.mapped_proxy(path: application_root, request: request)
+            mapped_endpoint = subject.mapped_proxy(path: mapped_path, request: request)
             expected_endpoint = forward_proxy_builder.resolve(env: {})
             expect(mapped_endpoint).to eq(expected_endpoint)
           end
@@ -71,45 +126,19 @@ class SiteHub
           end
 
           subject do
-            described_class.new(:cookie_name).tap do |route_set|
-              route_set.add_proxy(url: "#{base_url}/sub_url", mapped_path: "#{application_root}/sub_url")
-              route_set.add_proxy(mapped_path: application_root, url: base_url)
+            described_class.new.tap do |route_set|
+              route_set.add_route(url: "#{base_url}/sub_url", mapped_path: "#{mapped_path}/sub_url")
+              route_set.add_route(mapped_path: mapped_path, url: base_url)
             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)
+            mapped_endpoint = subject.mapped_proxy(path: "#{mapped_path}/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/{nil_proxy_spec.rb → nil_route_spec.rb}

@@ -1,6 +1,6 @@
-require 'sitehub/nil_proxy'
+require 'sitehub/nil_route'
 class SiteHub
-  describe NilProxy do
+  describe NilRoute do
     describe '#call' do
       let(:app) do
         described_class.new

data/spec/sitehub/{forward_proxy_builder_spec.rb → route_builder_spec.rb}

@@ -1,12 +1,52 @@
 # rubocop:disable Metrics/ClassLength
-require 'sitehub/forward_proxy_builder'
+require 'sitehub/route_builder'
 
 class SiteHub
-  describe ForwardProxyBuilder do
+  describe RouteBuilder do
     include_context :middleware_test
 
+    describe '::from_hash' do
+      include_context :sitehub_json
+
+      subject do
+        described_class.from_hash(proxy_1, :expected).endpoints[route_1[:label]]
+      end
+
+      context 'splits' do
+        context 'sitehub_cookie_name' do
+          it 'sets it' do
+            expect(subject.sitehub_cookie_name).to eq(:expected)
+          end
+        end
+
+        context 'sitehub_cookie_path' do
+          it 'sets it' do
+            expect(subject.sitehub_cookie_path).to eq(proxy_1[:sitehub_cookie_path])
+          end
+        end
+
+        pending 'returns core with splits'
+      end
+
+      context 'routes' do
+        context 'sitehub_cookie_name' do
+          pending 'sets it'
+        end
+
+        context 'sitehub_cookie_path' do
+          pending 'sets it'
+        end
+        pending 'returns core with routes'
+      end
+
+      context 'default' do
+        it 'sets the default'
+      end
+    end
+
     subject do
-      described_class.new(mapped_path: '/path', sitehub_cookie_name: :cookie_name)
+      described_class.new(sitehub_cookie_name: :cookie_name,
+                          mapped_path: '/path')
     end
 
     it 'supports middleware' do
@@ -17,7 +57,11 @@ class SiteHub
       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 }
+          instance = described_class.new(sitehub_cookie_name: :name,
+                                         mapped_path: '/path') do
+            self_inside_block = self
+            default(url: :url)
+          end
           expect(self_inside_block).to eq(instance)
         end
       end
@@ -94,7 +138,8 @@ class SiteHub
           it 'stores a forward proxy builder' do
             subject.split(percentage: 50, &block)
 
-            expected_builder = described_class.new(mapped_path: subject.mapped_path, &block).build
+            expected_builder = described_class.new(sitehub_cookie_name: :cookie_name,
+                                                   mapped_path: subject.mapped_path, &block).build # sitehub_cookie_name: subject.sitehub_cookie_name
             expected_split = SiteHub::Collection::SplitRouteCollection::Split.new(0, 50, expected_builder)
             expect(subject.endpoints.values).to eq([expected_split])
           end
@@ -105,12 +150,15 @@ class SiteHub
         it 'stores a split for the version' do
           subject.split url: :url, label: :label, percentage: 50
 
-          expected_proxy = ForwardProxy.new(id: :label,
-                                            sitehub_cookie_name: :cookie_name,
-                                            mapped_url: :url,
-                                            mapped_path: subject.mapped_path)
+          proxy = ForwardProxy.new(mapped_url: :url,
+                                   mapped_path: subject.mapped_path)
+
+          expected_route = Route.new(proxy,
+                                     id: :label,
+                                     sitehub_cookie_name: :cookie_name,
+                                     sitehub_cookie_path: nil)
 
-          expected = Collection::SplitRouteCollection.new(expected_proxy => 50)
+          expected = Collection::SplitRouteCollection.new(expected_route => 50)
 
           expect(subject.endpoints).to eq(expected)
         end
@@ -118,7 +166,7 @@ class SiteHub
         context 'url not supplied' do
           it 'raises an error' do
             expect { subject.split(label: :label, percentage: 50) }
-              .to raise_error(ForwardProxyBuilder::InvalidDefinitionException)
+              .to raise_error(RouteBuilder::InvalidDefinitionException)
           end
         end
       end
@@ -128,7 +176,7 @@ class SiteHub
           subject.route url: :url, label: :label
 
           expect { subject.split(url: :url, label: :label, percentage: 50) }
-            .to raise_error(ForwardProxyBuilder::InvalidDefinitionException)
+            .to raise_error(RouteBuilder::InvalidDefinitionException)
         end
       end
     end
@@ -136,11 +184,16 @@ class SiteHub
     describe '#route' do
       it 'accepts a rule' do
         subject.route url: :url, label: :current, rule: :rule
-        expected_route = ForwardProxy.new(sitehub_cookie_name: :cookie_name,
-                                          id: :current,
-                                          rule: :rule,
-                                          mapped_url: :url,
-                                          mapped_path: subject.mapped_path)
+
+        proxy = ForwardProxy.new(mapped_url: :url,
+                                 mapped_path: subject.mapped_path)
+
+        expected_route = Route.new(proxy,
+                                   id: :current,
+                                   sitehub_cookie_name: :cookie_name,
+                                   sitehub_cookie_path: nil).tap do |route|
+          route.rule(:rule)
+        end
         expect(subject.endpoints).to eq(current: expected_route)
       end
 
@@ -179,7 +232,11 @@ class SiteHub
           rule = proc { true }
           subject.route(rule: rule, &block)
 
-          expected_builder = described_class.new(rule: rule, mapped_path: subject.mapped_path, &block).build
+          expected_builder = described_class.new(sitehub_cookie_name: :cookie_name,
+                                                 rule: rule, mapped_path: subject.mapped_path, &block).tap do |builder|
+            builder.sitehub_cookie_name subject.sitehub_cookie_name
+          end.build
+
           expect(subject.endpoints.values).to eq([expected_builder])
         end
 
@@ -201,67 +258,37 @@ class SiteHub
 
       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.route url: :url, label: :current
+          expect(subject.endpoints[:current]).to be_using_rack_stack(ForwardProxy)
           subject.build
+          expect(subject.endpoints[:current]).to be_using_rack_stack(ForwardProxy)
         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.route url: :url, label: :current
           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
+          expect(subject.endpoints[:current]).to be_using_rack_stack(middleware, ForwardProxy)
         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)
+          expect(subject.default_proxy).to be_using_rack_stack(middleware, ForwardProxy)
         end
       end
     end
 
     describe '#resolve' do
-      subject { described_class.new(mapped_path: '/') }
+      subject do
+        described_class.new(sitehub_cookie_name: :cookie_name,
+                            mapped_path: '/')
+      end
 
       context 'routes defined' do
         it 'returns that route' do
@@ -337,7 +364,8 @@ class SiteHub
 
     describe '#forward_proxy' do
       subject do
-        described_class.new(mapped_path: '/path', sitehub_cookie_name: :expected_cookie_name)
+        described_class.new(sitehub_cookie_name: :cookie_name,
+                            mapped_path: '/path')
       end
 
       it 'sets the sitehub_cookie_path' do
@@ -347,6 +375,7 @@ class SiteHub
       end
 
       it 'sets the sitehub_cookie_name' do
+        subject.sitehub_cookie_name :expected_cookie_name
         proxy = subject.forward_proxy(label: :label, url: :url)
         expect(proxy.sitehub_cookie_name).to eq(:expected_cookie_name)
       end