sitehub 0.4.10 → 0.5.0.alpha2

data/lib/sitehub/{nil_proxy.rb → nil_route.rb}

@@ -1,6 +1,6 @@
 require 'sitehub/resolver'
 class SiteHub
-  class NilProxy
+  class NilRoute
     include Resolver
     NOT_FOUND = Rack::Response.new(['page not found'], 404, {})
 

data/lib/sitehub/{forward_proxy_builder.rb → route_builder.rb}

@@ -10,7 +10,7 @@ require_relative 'forward_proxy'
 require_relative 'downstream_client'
 
 class SiteHub
-  class ForwardProxyBuilder
+  class RouteBuilder
     class InvalidDefinitionException < Exception
     end
 
@@ -18,23 +18,43 @@ class SiteHub
     ROUTES_WITH_SPLITS_MSG = 'you cant register routes and splits at the same level'.freeze
     INVALID_ROUTE_DEF_MSG = 'rule must be specified when supplying a block'.freeze
     IGNORING_URL_LABEL_MSG = 'Block supplied, ignoring URL and Label parameters'.freeze
+    URL_REQUIRED_MSG = 'URL must be supplied for splits and routes'.freeze
+
+    class << self
+      # TODO: support nest splits and routes
+      def from_hash(hash, sitehub_cookie_name)
+        new(sitehub_cookie_name: sitehub_cookie_name, sitehub_cookie_path: hash[:sitehub_cookie_path], mapped_path: hash[:path]) do
+          extend CollectionMethods
+
+          collection(hash, :splits).each do |split|
+            split(percentage: split[:percentage], url: split[:url], label: split[:label])
+          end
+
+          collection(hash, :routes).each do |route|
+            route(url: route[:url], label: route[:label])
+          end
+
+          default url: hash[:default] if hash[:default]
+        end
+      end
+    end
 
     extend GetterSetterMethods
-    include Rules, Resolver, Equality, Middleware
+    include Rules, Equality, Middleware
 
     transient :id
 
-    getter_setters :default_proxy, :sitehub_cookie_path
-    attr_reader :mapped_path, :sitehub_cookie_name, :id
+    getter_setters :default_proxy, :sitehub_cookie_path, :sitehub_cookie_name
+    attr_reader :mapped_path, :id
 
-    def initialize(url: nil, mapped_path:, rule: nil, sitehub_cookie_name: nil, &block)
+    def initialize(sitehub_cookie_name:, sitehub_cookie_path: nil, mapped_path:, rule: nil, &block)
       @id = UUID.generate(:compact)
       @mapped_path = mapped_path
+      @sitehub_cookie_name = sitehub_cookie_name
+      @sitehub_cookie_path = sitehub_cookie_path
       @splits = Collection::SplitRouteCollection.new
       @routes = Collection::RouteCollection.new
-      @sitehub_cookie_name = sitehub_cookie_name
-      rule(rule) if rule
-      default(url: url) if url
+      rule(rule)
 
       return unless block_given?
 
@@ -42,9 +62,17 @@ class SiteHub
       raise InvalidDefinitionException unless valid?
     end
 
-    def valid?
-      return true if default_proxy
-      endpoints.valid?
+    def build
+      if middleware?
+        build_with_middleware
+        build_default_with_middleware if default_proxy
+      end
+
+      self
+    end
+
+    def default(url:)
+      default_proxy(forward_proxy(label: :default, url: url))
     end
 
     def endpoints(collection = nil)
@@ -54,17 +82,21 @@ class SiteHub
       @endpoints = collection
     end
 
-    def split(percentage:, url: nil, label: nil, &block)
-      raise InvalidDefinitionException, INVALID_SPLIT_MSG unless block || url
-
-      proxy = if block
-                warn(IGNORING_URL_LABEL_MSG) if url || label
-                new(&block).build
-              else
-                forward_proxy(label: label, url: url)
-              end
+    def forward_proxy(label:, url:, rule: nil)
+      proxy = ForwardProxy.new(mapped_url: url, mapped_path: mapped_path)
+
+      id = (label || UUID.generate(:compact)).to_sym
+      Route.new(proxy,
+                id: id,
+                sitehub_cookie_path: sitehub_cookie_path,
+                sitehub_cookie_name: sitehub_cookie_name).tap do |wrapper|
+        wrapper.rule(rule)
+      end
+    end
 
-      splits.add proxy.id, proxy, percentage
+    def resolve(id: nil, env:)
+      id = id.to_s.to_sym
+      endpoints[id] || endpoints.resolve(env: env) || default_proxy
     end
 
     def route(url: nil, label: nil, rule: nil, &block)
@@ -79,59 +111,61 @@ class SiteHub
       routes.add(endpoint.id, endpoint)
     end
 
-    def default(url:)
-      default_proxy(forward_proxy(label: :default, url: url))
-    end
-
-    def build
-      if middleware?
-        build_with_middleware
-        build_default_with_middleware if default_proxy
-      end
+    def split(percentage:, url: nil, label: nil, &block)
+      raise InvalidDefinitionException, INVALID_SPLIT_MSG unless block || url
 
-      self
-    end
+      proxy = if block
+                warn(IGNORING_URL_LABEL_MSG) if url || label
+                new(&block).build
+              else
+                forward_proxy(label: label, url: url)
+              end
 
-    def resolve(id: nil, env:)
-      id = id.to_s.to_sym
-      endpoints[id] || endpoints.resolve(env: env) || default_proxy
+      splits.add proxy.id, proxy, percentage
     end
 
-    def forward_proxy(label:, url:, rule: nil)
-      label ||= UUID.generate(:compact)
-      ForwardProxy.new(sitehub_cookie_path: sitehub_cookie_path,
-                       sitehub_cookie_name: sitehub_cookie_name,
-                       id: label.to_sym,
-                       rule: rule,
-                       mapped_url: url,
-                       mapped_path: mapped_path)
+    def valid?
+      return true if default_proxy
+      endpoints.valid?
     end
 
     private
 
-    def routes
-      endpoints(@routes)
+    def add_middleware_to_proxy(proxy)
+      middlewares.each do |middleware_args_and_block|
+        middleware_class, args, block = middleware_args_and_block
+        proxy.use middleware_class, *args, &block
+      end
     end
 
-    def splits
-      endpoints(@splits)
+    def build_default_with_middleware
+      add_middleware_to_proxy(default_proxy)
+      default_proxy.init
     end
 
     def build_with_middleware
-      endpoints.transform do |proxy|
-        apply_middleware(proxy).tap do |wrapped_proxy|
-          wrapped_proxy.extend(Rules, Resolver)
-          wrapped_proxy.rule(proxy.rule)
-        end
+      endpoints.values.each do |proxy|
+        add_middleware_to_proxy(proxy)
+        proxy.init
       end
     end
 
-    def build_default_with_middleware
-      default_proxy(apply_middleware(default_proxy))
+    def new(rule: nil, &block)
+      self.class.new(sitehub_cookie_name: sitehub_cookie_name,
+                     mapped_path: mapped_path,
+                     rule: rule,
+                     &block).tap do |builder|
+        builder.sitehub_cookie_name sitehub_cookie_name
+        builder.sitehub_cookie_path sitehub_cookie_path
+      end
     end
 
-    def new(rule: nil, &block)
-      self.class.new(mapped_path: mapped_path, rule: rule, &block)
+    def splits
+      endpoints(@splits)
+    end
+
+    def routes
+      endpoints(@routes)
     end
   end
 end

data/lib/sitehub/version.rb

@@ -1,3 +1,3 @@
 class SiteHub
-  VERSION = '0.4.10'.freeze
+  VERSION = '0.5.0.alpha2'.freeze
 end

data/sitehub.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(spec)/*.rb})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'rack', '~> 1.6.8'
+  spec.add_dependency 'rack'
   spec.add_dependency 'uuid'
   spec.add_dependency 'em-http-request'
   spec.add_dependency 'rack-ssl-enforcer'
@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'faraday'
   spec.add_dependency 'em-synchrony'
   spec.add_dependency 'thin'
+  spec.add_dependency 'activesupport'
 
   spec.add_development_dependency 'bundler', '~> 1.5'
   spec.add_development_dependency 'rake'

data/spec/sitehub/builder_spec.rb

@@ -15,43 +15,6 @@ class SiteHub
       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: '/app1',
-                                                   sitehub_cookie_name: RECORDED_ROUTES_COOKIE).tap do |route|
-            route.default(url: :endpoint)
-          end
-          expect(subject.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: '/app',
-                                                   sitehub_cookie_name: RECORDED_ROUTES_COOKIE).tap do |route|
-            route.split url: :endpoint, percentage: 100, label: :label
-          end
-
-          expect(subject.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
@@ -69,13 +32,6 @@ class SiteHub
       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)
@@ -113,13 +69,47 @@ class SiteHub
       end
     end
 
-    describe '#build' do
-      it 'initializes the forward_proxies' do
-        expect(subject.forward_proxies).to receive(:init).and_call_original
-        subject.build
+    describe '#method_missing' do
+      context 'method not found' do
+        it 'throws an error' do
+          expect { subject.invalid_method }.to raise_error(NoMethodError)
+        end
+      end
+    end
+
+    describe '#method_missing' do
+      context 'method not found' do
+        it 'throws an error' do
+          expect { subject.invalid_method }.to raise_error(NoMethodError)
+        end
+      end
+    end
+
+    describe '#respond_to?' do
+      context 'method exists on core' do
+        it 'returns true' do
+          expect(subject.respond_to?(:proxy)).to eq(true)
+        end
+      end
+
+      context 'method exists on builder' do
+        it 'returns true' do
+          expect(subject.respond_to?(:access_logger)).to eq(true)
+        end
+      end
+
+      context 'method does not exist' do
+        it 'returns false' do
+          expect(subject.respond_to?(:missing)).to eq(false)
+        end
       end
+    end
 
+    describe '#build' do
       context 'default middleware' do
+        it 'returns a fiber pool' do
+          expect(subject.build).to be_a(Rack::FiberPool)
+        end
         it 'adds TransactionId middleware to the sitehub' do
           expect(subject.build).to be_using(Middleware::TransactionId)
         end
@@ -133,11 +123,11 @@ class SiteHub
           end
 
           it 'adds a forward proxies' do
-            expect(subject.build).to be_using(Middleware::ForwardProxies)
+            expect(subject.build).to be_using(Middleware::Routes)
           end
 
           it 'configures it with the sitehub_cookie_name' do
-            forward_proxies = find_middleware(subject.build, Middleware::ForwardProxies)
+            forward_proxies = find_middleware(subject.build, Middleware::Routes)
             expect(forward_proxies.sitehub_cookie_name).to eq(:custom_cookie_name)
           end
         end
@@ -149,37 +139,41 @@ class SiteHub
         it 'adds a ErrorLogger' do
           expect(subject.build).to be_using(Middleware::Logging::ErrorLogger)
         end
-        it 'adds a Rack FiberPool' do
-          expect(subject.build).to be_using(Rack::FiberPool)
-        end
 
         it 'adds a ErrorHandler' do
-          expect(subject.build).to be_using(Middleware::ErrorHandling)
         end
 
-        context 'reverse proxy' do
-          it 'adds a reverse proxy' do
-            expect(subject.build).to be_using(Middleware::ReverseProxy)
+        context 'config server specified' do
+          before do
+            subject.config_server :server_url
           end
 
-          it 'uses configured reverse proxy directives' do
-            subject.reverse_proxy(downstream_url: :upstream_path.to_s)
-            reverse_proxy = find_middleware(subject.build, Middleware::ReverseProxy)
+          it 'adds a ConfigLoader' do
+            expect(subject.build).to be_using(Middleware::ConfigLoader)
+          end
+
+          it 'adds it just before the reverse proxy' do
+            middleware_stack = collect_middleware(subject.build).collect(&:class)
+
+            expected_middleware = [Middleware::Logging::ErrorLogger,
+                                   Middleware::Logging::AccessLogger,
+                                   Middleware::ErrorHandling,
+                                   Middleware::TransactionId,
+                                   Middleware::ConfigLoader]
 
-            expect(reverse_proxy.path_directives).to eq(LocationRewriters.new(downstream_url: :upstream_path.to_s))
+            expect(middleware_stack).to eq(expected_middleware)
           end
         end
 
         it 'adds them in the right order' do
           middleware_stack = collect_middleware(subject.build).collect(&:class)
 
-          expected_middleware = [Rack::FiberPool,
-                                 Middleware::Logging::ErrorLogger,
+          expected_middleware = [Middleware::Logging::ErrorLogger,
                                  Middleware::Logging::AccessLogger,
                                  Middleware::ErrorHandling,
                                  Middleware::TransactionId,
                                  Middleware::ReverseProxy,
-                                 Middleware::ForwardProxies]
+                                 Middleware::Routes]
 
           expect(middleware_stack).to eq(expected_middleware)
         end

data/spec/sitehub/collection/route_collection_spec.rb

@@ -25,19 +25,6 @@ class SiteHub
       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

data/spec/sitehub/core_spec.rb

@@ -0,0 +1,131 @@
+class SiteHub
+  describe Core do
+    include_context :middleware_test
+    include_context :sitehub_json
+
+    describe '::from_hash' do
+      subject(:core) { described_class.from_hash(sitehub_json) }
+
+      subject(:expected) do
+        described_class.new do
+          sitehub_cookie_name 'custom_name'
+          proxy('/route_1') { route label: :label_1, url: 'http://lvl-up.uk/' }
+        end
+      end
+
+      context 'proxies missing' do
+        it 'throws and error' do
+          sitehub_json.delete(:proxies)
+          expect { core }.to raise_error(ConfigError)
+        end
+      end
+
+      context 'reverse_proxies missing' do
+        it 'does not throw an error' do
+          sitehub_json.delete(:reverse_proxies)
+          expect { core }.to_not raise_error
+        end
+      end
+
+      context 'proxies defined' do
+        it 'creates them' do
+          expect(core).to eq(expected)
+        end
+      end
+
+      context 'sitehub_cookie_name' do
+        it 'sets it' do
+          sitehub_json[:sitehub_cookie_name] = 'custom_name'
+
+          expect(core.sitehub_cookie_name).to eq(expected.sitehub_cookie_name)
+          expect(core.routes['/route_1'].sitehub_cookie_name).to eq(expected.sitehub_cookie_name)
+        end
+      end
+
+      context 'reverse_proxies' do
+        it 'sets them' do
+          sitehub_json[:reverse_proxies] = [{ downstream_url: :url, path: :path }]
+          expect(core.reverse_proxies).to eq(url: :path)
+        end
+      end
+    end
+
+    subject do
+      described_class.new
+    end
+
+    describe '#build' do
+      context 'reverse proxy' do
+        it 'adds a reverse proxy' do
+          expect(subject.build).to be_using(Middleware::ReverseProxy)
+        end
+
+        it 'uses configured reverse proxy directives' do
+          subject.reverse_proxy(downstream_url: :upstream_path.to_s)
+          reverse_proxy = find_middleware(subject.build, Middleware::ReverseProxy)
+
+          expect(reverse_proxy.path_directives).to eq(LocationRewriters.new(downstream_url: :upstream_path.to_s))
+        end
+      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 '#proxy' do
+      let(:expected_route) do
+        RouteBuilder.new(sitehub_cookie_name: RECORDED_ROUTES_COOKIE,
+                         mapped_path: '/app')
+      end
+
+      context 'string as parameters' do
+        it 'treats it as the mapped path' do
+          expect_any_instance_of(Middleware::Routes)
+            .to receive(:add_route)
+            .with(url: nil, mapped_path: '/app').and_call_original
+          subject.proxy('/app')
+        end
+      end
+
+      context 'hash as parameter' do
+        it 'treats the key as the mapped path and the value as downstream url' do
+          expect_any_instance_of(Middleware::Routes)
+            .to receive(:add_route)
+            .with(url: :downstream_url, mapped_path: '/app').and_call_original
+          subject.proxy('/app' => :downstream_url)
+        end
+      end
+
+      context 'block passed in' do
+        it 'uses the block when creating the proxy' do
+          proc = proc {}
+
+          expect_any_instance_of(Middleware::Routes).to receive(:add_route) do |*_args, &block|
+            expect(block).to be(proc)
+          end
+
+          subject.proxy('/app' => :downstream_url, &proc)
+        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.split url: :endpoint, percentage: 100, label: :label
+          expect(subject.routes['/app'].endpoints).to eq(expected_route.endpoints)
+        end
+      end
+    end
+  end
+end