sanford 0.9.0 → 0.10.0

data/test/unit/host_tests.rb

@@ -15,7 +15,7 @@ module Sanford::Host
 
     should have_readers :configuration, :services
     should have_imeths :name, :ip, :port, :pid_file, :logger, :verbose_logging
-    should have_imeths :runner, :error, :init, :service_handler_ns, :service
+    should have_imeths :error, :init, :service_handler_ns, :service
 
     should "know its configuration" do
       assert_kind_of Configuration, subject.configuration
@@ -54,10 +54,6 @@ module Sanford::Host
       subject.receives_keep_alive true
       assert_equal true, subject.receives_keep_alive
       assert_equal subject.receives_keep_alive, subject.configuration.receives_keep_alive
-
-      subject.runner Sanford::DefaultRunner
-      assert_equal Sanford::DefaultRunner, subject.runner
-      assert_equal subject.runner, subject.configuration.runner
     end
 
     should "add error procs to the configuration" do
@@ -123,7 +119,7 @@ module Sanford::Host
     subject{ @configuration }
 
     should have_imeths :name, :ip, :port, :pid_file, :logger, :verbose_logging
-    should have_imeths :receives_keep_alive, :runner, :error_procs, :init_procs
+    should have_imeths :receives_keep_alive, :error_procs, :init_procs
 
     should "default name to the class name of the host" do
       assert_equal @host_class.name, subject.name
@@ -133,10 +129,9 @@ module Sanford::Host
       assert_equal '0.0.0.0', subject.ip
       assert_nil subject.port
       assert_nil subject.pid_file
-      assert_equal Sanford.config.logger, subject.logger
+      assert_equal Sanford.config.logger.class, subject.logger.class
       assert_true  subject.verbose_logging
       assert_false subject.receives_keep_alive
-      assert_equal Sanford.config.runner, subject.runner
       assert_empty subject.error_procs
       assert_empty subject.init_procs
     end

data/test/unit/hosts_tests.rb

@@ -0,0 +1,50 @@
+require 'assert'
+require 'sanford/hosts'
+
+require 'sanford/host'
+
+class Sanford::Hosts
+
+  class UnitTests < Assert::Context
+    desc "Sandford::Hosts"
+    setup do
+      @hosts = Sanford::Hosts.new
+    end
+    subject{ @hosts }
+
+    should have_instance_methods :add, :first, :find
+
+  end
+
+  class FindTests < UnitTests
+    desc "find method"
+    setup do
+      @hosts.add ::NotNamedHost
+      @hosts.add ::NamedHost
+      @hosts.add ::BadlyNamedHost
+    end
+
+    should "allow finding hosts by their class name or configured name" do
+      assert_includes ::NotNamedHost, subject
+      assert_includes ::NamedHost, subject
+
+      assert_equal ::NotNamedHost, subject.find('NotNamedHost')
+      assert_equal ::NamedHost, subject.find('NamedHost')
+      assert_equal ::NamedHost, subject.find('named_host')
+    end
+
+    should "prefer hosts with a matching class name over configured name" do
+      assert_includes ::BadlyNamedHost, subject
+      assert_equal NotNamedHost, subject.find('NotNamedHost')
+    end
+
+  end
+
+  # Using this syntax because these classes need to be defined as top-level
+  # constants for ease in using their class names in the tests
+
+  ::NotNamedHost   = Class.new{ include Sanford::Host }
+  ::NamedHost      = Class.new{ include Sanford::Host; name 'named_host' }
+  ::BadlyNamedHost = Class.new{ include Sanford::Host; name 'NotNamedHost' }
+
+end

data/test/unit/manager_tests.rb

@@ -112,7 +112,7 @@ module Sanford::Manager
 
     should have_imeths :pid, :to_s, :write, :remove
 
-    should "return it's path with #to_s" do
+    should "return its path with #to_s" do
       assert_equal @pid_file_path, subject.to_s
     end
 

data/test/unit/runner_tests.rb

@@ -1,7 +1,7 @@
 require 'assert'
 require 'sanford/runner'
 
-require 'test/support/services'
+require 'test/support/service_handlers'
 
 module Sanford::Runner
 
@@ -9,31 +9,26 @@ module Sanford::Runner
     desc "Sanford::Runner"
     setup do
       request = Sanford::Protocol::Request.new('test', {})
-      @runner = Sanford::DefaultRunner.new(BasicServiceHandler, request)
+      @runner_class = Class.new do
+        include Sanford::Runner
+      end
+      @runner = @runner_class.new(BasicServiceHandler, request)
     end
     subject{ @runner }
 
     should have_cmeths :run
-    should have_readers :handler_class, :request, :logger, :run
-
-    should "run the handler and return the response it generates when `run` is called" do
-      response = subject.run
-
-      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']
-    end
+    should have_readers :handler_class, :request, :logger, :handler
+    should have_imeths :init, :init!, :run, :run!
+    should have_imeths :halt, :catch_halt
 
-    should "be able to build a runner with a handler class and params" do
-      response = nil
-      assert_nothing_raised do
-        response = Sanford::DefaultRunner.run(BasicServiceHandler, {})
+    should "not implement the run behavior" do
+      assert_raises NotImplementedError do
+        subject.run
       end
-
-      assert_equal 200, response.code
     end
 
   end
 
+  # runner behavior tests are handled via system tests
+
 end

data/test/unit/sanford_runner_tests.rb

@@ -0,0 +1,66 @@
+require 'assert'
+require 'sanford/sanford_runner'
+
+require 'sanford/runner'
+require 'test/support/service_handlers'
+
+class Sanford::SanfordRunner
+
+  class UnitTests < Assert::Context
+    desc "Sanford::SanfordRunner"
+    setup do
+      @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
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @request = Sanford::Protocol::Request.new('test', {})
+      @runner = @runner_class.new(BasicServiceHandler, @request)
+    end
+    subject{ @runner }
+
+    should "run the handler and return the response it generates when run" do
+      response = subject.run
+
+      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']
+    end
+
+  end
+
+  class CallbackTests < InitTests
+    setup do
+      @runner = @runner_class.new(FlagServiceHandler, @request)
+    end
+
+    should "call handler `before` and `after` callbacks when run" do
+      subject.run
+
+      assert_true subject.handler.before_called
+      assert_true subject.handler.after_called
+    end
+
+  end
+
+  # live runner behavior tests are handled via system tests
+
+end

data/test/unit/sanford_tests.rb

@@ -1,7 +1,7 @@
 require 'assert'
 require 'sanford'
 
-require 'ns-options/proxy'
+require 'sanford/config'
 
 module Sanford
 
@@ -11,60 +11,10 @@ module Sanford
 
     should have_imeths :config, :configure, :init, :register, :hosts
 
-  end
-
-  class ConfigTests < UnitTests
-    desc "Config"
-    subject{ Sanford::Config }
-
-    should have_imeths :services_file, :logger, :runner
-
-    should "be an NsOptions::Proxy" do
-      assert_includes NsOptions::Proxy, subject
-    end
-
-  end
-
-  class HostsTests < UnitTests
-    desc "Hosts"
-    setup do
-      @hosts = Sanford::Hosts.new
-    end
-    subject{ @hosts }
-
-    should have_instance_methods :add, :first, :find
-
-  end
-
-  class FindTests < HostsTests
-    desc "find method"
-    setup do
-      @hosts.add ::NotNamedHost
-      @hosts.add ::NamedHost
-      @hosts.add ::BadlyNamedHost
-    end
-
-    should "allow finding hosts by their class name or configured name" do
-      assert_includes ::NotNamedHost, subject
-      assert_includes ::NamedHost, subject
-
-      assert_equal ::NotNamedHost, subject.find('NotNamedHost')
-      assert_equal ::NamedHost, subject.find('NamedHost')
-      assert_equal ::NamedHost, subject.find('named_host')
-    end
-
-    should "prefer hosts with a matching class name over configured name" do
-      assert_includes ::BadlyNamedHost, subject
-      assert_equal NotNamedHost, subject.find('NotNamedHost')
+    should "return a `Config` instance with the `config` method" do
+      assert_kind_of Sanford::Config, subject.config
     end
 
   end
 
-  # Using this syntax because these classes need to be defined as top-level
-  # constants for ease in using their class names in the tests
-
-  ::NotNamedHost   = Class.new{ include Sanford::Host }
-  ::NamedHost      = Class.new{ include Sanford::Host; name 'named_host' }
-  ::BadlyNamedHost = Class.new{ include Sanford::Host; name 'NotNamedHost' }
-
 end

data/test/unit/server_tests.rb

@@ -1,8 +1,6 @@
 require 'assert'
 require 'sanford/server'
 
-require 'test/support/services'
-
 class Sanford::Server
 
   class UnitTests < Assert::Context
@@ -19,7 +17,7 @@ class Sanford::Server
       assert_includes DatTCP::Server, subject.class
     end
 
-    should "save it's host and host options but not initialize a host data yet" do
+    should "save its host and host options but not initialize a host data yet" do
       assert_equal TestHost, subject.sanford_host
       assert_equal true, subject.sanford_host_options[:receives_keep_alive]
       assert_nil subject.sanford_host_data

data/test/unit/service_handler_tests.rb

@@ -17,10 +17,13 @@ module Sanford::ServiceHandler
     subject{ @handler_class }
 
     should have_imeths :run
+    should have_imeths :before_callbacks, :after_callbacks
     should have_imeths :before_init_callbacks, :after_init_callbacks
     should have_imeths :before_run_callbacks,  :after_run_callbacks
+    should have_imeths :before, :after
     should have_imeths :before_init, :after_init
     should have_imeths :before_run,  :after_run
+    should have_imeths :prepend_before, :prepend_after
     should have_imeths :prepend_before_init, :prepend_after_init
     should have_imeths :prepend_before_run,  :prepend_after_run
 
@@ -33,6 +36,14 @@ module Sanford::ServiceHandler
       assert_equal true,  response.data
     end
 
+    should "return an empty array by default using `before_callbacks`" do
+      assert_equal [], subject.before_callbacks
+    end
+
+    should "return an empty array by default using `after_callbacks`" do
+      assert_equal [], subject.after_callbacks
+    end
+
     should "return an empty array by default using `before_init_callbacks`" do
       assert_equal [], subject.before_init_callbacks
     end
@@ -49,6 +60,20 @@ module Sanford::ServiceHandler
       assert_equal [], subject.after_run_callbacks
     end
 
+    should "append a block to the before callbacks using `before`" do
+      subject.before_callbacks << proc{ }
+      block = Proc.new{}
+      subject.before(&block)
+      assert_equal block, subject.before_callbacks.last
+    end
+
+    should "append a block to the after callbacks using `after`" do
+      subject.after_callbacks << proc{ }
+      block = Proc.new{}
+      subject.after(&block)
+      assert_equal block, subject.after_callbacks.last
+    end
+
     should "append a block to the before init callbacks using `before_init`" do
       subject.before_init_callbacks << proc{ }
       block = Proc.new{}
@@ -77,6 +102,20 @@ module Sanford::ServiceHandler
       assert_equal block, subject.after_run_callbacks.last
     end
 
+    should "prepend a block to the before callbacks using `prepend_before`" do
+      subject.before_callbacks << proc{ }
+      block = Proc.new{}
+      subject.prepend_before(&block)
+      assert_equal block, subject.before_callbacks.first
+    end
+
+    should "prepend a block to the after callbacks using `prepend_after`" do
+      subject.after_callbacks << proc{ }
+      block = Proc.new{}
+      subject.prepend_after(&block)
+      assert_equal block, subject.after_callbacks.first
+    end
+
     should "prepend a block to the before init callbacks using `prepend_before_init`" do
       subject.before_init_callbacks << proc{ }
       block = Proc.new{}
@@ -121,21 +160,25 @@ module Sanford::ServiceHandler
       assert_raises(NotImplementedError){ handler.run! }
     end
 
-    should "have called `init!` and it's callbacks" do
+    should "not call `before` callbacks when using a test runner" do
+      assert_nil subject.before_called
+    end
+
+    should "have called `init!` and its callbacks" do
       assert_true subject.before_init_called
       assert_true subject.second_before_init_called
       assert_true subject.init_bang_called
       assert_true subject.after_init_called
     end
 
-    should "not have called `run!` or it's callbacks when initialized" do
+    should "not have called `run!` or its callbacks when initialized" do
       assert_nil subject.before_run_called
       assert_nil subject.run_bang_called
       assert_nil subject.after_run_called
       assert_nil subject.second_after_run_called
     end
 
-    should "call `run!` and it's callbacks when it's `run`" do
+    should "call `run!` and its callbacks when its run" do
       subject.run
 
       assert_true subject.before_run_called
@@ -144,15 +187,11 @@ module Sanford::ServiceHandler
       assert_true subject.second_after_run_called
     end
 
-  end
-
-  class RunHandlerTests < UnitTests
-    desc "run_handler helper"
-
-    should "allow easily running another handler" do
-      response = test_runner(RunOtherHandler).run
-      assert_equal 'RunOtherHandler', response.data
+    should "not call `after` callbacks when run using a test runner" do
+      subject.run
+      assert_nil subject.after_called
     end
+
   end
 
   class HaltTests < UnitTests
@@ -203,7 +242,7 @@ module Sanford::ServiceHandler
       assert_equal 'before_init halting', response.status.message
     end
 
-    should "not call `after_init`, `run!` or it's callbacks when `init!` halts" do
+    should "not call `after_init`, `run!` or its callbacks when `init!` halts" do
       runner = test_runner(HaltingBehaviorServiceHandler, {
         'when' => 'init!'
       })
@@ -219,7 +258,7 @@ module Sanford::ServiceHandler
       assert_equal 'init! halting', response.status.message
     end
 
-    should "not call `run!` or it's callbacks when `after_init` halts" do
+    should "not call `run!` or its callbacks when `after_init` halts" do
       runner = test_runner(HaltingBehaviorServiceHandler, {
         'when' => 'after_init'
       })
@@ -285,6 +324,26 @@ module Sanford::ServiceHandler
 
   end
 
+  class RenderHandlerTests < UnitTests
+    desc "render helper method"
+
+    should "render template files" do
+      response = test_runner(RenderHandler).run
+      assert_equal ['test_template', 'RenderHandler', {}], response.data
+    end
+
+  end
+
+  class RunHandlerTests < UnitTests
+    desc "run_handler helper"
+
+    should "allow easily running another handler" do
+      response = test_runner(RunOtherHandler).run
+      assert_equal 'RunOtherHandler', response.data
+    end
+
+  end
+
   class InvalidHandlerTests < UnitTests
     desc "that is invalid"
 

data/test/unit/template_engine_tests.rb

@@ -0,0 +1,76 @@
+require 'assert'
+require 'sanford/template_engine'
+
+require 'pathname'
+require 'test/support/factory'
+
+class Sanford::TemplateEngine
+
+  class UnitTests < Assert::Context
+    desc "Sanford::TemplateEngine"
+    setup do
+      @source_path = Factory.path
+      @path = Factory.path
+      @service_handler = 'a-service-handler'
+      @locals = {}
+      @engine = Sanford::TemplateEngine.new('some' => 'opts')
+    end
+    subject{ @engine }
+
+    should have_readers :source_path, :opts
+    should have_imeths :render
+
+    should "default its source path" do
+      assert_equal Pathname.new(nil.to_s), subject.source_path
+    end
+
+    should "allow custom source paths" do
+      engine = Sanford::TemplateEngine.new('source_path' => @source_path)
+      assert_equal Pathname.new(@source_path.to_s), engine.source_path
+    end
+
+    should "default the opts if none given" do
+      exp_opts = {}
+      assert_equal exp_opts, Sanford::TemplateEngine.new.opts
+    end
+
+    should "allow custom opts" do
+      exp_opts = {'some' => 'opts'}
+      assert_equal exp_opts, subject.opts
+    end
+
+    should "raise NotImplementedError on `render`" do
+      assert_raises NotImplementedError do
+        subject.render(@path, @service_handler, @locals)
+      end
+    end
+
+  end
+
+  class NullTemplateEngineTests < Assert::Context
+    desc "Sanford::NullTemplateEngine"
+    setup do
+      @engine = Sanford::NullTemplateEngine.new('source_path' => ROOT)
+    end
+    subject{ @engine }
+
+    should "be a TemplateEngine" do
+      assert_kind_of Sanford::TemplateEngine, subject
+    end
+
+    should "read and return the given path in its source path on `render" do
+      exists_file = 'test/support/template.json'
+      exp = File.read(subject.source_path.join(exists_file).to_s)
+      assert_equal exp, subject.render(exists_file, @service_handler, @locals)
+    end
+
+    should "complain if given a path that does not exist in its source path" do
+      no_exists_file = '/does/not/exists'
+      assert_raises ArgumentError do
+        subject.render(no_exists_file, @service_handler, @locals)
+      end
+    end
+
+  end
+
+end

data/test/unit/template_source_tests.rb

@@ -0,0 +1,75 @@
+require 'assert'
+require 'sanford/template_source'
+
+require 'sanford/template_engine'
+
+class Sanford::TemplateSource
+
+  class UnitTests < Assert::Context
+    desc "Sanford::TemplateSource"
+    setup do
+      @source_path = File.join(ROOT, 'test/support')
+      @source = Sanford::TemplateSource.new(@source_path)
+    end
+    subject{ @source }
+
+    should have_readers :path, :engines
+    should have_imeths :engine
+
+    should "know its path" do
+      assert_equal @source_path.to_s, subject.path
+    end
+
+  end
+
+  class EngineRegistrationTests < UnitTests
+    desc "when registering an engine"
+    setup do
+      @empty_engine = Class.new(Sanford::TemplateEngine) do
+        def render(path, scope); ''; end
+      end
+    end
+
+    should "allow registering new engines" do
+      assert_kind_of Sanford::NullTemplateEngine, subject.engines['empty']
+      subject.engine 'empty', @empty_engine
+      assert_kind_of @empty_engine, subject.engines['empty']
+    end
+
+    should "register with the source path as a default option" do
+      subject.engine 'empty', @empty_engine
+      exp_opts = { 'source_path' => subject.path }
+      assert_equal exp_opts, subject.engines['empty'].opts
+
+      subject.engine 'empty', @empty_engine, 'an' => 'opt'
+      exp_opts = {
+        'source_path' => subject.path,
+        'an' => 'opt'
+      }
+      assert_equal exp_opts, subject.engines['empty'].opts
+
+      subject.engine 'empty', @empty_engine, 'source_path' => 'something'
+      exp_opts = { 'source_path' => 'something' }
+      assert_equal exp_opts, subject.engines['empty'].opts
+    end
+
+  end
+
+  class NullTemplateSourceTests < Assert::Context
+    desc "Sanford::NullTemplateSource"
+    setup do
+      @source = Sanford::NullTemplateSource.new
+    end
+    subject{ @source }
+
+    should "be a template source" do
+      assert_kind_of Sanford::TemplateSource, subject
+    end
+
+    should "have an empty path string" do
+      assert_equal '', subject.path
+    end
+
+  end
+
+end