sanford 0.8.0 → 0.9.0

data/test/unit/error_handler_tests.rb

@@ -1,8 +1,9 @@
 require 'assert'
+require 'sanford/error_handler'
 
 class Sanford::ErrorHandler
 
-  class BaseTests < Assert::Context
+  class UnitTests < Assert::Context
     desc "Sanford::ErrorHandler"
     setup do
       @exception = RuntimeError.new('test')
@@ -11,7 +12,7 @@ class Sanford::ErrorHandler
     end
     subject{ @error_handler }
 
-    should have_instance_methods :exception, :host_data, :request, :run
+    should have_imeths :exception, :host_data, :request, :run
 
     should "return a Sanford::Protocol::Response with `run`" do
       assert_instance_of Sanford::Protocol::Response, subject.run
@@ -28,7 +29,7 @@ class Sanford::ErrorHandler
 
   end
 
-  class ResponseFromProcTests < BaseTests
+  class ResponseFromProcTests < UnitTests
     desc "generating a respone from an error proc"
     setup do
       @host_defaults = { :ip => "localhost", :port => 8000 }
@@ -43,9 +44,9 @@ class Sanford::ErrorHandler
       }))
       response = Sanford::ErrorHandler.new(@exception, host_data).run
 
-      assert_equal 567,               response.code
-      assert_equal 'custom message',  response.status.message
-      assert_equal 'custom data',     response.data
+      assert_equal 567, response.code
+      assert_equal 'custom message', response.status.message
+      assert_equal 'custom data', response.data
     end
 
     should "use an integer returned by the error proc to generate a protocol response" do
@@ -76,12 +77,12 @@ class Sanford::ErrorHandler
       }))
       response = Sanford::ErrorHandler.new(@exception, host_data).run
 
-      assert_equal 500,                             response.code
+      assert_equal 500, response.code
       assert_equal 'An unexpected error occurred.', response.status.message
     end
 
     should "use the default behavior for an exception raised by the error proc " \
-      "and ignore the original exception" do
+           "and ignore the original exception" do
       host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
         :error_procs => [ proc{ raise Sanford::NotFoundError } ]
       }))
@@ -94,14 +95,14 @@ class Sanford::ErrorHandler
 
   end
 
-  class ResponseFromExceptionTests < BaseTests
+  class ResponseFromExceptionTests < UnitTests
     desc "generating a respone from an exception"
 
     should "build a 400 response with a protocol BadMessageError" do
       exception = generate_exception(Sanford::Protocol::BadMessageError, 'bad message')
       response = Sanford::ErrorHandler.new(exception, @host_data).run
 
-      assert_equal 400,           response.code
+      assert_equal 400, response.code
       assert_equal 'bad message', response.status.message
     end
 
@@ -109,7 +110,7 @@ class Sanford::ErrorHandler
       exception = generate_exception(Sanford::Protocol::BadRequestError, 'bad request')
       response = Sanford::ErrorHandler.new(exception, @host_data).run
 
-      assert_equal 400,           response.code
+      assert_equal 400, response.code
       assert_equal 'bad request', response.status.message
     end
 
@@ -124,7 +125,7 @@ class Sanford::ErrorHandler
     should "build a 500 response with all other exceptions" do
       response = Sanford::ErrorHandler.new(RuntimeError.new('test'), @host_data).run
 
-      assert_equal 500,                             response.code
+      assert_equal 500, response.code
       assert_equal 'An unexpected error occurred.', response.status.message
     end
 

data/test/unit/host_data_tests.rb

@@ -1,8 +1,11 @@
 require 'assert'
+require 'sanford/host_data'
+
+require 'test/support/services'
 
 class Sanford::HostData
 
-  class BaseTests < Assert::Context
+  class UnitTests < Assert::Context
     desc "Sanford::HostData"
     setup do
       TestHost.init_has_been_called = false
@@ -13,14 +16,27 @@ class Sanford::HostData
     end
     subject{ @host_data }
 
-    should have_instance_methods :name, :logger, :verbose, :keep_alive, :runner,
-      :error_procs, :run, :handler_class_for
+    should have_readers :name, :logger, :verbose, :keep_alive, :runner, :error_procs
+    should have_imeths :handler_class_for, :run
 
-    should "default it's configuration from the service host, but allow overrides" do
+    should "call the init procs" do
+      assert_equal true, TestHost.init_has_been_called
+    end
+
+    should "default its attrs from the host configuration" do
+      assert_equal TestHost.configuration.name,                subject.name
+      assert_equal TestHost.configuration.logger.class,        subject.logger.class
+      assert_equal TestHost.configuration.verbose_logging,     subject.verbose
+      assert_equal TestHost.configuration.receives_keep_alive, subject.keep_alive
+      assert_equal TestHost.configuration.runner.class,        subject.runner.class
+      assert_equal TestHost.configuration.error_procs,         subject.error_procs
+    end
+
+    should "allow overriding host configuration attrs" do
       host_data = Sanford::HostData.new(TestHost, :verbose_logging => false)
 
+      assert_false host_data.verbose
       assert_equal TestHost.receives_keep_alive, host_data.keep_alive
-      assert_equal false, host_data.verbose
     end
 
     should "ignore nil values passed as overrides" do
@@ -28,17 +44,13 @@ class Sanford::HostData
       assert_not_nil host_data.verbose
     end
 
-    should "have called the setup proc" do
-      assert_equal true, TestHost.init_has_been_called
-    end
-
     should "constantize a host's handlers" do
       handlers = subject.instance_variable_get("@handlers")
-      assert_equal TestHost::Authorized,  handlers['authorized']
-      assert_equal TestHost::Bad,         handlers['bad']
-      assert_equal TestHost::Echo,        handlers['echo']
-      assert_equal TestHost::HaltIt,      handlers['halt_it']
-      assert_equal TestHost::Multiply,    handlers['multiply']
+      assert_equal TestHost::Authorized, handlers['authorized']
+      assert_equal TestHost::Bad,        handlers['bad']
+      assert_equal TestHost::Echo,       handlers['echo']
+      assert_equal TestHost::HaltIt,     handlers['halt_it']
+      assert_equal TestHost::Multiply,   handlers['multiply']
     end
 
     should "look up handler classes with #handler_class_for" do

data/test/unit/host_tests.rb

@@ -1,35 +1,96 @@
 require 'assert'
+require 'sanford/host'
+
+require 'sanford/logger'
+require 'sanford/runner'
 
 module Sanford::Host
 
-  class BaseTests < Assert::Context
+  class UnitTests < Assert::Context
     desc "Sanford::Host"
     setup do
-      @configuration = MyHost.configuration.to_hash
+      @host_class = Class.new{ include Sanford::Host }
     end
-    teardown do
-      MyHost.configuration.apply(@configuration)
+    subject{ @host_class.instance }
+
+    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 "know its configuration" do
+      assert_kind_of Configuration, subject.configuration
     end
-    subject{ MyHost.instance }
 
-    should have_instance_methods :configuration, :name, :ip, :port, :pid_file,
-      :logger, :verbose_logging, :runner, :error, :init, :service_handler_ns,
-      :service, :services
+    should "have no services by default" do
+      assert_empty subject.services
+    end
 
-    should "get and set it's configuration options with their matching methods" do
+    should "get/set its configuration options" do
       subject.name 'my_awesome_host'
+      assert_equal 'my_awesome_host', subject.name
+      assert_equal subject.name, subject.configuration.name
+
+      subject.ip '127.0.0.1'
+      assert_equal '127.0.0.1', subject.ip
+      assert_equal subject.ip, subject.configuration.ip
+
+      subject.port '10100'
+      assert_equal 10100, subject.port
+      assert_equal subject.port, subject.configuration.port
+
+      subject.pid_file '/path/to/file'
+      assert_equal Pathname.new('/path/to/file'), subject.pid_file
+      assert_equal subject.pid_file, subject.configuration.pid_file
+
+      logger = Sanford::NullLogger.new
+      subject.logger logger
+      assert_equal logger, subject.logger
+      assert_equal subject.logger, subject.configuration.logger
+
+      subject.verbose_logging false
+      assert_equal false, subject.verbose_logging
+      assert_equal subject.verbose_logging, subject.configuration.verbose_logging
+
+      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
+      assert_empty subject.configuration.error_procs
+      subject.error &proc{}
+      assert_not_empty subject.configuration.error_procs
+    end
 
-      assert_equal 'my_awesome_host',           subject.name
-      assert_equal subject.configuration.port,  subject.port
+    should "add init procs to the configuration" do
+      assert_empty subject.configuration.init_procs
+      subject.init &proc{}
+      assert_not_empty subject.configuration.init_procs
     end
 
-    should "allow adding a service with #service" do
+    should "get/set its service_handler_ns" do
+      assert_nil subject.service_handler_ns
+      subject.service_handler_ns 'a-ns'
+      assert_equal 'a-ns', subject.service_handler_ns
+    end
+
+    should "add services" do
       subject.service_handler_ns 'MyNamespace'
       subject.service('test', 'MyServiceHandler')
 
       assert_equal 'MyNamespace::MyServiceHandler', subject.services['test']
     end
 
+    should "force string names when adding services" do
+      subject.service(:another_service, 'MyServiceHandler')
+      assert_nil subject.services[:another_service]
+      assert_equal 'MyServiceHandler', subject.services['another_service']
+    end
+
     should "ignore a namespace when a service class has leading colons" do
       subject.service_handler_ns 'MyNamespace'
       subject.service('test', '::MyServiceHandler')
@@ -39,11 +100,11 @@ module Sanford::Host
 
   end
 
-  class ClassMethodsTests < Assert::Context
-    desc "Sanford::Host class"
-    subject{ MyHost }
+  class ClassMethodsTests < UnitTests
+    desc "class"
+    subject{ @host_class }
 
-    should "proxy it's method to it's instance" do
+    should "proxy its method to its instance" do
       assert_equal subject.instance.name, subject.name
       assert subject.respond_to?(:pid_file)
     end
@@ -54,4 +115,32 @@ module Sanford::Host
 
   end
 
+  class ConfigurationTests < UnitTests
+    desc "Configuration"
+    setup do
+      @configuration = Configuration.new(@host_class.instance)
+    end
+    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 "default name to the class name of the host" do
+      assert_equal @host_class.name, subject.name
+    end
+
+    should "default its other attrs" do
+      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_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
+
+  end
+
 end

data/test/unit/manager_tests.rb

@@ -1,13 +1,13 @@
 require 'assert'
-require 'sanford/cli'
+require 'sanford/manager'
 
 module Sanford::Manager
 
-  class BaseTests < Assert::Context
+  class UnitTests < Assert::Context
     desc "Sanford::Manager"
     subject{ Sanford::Manager }
 
-    should have_instance_methods :call, :get_handler_class
+    should have_imeths :call, :get_handler_class
 
     should "return ServerHandler or SignalHandler with get_handler_class" do
       assert_equal Sanford::Manager::ServerHandler, subject.get_handler_class('run')
@@ -18,56 +18,16 @@ module Sanford::Manager
 
   end
 
-  class ServerHandlerTests < BaseTests
-    desc "ServerHandler"
-    setup do
-      @handler = Sanford::Manager::ServerHandler.new({ :host => 'TestHost' })
-    end
-    subject{ @handler }
-
-    should have_instance_methods :run, :start
-
-    should "raise an error when a host can't be found matching the `host` option" do
-      assert_raises(Sanford::NoHostError) do
-        Sanford::Manager::ServerHandler.new({ :host => 'poop' })
-      end
-    end
-
-    should "raise an error when a host is invalid for running a server" do
-      assert_raises(Sanford::InvalidHostError) do
-        Sanford::Manager::ServerHandler.new({ :host => 'InvalidHost' })
-      end
-    end
-
-  end
-
-  class SignalHandlertests < BaseTests
-    desc "SignalHandler"
-    setup do
-      @handler = Sanford::Manager::SignalHandler.new({ :pid => -1 })
-    end
-    subject{ @handler }
-
-    should have_instance_methods :stop, :restart
-
-    should "raise an error when a pid can't be found" do
-      assert_raises(Sanford::NoPIDError) do
-        Sanford::Manager::SignalHandler.new
-      end
-    end
-  end
-
-  class ConfigTests < BaseTests
+  class ConfigTests < UnitTests
     desc "Config"
     setup do
       @config = Sanford::Manager::Config.new({ :host => 'TestHost' })
     end
     subject{ @config }
 
-    should have_instance_methods :host_name, :host, :ip, :port, :pid, :pid_file
-    should have_instance_methods :file_descriptor, :client_file_descriptors
-    should have_instance_methods :restart_dir
-    should have_instance_methods :listen_args, :has_listen_args?, :found_host?
+    should have_readers :host_name, :host, :ip, :port, :pid, :pid_file, :restart_dir
+    should have_readers :file_descriptor, :client_file_descriptors
+    should have_imeths :listen_args, :has_listen_args?, :found_host?
 
     should "find a host based on the `host` option" do
       assert_equal TestHost, subject.host
@@ -81,8 +41,8 @@ module Sanford::Manager
     end
 
     should "use the first host if no host option is provided" do
-      manager = Sanford::Manager::Config.new({ :port => 1 })
-      assert_equal Sanford.hosts.first, manager.host
+      config = Sanford::Manager::Config.new({ :port => 1 })
+      assert_equal Sanford.hosts.first, config.host
     end
 
     should "return the file descriptor or ip and port with listen_args" do
@@ -103,7 +63,7 @@ module Sanford::Manager
 
     should "build a NullHost when a host can't be found" do
       config = Sanford::Manager::Config.new({ :host => 'poop' })
-      assert_instance_of Sanford::Manager::NullHost, config.host
+      assert_instance_of Sanford::Manager::Config::NullHost, config.host
       assert_equal false, config.found_host?
     end
 
@@ -139,4 +99,97 @@ module Sanford::Manager
 
   end
 
+  class PIDFileTests < ConfigTests
+    desc "PIDFile"
+    setup do
+      @pid_file_path = File.join(ROOT, "tmp/my.pid")
+      @pid_file = Sanford::Manager::Config::PIDFile.new(@pid_file_path)
+    end
+    teardown do
+      FileUtils.rm_rf(@pid_file_path)
+    end
+    subject{ @pid_file }
+
+    should have_imeths :pid, :to_s, :write, :remove
+
+    should "return it's path with #to_s" do
+      assert_equal @pid_file_path, subject.to_s
+    end
+
+    should "write the pid file with #write" do
+      subject.write
+
+      assert_file_exists @pid_file_path
+      assert_equal "#{Process.pid}\n", File.read(@pid_file_path)
+    end
+
+    should "return the value stored in the pid value with #pid" do
+      subject.write
+
+      assert_equal Process.pid, subject.pid
+    end
+
+    should "remove the file with #remove" do
+      subject.write
+      subject.remove
+
+      assert_not File.exists?(@pid_file_path)
+    end
+
+    should "complain nicely if it can't write the pid file" do
+      pid_file_path = 'does/not/exist.pid'
+      pid_file = Sanford::Manager::Config::PIDFile.new(pid_file_path)
+
+      err = nil
+      begin
+        pid_file.write
+      rescue Exception => err
+      end
+
+      assert err
+      assert_kind_of RuntimeError, err
+      assert_includes File.dirname(pid_file_path), err.message
+    end
+
+  end
+
+  class ServerHandlerTests < UnitTests
+    desc "ServerHandler"
+    setup do
+      @handler = Sanford::Manager::ServerHandler.new({ :host => 'TestHost' })
+    end
+    subject{ @handler }
+
+    should have_imeths :run, :start
+
+    should "raise an error when a host can't be found" do
+      assert_raises(Sanford::NoHostError) do
+        Sanford::Manager::ServerHandler.new({ :host => 'not_found' })
+      end
+    end
+
+    should "raise an error when a host is invalid for running a server" do
+      assert_raises(Sanford::InvalidHostError) do
+        Sanford::Manager::ServerHandler.new({ :host => 'InvalidHost' })
+      end
+    end
+
+  end
+
+  class SignalHandlertests < UnitTests
+    desc "SignalHandler"
+    setup do
+      @handler = Sanford::Manager::SignalHandler.new({ :pid => -1 })
+    end
+    subject{ @handler }
+
+    should have_imeths :stop, :restart
+
+    should "raise an error when a pid can't be found" do
+      assert_raises(Sanford::NoPIDError) do
+        Sanford::Manager::SignalHandler.new
+      end
+    end
+  end
+
 end

data/test/unit/runner_tests.rb

@@ -1,8 +1,11 @@
 require 'assert'
+require 'sanford/runner'
+
+require 'test/support/services'
 
 module Sanford::Runner
 
-  class BaseTests < Assert::Context
+  class UnitTests < Assert::Context
     desc "Sanford::Runner"
     setup do
       request = Sanford::Protocol::Request.new('test', {})
@@ -10,8 +13,8 @@ module Sanford::Runner
     end
     subject{ @runner }
 
-    should have_instance_methods :handler_class, :request, :logger, :run
-    should have_class_methods :run
+    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

data/test/unit/sanford_tests.rb

@@ -0,0 +1,70 @@
+require 'assert'
+require 'sanford'
+
+require 'ns-options/proxy'
+
+module Sanford
+
+  class UnitTests < Assert::Context
+    desc "Sanford"
+    subject{ 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')
+    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,20 +1,22 @@
 require 'assert'
 require 'sanford/server'
 
+require 'test/support/services'
+
 class Sanford::Server
 
-  class BaseTests < Assert::Context
+  class UnitTests < Assert::Context
     desc "Sanford::Server"
     setup do
-      @server = Sanford::Server.new(TestHost, { :keep_alive => true })
+      @server = Sanford::Server.new(TestHost, :keep_alive => true)
     end
     subject{ @server }
 
-    should have_instance_methods :sanford_host, :sanford_host_data, :sanford_host_options
-    should have_instance_methods :on_run
+    should have_readers :sanford_host, :sanford_host_data, :sanford_host_options
+    should have_imeths :on_run
 
     should "include DatTCP::Server" do
-      assert_includes DatTCP::Server, subject.class.included_modules
+      assert_includes DatTCP::Server, subject.class
     end
 
     should "save it's host and host options but not initialize a host data yet" do
@@ -25,7 +27,7 @@ class Sanford::Server
 
   end
 
-  class RunTests < BaseTests
+  class RunTests < UnitTests
     desc "run"
     setup do
       @server.listen(TestHost.ip, TestHost.port)