sitehub 0.5.0.alpha3 → 0.5.0.alpha4

data/spec/sitehub/integration_spec.rb

@@ -1,20 +1,198 @@
 require 'async/middleware'
-describe 'proxying calls' do
-  include_context :site_hub
+require 'stringio'
+shared_context :site_hub do
+  let(:downstream_url) { 'http://localhost:12345' }
+  let(:experiment1_url) { "#{downstream_url}/experiment1" }
+  let(:experiment2_url) { "#{downstream_url}/experiment2" }
 
-  describe 'supported HTTP verbs' do
-    before do
-      WebMock.enable!
+  before do
+    WebMock.enable!
+    stub_request(:get, experiment1_url).to_return(body: 'hello')
+    stub_request(:get, experiment2_url).to_return(body: 'experiment1_body')
+  end
+
+  let(:builder) do
+    SiteHub::Builder.new.tap do |builder|
+      builder.access_logger StringIO.new
+      builder.error_logger StringIO.new
+      experiment1_url = experiment1_url()
+      experiment2_url = experiment2_url()
+
+      builder.proxy '/endpoint' do
+        split(label: :experiment1, percentage: 100) do
+          split percentage: 100, label: 'variant1', url: experiment1_url
+        end
+
+        split(label: :experiment2, percentage: 0) do
+          split percentage: 100, label: 'variant1', url: experiment2_url
+        end
+      end
     end
+  end
+
+  let(:rack_application) do
+    builder.build
+  end
+end
 
-    let(:app) { Async::Middleware.new(rack_application) }
+describe 'proxying calls' do
+  include_context :site_hub
 
+  let(:app) { Async::Middleware.new(rack_application) }
+  describe 'supported HTTP verbs' do
     %i(get post put delete).each do |verb|
       it 'forwards the downstream' do
-        stub_request(verb, downstream_url).to_return(body: 'hello')
+        stub_request(verb, experiment1_url).to_return(body: 'hello')
         send(verb, '/endpoint')
         expect(app.last_response.body).to eq(['hello'])
       end
     end
   end
+
+  describe 'route affinity' do
+    context 'requested route cookie not present' do
+      it 'drops a cookie to keep you on the same path' do
+        stub_request(:get, downstream_url).to_return(body: 'hello')
+        get('/endpoint')
+        expect(app.last_response.cookies[SiteHub::RECORDED_ROUTES_COOKIE][:value]).to eq('experiment1|variant1')
+      end
+    end
+
+    context 'requested route cookie present' do
+      it 'proxies to the preselected route' do
+        get('/endpoint', {}, 'HTTP_COOKIE' => "#{SiteHub::RECORDED_ROUTES_COOKIE}=experiment2|variant1")
+        expect(app.last_response.body).to eq(['experiment1_body'])
+
+        expect(app.last_response.cookies[SiteHub::RECORDED_ROUTES_COOKIE][:value]).to eq('experiment2|variant1')
+      end
+    end
+  end
+
+  # describe 'middleware' do
+  #
+  #   include_context :middleware_test
+  #
+  #   let(:app) { Async::Middleware.new(rack_application) }
+  #
+  #   def middleware name
+  #     create_middleware.tap do |clazz|
+  #       clazz.class_eval do
+  #         define_method :call do |env|
+  #           callback = env['async.callback'] || env['async.orig_callback']
+  #           env['async.orig_callback'] = env['async.callback'] = proc do |status, headers, body|
+  #             if body.is_a?(Rack::BodyProxy)
+  #               body = "#{name}, #{body.body.join}"
+  #             end
+  #
+  #             callback.call(status, headers, body)
+  #           end
+  #           @app.call(env)
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   before do
+  #     stub_request(:get, downstream_url).to_return(body: 'hello')
+  #   end
+  #
+  #   context 'middleware added to top level' do
+  #     let(:builder) do
+  #       middleware = middleware(:middleware1)
+  #       downstream_url = downstream_url()
+  #
+  #       SiteHub::Builder.new do
+  #         access_logger StringIO.new
+  #         use middleware
+  #         proxy '/1' => downstream_url
+  #         proxy '/2' => downstream_url
+  #       end
+  #     end
+  #
+  #     it 'adds it to each route' do
+  #       get('/1')
+  #       expect(app.last_response.body.join).to eq('middleware1, hello')
+  #       get('/2')
+  #       expect(app.last_response.body.join).to eq('middleware1, hello')
+  #     end
+  #   end
+  #
+  #   context 'middleware added to specific route' do
+  #     let(:builder) do
+  #       middleware = middleware(:middleware1)
+  #       downstream_url = downstream_url()
+  #
+  #       SiteHub::Builder.new do
+  #         access_logger StringIO.new
+  #         proxy '/1' do
+  #           use middleware
+  #           route label: :with_middleware, url: downstream_url
+  #         end
+  #         proxy '/2' => downstream_url
+  #       end
+  #     end
+  #
+  #     it 'adds it to that route only' do
+  #       get('/1')
+  #       expect(app.last_response.body.join).to eq('middleware1, hello')
+  #       get('/2')
+  #       expect(app.last_response.body.join).to eq('hello')
+  #     end
+  #   end
+  #
+  #   context 'base inherited middleware' do
+  #     let(:builder) do
+  #       middleware1 = middleware(:middleware1)
+  #       middleware2 = middleware(:middleware2)
+  #       downstream_url = downstream_url()
+  #
+  #       SiteHub::Builder.new do
+  #         access_logger StringIO.new
+  #         use middleware1
+  #         proxy '/1' do
+  #           use middleware2
+  #           route label: :with_middleware, url: downstream_url
+  #         end
+  #         # proxy '/2' => downstream_url
+  #       end
+  #     end
+  #
+  #     it 'adds it to that route only' do
+  #       get('/1')
+  #       expect(app.last_response.body.join).to eq('middleware1, middleware2,  hello')
+  #       get('/2')
+  #       expect(app.last_response.body.join).to eq('middleware1, hello')
+  #     end
+  #   end
+  #
+  #   context 'nested inherited middleware' do
+  #     let(:builder) do
+  #       middleware1 = middleware(:middleware1)
+  #       middleware2 = middleware(:middleware2)
+  #       downstream_url = downstream_url()
+  #
+  #       SiteHub::Builder.new do
+  #         access_logger StringIO.new
+  #
+  #         proxy '/1' do
+  #           split percentage: 100, label: :experiment1 do
+  #             use middleware1
+  #             split percentage: 100, label: :with_middleware  do
+  #               use middleware2
+  #               split percentage: 100, label: :with_nested_middleware, url: downstream_url
+  #             end
+  #           end
+  #         end
+  #         proxy '/2' => downstream_url
+  #       end
+  #     end
+  #
+  #     it 'adds it to that route only' do
+  #       get('/1')
+  #       expect(app.last_response.body.join).to eq('middleware1, middleware2,  hello')
+  #       get('/2')
+  #       expect(app.last_response.body.join).to eq('middleware1, hello')
+  #     end
+  #   end
+  # end
 end

data/spec/sitehub/middleware/routes_spec.rb

@@ -41,7 +41,7 @@ class SiteHub
           end
         end
 
-        context 'no version explicitly defined' do
+        context 'url specified' do
           let(:expected_route) do
             proxy = ForwardProxy.new(mapped_path: mapped_path, mapped_url: :url)
             route(proxy, id: :default)
@@ -50,7 +50,7 @@ class SiteHub
           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)
+            expect(route.default_route).to eq(expected_route)
           end
         end
       end
@@ -69,7 +69,7 @@ class SiteHub
         context 'mapped_route found' do
           it 'uses the forward proxy' do
             subject
-            expect(forward_proxy_builder.endpoints[:current]).to receive(:call) do
+            expect(forward_proxy_builder.routes[:current]).to receive(:call) do
               [200, {}, []]
             end
             expect(get(mapped_path).status).to eq(200)
@@ -87,11 +87,17 @@ class SiteHub
       describe '#mapped_route' do
         let(:request) { Rack::Request.new({}) }
 
-        it 'uses the id in the sitehub_cookie to resolve the correct route' do
+        before do
           subject.sitehub_cookie_name :cookie_name
+          subject.add_route mapped_path: mapped_path do
+            route label: :preset_id, url: :url
+          end
+        end
+
+        it 'uses the id in the sitehub_cookie to resolve the correct route' do
           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: mapped_path, request: request)
+          subject.mapped_route(path: mapped_path, request: request)
         end
 
         context 'regex match on path' do
@@ -106,7 +112,7 @@ class SiteHub
           end
 
           it 'matches and subsitutes the captured group' do
-            mapped_endpoint = subject.mapped_proxy(path: "#{mapped_path}/123/view", request: request)
+            mapped_endpoint = subject.mapped_route(path: "#{mapped_path}/123/view", request: request)
             expected_endpoint = fuzzy_matcher.resolve(env: {})
             expect(mapped_endpoint).to eq(expected_endpoint)
           end
@@ -114,7 +120,7 @@ class SiteHub
 
         context 'exact match on path' do
           it 'proxies to the requested path' do
-            mapped_endpoint = subject.mapped_proxy(path: mapped_path, request: request)
+            mapped_endpoint = subject.mapped_route(path: mapped_path, request: request)
             expected_endpoint = forward_proxy_builder.resolve(env: {})
             expect(mapped_endpoint).to eq(expected_endpoint)
           end
@@ -134,7 +140,7 @@ class SiteHub
 
           it 'matches the first endpoint' do
             expected_endpoint = more_specific_proxy_builder.resolve(env: {})
-            mapped_endpoint = subject.mapped_proxy(path: "#{mapped_path}/sub_url", request: request)
+            mapped_endpoint = subject.mapped_route(path: "#{mapped_path}/sub_url", request: request)
             expect(mapped_endpoint).to eq(expected_endpoint)
           end
         end

data/spec/sitehub/route_builder_spec.rb

@@ -9,7 +9,7 @@ class SiteHub
       include_context :sitehub_json
 
       subject do
-        described_class.from_hash(proxy_1, :expected).endpoints[route_1[:label]]
+        described_class.from_hash(proxy_1, :expected).routes[route_1[:label]]
       end
 
       context 'splits' do
@@ -49,22 +49,57 @@ class SiteHub
                           mapped_path: '/path')
     end
 
+    describe '#routes' do
+      it 'returns RouteCollection by default' do
+        expect(subject.routes).to be_a(Collection::RouteCollection)
+      end
+
+      it 'returns the same intance everytime' do
+        collection = Collection::SplitRouteCollection.new
+        subject.routes(collection)
+        expect(subject.routes).to be(collection)
+      end
+
+      context 'endpoints already set' do
+        context 'different object supplied' do
+          it 'raises an error' do
+            subject.routes(Collection::SplitRouteCollection.new)
+            expect { subject.routes(Collection::RouteCollection.new) }
+              .to raise_error(RouteBuilder::InvalidDefinitionException)
+          end
+        end
+      end
+    end
+
     it 'supports middleware' do
       expect(described_class).to include(Middleware)
     end
 
     describe '#initialize' do
+      let(:named_parameters) do
+        { sitehub_cookie_name: :name,
+          mapped_path: '/path' }
+      end
+
       context 'with a block' do
         it 'evaluates the block in the context of the instance' do
           self_inside_block = nil
-          instance = described_class.new(sitehub_cookie_name: :name,
-                                         mapped_path: '/path') do
+          instance = described_class.new(named_parameters) do
             self_inside_block = self
             default(url: :url)
           end
           expect(self_inside_block).to eq(instance)
         end
       end
+
+      context 'id' do
+        context 'id supplied' do
+          it 'sets the id using it' do
+            subject = described_class.new(named_parameters.merge(id: :custom_id))
+            expect(subject.id).to eq(:custom_id)
+          end
+        end
+      end
     end
 
     describe 'valid?' do
@@ -104,86 +139,22 @@ class SiteHub
     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
+      it 'setups up a splits collection' do
+        subject.split percentage: 10, url: :url, label: :label
+        expect(subject.routes).to be_a(Collection::SplitRouteCollection)
       end
+    end
 
-      context 'split supplied' do
-        let(:block) do
-          proc do
-            default url: :url
-          end
-        end
-
-        context 'url' do
-          it 'gives a warning to say that the url will not be used' do
-            expect(subject).to receive(:warn).with(described_class::IGNORING_URL_LABEL_MSG)
-            subject.split(percentage: 50, url: :url, &block)
-          end
-        end
-
-        context 'label' do
-          it 'gives a warning to say that the url will not be used' do
-            expect(subject).to receive(:warn).with(described_class::IGNORING_URL_LABEL_MSG)
-            subject.split(percentage: 50, label: :label, &block)
-          end
-        end
-
-        context 'block supplied' do
-          it 'stores a forward proxy builder' do
-            subject.split(percentage: 50, &block)
-
-            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
-        end
-      end
-
-      context 'block not supplied' do
-        it 'stores a split for the version' do
-          subject.split url: :url, label: :label, percentage: 50
-
-          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_route => 50)
-
-          expect(subject.endpoints).to eq(expected)
-        end
-
-        context 'url not supplied' do
-          it 'raises an error' do
-            expect { subject.split(label: :label, percentage: 50) }
-              .to raise_error(RouteBuilder::InvalidDefinitionException)
-          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(RouteBuilder::InvalidDefinitionException)
-        end
+    describe '#route' do
+      it 'sets up the routes collection' do
+        subject.route url: :url, label: :current
+        expect(subject.routes).to be_a(Collection::RouteCollection)
       end
     end
 
-    describe '#route' do
-      it 'accepts a rule' do
-        subject.route url: :url, label: :current, rule: :rule
+    describe '#add_endpoint' do
+      it 'stores the route against the given label' do
+        subject.add_route url: :url, label: :current
 
         proxy = ForwardProxy.new(mapped_url: :url,
                                  mapped_path: subject.mapped_path)
@@ -191,60 +162,80 @@ class SiteHub
         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)
+                                   sitehub_cookie_path: nil)
+
+        expect(subject.routes[:current]).to eq(expected_route)
+      end
+
+      it 'accepts a rule' do
+        endpoint = subject.add_route url: :url, label: :current, rule: :rule
+        expect(endpoint.rule).to eq(:rule)
+      end
+
+      it 'accepts a percentage' do
+        subject.routes(Collection::SplitRouteCollection.new)
+        endpoint = subject.add_route url: :url, label: :current, percentage: 50
+        expect(endpoint.upper).to eq(50)
       end
 
       context 'block supplied' do
         let(:block) do
           proc do
-            route url: :url, label: :label1
+            route url: :url, label: :label2, rule: :rule do
+              route url: :url, label: :label3
+            end
           end
         end
 
+        it 'stores the nested route_builder against the label' do
+          rule = proc { true }
+          subject.add_route(rule: rule, label: :label1, &block)
+          subject.use middleware
+
+          expected_endpoints = RouteBuilder.new(rule: rule,
+                                                id: :label1,
+                                                sitehub_cookie_name: :cookie_name,
+                                                mapped_path: '/path',
+                                                &block).build
+
+          expect(subject.routes[:label1]).to eq(expected_endpoints)
+          subject.build
+        end
+
         describe '#errors and warnings' do
-          context 'rule not supplied' do
+          context 'precentage and rule not supplied' do
             it 'raise an error' do
-              expected_message = described_class::INVALID_ROUTE_DEF_MSG
-              expect { subject.route {} }
+              expected_message = described_class::RULE_NOT_SPECIFIED_MSG
+              expect { subject.add_route(label: :label) {} }
                 .to raise_exception described_class::InvalidDefinitionException, expected_message
             end
           end
 
           context 'url' do
             it 'gives a warning to say that the url will not be used' do
-              expect(subject).to receive(:warn).with(described_class::IGNORING_URL_LABEL_MSG)
-              subject.route(rule: :rule, url: :url, &block)
-            end
-          end
-
-          context 'label' do
-            it 'gives a warning to say that the url will not be used' do
-              expect(subject).to receive(:warn).with(described_class::IGNORING_URL_LABEL_MSG)
-              subject.route(rule: :rule, label: :label, &block)
+              expect(subject).to receive(:warn).with(described_class::IGNORING_URL_MSG)
+              subject.add_route(rule: :rule, url: :url, label: :label, &block)
             end
           end
         end
 
         it 'stores a proxy builder' do
           rule = proc { true }
-          subject.route(rule: rule, &block)
+          subject.add_route(rule: rule, label: :label, &block)
 
-          expected_builder = described_class.new(sitehub_cookie_name: :cookie_name,
-                                                 rule: rule, mapped_path: subject.mapped_path, &block).tap do |builder|
+          expected_endpoints = described_class.new(id: :label, 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])
+          expect(subject.routes.values).to eq([expected_endpoints])
         end
 
         context 'invalid definitions inside block' do
           it 'raises an error' do
             rule = proc { true }
             expect do
-              subject.route rule: rule do
+              subject.add_route rule: rule, label: :label do
                 split percentage: 20, url: :url, label: :label1
               end
             end.to raise_exception described_class::InvalidDefinitionException
@@ -259,9 +250,9 @@ class SiteHub
       context 'middleware not specified' do
         it 'leaves it the proxies alone' do
           subject.route url: :url, label: :current
-          expect(subject.endpoints[:current]).to be_using_rack_stack(ForwardProxy)
+          expect(subject.routes[:current]).to be_using_rack_stack(ForwardProxy)
           subject.build
-          expect(subject.endpoints[:current]).to be_using_rack_stack(ForwardProxy)
+          expect(subject.routes[:current]).to be_using_rack_stack(ForwardProxy)
         end
       end
 
@@ -273,79 +264,77 @@ class SiteHub
         it 'wraps the forward proxies in the middleware' do
           subject.route url: :url, label: :current
           subject.build
-          expect(subject.endpoints[:current]).to be_using_rack_stack(middleware, ForwardProxy)
+          expect(subject.routes[:current]).to be_using_rack_stack(middleware, ForwardProxy)
         end
 
         it 'wraps the default in the middleware' do
           subject.default url: :url
           subject.build
-          expect(subject.default_proxy).to be_using_rack_stack(middleware, ForwardProxy)
+          expect(subject.default_route).to be_using_rack_stack(middleware, ForwardProxy)
+        end
+
+        context 'nested routes' do
+          pending 'what should it do?'
         end
       end
     end
 
     describe '#resolve' do
-      subject do
-        described_class.new(sitehub_cookie_name: :cookie_name,
-                            mapped_path: '/')
-      end
-
-      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.endpoints.class).to receive(:resolve).with(id: :'', env: :env).and_call_original
-          subject.resolve(env: :env)
-        end
-
-        it 'passes the requested route id when resolving the correct route' do
-          expect_any_instance_of(subject.endpoints.class).to receive(:resolve).with(id: :required_route_id, env: :env).and_call_original
-          subject.resolve(id: :required_route_id, env: :env)
-        end
-      end
+      context 'id not supplied' do
+        context 'routes defined' do
+          it 'returns that route' do
+            subject.route url: :url, label: :current
+            expect(subject.resolve(env: {})).to eq(subject.routes.values.first)
+          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)
+          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 not defined' do
           it 'returns the default' do
             subject.default url: :url
-            expect(subject.resolve(env: {})).to eq(subject.default_proxy)
+            expect(subject.resolve(env: {})).to eq(subject.default_route)
           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
+      context 'id supplied' do
+        context 'nested routes' do
+          let!(:expected) do
+            result = nil
+            subject.split percentage: 0, label: :experiment1 do
+              result = split percentage: 100, url: :url1, label: :new
+            end
+            subject.split percentage: 100, label: :experiment2, url: :url
+            result.value
           end
 
-          let(:application_version1) do
-            subject.endpoints.values.find do |pick|
-              pick.value.id == :new
-            end.value
+          it 'returns that route' do
+            expect(subject.resolve(id: expected.id, env: {})).to eq(expected)
           end
+        end
 
-          context 'string supplied' do
-            it 'redirects to that version' do
-              expect(subject.resolve(id: :new.to_s, env: {})).to eq(application_version1)
-            end
+        context 'id does not exist' do
+          let!(:expected) do
+            subject.default url: :url
+            subject.default_route
           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
+          it 'returns the default route' do
+            expect(subject.resolve(id: :missing, env: {})).to eq(expected)
+          end
+        end
+
+        context 'non nested route' do
+          let!(:expected) do
+            subject.split(percentage: 100, label: :experiment1, url: :url).value
+          end
+
+          it 'returns that route' do
+            expect(subject.resolve(id: expected.id, env: {})).to eq(expected)
           end
         end
       end
@@ -354,15 +343,15 @@ class SiteHub
     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)
+          subject.routes(:collection)
+          expect(subject.routes).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
+          subject.routes(:collection1)
+          expect { subject.routes(:collection2) }.to raise_exception described_class::InvalidDefinitionException
         end
       end
     end