sitehub 0.4.1

data/spec/sitehub/logging/log_stash_spec.rb

@@ -0,0 +1,21 @@
+require 'sitehub/logging/log_stash'
+
+class SiteHub
+  module Logging
+    describe LogStash do
+
+      it 'inherits Array' do
+        expect(subject).to be_a_kind_of(Array)
+      end
+
+      describe '#<<' do
+
+        it 'adds a LogEntry' do
+          allow(Time).to receive(:now).and_return(:current_time)
+          subject << :message
+          expect(subject).to eq([LogEntry.new(:message)])
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/logging/log_wrapper_spec.rb

@@ -0,0 +1,33 @@
+require 'sitehub/logging/log_wrapper'
+class SiteHub
+  module Logging
+
+    describe LogWrapper do
+
+      describe '#write' do
+        let(:logger) { double('logger') }
+        subject do
+          described_class.new(logger)
+        end
+
+        context 'logger responds to <<' do
+          it 'calls << when writing out the log' do
+            message = 'message'
+            expect(logger).to receive(:<<).with(message)
+            subject.write(message)
+          end
+        end
+
+        context 'logger responds to write' do
+
+          it 'calls << when writing out the log' do
+            message = 'message'
+            expect(logger).to receive(:write).with(message)
+            subject.write(message)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/sitehub/middleware_spec.rb

@@ -0,0 +1,69 @@
+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
+
+    describe '#use' do
+      it 'stores the middleware to be used by the forward proxies' do
+        block = proc {}
+        args = [:args]
+        subject.use :middleware, *args, &block
+        expect(subject.middlewares).to eq([[:middleware, args, block]])
+      end
+    end
+
+    describe '#apply_middleware' do
+
+      context 'middleware defined' do
+
+        it 'wraps the supplied app in the middleware' do
+          subject.use middleware
+          result = subject.apply_middleware(:app)
+          expect(result).to be_a(middleware)
+          expect(result.app).to eq(:app)
+        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
+
+          result = subject.apply_middleware(:app)
+
+          expect(result).to be_a(middleware_1)
+          expect(result).to be_using(middleware_2)
+        end
+
+        context 'args supplied' do
+          it 'passes the arg to the middleware' do
+            subject.use middleware, :arg
+            result = subject.apply_middleware(:app)
+            expect(result.arg).to eq(:arg)
+          end
+        end
+
+        context 'block supplied' do
+          it 'passes the block to the middleware' do
+            block_passed = false
+
+            subject.use middleware do
+              block_passed = true
+            end
+
+            subject.apply_middleware(:app)
+            expect(block_passed).to be(true)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/spec/sitehub/path_directive_spec.rb

@@ -0,0 +1,50 @@
+require 'sitehub/path_directive'
+class SiteHub
+  describe PathDirective do
+
+    subject do
+      described_class.new(%r{/match}, '/path_template')
+    end
+
+    describe '#match?' do
+
+      context 'matcher applies' do
+        it 'returns true' do
+          expect(subject.match?('/match')).to eq(true)
+        end
+      end
+
+      context 'matcher does not apply' do
+        it 'returns false' do
+          expect(subject.match?('/mismatch')).to eq(false)
+        end
+      end
+    end
+
+    describe '#apply' do
+      subject do
+        described_class.new(Regexp.new('http://www.upstream.com/orders/(.*)'), '/$1')
+      end
+
+      let(:url){'http://www.upstream.com/orders/123'}
+
+      it 'uses the url to populate the path template' do
+        expect(subject.apply(url)).to eq('/123')
+      end
+
+      it 'retains the query string' do
+        expect(subject.apply("#{url}?param=value")).to eq('/123?param=value')
+      end
+    end
+
+    describe '#path_template' do
+      it 'returns a duplicate of the path_template every time' do
+        version1, version2 = subject.path_template, subject.path_template
+        expect(version1).to eq(version2)
+        expect(version1).to_not be(version2)
+      end
+    end
+
+  end
+
+end

data/spec/sitehub/path_directives_spec.rb

@@ -0,0 +1,45 @@
+require 'sitehub/path_directives'
+class SiteHub
+  describe PathDirectives do
+    it 'is an array' do
+      expect(subject).to be_kind_of(Array)
+    end
+
+    describe '#initialize' do
+      context 'hash key is a regexp' do
+        it 'leaves the key has a regexp' do
+          key = %r{/.*/}
+          value = '/'
+          expect(described_class.new(key => value)).to eq([PathDirective.new(key,value)])
+        end
+      end
+
+      context 'hash key is a string' do
+        it 'converts the key to a regexp' do
+          key = 'string'
+          value = '/'
+          expect(described_class.new(key => value)).to eq([PathDirective.new(Regexp.new(key),value)])
+        end
+      end
+    end
+
+    describe '#find' do
+      let(:matcher){Regexp.new('/orders/(.*)')}
+      let(:path_template){'/orders/$1'}
+      subject do
+        described_class.new(matcher => path_template)
+      end
+      context 'url matches matcher' do
+        it 'returns the path directive' do
+          expect(subject.find('http://url.com/orders/123')).to eq(PathDirective.new(matcher,path_template))
+        end
+      end
+      context 'url does not matches matcher' do
+        it 'returns nil' do
+          expect(subject.find('http://url.com/mismatch')).to eq(nil)
+        end
+      end
+
+    end
+  end
+end

data/spec/sitehub/request_mapping_spec.rb

@@ -0,0 +1,71 @@
+require 'sitehub/request_mapping'
+
+class SiteHub
+  describe RequestMapping do
+
+    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
+      context 'mapped_path is a regexp' 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
+        it 'returns the computed uri' do
+          expect(subject.computed_uri).to eq('http://downstream_url/123/view')
+        end
+      end
+
+      context 'mapped_path is a string' do
+        subject do
+          described_class.new(source_url: 'http://upstream.com/articles',
+                              mapped_url: 'http://downstream_url/articles',
+                              mapped_path: '/articles')
+        end
+
+        it 'returns the mapped url' do
+          expect(subject.computed_uri).to eq('http://downstream_url/articles')
+        end
+      end
+
+      context 'when there is a query string on the source url' do
+        subject do
+          described_class.new(source_url: 'http://upstream.com/articles?param=value',
+                              mapped_url: 'http://downstream_url/$1',
+                              mapped_path: %r{/(.*)})
+        end
+        it 'keeps the querystring' do
+          expect(subject.computed_uri).to eq('http://downstream_url/articles?param=value')
+        end
+      end
+
+
+    end
+  end
+end

data/spec/sitehub/resolver_spec.rb

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

data/spec/sitehub/reverse_proxy_spec.rb

@@ -0,0 +1,105 @@
+class SiteHub
+
+  describe ReverseProxy do
+
+    include_context :middleware_test
+
+
+    let(:mapped_path){'/orders'}
+    let(:user_facing_app_url){"http://example.org#{mapped_path}"}
+
+
+    let(:downstream_mapping){'https://downstream.com/app1/orders'}
+    let(:downstream_location){"#{downstream_mapping}/123/confirmation"}
+    let(:request_mapping){RequestMapping.new source_url: "#{user_facing_app_url}/123/payment", mapped_url: downstream_mapping, mapped_path: mapped_path}
+    let(:app) do
+      proc{downstream_response}
+    end
+    let(:downstream_response){Rack::Response.new('downstream', 200, {'header1' => 'header1'} )}
+
+    #subject do
+    #  described_class.new(inner_app, [])
+    #end
+
+    subject(:reverse_proxy){described_class.new(app, [])}
+    let(:env){{REQUEST_MAPPING => request_mapping}}
+
+    describe '#call' do
+
+
+
+      subject(:response) do
+        status, headers, body = reverse_proxy.call(env).to_a
+        Rack::Response.new(body,status, headers)
+      end
+
+      it 'copies the downstream body in to the response' do
+        expect(response.body).to eq(downstream_response.body)
+      end
+
+      it 'copies the downstream headers in to the response' do
+        expect(response.headers).to eq(downstream_response.headers)
+      end
+
+      it 'copies the downstream status in to the response' do
+        expect(response.status).to eq(downstream_response.status)
+      end
+
+      context 'cookies' do
+        context 'downstream response contains a cookie' do
+          it 'rewrites it to use the upstream domain' do
+            downstream_response.set_cookie('downstream.cookie', domain: '.downstream.com', value: 'value')
+            expect(reverse_proxy).to receive(:rewrite_cookies).with(downstream_response.headers, substitute_domain: URI(request_mapping.source_url).host)
+            reverse_proxy.call(env)
+          end
+        end
+
+        context 'downstream response does not contain a cookie' do
+          it 'does not attempt to rewrite the cookies' do
+            downstream_headers = downstream_response.headers
+            downstream_headers[HttpHeaders::LOCATION_HEADER] = downstream_location
+            expect(reverse_proxy).not_to receive(:rewrite_cookies)
+            reverse_proxy.call(env)
+          end
+        end
+      end
+
+      #Location, Content-Location and URI
+      it 'rewrites the Location header' do
+        downstream_response.headers[HttpHeaders::LOCATION_HEADER] = downstream_location
+        expect(reverse_proxy).to receive(:interpolate_location).with(downstream_location, request_mapping.source_url).and_return(:interpolated_location)
+        reverse_proxy.call(env)
+        expect(downstream_response.headers[HttpHeaders::LOCATION_HEADER]).to eq(:interpolated_location)
+      end
+
+    end
+
+    describe '#interpolate_location' do
+      it 'changes the domain' do
+        expect(reverse_proxy.interpolate_location(downstream_location, request_mapping.source_url)).to eq("http://example.org/app1/orders/123/confirmation")
+      end
+
+      context 'there is a directive that applies' do
+        context 'matcher is a regexp' do
+          subject do
+            directive = {%r{#{downstream_mapping}/(.*)/confirmation} => '/confirmation/$1'}
+            described_class.new(inner_app,directive)
+          end
+          it 'changes the path' do
+            expect(subject.interpolate_location(downstream_location, request_mapping.source_url)).to eq("http://example.org/confirmation/123")
+          end
+        end
+
+        context 'matcher is a string' do
+          subject do
+            directive = {"http://downstream.com/confirmation" => '/congratulations'}
+            described_class.new(inner_app,directive)
+          end
+          it 'changes the path' do
+            expect(subject.interpolate_location('http://downstream.com/confirmation', request_mapping.source_url)).to eq("http://example.org/congratulations")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/transaction_id_spec.rb

@@ -0,0 +1,28 @@
+require 'sitehub/transaction_id'
+
+class SiteHub
+  describe TransactionId do
+    let(:transaction_id){Constants::RackHttpHeaderKeys::TRANSACTION_ID}
+    subject do
+      described_class.new(Proc.new{})
+    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