sitehub 0.5.0.alpha5 → 0.5.0.alpha6

data/spec/integration/middleware_spec.rb

@@ -0,0 +1,129 @@
+describe 'middleware' do
+  include_context :middleware_test
+
+  let(:downstream_url) { 'http://localhost:12345' }
+  let(:experiment1_url) { "#{downstream_url}/experiment1" }
+  let(:experiment2_url) { "#{downstream_url}/experiment2" }
+
+  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|
+            body = body.body.join if body.is_a?(Rack::BodyProxy)
+
+            callback.call(status, headers, "#{name}, #{body}")
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+
+  let(:app) { Async::Middleware.new(builder) }
+
+  before do
+    WebMock.enable!
+    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.build 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.build 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.build 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.build 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('hello')
+    end
+  end
+end

data/spec/integration/version_affinity_spec.rb

@@ -0,0 +1,55 @@
+require 'stringio'
+
+describe 'route affinity' do
+  let(:downstream_url) { 'http://localhost:12345' }
+  let(:experiment1_url) { "#{downstream_url}/experiment1" }
+  let(:experiment2_url) { "#{downstream_url}/experiment2" }
+
+  let(:experiment_body_1) { 'experiment1_body' }
+  let(:experiment_body_2) { 'experiment2_body' }
+
+  before do
+    WebMock.enable!
+  end
+
+  let(:app) do
+    experiment1_url = experiment1_url()
+    experiment2_url = experiment2_url()
+
+    sitehub = SiteHub.build do
+      access_logger StringIO.new
+      error_logger StringIO.new
+
+      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: 0, label: 'variant1', url: experiment2_url
+          split percentage: 100, label: 'variant2', url: :should_not_be_called
+        end
+      end
+    end
+    Async::Middleware.new(sitehub)
+  end
+
+  context 'requested route cookie not present' do
+    it 'drops a cookie to keep you on the same path' do
+      stub_request(:get, experiment1_url).to_return(body: experiment_body_1)
+      get('/endpoint')
+      expect(app.last_response.body).to eq([experiment_body_1])
+      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
+      stub_request(:get, experiment2_url).to_return(body: experiment_body_2)
+
+      get('/endpoint', {}, 'HTTP_COOKIE' => "#{SiteHub::RECORDED_ROUTES_COOKIE}=experiment2|variant1")
+      expect(app.last_response.body).to eq([experiment_body_2])
+      expect(app.last_response.cookies[SiteHub::RECORDED_ROUTES_COOKIE][:value]).to eq('experiment2|variant1')
+    end
+  end
+end

data/spec/sitehub/builder_spec.rb

@@ -123,11 +123,11 @@ class SiteHub
           end
 
           it 'adds a forward proxies' do
-            expect(subject.build).to be_using(Middleware::Routes)
+            expect(subject.build).to be_using(Middleware::CandidateRouteMappings)
           end
 
           it 'configures it with the sitehub_cookie_name' do
-            forward_proxies = find_middleware(subject.build, Middleware::Routes)
+            forward_proxies = find_middleware(subject.build, Middleware::CandidateRouteMappings)
             expect(forward_proxies.sitehub_cookie_name).to eq(:custom_cookie_name)
           end
         end
@@ -173,7 +173,7 @@ class SiteHub
                                  Middleware::ErrorHandling,
                                  Middleware::TransactionId,
                                  Middleware::ReverseProxy,
-                                 Middleware::Routes]
+                                 Middleware::CandidateRouteMappings]
 
           expect(middleware_stack).to eq(expected_middleware)
         end

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

@@ -1,18 +1,17 @@
 # rubocop:disable Metrics/ClassLength
-require 'sitehub/route_builder'
+require 'sitehub/candidate_routes'
 
 class SiteHub
-  describe RouteBuilder do
+  describe CandidateRoutes do
     include_context :middleware_test
 
     describe '::from_hash' do
       include_context :sitehub_json
 
-      subject do
-        described_class.from_hash(proxy_1, :expected).routes[Identifier.new(route_1[:label])]
-      end
-
       context 'splits' do
+        subject do
+          described_class.from_hash(split_proxy, :expected)
+        end
         context 'sitehub_cookie_name' do
           it 'sets it' do
             expect(subject.sitehub_cookie_name).to eq(:expected)
@@ -21,26 +20,110 @@ class SiteHub
 
         context 'sitehub_cookie_path' do
           it 'sets it' do
-            expect(subject.sitehub_cookie_path).to eq(proxy_1[:sitehub_cookie_path])
+            expect(subject.sitehub_cookie_path).to eq(split_proxy[:sitehub_cookie_path])
           end
         end
 
-        pending 'returns core with splits'
+        it 'returns core with splits' do
+          split_1 = split_1()
+          split_2 = split_2()
+          expected = described_class.new(sitehub_cookie_name: :expected,
+                                         sitehub_cookie_path: subject.sitehub_cookie_path,
+                                         mapped_path: subject.mapped_path) do
+            split percentage: split_1[:percentage], label: split_1[:label], url: split_1[:url]
+            split percentage: split_2[:percentage], label: split_2[:label], url: split_2[:url]
+          end
+          expect(subject.candidates).to eq(expected.candidates)
+        end
+
+        context 'default' do
+          it 'sets it' do
+            expect(subject.default_route.app.mapped_url).to eq(split_proxy[:default])
+          end
+        end
       end
 
       context 'routes' do
+        subject do
+          described_class.from_hash(routes_proxy, :expected)
+        end
+
         context 'sitehub_cookie_name' do
-          pending 'sets it'
+          it 'sets it' do
+            expect(subject.sitehub_cookie_name).to eq(:expected)
+          end
         end
 
         context 'sitehub_cookie_path' do
-          pending 'sets it'
+          it 'sets it' do
+            expect(subject.sitehub_cookie_path).to eq(routes_proxy[:sitehub_cookie_path])
+          end
+        end
+
+        it 'returns core with routes' do
+          route_1 = route_1()
+          expected = described_class.new(sitehub_cookie_name: :expected,
+                                         sitehub_cookie_path: subject.sitehub_cookie_path,
+                                         mapped_path: subject.mapped_path) do
+            route label: route_1[:label], url: route_1[:url]
+          end
+          expect(subject.candidates).to eq(expected.candidates)
+        end
+
+        context 'default' do
+          it 'sets it' do
+            expect(subject.default_route.app.mapped_url).to eq(routes_proxy[:default])
+          end
+        end
+      end
+
+      context 'nested routes' do
+        context 'routes inside a split' do
+          subject do
+            described_class.from_hash(nested_route_proxy, :expected)
+          end
+
+          it 'creates them' do
+            route_1 = route_1()
+            nested_route = nested_route()
+
+            expected = described_class.new(sitehub_cookie_name: :expected,
+                                           sitehub_cookie_path: subject.sitehub_cookie_path,
+                                           mapped_path: subject.mapped_path) do
+              split(percentage: nested_route[:percentage], label: nested_route[:label]) do
+                route label: route_1[:label], url: route_1[:url]
+              end
+            end
+            expect(subject).to eq(expected)
+          end
+        end
+
+        context 'splits in a split' do
+          subject do
+            described_class.from_hash(nested_split_proxy, :expected)
+          end
+
+          it 'creates them' do
+            split_1 = split_1()
+            split_2 = split_2()
+            nested_split = nested_split()
+
+            expected = described_class.new(sitehub_cookie_name: :expected,
+                                           sitehub_cookie_path: subject.sitehub_cookie_path,
+                                           mapped_path: subject.mapped_path) do
+              split(percentage: nested_split[:percentage], label: nested_split[:label]) do
+                split percentage: split_1[:percentage], label: split_1[:label], url: split_1[:url]
+                split percentage: split_2[:percentage], label: split_2[:label], url: split_2[:url]
+              end
+            end
+            expect(subject).to eq(expected)
+          end
         end
-        pending 'returns core with routes'
       end
 
       context 'default' do
-        it 'sets the default'
+        it 'sets the default' do
+        end
       end
     end
 
@@ -51,26 +134,35 @@ class SiteHub
 
     describe '#routes' do
       it 'returns RouteCollection by default' do
-        expect(subject.routes).to be_a(Collection::RouteCollection)
+        expect(subject.candidates).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)
+        subject.candidates(collection)
+        expect(subject.candidates).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)
+            subject.candidates(Collection::SplitRouteCollection.new)
+            expect { subject.candidates(Collection::RouteCollection.new) }
+              .to raise_error(CandidateRoutes::InvalidDefinitionException)
           end
         end
       end
     end
 
+    describe '#[]' do
+      context 'id of existing route passed in' do
+        it 'returns it' do
+          subject.split(label: :current, percentage: 100, url: :url)
+          expect(subject[:current]).to eq(subject[:current])
+        end
+      end
+    end
+
     it 'supports middleware' do
       expect(described_class).to include(Middleware)
     end
@@ -141,20 +233,20 @@ class SiteHub
     describe '#split' do
       it 'setups up a splits collection' do
         subject.split percentage: 10, url: :url, label: :label
-        expect(subject.routes).to be_a(Collection::SplitRouteCollection)
+        expect(subject.candidates).to be_a(Collection::SplitRouteCollection)
       end
     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)
+        expect(subject.candidates).to be_a(Collection::RouteCollection)
       end
     end
 
-    describe '#add_endpoint' do
+    describe '#add' do
       it 'stores the route against the given label' do
-        subject.add_route url: :url, label: :current
+        subject.add url: :url, label: :current
 
         proxy = ForwardProxy.new(mapped_url: :url,
                                  mapped_path: subject.mapped_path)
@@ -164,17 +256,17 @@ class SiteHub
                                    sitehub_cookie_name: :cookie_name,
                                    sitehub_cookie_path: nil)
 
-        expect(subject.routes[Identifier.new(:current)]).to eq(expected_route)
+        expect(subject[:current]).to eq(expected_route)
       end
 
       it 'accepts a rule' do
-        endpoint = subject.add_route url: :url, label: :current, rule: :rule
+        endpoint = subject.add 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
+        subject.candidates(Collection::SplitRouteCollection.new)
+        endpoint = subject.add url: :url, label: :current, percentage: 50
         expect(endpoint.upper).to eq(50)
       end
 
@@ -189,53 +281,65 @@ class SiteHub
 
         it 'stores the nested route_builder against the label' do
           rule = proc { true }
-          subject.add_route(rule: rule, label: :label1, &block)
+          subject.add(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
+          expected_endpoints = CandidateRoutes.new(rule: rule,
+                                                   id: :label1,
+                                                   sitehub_cookie_name: :cookie_name,
+                                                   mapped_path: '/path',
+                                                   &block).build
 
-          expect(subject.routes[Identifier.new(:label1)]).to eq(expected_endpoints)
+          expect(subject[:label1]).to eq(expected_endpoints)
           subject.build
         end
 
         describe '#errors and warnings' do
           context 'precentage and rule not supplied' do
-            it 'raise an error' do
-              expected_message = described_class::RULE_NOT_SPECIFIED_MSG
-              expect { subject.add_route(label: :label) {} }
-                .to raise_exception described_class::InvalidDefinitionException, expected_message
+            context 'split required' do
+              it 'raise an error' do
+                subject.candidates(Collection::SplitRouteCollection.new)
+                expected_message = described_class::PERCENTAGE_NOT_SPECIFIED_MSG
+                expect { subject.add(label: :label) {} }
+                  .to raise_exception described_class::InvalidDefinitionException, expected_message
+              end
+            end
+
+            context 'route required' do
+              it 'raise an error' do
+                subject.candidates(Collection::RouteCollection.new)
+                expected_message = described_class::RULE_NOT_SPECIFIED_MSG
+                expect { subject.add(label: :label) {} }
+                  .to raise_exception described_class::InvalidDefinitionException, expected_message
+              end
             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_MSG)
-              subject.add_route(rule: :rule, url: :url, label: :label, &block)
+              subject.add(rule: :rule, url: :url, label: :label, &block)
             end
           end
         end
 
         it 'stores a proxy builder' do
           rule = proc { true }
-          subject.add_route(rule: rule, label: :label, &block)
+          subject.add(rule: rule, label: :label, &block)
 
           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.routes.values).to eq([expected_endpoints])
+          expect(subject.candidates.values).to eq([expected_endpoints])
         end
 
         context 'invalid definitions inside block' do
           it 'raises an error' do
             rule = proc { true }
             expect do
-              subject.add_route rule: rule, label: :label do
+              subject.add rule: rule, label: :label do
                 split percentage: 20, url: :url, label: :label1
               end
             end.to raise_exception described_class::InvalidDefinitionException
@@ -250,9 +354,9 @@ class SiteHub
       context 'middleware not specified' do
         it 'leaves it the proxies alone' do
           subject.route url: :url, label: :current
-          expect(subject.routes[Identifier.new(:current)]).to be_using_rack_stack(ForwardProxy)
+          expect(subject[:current]).to be_using_rack_stack(ForwardProxy)
           subject.build
-          expect(subject.routes[Identifier.new(:current)]).to be_using_rack_stack(ForwardProxy)
+          expect(subject[:current]).to be_using_rack_stack(ForwardProxy)
         end
       end
 
@@ -264,7 +368,7 @@ class SiteHub
         it 'wraps the forward proxies in the middleware' do
           subject.route url: :url, label: :current
           subject.build
-          expect(subject.routes[Identifier.new(:current)]).to be_using_rack_stack(middleware, ForwardProxy)
+          expect(subject[:current]).to be_using_rack_stack(middleware, ForwardProxy)
         end
 
         it 'wraps the default in the middleware' do
@@ -272,9 +376,18 @@ class SiteHub
           subject.build
           expect(subject.default_route).to be_using_rack_stack(middleware, ForwardProxy)
         end
+      end
 
-        context 'nested routes' do
-          pending 'what should it do?'
+      context 'middleware present on the parent route' do
+        it 'adds it to the list middleware to be added' do
+          middleware = middleware()
+          subject.split(percentage: 100, label: :parent) do
+            use middleware
+            split(percentage: 100, label: :child) do
+              default url: :url
+            end
+          end
+          expect(subject[:parent][:child].default_route).to be_using(middleware)
         end
       end
     end
@@ -284,11 +397,11 @@ class SiteHub
         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)
+            expect(subject.resolve(env: {})).to eq(subject.candidates.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
+            expect_any_instance_of(subject.candidates.class).to receive(:resolve).with(env: :env).and_call_original
             subject.resolve(env: :env)
           end
         end
@@ -343,15 +456,15 @@ class SiteHub
     context '#endpoints' do
       context 'called with a collection' do
         it 'sets endpoints to be that collection' do
-          subject.routes(:collection)
-          expect(subject.routes).to eq(:collection)
+          subject.candidates(:collection)
+          expect(subject.candidates).to eq(:collection)
         end
       end
 
       context 'already set with a different collection' do
         it 'raise an error' do
-          subject.routes(:collection1)
-          expect { subject.routes(:collection2) }.to raise_exception described_class::InvalidDefinitionException
+          subject.candidates(:collection1)
+          expect { subject.candidates(:collection2) }.to raise_exception described_class::InvalidDefinitionException
         end
       end
     end
@@ -374,5 +487,33 @@ class SiteHub
         expect(proxy.sitehub_cookie_name).to eq(:expected_cookie_name)
       end
     end
+
+    describe '#method_missing' do
+      context 'calling scope set' do
+        subject do
+          calling_scope = double(:calling_scope, parent_method: :called)
+          described_class.new(sitehub_cookie_name: :cookie_name,
+                              mapped_path: '/path',
+                              calling_scope: calling_scope)
+        end
+        context 'method on calling_context' do
+          it 'delegates to it' do
+            expect(subject.parent_method).to eq(:called)
+          end
+        end
+
+        context 'method on calling_context' do
+          it 'delegates to it' do
+            expect(subject.parent_method).to eq(:called)
+          end
+        end
+      end
+
+      context 'calling scope not set' do
+        it 'raises an error' do
+          expect { subject.parent_method }.to raise_error(NoMethodError)
+        end
+      end
+    end
   end
 end