sanford 0.10.1 → 0.11.0

data/test/unit/runner_tests.rb

@@ -1,34 +1,80 @@
 require 'assert'
 require 'sanford/runner'
 
-require 'test/support/service_handlers'
+require 'sanford/server_data'
+require 'sanford/service_handler'
 
-module Sanford::Runner
+class Sanford::Runner
 
   class UnitTests < Assert::Context
     desc "Sanford::Runner"
     setup do
-      request = Sanford::Protocol::Request.new('test', {})
-      @runner_class = Class.new do
-        include Sanford::Runner
-      end
-      @runner = @runner_class.new(BasicServiceHandler, request)
+      @handler_class = TestServiceHandler
+
+      @runner_class = Sanford::Runner
+    end
+    subject{ @runner_class }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @runner = @runner_class.new(@handler_class)
     end
     subject{ @runner }
 
-    should have_cmeths :run
-    should have_readers :handler_class, :request, :logger, :handler
-    should have_imeths :init, :init!, :run, :run!
-    should have_imeths :halt, :catch_halt
+    should have_readers :handler_class, :handler
+    should have_readers :request, :params, :logger, :template_source
+    should have_imeths :run
+    should have_imeths :halt
 
-    should "not implement the run behavior" do
-      assert_raises NotImplementedError do
-        subject.run
+    should "know its handler class and handler" do
+      assert_equal @handler_class, subject.handler_class
+      assert_instance_of @handler_class, subject.handler
+    end
+
+    should "not set its request, params, logger or template source" do
+      assert_nil subject.request
+      assert_nil subject.params
+      assert_nil subject.logger
+      assert_nil subject.template_source
+    end
+
+    should "throw halt with response args using `halt`" do
+      code = Factory.integer
+      message = Factory.string
+      data = Factory.string
+
+      result = catch(:halt) do
+        subject.halt(code, :message => message, :data => data)
       end
+      assert_instance_of ResponseArgs, result
+      assert_equal [ code, message ], result.status
+      assert_equal data, result.data
+    end
+
+    should "accept string keys using `halt`" do
+      code = Factory.integer
+      message = Factory.string
+      data = Factory.string
+
+      result = catch(:halt) do
+        subject.halt(code, 'message' => message, 'data' => data)
+      end
+      assert_instance_of ResponseArgs, result
+      assert_equal [ code, message ], result.status
+      assert_equal data, result.data
+    end
+
+    should "raise a not implemented error when run" do
+      assert_raises(NotImplementedError){ subject.run }
     end
 
   end
 
-  # runner behavior tests are handled via system tests
+  class TestServiceHandler
+    include Sanford::ServiceHandler
+  end
 
 end

data/test/unit/sanford_runner_tests.rb

@@ -1,29 +1,29 @@
 require 'assert'
 require 'sanford/sanford_runner'
 
-require 'sanford/runner'
-require 'test/support/service_handlers'
+require 'sanford/server_data'
+require 'sanford/service_handler'
 
 class Sanford::SanfordRunner
 
   class UnitTests < Assert::Context
     desc "Sanford::SanfordRunner"
     setup do
+      @handler_class = TestServiceHandler
+      @request = Sanford::Protocol::Request.new(Factory.string, {
+        :something => Factory.string
+      })
+      @server_data = Sanford::ServerData.new({
+        :logger => Factory.string,
+        :template_source => Factory.string
+      })
+
       @runner_class = Sanford::SanfordRunner
     end
     subject{ @runner_class }
 
-    should "be a Runner" do
-      assert_includes Sanford::Runner, subject
-    end
-
-    should "be able to build a runner with a handler class and params and run it" do
-      response = nil
-      assert_nothing_raised do
-        response = subject.run(BasicServiceHandler, {})
-      end
-
-      assert_equal 200, response.code
+    should "be a runner" do
+      assert_true subject < Sanford::Runner
     end
 
   end
@@ -31,36 +31,170 @@ class Sanford::SanfordRunner
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @request = Sanford::Protocol::Request.new('test', {})
-      @runner = @runner_class.new(BasicServiceHandler, @request)
+      @runner = @runner_class.new(@handler_class, @request, @server_data)
     end
     subject{ @runner }
 
-    should "run the handler and return the response it generates when run" do
-      response = subject.run
+    should "know its request, params, logger and template source" do
+      assert_equal @request, subject.request
+      assert_equal @request.params, subject.params
+      assert_equal @server_data.logger, subject.logger
+      assert_equal @server_data.template_source, subject.template_source
+    end
+
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @handler = @runner.handler
+      @response = @runner.run
+    end
+    subject{ @response }
+
+    should "run the handlers 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
+      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
 
-      assert_instance_of Sanford::Protocol::Response, response
-      assert_equal 200, response.code
-      assert_equal 'Joe Test', response.data['name']
-      assert_equal 'joe.test@example.com',  response.data['email']
+    should "run the handlers after callbacks" do
+      assert_equal 5, @handler.first_after_call_order
+      assert_equal 6, @handler.second_after_call_order
     end
 
   end
 
-  class CallbackTests < InitTests
+  class RunHaltInBeforeTests < UnitTests
+    desc "running a handler that halts in a before callback"
     setup do
-      @runner = @runner_class.new(FlagServiceHandler, @request)
+      req = Sanford::Protocol::Request.new(Factory.string, 'halt' => 'before')
+      runner = @runner_class.new(@handler_class, req, @server_data).tap(&:run)
+      @handler = runner.handler
+    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
     end
 
-    should "call handler `before` and `after` callbacks when run" do
-      subject.run
+  end
 
-      assert_true subject.handler.before_called
-      assert_true subject.handler.after_called
+  class RunHandlerHaltInitTests < UnitTests
+    desc "running a handler that halts in init"
+    setup do
+      req = Sanford::Protocol::Request.new(Factory.string, 'halt' => 'init')
+      runner = @runner_class.new(@handler_class, req, @server_data).tap(&:run)
+      @handler = runner.handler
+    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
     end
 
   end
 
-  # live runner behavior tests are handled via system tests
+  class RunHandlerHaltRunTests < UnitTests
+    desc "running a handler that halts in run"
+    setup do
+      req = Sanford::Protocol::Request.new(Factory.string, 'halt' => 'run')
+      runner = @runner_class.new(@handler_class, req, @server_data).tap(&:run)
+      @handler = runner.handler
+    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_nil subject.first_after_call_order
+      assert_nil subject.second_after_call_order
+    end
+
+  end
+
+  class RunHandlerHaltAfterTests < UnitTests
+    desc "running a handler that halts in a after callback"
+    setup do
+      req = Sanford::Protocol::Request.new(Factory.string, 'halt' => 'after')
+      runner = @runner_class.new(@handler_class, req, @server_data).tap(&:run)
+      @handler = runner.handler
+    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
+    end
+
+  end
+
+  class TestServiceHandler
+    include Sanford::ServiceHandler
+
+    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
+    attr_reader :response_data
+
+    before do
+      @first_before_call_order = next_call_order
+      halt_if('before')
+    end
+    before{ @second_before_call_order = next_call_order }
+
+    after do
+      @first_after_call_order = next_call_order
+      halt_if('after')
+    end
+    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')
+      @response_data ||= Factory.string
+    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/sanford_tests.rb

@@ -1,20 +1,12 @@
 require 'assert'
 require 'sanford'
 
-require 'sanford/config'
-
 module Sanford
 
   class UnitTests < Assert::Context
     desc "Sanford"
     subject{ Sanford }
 
-    should have_imeths :config, :configure, :init, :register, :hosts
-
-    should "return a `Config` instance with the `config` method" do
-      assert_kind_of Sanford::Config, subject.config
-    end
-
   end
 
 end

data/test/unit/server_data_tests.rb

@@ -0,0 +1,87 @@
+require 'assert'
+require 'sanford/server_data'
+
+require 'sanford/route'
+
+class Sanford::ServerData
+
+  class UnitTests < Assert::Context
+    desc "Sanford::ServerData"
+    setup do
+      @name = Factory.string
+      @ip = Factory.string
+      @port = Factory.integer
+      @pid_file = Factory.file_path
+      @logger = Factory.string
+      @verbose_logging = Factory.boolean
+      @receives_keep_alive = Factory.boolean
+      @error_procs = [ proc{ } ]
+      @route = Sanford::Route.new(Factory.string, TestHandler.to_s).tap(&:validate!)
+
+      @server_data = Sanford::ServerData.new({
+        :name => @name,
+        :ip => @ip,
+        :port => @port,
+        :pid_file => @pid_file,
+        :logger => @logger,
+        :verbose_logging => @verbose_logging,
+        :receives_keep_alive => @receives_keep_alive,
+        :error_procs => @error_procs,
+        :routes => [ @route ]
+      })
+    end
+    subject{ @server_data }
+
+    should have_readers :name
+    should have_readers :ip, :port
+    should have_readers :pid_file
+    should have_readers :logger, :verbose_logging
+    should have_readers :receives_keep_alive
+    should have_readers :error_procs
+    should have_readers :routes
+
+    should "know its attributes" do
+      assert_equal @name, subject.name
+      assert_equal @ip, subject.ip
+      assert_equal @port, subject.port
+      assert_equal @pid_file, subject.pid_file
+      assert_equal @logger, subject.logger
+      assert_equal @verbose_logging, subject.verbose_logging
+      assert_equal @receives_keep_alive, subject.receives_keep_alive
+      assert_equal @error_procs, subject.error_procs
+    end
+
+    should "build a routes lookup hash" do
+      expected = { @route.name => @route }
+      assert_equal expected, subject.routes
+    end
+
+    should "allow lookup a route using `route_for`" do
+      route = subject.route_for(@route.name)
+      assert_equal @route, route
+    end
+
+    should "raise a not found error using `route_for` with an invalid name" do
+      assert_raises(Sanford::NotFoundError) do
+        subject.route_for(Factory.string)
+      end
+    end
+
+    should "default its attributes when they aren't provided" do
+      server_data = Sanford::ServerData.new
+      assert_nil server_data.name
+      assert_nil server_data.ip
+      assert_nil server_data.port
+      assert_nil server_data.pid_file
+      assert_nil server_data.logger
+      assert_false server_data.verbose_logging
+      assert_false server_data.receives_keep_alive
+      assert_equal [], server_data.error_procs
+      assert_equal({}, server_data.routes)
+    end
+
+  end
+
+  TestHandler = Class.new
+
+end