sitehub 0.4.3 → 0.4.6

data/spec/sitehub/logging/error_logger_spec.rb

@@ -1,78 +0,0 @@
-require 'sitehub/logging/error_logger'
-
-class SiteHub
-  module Logging
-    describe ErrorLogger do
-      let(:app) { proc { [200, {}, []] } }
-      subject { described_class.new(app) }
-
-      describe '#initialize' do
-        context 'logger supplied' do
-          it 'sets logger to that logger' do
-            expect(described_class.new(:app, :custom_logger).logger).to eq(LogWrapper.new(:custom_logger))
-          end
-        end
-
-        context 'logger not supplied' do
-          it 'sets the logger to go to STDERR' do
-            expect(::Logger).to receive(:new).with(STDERR).and_return(:logging)
-            expect(described_class.new(:app).logger).to eq(LogWrapper.new(:logging))
-          end
-        end
-      end
-
-      describe '#before_call' do
-        it 'adds a collection hold errors' do
-          env = {}
-          subject.call(env)
-          expect(env[ERRORS]).to eq([])
-        end
-      end
-
-      describe '#call' do
-        let(:output) { StringIO.new }
-        let(:logger) { Logger.new(output) }
-        let(:error_message) { 'error' }
-        let(:errors) do
-          Logging::LogStash.new.tap do |stash|
-            stash << error_message
-          end
-        end
-        subject { described_class.new(app, logger) }
-
-        context 'errors have occurred' do
-          it 'logs errors' do
-            log_message = subject.log_message(error: error_message, transaction_id: :transaction_id)
-            subject.call(ERRORS => errors, Constants::RackHttpHeaderKeys::TRANSACTION_ID => :transaction_id)
-            expect(output.string).to eq(log_message)
-          end
-        end
-
-        context 'no errors have occured' do
-          it 'does not log anything' do
-            expect(logger).to_not receive(:write)
-            subject.call(ERRORS => [])
-          end
-        end
-      end
-
-      describe '#log_message' do
-        let(:error) { 'error' }
-        it 'contains the time and date' do
-          now = Time.now
-          expect(Time).to receive(:now).and_return(now)
-          expected_time = now.strftime('%d/%b/%Y:%H:%M:%S %z')
-          expect(subject.log_message(error: error, transaction_id: :transaction_id)).to start_with("[#{expected_time}]")
-        end
-
-        it 'logs statements made against blah' do
-          expect(subject.log_message(error: error, transaction_id: :transaction_id)).to match(/ERROR: .* -  ?#{error}$/)
-        end
-
-        it 'contains the transation id of the request' do
-          expect(subject.log_message(error: error, transaction_id: :transaction_id)).to include('ERROR: transaction_id')
-        end
-      end
-    end
-  end
-end

data/spec/sitehub/logging/log_entry_spec.rb

@@ -1,31 +0,0 @@
-require 'sitehub/logging/log_entry'
-class SiteHub
-  module Logging
-    describe LogEntry do
-      describe '#initialize' do
-        let(:time) { Time.now }
-        subject do
-          described_class.new(:message, time)
-        end
-
-        it 'sets the message' do
-          expect(subject.message).to be(:message)
-        end
-
-        it 'sets the time' do
-          expect(subject.time).to be(time)
-        end
-
-        context 'time not supplied' do
-          subject do
-            described_class.new(:message)
-          end
-          it 'defaults the time' do
-            expect(Time).to receive(:now).and_return(:current_time)
-            expect(subject.time).to be(:current_time)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/sitehub/logging/log_stash_spec.rb

@@ -1,19 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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/path_directive_spec.rb

@@ -1,47 +0,0 @@
-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 = subject.path_template
-        version2 = subject.path_template
-        expect(version1).to eq(version2)
-        expect(version1).to_not be(version2)
-      end
-    end
-  end
-end

data/spec/sitehub/reverse_proxy_spec.rb

@@ -1,111 +0,0 @@
-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) do
-      RequestMapping.new source_url: "#{user_facing_app_url}/123/payment",
-                         mapped_url: downstream_mapping,
-                         mapped_path: mapped_path
-    end
-
-    let(:app) do
-      proc { downstream_response }
-    end
-    let(:downstream_response) { Rack::Response.new('downstream', 200, 'header1' => 'header1') }
-
-    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
-          let(:downstream_url) { 'http://downstream.com/confirmation' }
-          subject do
-            directive = { downstream_url => '/congratulations' }
-            described_class.new(inner_app, directive)
-          end
-          it 'changes the path' do
-            actual = subject.interpolate_location(downstream_url, request_mapping.source_url)
-            expected = 'http://example.org/congratulations'
-            expect(actual).to eq(expected)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/sitehub/transaction_id_spec.rb

@@ -1,28 +0,0 @@
-require 'sitehub/transaction_id'
-
-class SiteHub
-  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

data/spec/support/async/response_handler.rb

@@ -1,16 +0,0 @@
-module Async
-  class ResponseHandler < EM::DefaultDeferrable
-    attr_reader :last_response, :callback_args
-
-    alias arg callback_args
-
-    def succeed(arg)
-      sitehub_response = arg[:downstream_response]
-      instance_variable_set(:@arg, arg)
-      status, headers, body = *sitehub_response.to_a
-      rack_response = Rack::Response.new(body, status, headers)
-      instance_variable_set(:@last_response, rack_response)
-      EM.stop
-    end
-  end
-end

data/spec/support/shared_contexts/async_context.rb

@@ -1,14 +0,0 @@
-require_relative '../async'
-shared_context :async do
-  def callback
-    @callback ||= Async::Callback.new
-  end
-
-  def async_response_handler
-    @async_response_handler = Async::ResponseHandler.new
-  end
-
-  def last_response
-    app.last_response
-  end
-end