sitehub 0.4.1

data/sitehub.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sitehub/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sitehub"
+  spec.version       = SiteHub::VERSION
+  spec.authors       = ["Ladtech"]
+  spec.email         = ["team@lad-tech.com"]
+  spec.summary       = %q{A/B testing enabled HTTP proxy}
+  spec.description   = %q{A/B testing enabled HTTP proxy}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/*.rb})
+  spec.require_paths = ["lib"]
+
+
+  spec.add_dependency "rack"
+  spec.add_dependency "uuid"
+  spec.add_dependency "em-http-request"
+  spec.add_dependency "rack-ssl-enforcer"
+  spec.add_dependency "rack-fiber_pool"
+  spec.add_dependency "faraday"
+  spec.add_dependency "em-synchrony"
+  spec.add_dependency "thin"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.2.0"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "geminabox"
+  spec.add_development_dependency "simplecov"
+  #spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "memory_profiler"
+  
+  spec.add_development_dependency "ruby-prof"
+
+end

data/spec/basket_spec.rb

@@ -0,0 +1,30 @@
+class Basket
+
+  attr_reader :items
+  def initialize shopping_list
+    @items = parse(shopping_list)
+  end
+
+  def parse shopping_list
+    shopping_list.lines[1..-1].collect { |item|
+      item.chomp.to_sym
+    }
+  end
+end
+
+describe Basket do
+
+  describe '#initialize' do
+    it 'takes a shopping list' do
+
+      shopping_list=<<LIST
+list
+apple
+carrot
+LIST
+
+      basket = described_class.new(shopping_list)
+      expect(basket.items).to eq([:apple, :carrot])
+    end
+  end
+end

data/spec/sitehub/builder_spec.rb

@@ -0,0 +1,203 @@
+require 'sitehub/builder'
+
+class SiteHub
+
+
+  describe Builder do
+
+    include_context :middleware_test
+
+    subject do
+      described_class.new do
+        proxy '/app1' => :endpoint
+      end
+    end
+
+    it 'supports middleware' do
+      expect(subject).to be_kind_of(Middleware)
+    end
+
+    describe '#proxy' do
+      context 'no version explicitly defined' do
+
+        subject do
+          described_class.new do
+            proxy '/app1' => :endpoint
+          end
+        end
+
+
+        it 'the defined route is used 100% of the time' do
+          expected_proxy = ForwardProxyBuilder.new(mapped_path: '/path').tap do |route|
+            route.default(url: :endpoint)
+          end
+          expect(subject.forward_proxies.forward_proxies['/app1']).to eq(expected_proxy)
+        end
+      end
+
+      context 'custom route defined' do
+        subject do
+          described_class.new do
+            proxy('/app') do
+              split url: :endpoint, label: :label, percentage: 100
+            end
+          end
+        end
+
+        it 'passes the block to the route constructor' do
+          expected_route = ForwardProxyBuilder.new(mapped_path: '/path').tap do |route|
+            route.split url: :endpoint, percentage: 100, label: :label
+          end
+
+          expect(subject.forward_proxies.forward_proxies['/app'].endpoints).to eq(expected_route.endpoints)
+        end
+      end
+    end
+
+    describe "#access_logger" do
+      it ' sets the logger' do
+        subject.access_logger :access_logger
+        sitehub = subject.build
+        logger_middleware = find_middleware(sitehub, Logging::AccessLogger)
+        expect(logger_middleware.logger).to eq(Logging::LogWrapper.new(:access_logger))
+      end
+
+      it 'defaults to STDOUT' do
+        allow(::Logger).to receive(:new).and_return(:a_logger)
+        expect(::Logger).to receive(:new).with(STDOUT).and_return(:stdout_logger)
+        sitehub = subject.build
+        logger_middleware = find_middleware(sitehub, Logging::AccessLogger)
+        expect(logger_middleware.logger).to eq(Logging::LogWrapper.new(:stdout_logger))
+      end
+
+    end
+
+    describe '#reverse_proxy' do
+      it 'registers a reverse proxy' do
+        subject.reverse_proxy(:downstream_url => :upstream_path)
+        expect(subject.reverse_proxies).to eq({:downstream_url => :upstream_path})
+      end
+    end
+
+    describe '#sitehub_cookie_name' do
+      it 'defaults to sitehub.recorded_route' do
+        expect(subject.sitehub_cookie_name).to eq(RECORDED_ROUTES_COOKIE)
+      end
+
+      it 'is passed to forward_proxy_builders' do
+        subject.sitehub_cookie_name :expected_cookie_name
+        proxy = subject.proxy '/app1' => :endpoint
+        expect(proxy.sitehub_cookie_name).to eq(:expected_cookie_name)
+      end
+    end
+
+    describe "#error_logger" do
+      it 'sets the logger' do
+        subject.error_logger :error_logger
+        sitehub = subject.build
+        logger_middleware = find_middleware(sitehub, SiteHub::Logging::ErrorLogger)
+        expect(logger_middleware.logger).to eq(Logging::LogWrapper.new(:error_logger))
+      end
+
+      it 'defaults to STDERR' do
+        allow(::Logger).to receive(:new).and_return(:a_logger)
+        expect(::Logger).to receive(:new).with(STDERR).and_return(:stderr_logger)
+        sitehub = subject.build
+        logger_middleware = find_middleware(sitehub, SiteHub::Logging::ErrorLogger)
+        expect(logger_middleware.logger).to eq(Logging::LogWrapper.new(:stderr_logger))
+      end
+
+    end
+
+    describe '#build' do
+
+      it 'initializes the forward_proxies' do
+        expect(subject.forward_proxies).to receive(:init).and_call_original
+        subject.build
+      end
+
+      context 'default middleware' do
+        it 'adds TransactionId middleware to the sitehub' do
+          expect(subject.build).to be_using(TransactionId)
+        end
+
+        it 'adds a forward proxies' do
+          expect(subject.build).to be_using(ForwardProxies)
+        end
+
+        it 'adds a AccessLogger' do
+          expect(subject.build).to be_using(Logging::AccessLogger)
+        end
+
+        it 'adds a ErrorLogger' do
+          expect(subject.build).to be_using(Logging::ErrorLogger)
+        end
+        it 'adds a Rack FiberPool' do
+          expect(subject.build).to be_using(Rack::FiberPool)
+        end
+
+        context 'reverse proxy' do
+          it 'adds a reverse proxy' do
+            expect(subject.build).to be_using(ReverseProxy)
+          end
+
+          it 'uses configured reverse proxy directives' do
+            subject.reverse_proxy({:downstream_url => :upstream_path.to_s})
+            reverse_proxy = find_middleware(subject.build, ReverseProxy)
+
+            expect(reverse_proxy.path_directives).to eq(PathDirectives.new(:downstream_url => :upstream_path.to_s))
+          end
+        end
+
+
+        it 'adds them in the right order' do
+          middleware_stack = collect_middleware(subject.build).collect{|m| m.class}
+          expect(middleware_stack).to eq([Rack::FiberPool, Logging::ErrorLogger, Logging::AccessLogger,TransactionId, ReverseProxy, ForwardProxies])
+        end
+      end
+
+      context 'middleware defined' do
+        it 'wraps the sitehub with it' do
+          subject.use middleware
+          expect(subject.build).to be_using(middleware)
+        end
+      end
+
+      context '#force_ssl' do
+        context 'true' do
+          subject do
+            described_class.new do
+              force_ssl
+            end.build
+          end
+
+          it 'adds SslEnforcer Middleware to the sitehub at the top level' do
+            expect(subject).to be_a(Rack::SslEnforcer)
+          end
+
+          context 'exclusions supplied' do
+            subject do
+              described_class.new do
+                force_ssl except: :google
+              end.build
+            end
+            it 'gives them to the ssl enforcer middleware' do
+              exclusions = subject.instance_variable_get(:@options)[:except]
+              expect(exclusions).to eq(:google)
+            end
+          end
+        end
+
+        context 'false' do
+          it 'does not add SslEnforcer middleware' do
+            sitehub = described_class.new.build
+
+            expect(sitehub).to_not be_using(Rack::SslEnforcer)
+          end
+        end
+
+      end
+    end
+
+  end
+end

data/spec/sitehub/collection/route_collection_spec.rb

@@ -0,0 +1,91 @@
+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) }
+
+    it 'is a collection' do
+      expect(subject).to be_a(Collection)
+    end
+
+    describe '#add' do
+      it 'stores a value' do
+        subject.add :id, route_without_rule
+        expect(subject[:id]).to be(route_without_rule)
+      end
+    end
+
+    describe '#transform' do
+      it "replaces the stores values with what's returned from the block" do
+        subject.add :id, route_without_rule
+        value_before_transform = subject[:id]
+        subject.transform do |value|
+          expect(value).to be(value_before_transform)
+          :transformed_value
+        end
+
+        expect(subject[:id]).to eq(:transformed_value)
+      end
+    end
+
+    describe '#valid?' do
+      context 'route added' do
+        it 'returns true' do
+          subject.add :id,route_without_rule
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'no routes added' do
+        it 'returns false' do
+          expect(subject).to_not be_valid
+        end
+      end
+    end
+
+    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)
+          subject.add(:id, route_without_rule)
+          expect(subject.resolve({})).to be(route_without_rule)
+        end
+      end
+      context 'rule on route' do
+
+        it 'passes the environment to the rule' do
+          request_env = {}
+          rule = proc {|env| env[:env_passed_in] = true}
+
+          proxy = ForwardProxy.new(url: :url, id: :id, sitehub_cookie_name: :cookie_name)
+          proxy.rule(rule)
+          subject.add(:id, proxy)
+          subject.resolve(env: request_env)
+          expect(request_env[:env_passed_in]).to eq(true)
+        end
+
+        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)
+            subject.add(:id, route_with_rule)
+            expect(subject.resolve({})).to be(route_with_rule)
+          end
+
+        end
+
+        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 })
+            subject.add(:id, route_with_rule)
+            expect(subject.resolve({})).to eq(nil)
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/sitehub/collection/split_route_collection_spec.rb

@@ -0,0 +1,111 @@
+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) }
+
+    it 'is a collection' do
+      expect(subject).to be_a(Collection)
+    end
+
+    describe '#add' do
+      before do
+        subject.add route_1.id, route_1, 50
+      end
+      it 'stores a value' do
+        expect(subject[route_1.id]).to be(route_1)
+      end
+
+      it 'sets the selection boundary which is used to choose routes' do
+        subject.add route_2.id, route_2, 50
+        first = subject.values.first
+        second = subject.values.last
+
+        expect(first.lower).to eq(0)
+        expect(first.upper).to eq(50)
+
+        expect(second.lower).to eq(50)
+        expect(second.upper).to eq(100)
+      end
+
+      context 'entry is added which takes splits total over 100%' do
+        it 'raises an error' do
+          expect{subject.add route_2.id, route_2, 101}.to raise_exception described_class::InvalidSplitException, 'total split percentages can not be greater than 100%'
+        end
+      end
+
+      context 'non fixnum passed in' do
+        it 'raises and error' do
+          expect{subject.add route_2.id, route_2, 1.1}.to raise_exception described_class::InvalidSplitException, 'splits must be a Fixnum'
+        end
+      end
+    end
+
+    describe '#resolve' do
+      before do
+        subject.add route_1.id, route_1, 50
+        subject.add route_2.id, route_2, 50
+      end
+
+      context 'rand returns a number within a boundry' do
+        it 'it returns the entry with that set of boundaries' do
+          expect(subject).to receive(:rand).and_return(15)
+          expect(subject.resolve).to eq(route_1)
+        end
+      end
+
+      context 'rand returns a number equal to the lower boundary of an entry' do
+        it 'it returns the entry whos lower boundary is equal to that number' do
+          expect(subject).to receive(:rand).and_return(50)
+          expect(subject.resolve).to eq(route_2)
+        end
+      end
+    end
+
+    describe '#transform' do
+      it "replaces the stores values with what's returned from the block" do
+        subject.add route_1.id, route_1, 50
+        value_before_transform = subject[route_1.id]
+        subject.transform do |value|
+          expect(value).to be(value_before_transform)
+          :transformed_value
+        end
+
+        expect(subject[route_1.id]).to eq(:transformed_value)
+      end
+    end
+
+    describe "#valid?" do
+
+      context 'splits == to 100' do
+        it 'returns true' do
+          subject.add route_1.id, route_1, 50
+          subject.add route_2.id, route_2, 50
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'splits not == 100' do
+        it 'returns false' do
+          subject.add route_1.id, route_1, 50
+          expect(subject).to_not be_valid
+        end
+        it 'gives a warning' do
+          expect(subject).to receive(:warn).with('splits do not add up to 100% and no default has been specified')
+          subject.valid?
+        end
+      end
+
+      context 'no entries added' do
+        it 'returns false' do
+          expect(subject).to_not be_valid
+        end
+      end
+    end
+  end
+
+end