deas 0.42.0 → 0.43.0

data/test/unit/handler_proxy_tests.rb

@@ -38,23 +38,19 @@ class Deas::HandlerProxy
 
       Assert.stub(@proxy, :handler_class){ EmptyViewHandler }
 
-      @server_data        = Factory.server_data
-      @fake_sinatra_call  = Factory.sinatra_call
-      @splat_sym_param    = Factory.string
-      @splat_string_param = Factory.string
-      @fake_sinatra_call.params = {
-        :splat     => [@splat_sym_param],
-        'splat'    => [@splat_string_param],
+      @server_data  = Factory.server_data
+      @request_data = Factory.request_data(:params => {
+        :splat     => [Factory.string],
+        'splat'    => [Factory.string],
         :captures  => [Factory.string],
         'captures' => [Factory.string]
-      }
-
-      @proxy.run(@server_data, @fake_sinatra_call)
+      })
+      @proxy.run(@server_data, @request_data)
     end
 
     should "remove any 'splat' or 'captures' params added by Sinatra's router" do
       [:splat, 'splat', :captures, 'captures'].each do |param_name|
-        assert_nil @fake_sinatra_call.params[param_name]
+        assert_nil @request_data.params[param_name]
       end
     end
 
@@ -65,44 +61,40 @@ class Deas::HandlerProxy
         :logger          => @server_data.logger,
         :router          => @server_data.router,
         :template_source => @server_data.template_source,
-        :request         => @fake_sinatra_call.request,
-        :session         => @fake_sinatra_call.session,
-        :params          => @fake_sinatra_call.params,
-        :splat           => @splat_sym_param
+        :request         => @request_data.request,
+        :params          => @request_data.params,
+        :route_path      => @request_data.route_path
       }
       assert_equal exp_args, @runner_spy.args
 
       assert_true @runner_spy.run_called
     end
 
-    should "prefer splat sym params over splat string params" do
-      assert_equal @splat_sym_param, @runner_spy.args[:splat]
-
-      @fake_sinatra_call.params['splat'] = [@splat_string_param]
-      proxy = Deas::HandlerProxy.new('EmptyViewHandler')
-      Assert.stub(proxy, :handler_class){ EmptyViewHandler }
-      proxy.run(@server_data, @fake_sinatra_call)
-      assert_equal @splat_string_param, @runner_spy.args[:splat]
-    end
-
     should "add data to the request env to make it available to Rack" do
       exp = subject.handler_class
-      assert_equal exp, @fake_sinatra_call.request.env['deas.handler_class']
+      assert_equal exp, @request_data.request.env['deas.handler_class']
 
       exp = @runner_spy.handler
-      assert_equal exp, @fake_sinatra_call.request.env['deas.handler']
+      assert_equal exp, @request_data.request.env['deas.handler']
 
       exp = @runner_spy.params
-      assert_equal exp, @fake_sinatra_call.request.env['deas.params']
+      assert_equal exp, @request_data.request.env['deas.params']
+
+      exp = @runner_spy.splat
+      assert_equal exp, @request_data.request.env['deas.splat']
+
+      exp = @runner_spy.route_path
+      assert_equal exp, @request_data.request.env['deas.route_path']
     end
 
     should "log the handler class name and the params" do
       exp_msgs = [
         "  Handler: #{subject.handler_class.name}",
         "  Params:  #{@runner_spy.params.inspect}",
-        "  Splat:   #{@runner_spy.splat.inspect}"
+        "  Splat:   #{@runner_spy.splat.inspect}",
+        "  Route:   #{@runner_spy.route_path.inspect}"
       ]
-      assert_equal exp_msgs, @fake_sinatra_call.request.logging_msgs
+      assert_equal exp_msgs, @request_data.request.logging_msgs
     end
 
   end
@@ -112,7 +104,7 @@ class Deas::HandlerProxy
     attr_reader :run_called
     attr_reader :handler_class, :handler, :args
     attr_reader :logger, :router, :template_source
-    attr_reader :request, :session, :params, :splat
+    attr_reader :request, :params, :splat, :route_path
 
     def initialize
       @run_called = false
@@ -127,9 +119,12 @@ class Deas::HandlerProxy
       @router          = args[:router]
       @template_source = args[:template_source]
       @request         = args[:request]
-      @session         = args[:session]
       @params          = args[:params]
-      @splat           = args[:splat]
+      @route_path      = args[:route_path]
+
+      # runners parse the splat value from the PATH_INFO and route path. just
+      # use a placeholder value for the spy.
+      @splat = Factory.string
     end
 
     def run

data/test/unit/logging_tests.rb

@@ -7,11 +7,11 @@ module Deas::Logging
     desc "Deas::Logging"
     subject{ Deas::Logging }
 
-    should have_imeths :middleware
+    should have_imeths :middleware_args
 
-    should "return a middleware class given a verbose flag" do
-      assert_equal Deas::VerboseLogging, subject.middleware(true)
-      assert_equal Deas::SummaryLogging, subject.middleware(false)
+    should "return middleware args given a verbose flag" do
+      assert_equal [Deas::VerboseLogging], subject.middleware_args(true)
+      assert_equal [Deas::SummaryLogging], subject.middleware_args(false)
     end
 
   end
@@ -205,9 +205,11 @@ module Deas::Logging
     desc "when init"
     setup do
       @params = { Factory.string => Factory.string }
+      @splat  = Factory.string
       @handler_class = TestHandler
       @env.merge!({
         'deas.params'        => @params,
+        'deas.splat'         => @splat,
         'deas.handler_class' => @handler_class
       })
 
@@ -237,6 +239,7 @@ module Deas::Logging
         'method'  => @env['REQUEST_METHOD'],
         'path'    => @env['PATH_INFO'],
         'params'  => @env['deas.params'],
+        'splat'   => @env['deas.splat'],
         'time'    => @env['deas.time_taken'],
         'status'  => @resp_status,
         'handler' => @handler_class.name,
@@ -253,6 +256,7 @@ module Deas::Logging
         'method'  => @env['REQUEST_METHOD'],
         'path'    => @env['PATH_INFO'],
         'params'  => @env['deas.params'],
+        'splat'   => @env['deas.splat'],
         'time'    => @env['deas.time_taken'],
         'status'  => @resp_status,
         'redir'   => @resp_headers['Location']
@@ -268,6 +272,7 @@ module Deas::Logging
         'method'  => @env['REQUEST_METHOD'],
         'path'    => @env['PATH_INFO'],
         'params'  => @env['deas.params'],
+        'splat'   => @env['deas.splat'],
         'time'    => @env['deas.time_taken'],
         'status'  => @resp_status,
         'handler' => @handler_class.name,
@@ -282,7 +287,7 @@ module Deas::Logging
     subject{ Deas::SummaryLine }
 
     should "output its attributes in a specific order" do
-      assert_equal %w{time status method path handler params redir}, subject.keys
+      assert_equal %w{time status method path handler params splat redir}, subject.keys
     end
 
     should "output its attributes in a single line" do
@@ -293,6 +298,7 @@ module Deas::Logging
         'path'    => 'pth',
         'handler' => 'h',
         'params'  => 'p',
+        'splat'   => 'spl',
         'redir'   => 'r'
       }
       exp_line = "time=\"t\" "\
@@ -301,6 +307,7 @@ module Deas::Logging
                  "path=\"pth\" "\
                  "handler=\"h\" "\
                  "params=\"p\" "\
+                 "splat=\"spl\" "\
                  "redir=\"r\""
       assert_equal exp_line, subject.new(line_attrs)
     end

data/test/unit/request_data_tests.rb

@@ -0,0 +1,57 @@
+require 'assert'
+require 'deas/request_data'
+
+class Deas::RequestData
+
+  class UnitTests < Assert::Context
+    desc "Deas::RequestData"
+    setup do
+      @request    = Factory.string
+      @response   = Factory.string
+      @params     = Factory.string
+      @route_path = Factory.string
+
+      @request_data = Deas::RequestData.new({
+        :request    => @request,
+        :response   => @response,
+        :params     => @params,
+        :route_path => @route_path
+      })
+    end
+    subject{ @request_data }
+
+    should have_readers :request, :response, :params, :route_path
+
+    should "know its attributes" do
+      assert_equal @request,    subject.request
+      assert_equal @response,   subject.response
+      assert_equal @params,     subject.params
+      assert_equal @route_path, subject.route_path
+    end
+
+    should "default its attributes when they aren't provided" do
+      request_data = Deas::RequestData.new({})
+
+      assert_nil request_data.request
+      assert_nil request_data.response
+      assert_nil request_data.params
+      assert_nil request_data.route_path
+    end
+
+    should "know if it is equal to another request data" do
+      request_data = Deas::RequestData.new({
+        :request    => @request,
+        :response   => @response,
+        :params     => @params,
+        :route_path => @route_path
+      })
+      assert_equal request_data, subject
+
+      request_data = Deas::RequestData.new({})
+      assert_not_equal request_data, subject
+    end
+
+
+  end
+
+end

data/test/unit/route_tests.rb

@@ -10,8 +10,8 @@ class Deas::Route
   class UnitTests < Assert::Context
     desc "Deas::Route"
     setup do
-      @req_type_name = Factory.string
-      @proxy = HandlerProxySpy.new
+      @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
@@ -40,46 +40,46 @@ class Deas::Route
   class RunTests < UnitTests
     desc "when run"
     setup do
-      @server_data       = Factory.server_data
-      @fake_sinatra_call = Factory.sinatra_call
+      @server_data  = Factory.server_data
+      @request_data = Factory.request_data
     end
 
     should "run the proxy for the given request type name" do
       Assert.stub(@server_data.router, :request_type_name).with(
-        @fake_sinatra_call.request
+        @request_data.request
       ){ @req_type_name }
 
-      @route.run(@server_data, @fake_sinatra_call)
+      @route.run(@server_data, @request_data)
       assert_true @proxy.run_called
+      assert_equal @server_data, @proxy.server_data
+      assert_equal @request_data, @proxy.request_data
     end
 
     should "halt 404 if it can't find a proxy for the given request type name" do
-      halt_value = catch(:halt) do
-        @route.run(@server_data, @fake_sinatra_call)
-      end
-      assert_equal [404], halt_value
+      exp = [404, Rack::Utils::HeaderHash.new, []]
+      assert_equal exp, @route.run(@server_data, @request_data)
     end
 
   end
 
   class HandlerProxySpy
 
-    attr_reader :validate_called, :run_called, :server_data, :sinatra_call
+    attr_reader :validate_called, :run_called, :server_data, :request_data
 
     def initialize
       @run_called      = false
       @validate_called = false
       @server_data     = nil
-      @sinatra_call    = nil
+      @request_data    = nil
     end
 
     def validate!
       @validate_called = true
     end
 
-    def run(server_data, sinatra_call)
-      @server_data  = sinatra_call
-      @sinatra_call = sinatra_call
+    def run(server_data, request_data)
+      @server_data  = server_data
+      @request_data = request_data
       @run_called   = true
     end
 

data/test/unit/router_tests.rb

@@ -43,7 +43,7 @@ class Deas::Router
     should have_imeths :route, :redirect, :not_found
     should have_imeths :apply_definitions!, :validate!
 
-    should "default its settings" do
+    should "default its attrs" do
       router = @router_class.new
       assert_nil router.view_handler_ns
       assert_nil router.base_url
@@ -370,11 +370,40 @@ class Deas::Router
       assert_equal [404, {}, body], handler.halt_args
     end
 
+    should "complain if adding a route with invalid splats in its path" do
+      [ "/something/other*/",
+        "/something/other*",
+        "/something/*other",
+        "/something*/other",
+        "/*something/other",
+        "/something/*/other/*",
+        "/something/*/other",
+        "/something/*/",
+        "/*/something",
+      ].each do |path|
+        assert_raises InvalidSplatError do
+          router = @router_class.new
+          router.route(:get, path)
+          router.apply_definitions!
+        end
+      end
+
+      [ "/something/*",
+        "/*"
+      ].each do |path|
+        assert_nothing_raised do
+          router = @router_class.new
+          router.route(:get, path)
+          router.apply_definitions!
+        end
+      end
+    end
+
   end
 
   class NamedUrlTests < InitTests
     setup do
-      @router.url('get_info', '/info/:for')
+      @router.url(:get_info, '/info/:for')
     end
 
     should "define a url given a name and a path" do
@@ -388,38 +417,23 @@ class Deas::Router
     end
 
     should "define a url with a custom escape query value proc" do
-      name = Factory.string
+      name = Factory.string.to_sym
       escape_proc = proc{ Factory.string }
       @router.url(name, Factory.path, :escape_query_value => escape_proc)
 
-      url = subject.urls[name.to_sym]
+      url = subject.urls[name]
       assert_equal escape_proc, url.escape_query_value_proc
     end
 
-    should "complain if defining a url with a non-string path" do
+    should "complain if defining a url with a non-symbol name" do
       assert_raises ArgumentError do
-        subject.url(:get_info, /^\/info/)
+        subject.url('get_info', '/info')
       end
     end
 
-    should "complain if defining a url with invalid splats" do
-      assert_raises ArgumentError do
-        subject.url(:get_info, "/something/*/other/*")
-      end
-      assert_raises ArgumentError do
-        subject.url(:get_info, "/something/*/other")
-      end
-      assert_raises ArgumentError do
-        subject.url(:get_info, "/something/*/")
-      end
+    should "complain if defining a url with a non-string path" do
       assert_raises ArgumentError do
-        subject.url(:get_info, "/*/something")
-      end
-      assert_nothing_raised do
-        subject.url(:get_info, "/something/*")
-      end
-      assert_nothing_raised do
-        subject.url(:get_info, "/*")
+        subject.url(:get_info, /^\/info/)
       end
     end
 
@@ -510,7 +524,7 @@ class Deas::Router
       url = Factory.url
       subject.base_url url
       path = Factory.path
-      subject.url('base_get_info', path)
+      subject.url(:base_get_info, path)
 
       exp_path = subject.prepend_base_url(path)
       assert_equal exp_path, subject.url_for(:base_get_info)

data/test/unit/runner_tests.rb

@@ -45,7 +45,7 @@ class Deas::Runner
 
     should have_readers :handler_class, :handler
     should have_readers :logger, :router, :template_source
-    should have_readers :request, :session, :params, :splat
+    should have_readers :request, :params, :route_path, :splat
     should have_imeths :run, :to_rack
     should have_imeths :status, :headers, :body, :content_type
     should have_imeths :halt, :redirect, :send_file
@@ -63,20 +63,21 @@ class Deas::Runner
       assert_kind_of Deas::NullTemplateSource, runner.template_source
 
       assert_nil runner.request
-      assert_nil runner.session
 
-      assert_equal({}, runner.params)
+      assert_equal Hash.new, runner.params
+      assert_equal '',       runner.route_path
+
+      assert_nil runner.splat
     end
 
     should "know its attrs" do
       args = {
-        :logger          => 'a-logger',
-        :router          => 'a-router',
-        :template_source => 'a-source',
-        :request         => 'a-request',
-        :session         => 'a-session',
-        :params          => {},
-        :splat           => 'a-splat'
+        :logger          => Factory.string,
+        :router          => Factory.string,
+        :template_source => Factory.string,
+        :request         => Factory.request,
+        :params          => { Factory.string => Factory.string },
+        :route_path      => Factory.string
       }
 
       runner = @runner_class.new(@handler_class, args)
@@ -85,9 +86,62 @@ class Deas::Runner
       assert_equal args[:router],          runner.router
       assert_equal args[:template_source], runner.template_source
       assert_equal args[:request],         runner.request
-      assert_equal args[:session],         runner.session
       assert_equal args[:params],          runner.params
-      assert_equal args[:splat],           runner.splat
+      assert_equal args[:route_path],      runner.route_path
+    end
+
+    should "know its splat value" do
+      route_path = [
+        '/some/:value/other/:value/*',
+        '/some/:value/*'
+      ].sample
+
+      params      = { 'value' => Factory.string }
+      splat       = Factory.integer(3).times.map{ Factory.string}.join('/')
+      path_info   = route_path.gsub(':value', params['value']).sub('*', splat)
+      request_env = { 'PATH_INFO' => path_info }
+
+      args = {
+        :request    => Factory.request(:env => request_env),
+        :params     => params,
+        :route_path => route_path
+      }
+
+      runner = @runner_class.new(@handler_class, args)
+      assert_equal splat, runner.splat
+    end
+
+    should "not have a splat value if there is no splat in the route path" do
+      route_path  = '/some/:value'
+      params      = { 'value' => Factory.string }
+      path_info   = route_path.gsub(':value', params['value'])
+      request_env = { 'PATH_INFO' => path_info }
+
+      args = {
+        :request    => Factory.request(:env => request_env),
+        :params     => params,
+        :route_path => route_path
+      }
+
+      runner = @runner_class.new(@handler_class, args)
+      assert_nil runner.splat
+    end
+
+    should "complain if it can't parse the splat param" do
+      route_path  = '/some/:value/*'
+      params      = { 'value' => Factory.string }
+      splat       = Factory.integer(3).times.map{ Factory.string}.join('/')
+      path_info   = "/some/#{Factory.string}"
+      request_env = { 'PATH_INFO' => path_info }
+
+      args = {
+        :request    => Factory.request(:env => request_env),
+        :params     => params,
+        :route_path => route_path
+      }
+
+      runner = @runner_class.new(@handler_class, args)
+      assert_raises(SplatParseError){ runner.splat }
     end
 
     should "not implement its run method" do