sanford 0.1.0 → 0.2.0

data/test/unit/error_handler_test.rb

@@ -0,0 +1,133 @@
+require 'assert'
+
+class Sanford::ErrorHandler
+
+  class BaseTest < Assert::Context
+    desc "Sanford::ErrorHandler"
+    setup do
+      @exception = RuntimeError.new('test')
+      @host_data = Sanford::HostData.new(EmptyHost, { :ip => "localhost", :port => 8000 })
+      @error_handler = Sanford::ErrorHandler.new(@exception, @host_data)
+    end
+    subject{ @error_handler }
+
+    should have_instance_methods :exception, :host_data, :request, :run
+
+    should "return a Sanford::Protocol::Response with `run`" do
+      assert_instance_of Sanford::Protocol::Response, subject.run
+    end
+
+    def generate_exception(exception_class, message = nil)
+      exception = nil
+      begin
+        raise exception_class, message
+      rescue Exception => exception
+      end
+      exception
+    end
+
+  end
+
+  class ResponseFromProcTest < BaseTest
+    desc "generating a respone from an error proc"
+    setup do
+      @host_defaults = { :ip => "localhost", :port => 8000 }
+    end
+
+    should "use the return-value of the error proc if it is a protocol response" do
+      error_proc = proc do |exception, host_data, request|
+        Sanford::Protocol::Response.new([ 567, 'custom message'], 'custom data')
+      end
+      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
+        :error_proc => error_proc
+      }))
+      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
+    end
+
+    should "use an integer returned by the error proc to generate a protocol response" do
+      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
+        :error_proc => proc{ 345 }
+      }))
+      response = Sanford::ErrorHandler.new(@exception, host_data).run
+
+      assert_equal 345, response.code
+      assert_nil response.status.message
+      assert_nil response.data
+    end
+
+    should "use a symbol returned by the error proc to generate a protocol response" do
+      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
+        :error_proc => proc{ :not_found }
+      }))
+      response = Sanford::ErrorHandler.new(@exception, host_data).run
+
+      assert_equal 404, response.code
+      assert_nil response.status.message
+      assert_nil response.data
+    end
+
+    should "use the default behavior if the error proc doesn't return a valid response result" do
+      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
+        :error_proc => proc{ true }
+      }))
+      response = Sanford::ErrorHandler.new(@exception, host_data).run
+
+      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
+      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
+        :error_proc => proc{ raise Sanford::NotFoundError }
+      }))
+      response = Sanford::ErrorHandler.new(@exception, host_data).run
+
+      assert_equal 404, response.code
+      assert_nil response.status.message
+      assert_nil response.data
+    end
+
+  end
+
+  class ResponseFromExceptionTest < BaseTest
+    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 'bad message', response.status.message
+    end
+
+    should "build a 400 response with a protocol BadRequestError" do
+      exception = generate_exception(Sanford::Protocol::BadRequestError, 'bad request')
+      response = Sanford::ErrorHandler.new(exception, @host_data).run
+
+      assert_equal 400,           response.code
+      assert_equal 'bad request', response.status.message
+    end
+
+    should "build a 404 response with a NotFoundError" do
+      exception = generate_exception(Sanford::NotFoundError, 'not found')
+      response = Sanford::ErrorHandler.new(exception, @host_data).run
+
+      assert_equal 404, response.code
+      assert_nil response.status.message
+    end
+
+    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 'An unexpected error occurred.', response.status.message
+    end
+
+  end
+
+end

data/test/unit/host_configuration_test.rb

@@ -0,0 +1,41 @@
+require 'assert'
+
+class Sanford::Host::Configuration
+
+  class BaseTest < Assert::Context
+    desc "Sanford::Host::Configuration"
+    setup do
+      @configuration = Sanford::Host::Configuration.new(EmptyHost.instance)
+    end
+    subject{ @configuration }
+
+    should have_instance_methods :name, :ip, :port, :pid_dir, :logger, :verbose_logging, :logger,
+      :error_proc
+
+    should "default name to the class name of the host" do
+      assert_equal 'EmptyHost', subject.name
+    end
+
+    should "default ip to 0.0.0.0" do
+      assert_equal '0.0.0.0', subject.ip
+    end
+
+    should "not default the port" do
+      assert_nil subject.port
+    end
+
+    should "default pid_dir to the current working directory" do
+      assert_equal Pathname.new(Dir.pwd), subject.pid_dir
+    end
+
+    should "default logger to a null logger" do
+      assert_instance_of Sanford::NullLogger, subject.logger
+    end
+
+    should "default verbose_logging to true" do
+      assert_equal true, subject.verbose_logging
+    end
+
+  end
+
+end

data/test/unit/host_data_test.rb

@@ -0,0 +1,65 @@
+require 'assert'
+
+require 'sanford/manager'
+
+class Sanford::HostData
+
+  class BaseTest < Assert::Context
+    desc "Sanford::HostData"
+    setup do
+      @host_data = Sanford::HostData.new(TestHost)
+    end
+    subject{ @host_data }
+
+    should have_instance_methods :name, :ip, :port, :pid_dir, :logger, :verbose,
+      :error_proc, :handler_class_for
+
+    should "default it's configuration from the service host, but allow overrides" do
+      host_data = Sanford::HostData.new(TestHost, :ip => '1.2.3.4', :port => 12345)
+
+      assert_equal 'TestHost',  host_data.name
+      assert_equal '1.2.3.4',   host_data.ip
+      assert_equal 12345,       host_data.port
+    end
+
+    should "constantize a host's handlers" do
+      handlers = subject.instance_variable_get("@handlers")
+
+      assert_equal TestHost::Authorized,  handlers['v1']['authorized']
+      assert_equal TestHost::Bad,         handlers['v1']['bad']
+      assert_equal TestHost::Echo,        handlers['v1']['echo']
+      assert_equal TestHost::HaltIt,      handlers['v1']['halt_it']
+      assert_equal TestHost::Multiply,    handlers['v1']['multiply']
+    end
+
+    should "ignore nil values passed as overrides" do
+      host_data = Sanford::HostData.new(TestHost, :ip => nil)
+
+      assert_not_nil host_data.ip
+    end
+
+    should "raise a custom exception when passed invalid host" do
+      assert_raises(Sanford::InvalidHostError) do
+        Sanford::Manager.new(InvalidHost)
+      end
+    end
+
+    should "look up handler classes with #handler_class_for" do
+      assert_equal TestHost::Echo, subject.handler_class_for('v1', 'echo')
+    end
+
+    should "raise a custom error when handler_class_for is called with an unknown service" do
+      assert_raises(Sanford::NotFoundError) do
+        subject.handler_class_for('not', 'defined')
+      end
+    end
+
+    should "raise a custom error when a service is configured with an undefined class" do
+      assert_raises(Sanford::NoHandlerClassError) do
+        Sanford::HostData.new(UndefinedHandlersHost)
+      end
+    end
+
+  end
+
+end

data/test/unit/host_test.rb

@@ -5,138 +5,46 @@ module Sanford::Host
   class BaseTest < Assert::Context
     desc "Sanford::Host"
     setup do
-      Test::Environment.store_and_clear_hosts
-      @host_class = Class.new do
-        include Sanford::Host
-        name  'anonymous_host'
-        ip    'anonymous.local'
-      end
-      @host = @host_class.new({ :port => 12345 })
+      @configuration = MyHost.configuration.to_hash
     end
     teardown do
-      Test::Environment.restore_hosts
+      MyHost.configuration.apply(@configuration)
     end
-    subject{ @host }
+    subject{ MyHost.instance }
 
-    should have_instance_methods :name, :config, :run
+    should have_instance_methods :configuration, :name, :ip, :port, :pid_dir, :logger,
+      :verbose_logging, :error, :version, :versioned_services
 
-    should "set name to it's class #name" do
-      assert_equal subject.class.name, subject.name
-    end
+    should "get and set it's configuration options with their matching methods" do
+      subject.name 'my_awesome_host'
 
-    should "proxy missing methods to it's config" do
-      assert_equal subject.config.port, subject.port
-      assert subject.respond_to?(:pid_dir)
-    end
+      assert_equal 'my_awesome_host',           subject.name
+      assert_equal subject.configuration.port,  subject.port
 
-    should "default it's configuration from the class and overwrite with values passed to new" do
-      assert_equal 'anonymous.local', subject.config.ip
-      assert_equal 12345, subject.config.port
-    end
-  end
 
-  class ConfigTest < BaseTest
-    desc "config"
-    setup do
-      @config = @host.config
     end
-    subject{ @config }
-
-    should have_instance_methods :name, :ip, :port, :pid_dir, :logger
-  end
-
-  class ClassMethodsTest < BaseTest
-    desc "class methods"
-    subject{ @host_class }
 
-    should have_instance_methods :config, :version
-    should have_instance_methods :name, :ip, :port, :pid_dir, :logger
+    should "add a version group with #version" do
+      subject.version('v1'){ }
 
-    should "have registered the class with sanford's known hosts" do
-      assert_includes subject, Sanford.config.hosts
-    end
-  end
-
-  class InvalidTest < BaseTest
-    desc "invalid configuration"
-    setup do
-      @host_class = Class.new do
-        include Sanford::Host
-        name 'invalid_host'
-      end
+      assert_equal({}, subject.versioned_services["v1"])
     end
 
-    should "raise a custom exception" do
-      assert_raises(Sanford::InvalidHostError) do
-        @host_class.new
-      end
-    end
   end
 
-  class VersionTest < BaseTest
-    desc "version class method"
-    setup do
-      @host_class.version('v1'){ }
-    end
+  class ClassMethodsTest < Assert::Context
+    desc "Sanford::Host class"
+    subject{ MyHost }
 
-    should "have added a version hash to the versioned_services config" do
-      assert_equal({}, @host_class.config.versioned_services["v1"])
-    end
-  end
-
-  class RunTest < BaseTest
-    desc "run method"
-    setup do
-      @host_class.version('v1') do
-        service 'test', 'DummyHost::Multiply'
-      end
-      @host = @host_class.new({ :port => 12000 })
-      @request = Sanford::Protocol::Request.new('v1', 'test', { 'number' => 2 })
-      @returned = @host.run(@request)
-    end
-    subject{ @returned }
-
-    should "have returned the data of calling the `init` and `run` method of the handler" do
-      expected_status_code = 200
-      expected_data = 2 * @request.params['number']
-
-      assert_equal expected_status_code, subject.first
-      assert_equal expected_data, subject.last
-    end
-  end
-
-  class RunNotFoundTest < BaseTest
-    desc "run method with a service and no matching service handler"
-    setup do
-      @host_class.version('v1') do
-        service 'test', 'DummyHost::Echo'
-      end
-      @host = @host_class.new({ :port => 12000 })
-      @request = Sanford::Protocol::Request.new('v4', 'what', {})
-    end
-
-    should "raise a Sanford::NotFound exception" do
-      assert_raises(Sanford::NotFoundError) do
-        @host.run(@request)
-      end
+    should "proxy it's method to it's instance" do
+      assert_equal subject.instance.name, subject.name
+      assert subject.respond_to?(:pid_dir)
     end
-  end
 
-  class RunNoHandlerClassTest < BaseTest
-    desc "run method with a service handler that doesn't exist"
-    setup do
-      @host_class.version('v1') do
-        service 'test', 'DoesntExist::AtAll'
-      end
-      @host = @host_class.new({ :port => 12000 })
-      @request = Sanford::Protocol::Request.new('v1', 'test', {})
+    should "have registered the class with sanford's known hosts" do
+      assert_includes subject, Sanford.hosts
     end
 
-    should "raise a Sanford::NoHandlerClass exception" do
-      assert_raises(Sanford::NoHandlerClassError) do
-        @host.run(@request)
-      end
-    end
   end
 
 end

data/test/unit/hosts_test.rb

@@ -0,0 +1,56 @@
+require 'assert'
+
+class Sanford::Hosts
+
+  class BaseTest < Assert::Context
+    desc "Sanford::hosts"
+    setup do
+      @hosts = Sanford::Hosts.new
+    end
+    subject{ @hosts }
+
+    should have_instance_methods :add, :first, :find
+
+  end
+
+  class FindTest < BaseTest
+    desc "find"
+    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 "check class name before configured name" do
+      assert_includes BadlyNamedHost, subject
+      assert_equal NotNamedHost, subject.find('NotNamedHost')
+    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 do
+      include Sanford::Host
+    end
+
+    ::NamedHost = Class.new do
+      include Sanford::Host
+      name 'named_host'
+    end
+
+    ::BadlyNamedHost = Class.new do
+      include Sanford::Host
+      name 'NotNamedHost'
+    end
+
+  end
+
+end

data/test/unit/manager_test.rb

@@ -1,13 +1,13 @@
 require 'assert'
-require 'ostruct'
+
+require 'sanford/manager'
 
 class Sanford::Manager
 
   class BaseTest < Assert::Context
     desc "Sanford::Manager"
     setup do
-      @dummy_host = DummyHost
-      @manager = Sanford::Manager.new(@dummy_host)
+      @manager = Sanford::Manager.new(TestHost)
     end
     subject{ @manager }
 

data/test/unit/runner_test.rb

@@ -0,0 +1,26 @@
+require 'assert'
+
+class Sanford::Runner
+
+  class BaseTest < Assert::Context
+    desc "Sanford::Runner"
+    setup do
+      request = Sanford::Protocol::Request.new('v1', 'test', {})
+      @runner = Sanford::Runner.new(BasicServiceHandler, request)
+    end
+    subject{ @runner }
+
+    should have_instance_methods :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
+
+  end
+
+end

data/test/unit/server_test.rb

@@ -1,18 +1,26 @@
 require 'assert'
 
+require 'sanford/server'
+require 'sanford/manager'
+
 class Sanford::Server
 
   class BaseTest < Assert::Context
     desc "Sanford::Server"
     setup do
-      @service_host = DummyHost.new
-      @server = Sanford::Server.new(@service_host)
+      @server = Sanford::Server.new(TestHost)
     end
     subject{ @server }
 
     should "include DatTCP::Server" do
       assert_includes DatTCP::Server, subject.class.included_modules
     end
+
+    should "use the service host's ip and port" do
+      assert_equal TestHost.ip,   subject.host
+      assert_equal TestHost.port, subject.port
+    end
+
   end
 
   # Sanford::Server#serve is tested in test/system/request_handling_test.rb,