deas 0.38.0 → 0.39.0

data/test/system/{rack_tests.rb → deas_tests.rb}

@@ -26,21 +26,27 @@ module Deas
 
     should "set the content type appropriately" do
       get '/show'
+      assert_equal 200, last_response.status
       assert_equal 'text/html;charset=utf-8', last_response.headers['Content-Type']
 
       get '/show.html'
+      assert_equal 200, last_response.status
       assert_equal 'text/html;charset=utf-8', last_response.headers['Content-Type']
 
       get '/show.json'
+      assert_equal 200, last_response.status
       assert_equal 'application/json;charset=utf-8', last_response.headers['Content-Type']
 
       get '/show-latin1-json'
+      assert_equal 200, last_response.status
       assert_equal 'application/json;charset=latin1', last_response.headers['Content-Type']
 
       get '/show-text'
+      assert_equal 200, last_response.status
       assert_equal 'text/plain', last_response.headers['Content-Type']
 
       get '/show-headers-text'
+      assert_equal 200, last_response.status
       assert_equal 'text/plain', last_response.headers['Content-Type']
     end
 
@@ -81,25 +87,25 @@ module Deas
 
     should "return a 302 redirecting to the expected locations" do
       get '/redirect'
-      expected_location = 'http://google.com'
+      exp_location = 'http://google.com'
 
-      assert_equal 302,               last_response.status
-      assert_equal expected_location, last_response.headers['Location']
+      assert_equal 302, last_response.status
+      assert_equal exp_location, last_response.headers['Location']
     end
 
     should "return a 302 redirect to the expected location " \
            "when using a route redirect" do
       get '/route_redirect'
-      expected_location = 'http://example.org/somewhere'
+      exp_location = 'http://example.org/somewhere'
 
-      assert_equal 302,               last_response.status
-      assert_equal expected_location, last_response.headers['Location']
+      assert_equal 302, last_response.status
+      assert_equal exp_location, last_response.headers['Location']
 
       get '/my_prefix/redirect'
-      expected_location = 'http://example.org/my_prefix/somewhere'
+      exp_location = 'http://example.org/my_prefix/somewhere'
 
-      assert_equal 302,               last_response.status
-      assert_equal expected_location, last_response.headers['Location']
+      assert_equal 302, last_response.status
+      assert_equal exp_location, last_response.headers['Location']
     end
 
   end
@@ -133,11 +139,10 @@ module Deas
 
     should "be able to access sinatra call data" do
       exp = {
-        'logger_class_name'       => 'Logger',
-        'request_method'          => 'GET',
-        'response_firstheaderval' => 'Content-Type',
-        'params_a_param'          => 'something',
-        'session_inspect'         => '{}'
+        'logger_class_name' => 'Logger',
+        'request_method'    => 'GET',
+        'params_a_param'    => 'something',
+        'session_inspect'   => '{}'
       }
       assert_equal exp.inspect, @data_inspect
     end

data/test/unit/deas_runner_tests.rb

@@ -4,18 +4,18 @@ require 'deas/deas_runner'
 require 'deas/runner'
 require 'deas/template_source'
 require 'test/support/normalized_params_spy'
-require 'test/support/view_handlers'
 
 class Deas::DeasRunner
 
   class UnitTests < Assert::Context
     desc "Deas::DeasRunner"
     setup do
-      @runner_class = Deas::DeasRunner
+      @handler_class = TestViewHandler
+      @runner_class  = Deas::DeasRunner
     end
     subject{ @runner_class }
 
-    should "be a `Runner`" do
+    should "be a runner" do
       assert subject < Deas::Runner
     end
 
@@ -28,43 +28,197 @@ class Deas::DeasRunner
       @norm_params_spy = Deas::Runner::NormalizedParamsSpy.new
       Assert.stub(NormalizedParams, :new){ |p| @norm_params_spy.new(p) }
 
-      @runner = @runner_class.new(DeasRunnerViewHandler, :params => @params)
+      @runner = @runner_class.new(@handler_class, :params => @params)
     end
     subject{ @runner }
 
     should have_imeths :run
 
+    should "call to normalize its params" do
+      assert_equal @params, @norm_params_spy.params
+      assert_true @norm_params_spy.value_called
+    end
+
     should "super its params arg" do
       assert_equal @params, subject.params
     end
 
-    should "call to normalize its params" do
-      assert_equal @params, @norm_params_spy.params
-      assert_true @norm_params_spy.value_called
+  end
+
+  class InitHandlerTests < InitTests
+    setup do
+      @handler = @runner.handler
+    end
+
+    private
+
+    def subject_to_rack_with_content_length
+      subject.to_rack.tap do |(s,h,b)|
+        h.merge!('Content-Length' => calc_content_length(b))
+      end
+    end
+
+    def calc_content_length(body)
+      body.inject(0){ |l, p| l + p.size }.to_s
     end
 
   end
 
-  class RunTests < InitTests
+  class RunTests < InitHandlerTests
     desc "and run"
     setup do
-      @response_value = @runner.run
-      @handler = @runner.instance_variable_get("@handler")
+      @response = @runner.run
+    end
+
+    should "run the handler's before callbacks" do
+      assert_equal 1, @handler.first_before_call_order
+      assert_equal 2, @handler.second_before_call_order
+    end
+
+    should "run the handler's init and run methods" do
+      assert_equal 3, @handler.init_call_order
+      assert_equal 4, @handler.run_call_order
+    end
+
+    should "run the handler's after callbacks" do
+      assert_equal 5, @handler.first_after_call_order
+      assert_equal 6, @handler.second_after_call_order
+    end
+
+    should "set the content length header in its response" do
+      status, headers, body = *@response
+      exp = calc_content_length(body)
+      assert_equal exp, headers['Content-Length']
+    end
+
+    should "only set the content length if it is not already set" do
+      custom_content_length = Factory.integer.to_s
+      subject.headers['Content-Length'] = custom_content_length
+
+      headers  = @runner.run[1]
+      assert_equal custom_content_length, headers['Content-Length']
+    end
+
+    should "return its `to_rack` value" do
+      assert_equal subject_to_rack_with_content_length, @response
+    end
+
+  end
+
+  class RunWithInitHaltTests < InitHandlerTests
+    desc "with a handler that halts on init"
+    setup do
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'init'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
     end
-    subject{ @handler }
 
-    should "run the before and after hooks" do
-      assert_equal true, subject.before_called
-      assert_equal true, subject.after_called
+    should "run the before and after callbacks despite the halt" do
+      assert_not_nil @handler.first_before_call_order
+      assert_not_nil @handler.second_before_call_order
+      assert_not_nil @handler.first_after_call_order
+      assert_not_nil @handler.second_after_call_order
     end
 
-    should "run the handler's init and run" do
-      assert_equal true, subject.init_bang_called
-      assert_equal true, subject.run_bang_called
+    should "stop processing when the halt is called" do
+      assert_not_nil @handler.init_call_order
+      assert_nil @handler.run_call_order
     end
 
-    should "use the handler's run! return value as its response value" do
-      assert_equal true, @response_value
+    should "return its `to_rack` value despite the halt" do
+      assert_equal subject_to_rack_with_content_length, @response
+    end
+
+  end
+
+  class RunWithRunHaltTests < InitHandlerTests
+    desc "with a handler that halts on run"
+    setup do
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'run'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
+    end
+
+    should "run the before and after callbacks despite the halt" do
+      assert_not_nil @handler.first_before_call_order
+      assert_not_nil @handler.second_before_call_order
+      assert_not_nil @handler.first_after_call_order
+      assert_not_nil @handler.second_after_call_order
+    end
+
+    should "stop processing when the halt is called" do
+      assert_not_nil @handler.init_call_order
+      assert_not_nil @handler.run_call_order
+    end
+
+    should "return its `to_rack` value despite the halt" do
+      assert_equal subject_to_rack_with_content_length, @response
+    end
+
+  end
+
+  class RunWithBeforeHaltTests < InitHandlerTests
+    desc "with a handler that halts in a before callback"
+    setup do
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'before'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
+    end
+
+    should "stop processing when the halt is called" do
+      assert_not_nil @handler.first_before_call_order
+      assert_nil @handler.second_before_call_order
+    end
+
+    should "not run the after callbacks b/c of the halt" do
+      assert_nil @handler.first_after_call_order
+      assert_nil @handler.second_after_call_order
+    end
+
+    should "not run the handler's init and run b/c of the halt" do
+      assert_nil @handler.init_call_order
+      assert_nil @handler.run_call_order
+    end
+
+    should "return its `to_rack` value despite the halt" do
+      assert_equal subject_to_rack_with_content_length, @response
+    end
+
+  end
+
+  class RunWithAfterHaltTests < InitHandlerTests
+    desc "with a handler that halts in an after callback"
+    setup do
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'after'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
+    end
+
+    should "run the before callback despite the halt" do
+      assert_not_nil @handler.first_before_call_order
+      assert_not_nil @handler.second_before_call_order
+    end
+
+    should "run the handler's init and run despite the halt" do
+      assert_not_nil @handler.init_call_order
+      assert_not_nil @handler.run_call_order
+    end
+
+    should "stop processing when the halt is called" do
+      assert_not_nil @handler.first_after_call_order
+      assert_nil @handler.second_after_call_order
+    end
+
+    should "return its `to_rack` value despite the halt" do
+      assert_equal subject_to_rack_with_content_length, @response
     end
 
   end
@@ -72,7 +226,7 @@ class Deas::DeasRunner
   class NormalizedParamsTests < UnitTests
     desc "NormalizedParams"
     setup do
-      @norm_params_class = Deas::SinatraRunner::NormalizedParams
+      @norm_params_class = Deas::DeasRunner::NormalizedParams
     end
 
     should "be a normalized params subclass" do
@@ -95,4 +249,39 @@ class Deas::DeasRunner
 
   end
 
+  class TestViewHandler
+    include Deas::ViewHandler
+
+    attr_accessor :halt_in_before, :halt_in_after
+    attr_reader :first_before_call_order, :second_before_call_order
+    attr_reader :first_after_call_order, :second_after_call_order
+    attr_reader :init_call_order, :run_call_order
+
+    before{ @first_before_call_order = next_call_order; halt_if('before') }
+    before{ @second_before_call_order = next_call_order }
+
+    after{ @first_after_call_order = next_call_order; halt_if('after') }
+    after{ @second_after_call_order = next_call_order }
+
+    def init!
+      @init_call_order = next_call_order
+      halt_if('init')
+    end
+
+    def run!
+      @run_call_order = next_call_order
+      halt_if('run')
+      body Factory.integer(3).times.map{ Factory.text }
+    end
+
+    private
+
+    def next_call_order; @order ||= 0; @order += 1; end
+
+    def halt_if(value)
+      halt Factory.integer if params['halt'] == value
+    end
+
+  end
+
 end

data/test/unit/handler_proxy_tests.rb

@@ -2,8 +2,8 @@ require 'assert'
 require 'deas/handler_proxy'
 
 require 'deas/exceptions'
-require 'deas/sinatra_runner'
-require 'test/support/view_handlers'
+require 'deas/deas_runner'
+require 'test/support/empty_view_handler'
 
 class Deas::HandlerProxy
 
@@ -30,8 +30,8 @@ class Deas::HandlerProxy
   class RunTests < UnitTests
     desc "when run"
     setup do
-      @runner_spy = SinatraRunnerSpy.new
-      Assert.stub(Deas::SinatraRunner, :new) do |*args|
+      @runner_spy = RunnerSpy.new
+      Assert.stub(Deas::DeasRunner, :new) do |*args|
         @runner_spy.build(*args)
         @runner_spy
       end
@@ -40,21 +40,32 @@ class Deas::HandlerProxy
 
       @server_data       = Factory.server_data
       @fake_sinatra_call = Factory.sinatra_call
+      @fake_sinatra_call.params = {
+        :splat     => Factory.string,
+        'splat'    => Factory.string,
+        :captures  => [Factory.string],
+        'captures' => [Factory.string]
+      }
+
       @proxy.run(@server_data, @fake_sinatra_call)
     end
 
-    should "build and run a sinatra runner" do
+    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]
+      end
+    end
+
+    should "build and run a deas 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          => @server_data.logger,
         :router          => @server_data.router,
-        :template_source => @server_data.template_source
+        :template_source => @server_data.template_source,
+        :request         => @fake_sinatra_call.request,
+        :session         => @fake_sinatra_call.session,
+        :params          => @fake_sinatra_call.params
       }
       assert_equal exp_args, @runner_spy.args
 
@@ -82,13 +93,12 @@ class Deas::HandlerProxy
 
   end
 
-  class SinatraRunnerSpy
+  class RunnerSpy
 
     attr_reader :run_called
     attr_reader :handler_class, :handler, :args
-    attr_reader :sinatra_call
-    attr_reader :request, :response, :session, :params
     attr_reader :logger, :router, :template_source
+    attr_reader :request, :session, :params
 
     def initialize
       @run_called = false
@@ -99,14 +109,12 @@ class Deas::HandlerProxy
       @handler       = handler_class.new(self)
       @args          = 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]
+      @request         = args[:request]
+      @session         = args[:session]
+      @params          = args[:params]
     end
 
     def run