deas 0.31.0 → 0.32.0

data/test/unit/redirect_proxy_tests.rb

@@ -1,7 +1,10 @@
 require 'assert'
 require 'deas/redirect_proxy'
 
+require 'deas/handler_proxy'
 require 'deas/test_helpers'
+require 'deas/url'
+require 'deas/view_handler'
 
 class Deas::RedirectProxy
 
@@ -12,11 +15,8 @@ class Deas::RedirectProxy
     end
     subject{ @proxy }
 
-    should have_readers :handler_class_name, :handler_class
-    should have_imeths :validate!
-
-    should "know its handler class name" do
-      assert_equal subject.handler_class.name, subject.handler_class_name
+    should "be a HandlerProxy" do
+      assert_kind_of Deas::HandlerProxy, subject
     end
 
   end
@@ -24,7 +24,7 @@ class Deas::RedirectProxy
   class HandlerClassTests < UnitTests
     include Deas::TestHelpers
 
-    desc "redir handler class"
+    desc "handler class"
     setup do
       @handler_class = @proxy.handler_class
     end
@@ -58,7 +58,7 @@ class Deas::RedirectProxy
   end
 
   class HandlerTests < HandlerClassTests
-    desc "redir handler instance"
+    desc "handler instance"
     setup do
       @handler = test_handler(@handler_class)
     end

data/test/unit/route_proxy_tests.rb

@@ -1,7 +1,8 @@
 require 'assert'
 require 'deas/route_proxy'
 
-require 'deas/test_helpers'
+require 'deas/exceptions'
+require 'deas/handler_proxy'
 require 'test/support/view_handlers'
 
 class Deas::RouteProxy
@@ -13,13 +14,30 @@ class Deas::RouteProxy
     end
     subject{ @proxy }
 
-    should have_readers :handler_class_name, :handler_class
-    should have_imeths :validate!
+    should "be a HandlerProxy" do
+      assert_kind_of Deas::HandlerProxy, subject
+    end
+
+    should "complain if given a nil handler class name" do
+      assert_raises(Deas::NoHandlerClassError) do
+        Deas::RouteProxy.new(nil)
+      end
+    end
 
-    should "know its handler class name" do
+    should "apply no view handler ns if none given" do
       assert_equal 'EmptyViewHandler', subject.handler_class_name
     end
 
+    should "apply an optional view handler ns if it is given" do
+      proxy = Deas::RouteProxy.new('NsTest', 'MyStuff')
+      assert_equal 'MyStuff::NsTest', proxy.handler_class_name
+    end
+
+    should "ignore the ns when given a class name with leading colons" do
+      proxy = Deas::RouteProxy.new('::NoNsTest', 'MyStuff')
+      assert_equal '::NoNsTest', proxy.handler_class_name
+    end
+
     should "set its handler class on `validate!`" do
       assert_nil subject.handler_class
 

data/test/unit/route_tests.rb

@@ -1,7 +1,7 @@
 require 'assert'
 require 'deas/route'
 
-require 'deas/sinatra_runner'
+require 'deas/exceptions'
 require 'deas/route_proxy'
 require 'test/support/fake_sinatra_call'
 require 'test/support/view_handlers'
@@ -11,32 +11,29 @@ class Deas::Route
   class UnitTests < Assert::Context
     desc "Deas::Route"
     setup do
-      @route_proxy = Deas::RouteProxy.new('EmptyViewHandler')
-      @route = Deas::Route.new(:get, '/test', @route_proxy)
+      @req_type_name = Factory.string
+      @proxy = HandlerProxySpy.new
+      @handler_proxies = Hash.new{ |h, k| raise(Deas::HandlerProxyNotFound) }.tap do |h|
+        h[@req_type_name] = @proxy
+      end
+
+      @route = Deas::Route.new(:get, '/test', @handler_proxies)
     end
     subject{ @route }
 
-    should have_readers :method, :path, :route_proxy, :handler_class
+    should have_readers :method, :path
     should have_imeths :validate!, :run
 
-    should "know its method, path and route proxy" do
+    should "know its method and path" do
       assert_equal :get, subject.method
       assert_equal '/test', subject.path
-      assert_equal @route_proxy, subject.route_proxy
     end
 
-    should "set its handler class on `validate!`" do
-      assert_nil subject.handler_class
+    should "validate its proxies on validate" do
+      assert_false @proxy.validate_called
 
       assert_nothing_raised{ subject.validate! }
-      assert_equal EmptyViewHandler, subject.handler_class
-    end
-
-    should "complain given an invalid handler class" do
-      proxy = Deas::RouteProxy.new('SomethingNotDefined')
-      assert_raises(Deas::NoHandlerClassError) do
-        Deas::Route.new(:get, '/test', proxy).validate!
-      end
+      assert_true @proxy.validate_called
     end
 
   end
@@ -45,81 +42,43 @@ class Deas::Route
     desc "when run"
     setup do
       @fake_sinatra_call = FakeSinatraCall.new
-      @runner_spy = SinatraRunnerSpy.new
-      Assert.stub(Deas::SinatraRunner, :new) do |*args|
-        @runner_spy.build(*args)
-        @runner_spy
-      end
-
-      @route.validate!
-      @route.run(@fake_sinatra_call)
-    end
-
-    should "build and run a sinatra runner" do
-      assert_equal subject.handler_class, @runner_spy.handler_class
-
-      exp_args = {
-        :sinatra_call => @fake_sinatra_call,
-        :request      => @fake_sinatra_call.request,
-        :response     => @fake_sinatra_call.response,
-        :session      => @fake_sinatra_call.session,
-        :params       => @fake_sinatra_call.params,
-        :logger       => @fake_sinatra_call.settings.logger,
-        :router       => @fake_sinatra_call.settings.router,
-        :template_source => @fake_sinatra_call.settings.template_source
-      }
-      assert_equal exp_args, @runner_spy.args
-
-      assert_true @runner_spy.run_called
     end
 
-    should "add the runner params to the request env" do
-      exp = @runner_spy.params
-      assert_equal exp, @fake_sinatra_call.request.env['deas.params']
-    end
+    should "run the proxy for the given request type name" do
+      Assert.stub(@fake_sinatra_call.settings.router, :request_type_name).with(
+        @fake_sinatra_call.request
+      ){ @req_type_name }
 
-    should "add the handler class name to the request env" do
-      exp = subject.handler_class.name
-      assert_equal exp, @fake_sinatra_call.request.env['deas.handler_class_name']
+      @route.run(@fake_sinatra_call)
+      assert_true @proxy.run_called
     end
 
-    should "log the handler and params" do
-      exp_msgs = [
-        "  Handler: #{subject.handler_class}",
-        "  Params:  #{@runner_spy.params.inspect}"
-      ]
-      assert_equal exp_msgs, @fake_sinatra_call.request.logging_msgs
+    should "halt 404 if it can't find a proxy for the given request type name" do
+      halt_value = catch(:halt) do
+        @route.run(@fake_sinatra_call)
+      end
+      assert_equal [404], halt_value
     end
 
   end
 
-  class SinatraRunnerSpy
+  class HandlerProxySpy
 
-    attr_reader :run_called
-    attr_reader :handler_class, :args
-    attr_reader :sinatra_call
-    attr_reader :request, :response, :session, :params
-    attr_reader :logger, :router, :template_source
+    attr_reader :validate_called, :run_called, :sinatra_call
 
     def initialize
-      @run_called = false
+      @run_called      = false
+      @validate_called = false
+      @sinatra_call    = nil
     end
 
-    def build(handler_class, args)
-      @handler_class, @args = handler_class, args
-
-      @sinatra_call = args[:sinatra_call]
-      @request      = args[:request]
-      @response     = args[:response]
-      @session      = args[:session]
-      @params       = args[:params]
-      @logger       = args[:logger]
-      @router       = args[:router]
-      @template_source = args[:template_source]
+    def validate!
+      @validate_called = true
     end
 
-    def run
-      @run_called = true
+    def run(sinatra_call)
+      @sinatra_call = sinatra_call
+      @run_called   = true
     end
 
   end

data/test/unit/router_tests.rb

@@ -1,154 +1,222 @@
 require 'assert'
 require 'deas/router'
 
+require 'deas/exceptions'
+require 'deas/route'
+require 'test/support/view_handlers'
+
 class Deas::Router
 
   class UnitTests < Assert::Context
     desc "Deas::Router"
     setup do
-      @router = Deas::Router.new
+      @router_class = Deas::Router
+    end
+    subject{ @router_class }
+
+    should "know its default request type name" do
+      assert_equal 'default', subject::DEFAULT_REQUEST_TYPE_NAME
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @router = @router_class.new
     end
     subject{ @router }
 
-    should have_accessors :urls, :routes
+    should have_readers :request_types, :urls, :routes
+
     should have_imeths :view_handler_ns, :base_url, :prepend_base_url
     should have_imeths :url, :url_for
+    should have_imeths :default_request_type_name, :add_request_type
+    should have_imeths :request_type_name
     should have_imeths :get, :post, :put, :patch, :delete
     should have_imeths :route, :redirect
 
-    should "have no view_handler_ns, base_url, urls, or routes by default" do
+    should "default its settings" do
       assert_nil subject.view_handler_ns
       assert_nil subject.base_url
+      assert_empty subject.request_types
       assert_empty subject.urls
       assert_empty subject.routes
+
+      exp = @router_class::DEFAULT_REQUEST_TYPE_NAME
+      assert_equal exp, subject.default_request_type_name
     end
 
-    should "add a GET route using #get" do
-      subject.get('/things', 'ListThings')
+    should "set a view handler namespace" do
+      subject.view_handler_ns(exp = Factory.string)
+      assert_equal exp, subject.view_handler_ns
+    end
 
-      route = subject.routes[0]
-      assert_instance_of Deas::Route, route
-      assert_equal :get,         route.method
-      assert_equal '/things',    route.path
-      assert_equal 'ListThings', route.route_proxy.handler_class_name
+    should "set a base url" do
+      subject.base_url(exp = Factory.url)
+      assert_equal exp, subject.base_url
     end
 
-    should "add a POST route using #post" do
-      subject.post('/things', 'CreateThing')
+    should "prepend the base url to any url path" do
+      url_path = Factory.path
+      base_url = Factory.url
 
-      route = subject.routes[0]
-      assert_instance_of Deas::Route, route
-      assert_equal :post,         route.method
-      assert_equal '/things',     route.path
-      assert_equal 'CreateThing', route.route_proxy.handler_class_name
+      assert_equal url_path, subject.prepend_base_url(url_path)
+
+      subject.base_url base_url
+      assert_equal "#{base_url}#{url_path}", subject.prepend_base_url(url_path)
     end
 
-    should "add a PUT route using #put" do
-      subject.put('/things/:id', 'UpdateThing')
+    should "prepend the base url when adding routes" do
+      url = Factory.url
+      subject.base_url url
+      path = Factory.path
+      route = subject.get(path, Object)
 
-      route = subject.routes[0]
-      assert_instance_of Deas::Route, route
-      assert_equal :put,          route.method
-      assert_equal '/things/:id', route.path
-      assert_equal 'UpdateThing', route.route_proxy.handler_class_name
+      exp_path = subject.prepend_base_url(path)
+      assert_equal exp_path, route.path
     end
 
-    should "add a PATCH route using #patch" do
-      subject.patch('/things/:id', 'UpdateThing')
+    should "prepend the base url when adding redirects" do
+      url = Factory.url
+      subject.base_url url
+      path = Factory.path
+      redirect = subject.redirect(path, Factory.path)
 
-      route = subject.routes[0]
-      assert_instance_of Deas::Route, route
-      assert_equal :patch,        route.method
-      assert_equal '/things/:id', route.path
-      assert_equal 'UpdateThing', route.route_proxy.handler_class_name
+      exp_path = subject.prepend_base_url(path)
+      assert_equal exp_path, redirect.path
     end
 
-    should "add a DELETE route using #delete" do
-      subject.delete('/things/:id', 'DeleteThing')
+    should "set a default request type name" do
+      subject.default_request_type_name(exp = Factory.string)
+      assert_equal exp, subject.default_request_type_name
+    end
 
-      route = subject.routes[0]
-      assert_instance_of Deas::Route, route
-      assert_equal :delete,       route.method
-      assert_equal '/things/:id', route.path
-      assert_equal 'DeleteThing', route.route_proxy.handler_class_name
+    should "add request types" do
+      assert_empty subject.request_types
+
+      name, proc = Factory.string, Proc.new{}
+      subject.add_request_type(name, &proc)
+      assert_not_empty subject.request_types
+
+      rt = subject.request_types.last
+      assert_equal name, rt.name
+      assert_equal proc, rt.proc
     end
 
-    should "allow defining any kind of route using #route" do
-      subject.route(:options, '/get_info', 'GetInfo')
+    should "lookup request type names" do
+      request = Factory.string
+      name = Factory.string
+      proc = Proc.new{ |r| r == request }
+      subject.add_request_type(name, &proc)
+      subject.add_request_type(Factory.string, &proc)
 
-      route = subject.routes[0]
-      assert_instance_of Deas::Route, route
-      assert_equal :options,    route.method
-      assert_equal '/get_info', route.path
-      assert_equal 'GetInfo',   route.route_proxy.handler_class_name
+      exp = name
+      assert_equal exp, subject.request_type_name(request)
+
+      exp = subject.default_request_type_name
+      assert_equal exp, subject.request_type_name(Factory.string)
     end
 
-    should "set a view handler namespace and use it when defining routes" do
-      subject.view_handler_ns 'MyStuff'
-      assert_equal 'MyStuff', subject.view_handler_ns
+    should "add get, post, put, patch and delete routes" do
+      Assert.stub(subject, :route){ |*args| RouteSpy.new(*args) }
+      path = Factory.path
+      args = [Factory.string]
+
+      [:get, :post, :put, :patch, :delete].each do |meth|
+        route = subject.send(meth, path, *args)
+        assert_equal meth, route.method
+        assert_equal path, route.path
+        assert_equal args, route.args
+      end
+    end
 
-      # should use the ns
-      route = subject.route(:get, '/ns_test', 'NsTest')
-      assert_equal 'MyStuff::NsTest', route.route_proxy.handler_class_name
+    should "instance eval any given block" do
+      ns = Factory.string
+      router = Deas::Router.new do
+        view_handler_ns ns
+      end
 
-      # should ignore the ns when the leading colons are present
-      route = subject.route(:post, '/no_ns_test', '::NoNsTest')
-      assert_equal '::NoNsTest', route.route_proxy.handler_class_name
+      assert_equal ns, router.view_handler_ns
     end
 
-    should "set a base url" do
-      url = Factory.url
-      subject.base_url url
+  end
 
-      assert_equal url, subject.base_url
+  class RouteTests < InitTests
+    setup do
+      @method = Factory.string
+      @path1  = Factory.path
+      @path2  = Factory.path
+      @handler_class_name1 = Factory.string
+      @handler_class_name2 = Factory.string
     end
 
-    should "prepend the base url to any url path" do
-      url_path = Factory.path
-      base_url = Factory.url
+    should "add a Route with the given method and path" do
+      assert_empty subject.routes
 
-      assert_equal url_path, subject.prepend_base_url(url_path)
+      subject.route(@method, @path1)
+      assert_not_empty subject.routes
 
-      subject.base_url base_url
-      assert_equal "#{base_url}#{url_path}", subject.prepend_base_url(url_path)
+      route = subject.routes.last
+      assert_instance_of Deas::Route, route
+      assert_equal @method, route.method
+      assert_equal @path1,  route.path
+
+      proxies = route.handler_proxies
+      assert_kind_of HandlerProxies, proxies
+      assert_empty proxies
+      assert_equal subject.default_request_type_name, proxies.default_type
     end
 
-    should "prepend the base url when adding routes" do
-      url = Factory.url
-      subject.base_url url
-      path = Factory.path
-      route = subject.get(path, Object)
+    should "proxy any handler class given for the default request type" do
+      subject.route(@method, @path1, @handler_class_name1)
+      route = subject.routes.last
+      proxy = route.handler_proxies[subject.default_request_type_name]
+      assert_kind_of Deas::RouteProxy, proxy
+      assert_equal @handler_class_name1, proxy.handler_class_name
 
-      exp_path = subject.prepend_base_url(path)
-      assert_equal exp_path, route.path
+      subject.route(@method, @path1, @handler_class_name1, {
+        subject.default_request_type_name => @handler_class_name2
+      })
+      route = subject.routes.last
+      proxy = route.handler_proxies[subject.default_request_type_name]
+      assert_kind_of Deas::RouteProxy, proxy
+      assert_not_nil proxy
+      assert_equal @handler_class_name2, proxy.handler_class_name
     end
 
-    should "add a redirect route using #redirect" do
-      subject.redirect('/invalid', '/assets')
+    should "proxy handler classes for their specified request types" do
+      subject.route(@method, @path1, {
+        '1' => @handler_class_name1,
+        '2' => @handler_class_name2,
+      })
+      route = subject.routes.last
 
-      route = subject.routes[0]
-      assert_instance_of Deas::Route, route
-      assert_equal :get,       route.method
-      assert_equal '/invalid', route.path
-      assert_equal 'Deas::RedirectHandler', route.route_proxy.handler_class_name
+      proxy = route.handler_proxies['1']
+      assert_kind_of Deas::RouteProxy, proxy
+      assert_equal @handler_class_name1, proxy.handler_class_name
 
-      route.validate!
-      assert_not_nil route.handler_class
+      proxy = route.handler_proxies['2']
+      assert_kind_of Deas::RouteProxy, proxy
+      assert_equal @handler_class_name2, proxy.handler_class_name
     end
 
-    should "instance eval any given block" do
-      router = Deas::Router.new do
-        get('/things', 'ListThings')
-      end
+    should "add redirect routes" do
+      subject.redirect(@path1, @path2)
 
-      assert_equal 1, router.routes.size
-      assert_instance_of Deas::Route, router.routes.first
+      route = subject.routes.last
+      assert_instance_of Deas::Route, route
+      assert_equal :get,   route.method
+      assert_equal @path1, route.path
+
+      proxy = route.handler_proxies[subject.default_request_type_name]
+      assert_kind_of Deas::RedirectProxy, proxy
+      assert_equal 'Deas::RedirectHandler', proxy.handler_class_name
     end
 
   end
 
-  class NamedUrlTests < UnitTests
-    desc "when using named urls"
+  class NamedUrlTests < InitTests
     setup do
       @router.url('get_info', '/info/:for')
     end
@@ -220,4 +288,63 @@ class Deas::Router
 
   end
 
+  class HandlerProxiesTests < UnitTests
+    desc "HandlerProxies"
+    setup do
+      @default_type = Factory.string
+      @other_type   = Factory.string
+      @proxies = {
+        @default_type => Factory.string,
+        @other_type   => Factory.string
+      }
+      @handler_proxies = HandlerProxies.new(@proxies, @default_type)
+    end
+    subject{ @handler_proxies }
+
+    should have_reader :default_type
+    should have_imeths :[], :each, :empty?
+
+    should "know its default type" do
+      assert_equal @default_type, subject.default_type
+    end
+
+    should "find the proxy for the given type" do
+      assert_equal @proxies[@other_type], subject[@other_type]
+    end
+
+    should "find the default proxy if there is no proxy for the given type" do
+      assert_equal @proxies[subject.default_type], subject[Factory.string]
+    end
+
+    should "complain if there is no proxy for the given type and no default proxy" do
+      handler_proxies = HandlerProxies.new({}, @default_type)
+      assert_raises(Deas::HandlerProxyNotFound) do
+        handler_proxies[Factory.string]
+      end
+    end
+
+    should "demeter its given proxies each method" do
+      exp = ''
+      @proxies.each{ |k, v| exp << v }
+      act = ''
+      subject.each{ |k, v| act << v }
+
+      assert_equal exp, act
+    end
+
+    should "demeter its given proxies empty? method" do
+      Assert.stub(@proxies, :empty?){ false }
+      assert_false subject.empty?
+
+      Assert.stub(@proxies, :empty?){ true }
+      assert_true subject.empty?
+    end
+
+  end
+
+  class RouteSpy < Struct.new(:method, :path, :args)
+    def initialize(method, path, *args)
+      super(method, path, args)
+    end
+  end
 end