sitehub 0.4.3 → 0.4.6

data/spec/sitehub/collection/route_collection_spec.rb

@@ -1,9 +1,18 @@
 require 'sitehub/collection/route_collection'
-require 'sitehub/forward_proxy'
 
 class SiteHub
   describe Collection::RouteCollection do
-    let(:route_without_rule) { ForwardProxy.new(url: :url, id: :id, sitehub_cookie_name: :cookie_name) }
+    let(:collection_entry) do
+      Class.new do
+        include Rules, Resolver
+
+        def initialize(rule = nil)
+          @rule = rule
+        end
+      end
+    end
+
+    let(:route_without_rule) { collection_entry.new }
 
     it 'is a collection' do
       expect(subject).to be_a(Collection)
@@ -47,7 +56,7 @@ class SiteHub
     describe '#resolve' do
       context 'no rule on route' do
         it 'returns the route' do
-          route_without_rule = ForwardProxy.new(url: :url, id: :id, sitehub_cookie_name: :cookie_name)
+          route_without_rule = collection_entry.new
           subject.add(:id, route_without_rule)
           expect(subject.resolve({})).to be(route_without_rule)
         end
@@ -57,9 +66,7 @@ class SiteHub
           request_env = {}
           rule = proc { |env| env[:env_passed_in] = true }
 
-          proxy = ForwardProxy.new(url: :url,
-                                   id: :id,
-                                   sitehub_cookie_name: :cookie_name)
+          proxy = collection_entry.new
           proxy.rule(rule)
           subject.add(:id, proxy)
           subject.resolve(env: request_env)
@@ -68,10 +75,7 @@ class SiteHub
 
         context 'rule applies' do
           it 'returns the route' do
-            route_with_rule = ForwardProxy.new(url: :url,
-                                               id: :id,
-                                               rule: proc { true },
-                                               sitehub_cookie_name: :cookie_name)
+            route_with_rule = collection_entry.new(proc { true })
             subject.add(:id, route_with_rule)
             expect(subject.resolve({})).to be(route_with_rule)
           end
@@ -79,10 +83,7 @@ class SiteHub
 
         context 'rule does not apply' do
           it 'returns nil' do
-            route_with_rule = ForwardProxy.new(url: :url,
-                                               id: :id,
-                                               sitehub_cookie_name: :cookie_name,
-                                               rule: proc { false })
+            route_with_rule = collection_entry.new(proc { false })
             subject.add(:id, route_with_rule)
             expect(subject.resolve({})).to eq(nil)
           end

data/spec/sitehub/collection/split_route_collection/split_spec.rb

@@ -0,0 +1,26 @@
+require 'sitehub/collection/split_route_collection/split.rb'
+
+class SiteHub
+  class Collection
+    class SplitRouteCollection < Collection
+      describe Split do
+        describe '#update_value' do
+          subject do
+            described_class.new(:lower, :upper, :original)
+          end
+
+          it 'sets the value to be the out of the supplied block' do
+            subject.update_value { :new }
+            expect(subject.value).to eq(:new)
+          end
+
+          it 'passes the current value to the block' do
+            subject.update_value do |value|
+              expect(value).to eq(:original)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/collection/split_route_collection_spec.rb

@@ -1,10 +1,22 @@
 require 'sitehub/collection/split_route_collection'
-require 'sitehub/forward_proxy'
 
 class SiteHub
   describe Collection::SplitRouteCollection do
-    let(:route_1) { ForwardProxy.new(url: :url, id: :id1, sitehub_cookie_name: :cookie_name) }
-    let(:route_2) { ForwardProxy.new(url: :url, id: :id2, sitehub_cookie_name: :cookie_name) }
+    let(:collection_entry) do
+      Class.new do
+        include Rules, Resolver
+
+        attr_reader :id
+
+        def initialize(rule = nil, id:)
+          @id = id
+          @rule = rule
+        end
+      end
+    end
+
+    let(:route_1) { collection_entry.new(id: :id1) }
+    let(:route_2) { collection_entry.new(id: :id2) }
 
     it 'is a collection' do
       expect(subject).to be_a(Collection)

data/spec/sitehub/cookie/flag_spec.rb

@@ -2,7 +2,7 @@ class SiteHub
   class Cookie
     describe Flag do
       let(:name) { 'flag' }
-      let(:string_sanitiser) { Object.new.tap { |o| o.extend(StringSanitiser) } }
+      let(:string_sanitiser) { Object.new.tap { |object| object.extend(StringUtils) } }
       subject do
         described_class.new(name)
       end

data/spec/sitehub/cookie_rewriting_spec.rb

@@ -2,6 +2,8 @@ require 'sitehub/cookie_rewriting'
 
 class SiteHub
   describe CookieRewriting do
+    include_context :module_spec
+
     let(:downstream_domain) { '.downstream_domain.com' }
 
     let(:request_mapping) do
@@ -15,12 +17,6 @@ class SiteHub
     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)
@@ -31,11 +27,11 @@ class SiteHub
         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])
+        first_cookie = SiteHub::Cookie.new(cookie_strings[0])
+        second_cookie = SiteHub::Cookie.new(cookie_strings[1])
         expected = {
-          cookie1.name => cookie1,
-          cookie2.name => cookie2
+          first_cookie.name => first_cookie,
+          second_cookie.name => second_cookie
         }
         result = subject.cookies_string_as_hash(cookie_header)
         expect(result).to eq(expected)

data/spec/sitehub/downstream_client_spec.rb

@@ -0,0 +1,72 @@
+require 'sitehub/downstream_client'
+
+class SiteHub
+  describe DownstreamClient do
+    include_context :rack_request
+    include_context :http_proxy_rules
+
+    let(:current_version_url) { 'http://127.0.0.1:10111' }
+    let(:mapped_path) { '/path' }
+
+    let(:app) do
+      described_class.new
+    end
+
+    let(:body) { 'body' }
+    let(:http_headers) { {} }
+    let(:http_method) { :get }
+    let(:env) { env_for(path: mapped_path, env: http_headers, method: http_method) }
+
+    let(:request) do
+      SiteHub::Request.new(env: env).tap do |request|
+        request.map(mapped_path, current_version_url)
+      end
+    end
+
+    describe '#call' do
+      context 'downstream request' do
+        before do
+          stub_request(http_method, current_version_url).to_return(body: 'body')
+        end
+
+        context 'non get request' do
+          let(:http_method) { :put }
+          let(:env) do
+            env_for(path: mapped_path,
+                    env: http_headers,
+                    params_or_body: body,
+                    method: http_method)
+          end
+
+          it 'preserves the body when forwarding request' do
+            stub_request(http_method, current_version_url)
+            subject.call(request)
+            assert_requested http_method, current_version_url, body: body
+          end
+        end
+
+        it 'preserves the headers when forwarding request' do
+          http_headers['HTTP_HEADER'] = 'value'
+          subject.call(request)
+          assert_requested http_method, current_version_url, headers: { 'Header' => 'value' }
+        end
+
+        it_behaves_like 'prohibited_header_filter' do
+          include_context :rack_request
+
+          subject do
+            headers = format_http_to_rack_headers(prohibited_headers.merge(permitted_header => 'value'))
+            headers.each do |key, value|
+              http_headers[key] = value
+            end
+
+            subject = described_class.new
+            subject.call(request)
+
+            WebMock::RequestRegistry.instance.requested_signatures.hash.keys.first.headers
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/equality_spec.rb

@@ -0,0 +1,32 @@
+class SiteHub
+  describe Equality do
+    subject(:test_class) do
+      Class.new do
+        include Equality
+
+        def initialize(first_attribute, second_attribute)
+          @first_attribute = first_attribute
+          @second_attribute = second_attribute
+        end
+      end
+    end
+    subject do
+      test_class.new(:foo, :bar)
+    end
+
+    describe '#==' do
+      context 'match' do
+        it 'returns true' do
+          match = test_class.new(:foo, :bar)
+          expect(subject).to eq(match)
+        end
+      end
+      context 'mismatch' do
+        it 'returns false' do
+          match = test_class.new(:wrong, :bar)
+          expect(subject).to_not eq(match)
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/forward_proxy_builder_spec.rb

@@ -6,7 +6,7 @@ class SiteHub
     include_context :middleware_test
 
     subject do
-      described_class.new(mapped_path: '/path')
+      described_class.new(mapped_path: '/path', sitehub_cookie_name: :cookie_name)
     end
 
     it 'supports middleware' do
@@ -70,42 +70,55 @@ class SiteHub
       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
-            proc = proc do
-              default url: :url
-            end
-
-            subject.split(percentage: 50, &proc)
+            subject.split(percentage: 50, &block)
 
-            expected_builder = described_class.new(mapped_path: subject.mapped_path, &proc)
+            expected_builder = described_class.new(mapped_path: subject.mapped_path, &block).build
             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
+      context 'block not supplied' do
+        it 'stores a split for the version' do
+          subject.split url: :url, label: :label, percentage: 50
 
-            expected_proxy = { ForwardProxy.new(url: :url, id: :label, sitehub_cookie_name: :cookie_name) => 50 }
-            expected = Collection::SplitRouteCollection.new(expected_proxy)
+          expected_proxy = ForwardProxy.new(id: :label,
+                                            sitehub_cookie_name: :cookie_name,
+                                            mapped_url: :url,
+                                            mapped_path: subject.mapped_path)
 
-            expect(subject.endpoints).to eq(expected)
-          end
+          expected = Collection::SplitRouteCollection.new(expected_proxy => 50)
 
-          context 'label not supplied' do
-            it 'raises an error' do
-              expect { subject.split(url: :url, percentage: 50) }
-                .to raise_error(ForwardProxyBuilder::InvalidDefinitionException)
-            end
-          end
+          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(ForwardProxyBuilder::InvalidDefinitionException)
-            end
+        context 'url not supplied' do
+          it 'raises an error' do
+            expect { subject.split(label: :label, percentage: 50) }
+              .to raise_error(ForwardProxyBuilder::InvalidDefinitionException)
           end
         end
       end
@@ -120,30 +133,53 @@ class SiteHub
       end
     end
 
-    describe 'route' do
+    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)
+        expected_route = ForwardProxy.new(sitehub_cookie_name: :cookie_name,
+                                          id: :current,
+                                          rule: :rule,
+                                          mapped_url: :url,
+                                          mapped_path: subject.mapped_path)
+        expect(subject.endpoints).to eq(current: expected_route)
       end
 
       context 'block supplied' do
-        context 'rule not supplied' do
-          it 'raise an error' do
-            expected_message = described_class::INVALID_ROUTE_DEF_MSG
-            expect { subject.route {} }.to raise_exception described_class::InvalidDefinitionException, expected_message
+        let(:block) do
+          proc do
+            route url: :url, label: :label1
           end
         end
 
-        it 'stores a proxy builder' do
-          rule = proc { true }
-          proc = proc do
-            route url: :url, label: :label1
+        describe '#errors and warnings' do
+          context 'rule not supplied' do
+            it 'raise an error' do
+              expected_message = described_class::INVALID_ROUTE_DEF_MSG
+              expect { subject.route {} }
+                .to raise_exception described_class::InvalidDefinitionException, expected_message
+            end
           end
 
-          subject.route(rule: rule, &proc)
+          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)
+            end
+          end
+        end
+
+        it 'stores a proxy builder' do
+          rule = proc { true }
+          subject.route(rule: rule, &block)
 
-          expected_builder = described_class.new(mapped_path: subject.mapped_path, &proc)
+          expected_builder = described_class.new(rule: rule, mapped_path: subject.mapped_path, &block).build
           expect(subject.endpoints.values).to eq([expected_builder])
         end
 
@@ -223,6 +259,7 @@ class SiteHub
         end
       end
     end
+
     describe '#resolve' do
       subject { described_class.new(mapped_path: '/') }
 
@@ -233,7 +270,7 @@ class SiteHub
         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.endpoints.class).to receive(:resolve).with(env: :env).and_call_original
           subject.resolve(env: :env)
         end
       end
@@ -253,22 +290,6 @@ class SiteHub
         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
@@ -298,6 +319,22 @@ class SiteHub
       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
+
     describe '#forward_proxy' do
       subject do
         described_class.new(mapped_path: '/path', sitehub_cookie_name: :expected_cookie_name)