sanford 0.1.0 → 0.2.0

data/test/support/service_handlers.rb

@@ -1,115 +1,103 @@
-# A bunch of service handler examples. These are defined to implement certain
-# edge cases and are for specific tests within the test suite.
-#
-
-class StaticServiceHandler
+class TestServiceHandler
   include Sanford::ServiceHandler
 
-  # builds with the same request and logger always, just for convenience
-
-  def initialize(logger = nil, request = nil)
-    request ||= Sanford::Protocol::Request.new('v1', 'name', {})
-    super(logger || Sanford::NullLogger.new, request)
-  end
-
 end
 
-class ManualThrowServiceHandler < StaticServiceHandler
+class BasicServiceHandler
+  include Sanford::ServiceHandler
 
   def run!
-    throw(:halt, 'halted!')
+    { 'name' => 'Joe Test', 'email' => "joe.test@example.com" }
   end
 
 end
 
-class HaltWithServiceHandler < StaticServiceHandler
+class FlagServiceHandler
+  include Sanford::ServiceHandler
 
-  def initialize(halt_with)
-    request = Sanford::Protocol::Request.new('v1', 'name', {
-      'halt_with' => halt_with.dup
-    })
-    super(Sanford::NullLogger.new, request)
-  end
+  attr_reader :before_init_called, :init_bang_called, :after_init_called,
+    :before_run_called, :run_bang_called, :after_run_called
 
-  def run!
-    params['halt_with'].tap do |halt_with|
-      halt(halt_with.delete('code'), halt_with)
-    end
+  def before_init
+    @before_init_called = true
   end
 
-end
+  def init!
+    @init_bang_called = true
+  end
 
-class NoopServiceHandler < StaticServiceHandler
+  def after_init
+    @after_init_called = true
+  end
 
-  # simply overwrites the default `run!` so it doesn't error
+  def before_run
+    @before_run_called = true
+  end
 
   def run!
-    # nothing!
+    @run_bang_called = true
+  end
+
+  def after_run
+    @after_run_called = true
   end
 
 end
 
-class FlaggedServiceHandler < NoopServiceHandler
+class HaltServiceHandler
+  include Sanford::ServiceHandler
 
-  # flags a bunch of methods as they are run by setting instance variables
+  def run!
+    halt params['code'], :message => params['message'], :data => params['data']
+  end
 
-  FLAGGED_METHODS = {
-    'init'        => :init_called,
-    'init!'       => :init_bang_called,
-    'run!'        => :run_bang_called,
-    'before_run'  => :before_run_called,
-    'after_run'   => :after_run_called
-  }
-  FLAGS = FLAGGED_METHODS.values
+end
 
-  attr_reader *FLAGS
+class HaltingBehaviorServiceHandler < FlagServiceHandler
 
-  def initialize(*passed)
+  def before_init
     super
-    FLAGS.each{|name| self.instance_variable_set("@#{name}", false) }
+    halt_when('before_init')
   end
 
-  FLAGGED_METHODS.each do |method_name, instance_variable_name|
-
-    # def before_run
-    #   super
-    #   @before_run_called = true
-    # end
-    define_method(method_name) do
-      super
-      self.instance_variable_set("@#{instance_variable_name}", true)
-    end
-
+  def init!
+    super
+    halt_when('init!')
   end
 
-end
-
-class ConfigurableServiceHandler < FlaggedServiceHandler
-
-  def initialize(options = {})
-    @options = options
+  def after_init
     super
+    halt_when('after_init')
   end
 
   def before_run
     super
-    if @options[:before_run]
-      self.instance_eval(&@options[:before_run])
-    end
+    halt_when('before_run')
   end
 
   def run!
     super
-    if @options[:run!]
-      self.instance_eval(&@options[:run!])
-    end
+    halt_when('run!')
   end
 
   def after_run
     super
-    if @options[:after_run]
-      self.instance_eval(&@options[:after_run])
-    end
+    halt_when('after_run')
+  end
+
+  def halt_when(method_name)
+    return if ![*params['when']].include?(method_name)
+    halt(200, {
+      :message  => "#{method_name} halting",
+      :data     => {
+        :before_init_called => @before_init_called,
+        :init_bang_called   => @init_bang_called,
+        :after_init_called  => @after_init_called,
+        :before_run_called  => @before_run_called,
+        :run_bang_called    => @run_bang_called,
+        :after_run_called   => @after_run_called
+      }
+    })
   end
 
 end

data/test/support/services.rb

@@ -1,23 +1,32 @@
 require 'logger'
 
-class DummyHost
+class TestHost
   include Sanford::Host
 
   ip      'localhost'
   port    12000
   pid_dir File.expand_path('../../../tmp/', __FILE__)
 
-  logger = Logger.new(File.expand_path("../../../log/test.log", __FILE__))
-  logger.level = Logger::DEBUG
+  logger(Logger.new(File.expand_path("../../../log/test.log", __FILE__)).tap do |logger|
+    logger.level = Logger::DEBUG
+  end)
+  verbose_logging true
 
-  version 'v1' do
-    service_handler_ns 'DummyHost'
+  error do |exception, host_data, request|
+    if exception.kind_of?(::MyCustomError)
+      Sanford::Protocol::Response.new([ 987, 'custom error!' ])
+    end
+  end
 
-    service 'echo',       'Echo'
-    service 'bad',        'Bad'
-    service 'multiply',   'Multiply'
-    service 'halt_it',    '::DummyHost::HaltIt'
-    service 'authorized', 'Authorized'
+  version 'v1' do
+    service_handler_ns 'TestHost'
+
+    service 'echo',         'Echo'
+    service 'bad',          'Bad'
+    service 'multiply',     'Multiply'
+    service 'halt_it',      '::TestHost::HaltIt'
+    service 'authorized',   'Authorized'
+    service 'custom_error', 'CustomError'
   end
 
   class Echo
@@ -69,4 +78,40 @@ class DummyHost
 
   end
 
+  ::MyCustomError = Class.new(RuntimeError)
+
+  class CustomError
+    include Sanford::ServiceHandler
+
+    def run!
+      raise ::MyCustomError
+    end
+
+  end
+
+end
+
+class MyHost
+  include Sanford::Host
+
+  name  'my_host'
+  ip    'my.local'
+end
+
+class InvalidHost
+  include Sanford::Host
+
+  name 'invalid_host'
+end
+
+class UndefinedHandlersHost
+  include Sanford::Host
+
+  version 'v1' do
+    service 'undefined', 'ThisIsNotDefined'
+  end
+end
+
+class EmptyHost
+  include Sanford::Host
 end

data/test/system/managing_test.rb

@@ -1,5 +1,7 @@
 require 'assert'
 
+require 'sanford/manager'
+
 class ManagingTest < Assert::Context
   desc "Using Sanford's manager"
   setup do
@@ -15,7 +17,7 @@ class ManagingTest < Assert::Context
     include Test::ForkManagerHelper
 
     setup do
-      Sanford.config.hosts.add(DummyHost)
+      Sanford.register(TestHost)
     end
   end
 
@@ -23,11 +25,9 @@ class ManagingTest < Assert::Context
     desc "to run a service host"
 
     should "start a sanford server for the only service host that is configured" do
-      host = Sanford.config.hosts.first
-
       self.call_sanford_manager(:run) do
-        assert_nothing_raised{ self.open_socket(host.config.ip, host.config.port) }
-        assert File.exists?(self.expected_pid_file(host, host.config.ip, host.config.port))
+        assert_nothing_raised{ self.open_socket(TestHost.ip, TestHost.port) }
+        assert File.exists?(self.expected_pid_file(TestHost, TestHost.ip, TestHost.port))
       end
     end
   end
@@ -35,17 +35,17 @@ class ManagingTest < Assert::Context
   class RunWithOptionsTest < CallTest
     desc "to run a service host and passing options"
     setup do
-      # make sure that DummyHost isn't the only 'host'
-      Sanford.config.hosts.add(Class.new)
+      # make sure that TestHost isn't the only 'host'
+      Sanford.register(Class.new)
     end
 
     should "start a sanford server for the specified service host and " \
            "use the passed options to override it's configuration" do
-      host = Sanford.config.find_host('DummyHost')
+      host = Sanford.hosts.find('TestHost')
 
-      self.call_sanford_manager(:run, { :host => 'DummyHost', :port => 12345 }) do
-        assert_nothing_raised{ self.open_socket(host.config.ip, 12345) }
-        assert File.exists?(self.expected_pid_file(host, host.config.ip, 12345))
+      self.call_sanford_manager(:run, { :host => 'TestHost', :port => 12345 }) do
+        assert_nothing_raised{ self.open_socket(host.ip, 12345) }
+        assert File.exists?(self.expected_pid_file(host, host.ip, 12345))
       end
     end
   end
@@ -54,10 +54,10 @@ class ManagingTest < Assert::Context
     desc "to run a service host and setting env vars"
     setup do
       @current = ENV.delete('SANFORD_HOST'), ENV.delete('SANFORD_IP'), ENV.delete('SANFORD_PORT')
-      ENV['SANFORD_HOST'] = 'DummyHost'
+      ENV['SANFORD_HOST'] = 'TestHost'
       ENV['SANFORD_IP'], ENV['SANFORD_PORT'] = 'localhost', '54321'
-      # make sure that DummyHost isn't the only 'host'
-      Sanford.config.hosts.add(Class.new)
+      # make sure that TestHost isn't the only 'host'
+      Sanford.register(Class.new)
     end
     teardown do
       ENV['SANFORD_HOST'], ENV['SANFORD_IP'], ENV['SANFORD_PORT'] = @current
@@ -65,7 +65,7 @@ class ManagingTest < Assert::Context
 
     should "start a sanford server for the specified service host and " \
            "use the env vars to override it's configuration" do
-      host = Sanford.config.find_host(ENV['SANFORD_HOST'])
+      host = Sanford.hosts.find(ENV['SANFORD_HOST'])
       port = ENV['SANFORD_PORT'].to_i
 
       self.call_sanford_manager(:run) do
@@ -78,8 +78,8 @@ class ManagingTest < Assert::Context
   class BadHostTest < ManagingTest
     desc "with a bad host name"
     setup do
-      Sanford.config.hosts.clear
-      Sanford.config.hosts.add(Class.new)
+      Sanford.hosts.clear
+      Sanford.register(Class.new)
     end
 
     should "raise an exception when a service host can't be found" do
@@ -92,7 +92,7 @@ class ManagingTest < Assert::Context
   class NoHostsTest < ManagingTest
     desc "with no hosts"
     setup do
-      Sanford.config.hosts.clear
+      Sanford.hosts.clear
     end
 
     should "raise an exception when there aren't any service hosts" do

data/test/system/request_handling_test.rb

@@ -1,16 +1,18 @@
 # This test is intended as a high level test against Sanford's server. This will
 # use multiple request scenarios to test out Sanford's behavior and how it
-# responds.
+# responds. These tests depend on a socket (or the protocol's connection) and
+# thus are a system level test.
 #
 require 'assert'
 
+require 'sanford/manager'
+
 class RequestHandlingTest < Assert::Context
   include Test::ForkServerHelper
 
   desc "Sanford's handling of requests"
   setup do
-    @service_host = DummyHost.new
-    @server = Sanford::Server.new(@service_host, { :ready_timeout => 0 })
+    @server = Sanford::Server.new(TestHost, { :ready_timeout => 0 })
   end
 
   # Simple service test that echos back the params sent to it
@@ -19,7 +21,7 @@ class RequestHandlingTest < Assert::Context
 
     should "return a successful response and echo the params sent to it" do
       self.start_server(@server) do
-        response = SimpleClient.call_with_request(@service_host, 'v1', 'echo', {
+        response = SimpleClient.call_with_request(TestHost, 'v1', 'echo', {
           :message => 'test'
         })
 
@@ -47,7 +49,7 @@ class RequestHandlingTest < Assert::Context
     should "return a bad request response with an error message" do
       self.start_server(@server) do
         bytes = [ Sanford::Protocol.msg_version, "\000" ].join
-        response = SimpleClient.call_with(@service_host, bytes)
+        response = SimpleClient.call_with(TestHost, bytes)
 
         assert_equal 400,     response.status.code
         assert_match "size",  response.status.message
@@ -63,7 +65,7 @@ class RequestHandlingTest < Assert::Context
     should "return a bad request response with an error message" do
       self.start_server(@server) do
         bytes = [ Sanford::Protocol.msg_version, "\000" ].join
-        response = SimpleClient.call_with_msg_body(@service_host, {}, nil, "\000")
+        response = SimpleClient.call_with_msg_body(TestHost, {}, nil, "\000")
 
         assert_equal 400,                 response.status.code
         assert_match "Protocol version",  response.status.message
@@ -77,7 +79,7 @@ class RequestHandlingTest < Assert::Context
     desc "when sent a request with an invalid body"
     should "return a bad request response with an error message" do
       self.start_server(@server) do
-        response = SimpleClient.call_with_encoded_msg_body(@service_host, "\000\001\010\011" * 2)
+        response = SimpleClient.call_with_encoded_msg_body(TestHost, "\000\001\010\011" * 2)
 
         assert_equal 400,     response.status.code
         assert_match "body",  response.status.message
@@ -86,98 +88,6 @@ class RequestHandlingTest < Assert::Context
     end
   end
 
-  class MissingServiceNameTest < ErroringRequestTest
-    desc "when sent a request with no service name"
-
-    should "return a bad request response" do
-      self.start_server(@server) do
-        request_hash = Sanford::Protocol::Request.new('v1', 'what', {}).to_hash
-        request_hash.delete('name')
-        response = SimpleClient.call_with_msg_body(@service_host, request_hash)
-
-        assert_equal 400,       response.status.code
-        assert_match "request", response.status.message
-        assert_match "name",    response.status.message
-        assert_equal nil,       response.data
-      end
-    end
-  end
-
-  class MissingServiceVersionTest < ErroringRequestTest
-    desc "when sent a request with no service version"
-
-    should "return a bad request response" do
-      self.start_server(@server) do
-        request_hash = Sanford::Protocol::Request.new('v1', 'what', {}).to_hash
-        request_hash.delete('version')
-        response = SimpleClient.call_with_msg_body(@service_host, request_hash)
-
-        assert_equal 400,       response.status.code
-        assert_match "request", response.status.message
-        assert_match "version", response.status.message
-        assert_equal nil,       response.data
-      end
-    end
-  end
-
-  # Requesting a service that is not defined
-  class NotFoundServiceTest < ErroringRequestTest
-    desc "when sent a request with no matching service name"
-
-    should "return a bad request response" do
-      self.start_server(@server) do
-        response = SimpleClient.call_with_request(@service_host, 'v1', 'what', {})
-
-        assert_equal 404, response.status.code
-        assert_equal nil, response.status.message
-        assert_equal nil, response.data
-      end
-    end
-  end
-
-  # Hitting a service that throws an exception
-  class ErrorServiceTest < ErroringRequestTest
-    desc "when sent a request that errors on the server"
-
-    should "return a bad request response" do
-      self.start_server(@server) do
-        response = SimpleClient.call_with_request(@service_host, 'v1', 'bad', {})
-
-        assert_equal 500,     response.status.code
-        assert_match "error", response.status.message
-        assert_equal nil,     response.data
-      end
-    end
-  end
-
-  class HaltTest < RequestHandlingTest
-    desc "when sent a request that halts"
-
-    should "return the response that was halted" do
-      self.start_server(@server) do
-        response = SimpleClient.call_with_request(@service_host, 'v1', 'halt_it', {})
-
-        assert_equal 728,                 response.status.code
-        assert_equal "I do what I want",  response.status.message
-        assert_equal [ 1, true, 'yes' ],  response.data
-      end
-    end
-  end
-
-  class AuthorizeRequestTest < RequestHandlingTest
-    desc "when sent a request that halts in a callback"
-
-    should "return the response that was halted" do
-      self.start_server(@server) do
-        response = SimpleClient.call_with_request(@service_host, 'v1', 'authorized', {})
-
-        assert_equal 401,               response.status.code
-        assert_equal "Not authorized",  response.status.message
-        assert_equal nil,               response.data
-      end
-    end
-  end
-
   class HangingRequestTest < ErroringRequestTest
     desc "when a client connects but doesn't send anything"
     setup do
@@ -189,7 +99,7 @@ class RequestHandlingTest < Assert::Context
 
     should "timeout" do
       self.start_server(@server) do
-        client = SimpleClient.new(@service_host, :with_delay => 0.2)
+        client = SimpleClient.new(TestHost, :with_delay => 0.2)
         response = client.call_with_request('v1', 'echo', { :message => 'test' })
 
         assert_equal 408,   response.status.code

data/test/unit/config_test.rb

@@ -6,49 +6,7 @@ module Sanford::Config
     desc "Sanford::Config"
     subject{ Sanford::Config }
 
-    should have_instance_methods :hosts, :services_config, :find_host
-  end
-
-  class FindHostTest < BaseTest
-    desc "find_host"
-    setup do
-      Test::Environment.store_and_clear_hosts
-      Sanford::Config.hosts.add(NotNamedHost)
-      Sanford::Config.hosts.add(NamedHost)
-      Sanford::Config.hosts.add(BadlyNamedHost)
-    end
-    teardown do
-      Test::Environment.restore_hosts
-    end
-
-    should "allow finding hosts by their class name or configured name" do
-      assert_includes NotNamedHost, subject.hosts
-      assert_includes NamedHost,    subject.hosts
-      assert_equal NotNamedHost,  subject.find_host('NotNamedHost')
-      assert_equal NamedHost,     subject.find_host('NamedHost')
-      assert_equal NamedHost,     subject.find_host('named_host')
-    end
-    should "check class name before configured name" do
-      assert_includes BadlyNamedHost, subject.hosts
-      assert_equal NotNamedHost, subject.find_host('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 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'
+    should have_instance_methods :services_config
   end
 
 end