sanford 0.15.1 → 0.16.0

data/test/unit/sanford_runner_tests.rb

@@ -10,7 +10,7 @@ class Sanford::SanfordRunner
     desc "Sanford::SanfordRunner"
     setup do
       @handler_class = TestServiceHandler
-      @runner_class = Sanford::SanfordRunner
+      @runner_class  = Sanford::SanfordRunner
     end
     subject{ @runner_class }
 
@@ -34,113 +34,149 @@ class Sanford::SanfordRunner
   class RunTests < InitTests
     desc "and run"
     setup do
-      @handler = @runner.handler
+      @handler  = @runner.handler
       @response = @runner.run
     end
-    subject{ @response }
 
-    should "run the handlers before callbacks" do
+    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 handlers init" do
+    should "run the handler's init and run methods" do
       assert_equal 3, @handler.init_call_order
-    end
-
-    should "run the handlers run and use its result to build a response" do
       assert_equal 4, @handler.run_call_order
-      assert_instance_of Sanford::Protocol::Response, subject
-      assert_equal @handler.response_data, subject.data
     end
 
-    should "run the handlers after callbacks" do
+    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 "return its `to_response` value" do
+      assert_equal subject.to_response, @response
+    end
+
   end
 
-  class RunHaltInBeforeTests < UnitTests
-    desc "running a handler that halts in a before callback"
+  class RunWithInitHaltTests < UnitTests
+    desc "with a handler that halts on init"
     setup do
-      runner = @runner_class.new(@handler_class, :params => {
-        'halt' => 'before'
-      }).tap(&:run)
-      @handler = runner.handler
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'init'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
+    end
+    subject{ @runner }
+
+    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
-    subject{ @handler }
 
     should "stop processing when the halt is called" do
-      assert_not_nil subject.first_before_call_order
-      assert_nil subject.second_before_call_order
-      assert_nil subject.init_call_order
-      assert_nil subject.run_call_order
-      assert_nil subject.first_after_call_order
-      assert_nil subject.second_after_call_order
+      assert_not_nil @handler.init_call_order
+      assert_nil @handler.run_call_order
+    end
+
+    should "return its `to_response` value despite the halt" do
+      assert_equal subject.to_response, @response
     end
 
   end
 
-  class RunHandlerHaltInitTests < UnitTests
-    desc "running a handler that halts in init"
+  class RunWithRunHaltTests < UnitTests
+    desc "when run with a handler that halts on run"
     setup do
-      runner = @runner_class.new(@handler_class, :params => {
-        'halt' => 'init'
-      }).tap(&:run)
-      @handler = runner.handler
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'run'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
+    end
+    subject{ @runner }
+
+    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
-    subject{ @handler }
 
     should "stop processing when the halt is called" do
-      assert_not_nil subject.first_before_call_order
-      assert_not_nil subject.second_before_call_order
-      assert_not_nil subject.init_call_order
-      assert_nil subject.run_call_order
-      assert_nil subject.first_after_call_order
-      assert_nil subject.second_after_call_order
+      assert_not_nil @handler.init_call_order
+      assert_not_nil @handler.run_call_order
+    end
+
+    should "return its `to_response` value despite the halt" do
+      assert_equal subject.to_response, @response
     end
 
   end
 
-  class RunHandlerHaltRunTests < UnitTests
-    desc "running a handler that halts in run"
+  class RunWithBeforeHaltTests < UnitTests
+    desc "when run with a handler that halts in an after callback"
     setup do
-      runner = @runner_class.new(@handler_class, :params => {
-        'halt' => 'run'
-      }).tap(&:run)
-      @handler = runner.handler
+      @runner = @runner_class.new(@handler_class, :params => {
+        'halt' => 'before'
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
     end
-    subject{ @handler }
+    subject{ @runner }
 
     should "stop processing when the halt is called" do
-      assert_not_nil subject.first_before_call_order
-      assert_not_nil subject.second_before_call_order
-      assert_not_nil subject.init_call_order
-      assert_not_nil subject.run_call_order
-      assert_nil subject.first_after_call_order
-      assert_nil subject.second_after_call_order
+      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_response` value despite the halt" do
+      assert_equal subject.to_response, @response
     end
 
   end
 
-  class RunHandlerHaltAfterTests < UnitTests
-    desc "running a handler that halts in a after callback"
+  class RunWithAfterHaltTests < UnitTests
+    desc "when run with a handler that halts in an after callback"
     setup do
-      runner = @runner_class.new(@handler_class, :params => {
+      @runner = @runner_class.new(@handler_class, :params => {
         'halt' => 'after'
-      }).tap(&:run)
-      @handler = runner.handler
+      })
+      @handler  = @runner.handler
+      @response = @runner.run
+    end
+    subject{ @runner }
+
+    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
-    subject{ @handler }
 
     should "stop processing when the halt is called" do
-      assert_not_nil subject.first_before_call_order
-      assert_not_nil subject.second_before_call_order
-      assert_not_nil subject.init_call_order
-      assert_not_nil subject.run_call_order
-      assert_not_nil subject.first_after_call_order
-      assert_nil subject.second_after_call_order
+      assert_not_nil @handler.first_after_call_order
+      assert_nil @handler.second_after_call_order
+    end
+
+    should "return its `to_response` value despite the halt" do
+      assert_equal subject.to_response, @response
     end
 
   end
@@ -159,7 +195,11 @@ class Sanford::SanfordRunner
     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 init!
+      @init_call_order = next_call_order
+      halt_if('init')
+    end
+
     def run!
       @run_call_order = next_call_order
       halt_if('run')
@@ -169,9 +209,11 @@ class Sanford::SanfordRunner
     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/server_data_tests.rb

@@ -15,22 +15,22 @@ class Sanford::ServerData
 
       @route = Sanford::Route.new(Factory.string, TestHandler.to_s).tap(&:validate!)
       @config_hash = {
-        :name                  => Factory.string,
-        :ip                    => Factory.string,
-        :port                  => Factory.integer,
-        :pid_file              => Factory.file_path,
-        :receives_keep_alive   => Factory.boolean,
-        :verbose_logging       => Factory.boolean,
-        :logger                => Factory.string,
-        :template_source       => Factory.string,
-        :init_procs            => Factory.integer(3).times.map{ proc{} },
-        :error_procs           => Factory.integer(3).times.map{ proc{} },
-        :worker_start_procs    => Factory.integer(3).times.map{ proc{} },
-        :worker_shutdown_procs => Factory.integer(3).times.map{ proc{} },
-        :worker_sleep_procs    => Factory.integer(3).times.map{ proc{} },
-        :worker_wakeup_procs   => Factory.integer(3).times.map{ proc{} },
-        :router                => Factory.string,
-        :routes                => [@route]
+        :name                => Factory.string,
+        :ip                  => Factory.string,
+        :port                => Factory.integer,
+        :pid_file            => Factory.file_path,
+        :receives_keep_alive => Factory.boolean,
+        :worker_class        => Class.new,
+        :worker_params       => { Factory.string => Factory.string },
+        :num_workers         => Factory.integer,
+        :verbose_logging     => Factory.boolean,
+        :logger              => Factory.string,
+        :template_source     => Factory.string,
+        :shutdown_timeout    => Factory.integer,
+        :init_procs          => Factory.integer(3).times.map{ proc{} },
+        :error_procs         => Factory.integer(3).times.map{ proc{} },
+        :router              => Factory.string,
+        :routes              => [@route]
       }
       @server_data = Sanford::ServerData.new(@config_hash)
     end
@@ -43,10 +43,10 @@ class Sanford::ServerData
     should have_readers :name
     should have_readers :pid_file
     should have_readers :receives_keep_alive
-    should have_readers :verbose_logging, :logger, :template_source
+    should have_readers :worker_class, :worker_params, :num_workers
+    should have_readers :debug, :logger, :dtcp_logger, :verbose_logging
+    should have_readers :template_source, :shutdown_timeout
     should have_readers :init_procs, :error_procs
-    should have_readers :worker_start_procs, :worker_shutdown_procs
-    should have_readers :worker_sleep_procs, :worker_wakeup_procs
     should have_readers :router, :routes
     should have_accessors :ip, :port
 
@@ -59,18 +59,20 @@ class Sanford::ServerData
 
       assert_equal h[:receives_keep_alive], subject.receives_keep_alive
 
+      assert_equal h[:worker_class],  subject.worker_class
+      assert_equal h[:worker_params], subject.worker_params
+      assert_equal h[:num_workers],   subject.num_workers
+
       assert_equal h[:verbose_logging], subject.verbose_logging
       assert_equal h[:logger],          subject.logger
+
       assert_equal h[:template_source], subject.template_source
 
+      assert_equal h[:shutdown_timeout], subject.shutdown_timeout
+
       assert_equal h[:init_procs],  subject.init_procs
       assert_equal h[:error_procs], subject.error_procs
 
-      assert_equal h[:worker_start_procs],    subject.worker_start_procs
-      assert_equal h[:worker_shutdown_procs], subject.worker_shutdown_procs
-      assert_equal h[:worker_sleep_procs],    subject.worker_sleep_procs
-      assert_equal h[:worker_wakeup_procs],   subject.worker_wakeup_procs
-
       assert_equal h[:router], subject.router
     end
 
@@ -113,9 +115,16 @@ class Sanford::ServerData
 
       assert_false server_data.receives_keep_alive
 
+      assert_nil server_data.worker_class
+      assert_equal({}, server_data.worker_params)
+      assert_nil server_data.num_workers
+
       assert_false server_data.verbose_logging
       assert_nil   server_data.logger
-      assert_nil   server_data.template_source
+
+      assert_nil server_data.template_source
+
+      assert_nil server_data.shutdown_timeout
 
       assert_equal [], server_data.init_procs
       assert_equal [], server_data.error_procs