sitehub 0.4.3 → 0.4.6

data/spec/sitehub/middleware/transaction_id_spec.rb

@@ -0,0 +1,30 @@
+require 'sitehub/middleware/transaction_id'
+
+class SiteHub
+  module Middleware
+    describe TransactionId do
+      let(:transaction_id) { Constants::RackHttpHeaderKeys::TRANSACTION_ID }
+      subject do
+        described_class.new(proc {})
+      end
+      it 'adds a unique identifier to the request' do
+        uuid = UUID.generate(:compact)
+        expect(UUID).to receive(:generate).with(:compact).and_return(uuid)
+        env = {}
+        subject.call(env)
+
+        expect(env[transaction_id]).to eq(uuid)
+      end
+
+      context 'transaction id header already exists' do
+        it 'leaves it intact' do
+          expect(UUID).to_not receive(:generate)
+          env = { transaction_id => :exiting_id }
+          subject.call(env)
+
+          expect(env[transaction_id]).to eq(:exiting_id)
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/middleware_spec.rb

@@ -1,13 +1,8 @@
 require 'sitehub/middleware'
 class SiteHub
   describe Middleware do
-    include_context :middleware_test
-
-    subject do
-      Object.new.tap do |o|
-        o.extend(described_class)
-      end
-    end
+    include_context :middleware_test, :module_spec
+    include_context :module_spec
 
     describe '#use' do
       it 'stores the middleware to be used by the forward proxies' do
@@ -18,6 +13,21 @@ class SiteHub
       end
     end
 
+    describe '#middleware?' do
+      context 'middleware defined' do
+        it 'returns true' do
+          subject.use :middleware
+          expect(subject.middleware?).to eq(true)
+        end
+      end
+
+      context 'no middleware defined' do
+        it 'returns true' do
+          expect(subject.middleware?).to eq(false)
+        end
+      end
+    end
+
     describe '#apply_middleware' do
       context 'middleware defined' do
         it 'wraps the supplied app in the middleware' do
@@ -28,15 +38,15 @@ class SiteHub
         end
 
         it 'wraps the supplied app in the middleware in the order they were supplied' do
-          middleware_1 = create_middleware
-          middleware_2 = create_middleware
-          subject.use middleware_1
-          subject.use middleware_2
+          first_middleware = create_middleware
+          second_middleware = create_middleware
+          subject.use first_middleware
+          subject.use second_middleware
 
           result = subject.apply_middleware(:app)
 
-          expect(result).to be_a(middleware_1)
-          expect(result).to be_using(middleware_2)
+          expect(result).to be_a(first_middleware)
+          expect(result).to be_using(second_middleware)
         end
 
         context 'args supplied' do

data/spec/sitehub/nil_location_rewriter_spec.rb

@@ -0,0 +1,10 @@
+require 'sitehub/location_rewriters_spec'
+class SiteHub
+  describe NilLocationRewriter do
+    describe 'apply' do
+      it 'returns the location parameter' do
+        expect(subject.apply(:location, :source_url)).to eq(:location)
+      end
+    end
+  end
+end

data/spec/sitehub/nil_proxy_spec.rb

@@ -0,0 +1,14 @@
+require 'sitehub/nil_proxy'
+class SiteHub
+  describe NilProxy do
+    describe '#call' do
+      let(:app) do
+        described_class.new
+      end
+
+      it 'returns a 404' do
+        expect(get('/').status).to eq(404)
+      end
+    end
+  end
+end

data/spec/sitehub/request_mapping_spec.rb

@@ -2,34 +2,24 @@ require 'sitehub/request_mapping'
 
 class SiteHub
   describe RequestMapping do
+    let(:mapped_url) { 'http://downstream_url' }
+
+    subject do
+      described_class.new(source_url: 'http://upstream.com/articles/123',
+                          mapped_url: mapped_url,
+                          mapped_path: %r{/articles/(.*)})
+    end
+
     describe '#initialize' do
-      let(:mapped_url) { 'http://downstream_url' }
-      subject do
-        described_class.new(source_url: 'http://upstream.com/articles/123',
-                            mapped_url: mapped_url,
-                            mapped_path: %r{/articles/(.*)})
-      end
       it 'duplicates the mapped url as we mutate it' do
         expect(subject.mapped_url).to eq(mapped_url)
         expect(subject.mapped_url).to_not be(mapped_url)
       end
     end
 
-    describe '#cookie_path' do
-      subject do
-        described_class.new(source_url: 'http://upstream.com/articles/123',
-                            mapped_url: 'http://downstream_url/$1/view',
-                            mapped_path: %r{/articles/(.*)})
-      end
-
-      context 'mapped_path is a regexp' do
-        it 'returns the literal part of the mapped path' do
-          expect(subject.cookie_path).to eq('/articles')
-        end
-      end
-    end
-
     describe '#computed_uri' do
+      it_behaves_like 'a memoized helper'
+
       context 'mapped_path is a regexp' do
         subject do
           described_class.new(source_url: 'http://upstream.com/articles/123',
@@ -37,7 +27,7 @@ class SiteHub
                               mapped_path: %r{/articles/(.*)})
         end
         it 'returns the computed uri' do
-          expect(subject.computed_uri).to eq('http://downstream_url/123/view')
+          expect(subject.computed_uri).to eq(URI('http://downstream_url/123/view'))
         end
       end
 
@@ -49,7 +39,7 @@ class SiteHub
         end
 
         it 'returns the mapped url' do
-          expect(subject.computed_uri).to eq('http://downstream_url/articles')
+          expect(subject.computed_uri).to eq(URI('http://downstream_url/articles'))
         end
       end
 
@@ -60,9 +50,17 @@ class SiteHub
                               mapped_path: %r{/(.*)})
         end
         it 'keeps the querystring' do
-          expect(subject.computed_uri).to eq('http://downstream_url/articles?param=value')
+          expect(subject.computed_uri).to eq(URI('http://downstream_url/articles?param=value'))
         end
       end
     end
+
+    describe '#host' do
+      it_behaves_like 'a memoized helper'
+
+      it 'returns the host' do
+        expect(subject.host).to eq('upstream.com')
+      end
+    end
   end
 end

data/spec/sitehub/request_spec.rb

@@ -0,0 +1,228 @@
+# rubocop:disable Metrics/ClassLength
+class SiteHub
+  describe Request do
+    HttpHeaderKeys = Constants::HttpHeaderKeys
+    RackHttpHeaderKeys = Constants::RackHttpHeaderKeys
+
+    include_context :rack_request
+    include_context :http_proxy_rules
+
+    let(:rack_env) { env_for(method: :get) }
+
+    subject(:request) do
+      described_class.new(env: rack_env)
+    end
+
+    describe '#initialize' do
+      it 'sets the time' do
+        time = Time.now
+        expect(subject.time).to eq(time)
+      end
+    end
+
+    describe '#map' do
+      it 'sets mapped_url and mapped_path' do
+        path = 'path'
+        url = 'url'
+        subject.map(path, url)
+        expect(subject.mapped_path).to be(path)
+        expect(subject.mapped_url).to be(url)
+      end
+    end
+
+    describe '#request_method' do
+      let(:rack_env) { env_for(method: :get) }
+
+      it_behaves_like 'a memoized helper'
+
+      it 'returns the request method' do
+        expect(subject.request_method).to be(:get)
+      end
+    end
+
+    describe '#body' do
+      it_behaves_like 'a memoized helper'
+
+      let(:rack_env) { env_for(method: :post, params_or_body: 'body') }
+      it 'returns the request body' do
+        expect(subject.body).to eq('body')
+      end
+    end
+
+    describe '#headers' do
+      it_behaves_like 'prohibited_header_filter' do
+        let(:rack_env) { format_http_to_rack_headers(prohibited_headers.merge(permitted_header => 'value')) }
+        subject do
+          request.headers
+        end
+      end
+
+      it_behaves_like 'a memoized helper'
+
+      let(:x_forwarded_host) { HttpHeaderKeys::X_FORWARDED_HOST_HEADER }
+
+      context 'host header' do
+        context 'request mapped' do
+          it 'is set to the host identified in mapped url' do
+            expected_uri = URI('http://host:9292/somewhere')
+            subject.map('/mapped_path', expected_uri.to_s)
+            expect(subject.headers[HttpHeaderKeys::HOST_HEADER]).to eq("#{expected_uri.host}:#{expected_uri.port}")
+          end
+        end
+        context 'request not mapped' do
+          it 'is not set' do
+            expect(subject.headers[HttpHeaderKeys::HOST_HEADER]).to be_nil
+          end
+        end
+      end
+
+      context 'x-forwarded-host header' do
+        context 'header not present' do
+          it 'assigns it to the requested host' do
+            expect(subject.headers[x_forwarded_host]).to eq('example.org')
+          end
+        end
+
+        context 'header already present' do
+          let(:rack_env) { env_for(env: { format_as_rack_header_name(x_forwarded_host) => 'first.host,second.host' }) }
+
+          it 'appends the host to the existing value' do
+            expect(subject.headers[x_forwarded_host]).to eq('first.host,second.host,example.org')
+          end
+        end
+      end
+
+      # used for identifying the originating IP address of a request.
+      context 'x-forwarded-for' do
+        let(:x_forwarded_for) { HttpHeaderKeys::X_FORWARDED_FOR_HEADER }
+
+        context 'header not present' do
+          it 'introduces it assigned to the value the remote-addr http header' do
+            expect(subject.headers[x_forwarded_for]).to eq(rack_env['REMOTE_ADDR'])
+          end
+        end
+
+        context 'already present' do
+          let(:rack_env) { env_for(env: { format_as_rack_header_name(x_forwarded_for) => 'first_host_ip' }) }
+
+          it 'appends the value of the remote-addr header to it' do
+            expect(subject.headers[x_forwarded_for]).to eq("first_host_ip,#{rack_env['REMOTE_ADDR']}")
+          end
+        end
+      end
+    end
+
+    describe '#mapping' do
+      it_behaves_like 'a memoized helper'
+
+      it 'returns a RequestMapping' do
+        mapped_url = 'source_url'
+        mapped_path = 'mapped_path'
+        subject.map(mapped_path, mapped_url)
+
+        expected_mapping = RequestMapping.new(source_url: subject.url, mapped_url: mapped_url, mapped_path: mapped_path)
+        expect(subject.mapping).to eq(expected_mapping)
+      end
+    end
+
+    describe '#mapped?' do
+      it_behaves_like 'a memoized helper'
+
+      context 'request has been mapped' do
+        it 'returns true' do
+          subject.map('mapped_path', 'mapped_url')
+
+          expect(subject.mapped?).to eq(true)
+        end
+      end
+
+      context 'request has not been mapped' do
+        it 'returns false' do
+          subject.map(nil, nil)
+          expect(subject.mapped?).to eq(false)
+        end
+      end
+    end
+
+    describe '#remote_user' do
+      let(:rack_env) { env_for(env: { 'REMOTE_USER' => 'user' }) }
+      it 'returns the value of REMOTE_USER rack header' do
+        expect(subject.remote_user).to eq('user')
+      end
+    end
+
+    describe '#transation_id' do
+      let(:transaction_id) { HttpHeaderKeys::TRANSACTION_ID }
+      let(:rack_env) { env_for(env: { format_as_rack_header_name(transaction_id) => :transaction_id }) }
+
+      it 'returns the value of transaction_id header' do
+        expect(subject.transaction_id).to eq(:transaction_id)
+      end
+    end
+
+    describe '#http_version' do
+      let(:http_version) { RackHttpHeaderKeys::HTTP_VERSION }
+      let(:rack_env) { env_for(env: { http_version => :version }) }
+
+      it 'returns the value of http_version header' do
+        expect(subject.http_version).to eq(:version)
+      end
+    end
+
+    describe '#source_address' do
+      context 'x-forwarded-for header set' do
+        let(:x_forwarded_for) { HttpHeaderKeys::X_FORWARDED_FOR_HEADER }
+        let(:address) { 'first_host_ip' }
+        let(:rack_env) { env_for(env: { format_as_rack_header_name(x_forwarded_for) => address }) }
+
+        it 'appends the value of the remote-addr header to it' do
+          expect(subject.source_address).to eq(address)
+        end
+      end
+
+      context 'x-forwarded-for header not set' do
+        it 'returns REMOTE_ADDR' do
+          expect(subject.source_address).to eq(rack_env['REMOTE_ADDR'])
+        end
+      end
+    end
+
+    describe '#url' do
+      it_behaves_like 'a memoized helper'
+
+      it 'returns the source url' do
+        expect(subject.url).to eq(subject.rack_request.url)
+      end
+    end
+
+    describe '#params' do
+      it_behaves_like 'a memoized helper'
+
+      let(:params) { { 'param' => 'value' } }
+      let(:rack_env) { env_for(params_or_body: params) }
+      it 'returns the request params' do
+        expect(subject.params).to eq(params)
+      end
+    end
+
+    describe '#path' do
+      it_behaves_like 'a memoized helper'
+
+      let(:path) { '/path' }
+      let(:rack_env) { env_for(path: path) }
+      it 'returns the request path' do
+        expect(subject.path).to eq(path)
+      end
+    end
+
+    describe '#query_string' do
+      it_behaves_like 'a memoized helper'
+
+      let(:query_string) { 'param=value' }
+      let(:rack_env) { env_for(path: "/?#{query_string}") }
+      it 'returns the request path' do
+        expect(subject.query_string).to eq(query_string)
+      end
+    end
+  end
+end

data/spec/sitehub/resolver_spec.rb

@@ -1,11 +1,8 @@
 require 'sitehub/resolver'
 class SiteHub
   describe Resolver do
-    subject do
-      Object.new.tap do |o|
-        o.extend(described_class)
-      end
-    end
+    include_context :module_spec
+
     describe '#resolve' do
       it 'returns self' do
         expect(subject.resolve).to be(subject)

data/spec/sitehub/response_spec.rb

@@ -0,0 +1,30 @@
+class SiteHub
+  describe Response do
+    subject do
+      described_class.new([], 200, {})
+    end
+
+    it 'extends Rack::Response' do
+      expect(subject).to be_a(Rack::Response)
+    end
+
+    describe '#initialize' do
+      it 'sets the response time' do
+        expect(subject.time).to eq(Time.now)
+      end
+    end
+
+    describe 'time' do
+      it 'returns the same time every time' do
+        first_return = subject.time
+        expect(subject.time).to eq(first_return)
+      end
+    end
+
+    describe '#headers' do
+      it 'is an alias of header' do
+        expect(subject.method(:header)).to eq(subject.method(:headers))
+      end
+    end
+  end
+end