sanford 0.8.0 → 0.9.0

data/lib/sanford/runner.rb

@@ -7,48 +7,55 @@ module Sanford
 
     ResponseArgs = Struct.new(:status, :data)
 
-    attr_reader :handler_class, :request, :logger
-
     def self.included(klass)
-      klass.class_eval{ extend ClassMethods }
+      klass.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
     end
 
-    def initialize(handler_class, request, logger = nil)
-      @handler_class, @request = handler_class, request
-      @logger = logger || Sanford.config.logger
-      @handler = @handler_class.new(self)
-      self.init
-    end
+    module InstanceMethods
 
-    def init
-      self.init!
-    end
+      attr_reader :handler_class, :request, :logger
 
-    def init!
-    end
+      def initialize(handler_class, request, logger = nil)
+        @handler_class, @request = handler_class, request
+        @logger = logger || Sanford.config.logger
+        @handler = @handler_class.new(self)
+        self.init
+      end
 
-    def run
-      response_args = catch_halt{ self.run!(@handler) }
-      Sanford::Protocol::Response.new(response_args.status, response_args.data)
-    end
+      def init
+        self.init!
+      end
 
-    def run!
-      raise NotImplementedError
-    end
+      def init!
+      end
 
-    # It's best to keep what `halt` and `catch_halt` return in the same format.
-    # Currently this is a `ResponseArgs` object. This is so no matter how the
-    # block returns (either by throwing or running normally), you get the same
-    # thing kind of object.
+      def run
+        response_args = catch_halt{ self.run!(@handler) }
+        Sanford::Protocol::Response.new(response_args.status, response_args.data)
+      end
 
-    def halt(status, options = nil)
-      options = OpenStruct.new(options || {})
-      response_status = [ status, options.message ]
-      throw :halt, ResponseArgs.new(response_status, options.data)
-    end
+      def run!
+        raise NotImplementedError
+      end
+
+      # It's best to keep what `halt` and `catch_halt` return in the same format.
+      # Currently this is a `ResponseArgs` object. This is so no matter how the
+      # block returns (either by throwing or running normally), you get the same
+      # thing kind of object.
+
+      def halt(status, options = nil)
+        options = OpenStruct.new(options || {})
+        response_status = [ status, options.message ]
+        throw :halt, ResponseArgs.new(response_status, options.data)
+      end
+
+      def catch_halt(&block)
+        catch(:halt){ ResponseArgs.new(*block.call) }
+      end
 
-    def catch_halt(&block)
-      catch(:halt){ ResponseArgs.new(*block.call) }
     end
 
     module ClassMethods

data/lib/sanford/server.rb

@@ -9,6 +9,7 @@ module Sanford
 
   class Server
     include DatTCP::Server
+
     attr_reader :sanford_host, :sanford_host_data, :sanford_host_options
 
     def initialize(host, options = nil)

data/lib/sanford/service_handler.rb

@@ -1,6 +1,3 @@
-require 'sanford-protocol'
-require 'sanford/runner'
-
 module Sanford
 
   module ServiceHandler
@@ -18,58 +15,60 @@ module Sanford
     def self.included(klass)
       klass.class_eval do
         extend ClassMethods
+        include InstanceMethods
       end
     end
 
-    def initialize(runner)
-      @sanford_runner = runner
-    end
+    module InstanceMethods
 
-    def init
-      self.run_callback 'before_init'
-      self.init!
-      self.run_callback 'after_init'
-    end
+      def initialize(runner)
+        @sanford_runner = runner
+      end
 
-    def init!
-    end
+      def init
+        self.run_callback 'before_init'
+        self.init!
+        self.run_callback 'after_init'
+      end
 
-    def run
-      self.run_callback 'before_run'
-      data = self.run!
-      self.run_callback 'after_run'
-      [ 200, data ]
-    end
+      def init!
+      end
 
-    def run!
-      raise NotImplementedError
-    end
+      def run
+        self.run_callback 'before_run'
+        data = self.run!
+        self.run_callback 'after_run'
+        [ 200, data ]
+      end
 
-    def inspect
-      reference = '0x0%x' % (self.object_id << 1)
-      "#<#{self.class}:#{reference} @request=#{self.request.inspect}>"
-    end
+      def run!
+        raise NotImplementedError
+      end
 
-    protected
+      def inspect
+        reference = '0x0%x' % (self.object_id << 1)
+        "#<#{self.class}:#{reference} @request=#{self.request.inspect}>"
+      end
 
-    def before_init; end
-    def after_init;  end
-    def before_run;  end
-    def after_run;   end
+      protected
 
-    # Helpers
+      # Helpers
 
-    def run_handler(handler_class, params = nil)
-      handler_class.run(params || {}, self.logger)
-    end
+      def run_handler(handler_class, params = nil)
+        handler_class.run(params || {}, self.logger)
+      end
+
+      def halt(*args); @sanford_runner.halt(*args); end
+      def request;     @sanford_runner.request;     end
+      def params;      self.request.params;         end
+      def logger;      @sanford_runner.logger;      end
 
-    def halt(*args); @sanford_runner.halt(*args); end
-    def request;     @sanford_runner.request;     end
-    def params;      self.request.params;         end
-    def logger;      @sanford_runner.logger;      end
+      def run_callback(callback)
+        (self.class.send("#{callback}_callbacks") || []).each do |callback|
+          self.instance_eval(&callback)
+        end
+      end
 
-    def run_callback(callback)
-      self.send(callback.to_s)
     end
 
     module ClassMethods
@@ -78,6 +77,20 @@ module Sanford
         Sanford.config.runner.run(self, params || {}, logger)
       end
 
+      def before_init_callbacks; @before_init_callbacks ||= []; end
+      def after_init_callbacks;  @after_init_callbacks  ||= []; end
+      def before_run_callbacks;  @before_run_callbacks  ||= []; end
+      def after_run_callbacks;   @after_run_callbacks   ||= []; end
+
+      def before_init(&block); self.before_init_callbacks << block; end
+      def after_init(&block);  self.after_init_callbacks  << block; end
+      def before_run(&block);  self.before_run_callbacks  << block; end
+      def after_run(&block);   self.after_run_callbacks   << block; end
+      def prepend_before_init(&block); self.before_init_callbacks.unshift(block); end
+      def prepend_after_init(&block);  self.after_init_callbacks.unshift(block);  end
+      def prepend_before_run(&block);  self.before_run_callbacks.unshift(block);  end
+      def prepend_after_run(&block);   self.after_run_callbacks.unshift(block);   end
+
     end
 
   end

data/lib/sanford/test_helpers.rb

@@ -0,0 +1,19 @@
+require 'sanford/test_runner'
+
+module Sanford
+
+  module TestHelpers
+
+    module_function
+
+    def test_runner(handler_class, args = nil)
+      TestRunner.new(handler_class, args)
+    end
+
+    def test_handler(handler_class, args = nil)
+      test_runner(handler_class, args).handler
+    end
+
+  end
+
+end

data/lib/sanford/test_runner.rb

@@ -1,14 +1,24 @@
 require 'sanford-protocol'
-
 require 'sanford/runner'
+require 'sanford/service_handler'
 
 module Sanford
 
+  InvalidServiceHandlerError = Class.new(RuntimeError)
+
   class TestRunner
     include Sanford::Runner
 
     attr_reader :handler, :response
 
+    def initialize(handler_class, *args)
+      if !handler_class.include?(Sanford::ServiceHandler)
+        raise InvalidServiceHandlerError, "#{handler_class.inspect} is not a"\
+                                          " Sanford::ServiceHandler"
+      end
+      super
+    end
+
     def init!
       if !@request.kind_of?(Sanford::Protocol::Request)
         @request = test_request(@request)
@@ -21,28 +31,23 @@ module Sanford
     # want to `run` at all.
 
     def run
-      @response ||= build_response catch_halt{ @handler.run }
+      @response ||= build_response(catch_halt{ @handler.run }).tap do |response|
+        # attempt to serialize (and then throw away) the response data
+        # this will error on the developer if BSON can't serialize their response
+        Sanford::Protocol::BsonBody.new.encode(response.to_hash)
+      end
     end
 
     protected
 
     def test_request(params)
-      Sanford::Protocol::Request.new('name', params)
+      Sanford::Protocol::Request.new('name', params || {})
     end
 
     def build_response(response_args)
       Sanford::Protocol::Response.new(response_args.status, response_args.data) if response_args
     end
 
-    module Helpers
-      module_function
-
-      def test_runner(handler_class, params = nil, logger = nil)
-        TestRunner.new(handler_class, params || {}, logger)
-      end
-
-    end
-
   end
 
 end

data/lib/sanford/version.rb

@@ -1,3 +1,3 @@
 module Sanford
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/sanford.rb

@@ -13,14 +13,6 @@ ENV['SANFORD_SERVICES_FILE'] ||= 'config/services'
 
 module Sanford
 
-  def self.register(host)
-    @hosts.add(host)
-  end
-
-  def self.hosts
-    @hosts
-  end
-
   def self.config
     Sanford::Config
   end
@@ -35,6 +27,14 @@ module Sanford
     require self.config.services_file
   end
 
+  def self.register(host)
+    @hosts.add(host)
+  end
+
+  def self.hosts
+    @hosts
+  end
+
   module Config
     include NsOptions::Proxy
     option :services_file,  Pathname, :default => ENV['SANFORD_SERVICES_FILE']
@@ -48,12 +48,22 @@ module Sanford
       @set = Set.new(values)
     end
 
+    def method_missing(method, *args, &block)
+      @set.send(method, *args, &block)
+    end
+
+    def respond_to?(method)
+      super || @set.respond_to?(method)
+    end
+
     # We want class names to take precedence over a configured name, so that if
     # a user specifies a specific class, they always get it
     def find(name)
-      self.find_by_class_name(name) || self.find_by_name(name)
+      find_by_class_name(name) || find_by_name(name)
     end
 
+    private
+
     def find_by_class_name(class_name)
       @set.detect{|host_class| host_class.to_s == class_name.to_s }
     end
@@ -62,14 +72,6 @@ module Sanford
       @set.detect{|host_class| host_class.name == name.to_s }
     end
 
-    def method_missing(method, *args, &block)
-      @set.send(method, *args, &block)
-    end
-
-    def respond_to?(method)
-      super || @set.respond_to?(method)
-    end
-
   end
 
 end

data/sanford.gemspec

@@ -18,10 +18,10 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency("dat-tcp",           ["~>0.4"])
-  gem.add_dependency("ns-options",        ["~>1.0"])
-  gem.add_dependency("sanford-protocol",  ["~>0.6"])
+  gem.add_dependency("dat-tcp",           ["~> 0.4"])
+  gem.add_dependency("ns-options",        ["~> 1.1"])
+  gem.add_dependency("sanford-protocol",  ["~> 0.7"])
 
-  gem.add_development_dependency("assert",        ["~>2.3"])
-  gem.add_development_dependency("assert-mocha",  ["~>1.0"])
+  gem.add_development_dependency("assert",        ["~> 2.10"])
+  gem.add_development_dependency("assert-mocha",  ["~> 1.1"])
 end

data/test/support/service_handlers.rb

@@ -1,71 +1,80 @@
-class TestServiceHandler
+class BasicServiceHandler
   include Sanford::ServiceHandler
 
+  def run!
+    { 'name' => 'Joe Test', 'email' => "joe.test@example.com" }
+  end
+
 end
 
-class BasicServiceHandler
+class SerializeErrorServiceHandler
   include Sanford::ServiceHandler
 
+  # return data that fails BSON serialization
+  # BSON errors if it is sent date/datetime values
   def run!
-    { 'name' => 'Joe Test', 'email' => "joe.test@example.com" }
+    { 'date' => Date.today,
+      'datetime' => DateTime.now
+    }
   end
 
 end
 
-class FlagServiceHandler
-  include Sanford::ServiceHandler
+module CallbackServiceHandler
 
-  attr_reader :before_init_called, :init_bang_called, :after_init_called,
-    :before_run_called, :run_bang_called, :after_run_called
+  def self.included(receiver)
+    receiver.class_eval do
+      attr_reader :before_init_called, :init_bang_called, :after_init_called
+      attr_reader :before_run_called, :run_bang_called, :after_run_called
+      attr_reader :second_before_init_called, :second_after_run_called
 
-  def before_init
-    @before_init_called = true
-  end
+      before_init do
+        @before_init_called = true
+      end
+      before_init do
+        @second_before_init_called = true
+      end
 
-  def init!
-    @init_bang_called = true
-  end
+      after_init do
+        @after_init_called = true
+      end
+
+      before_run do
+        @before_run_called = true
+      end
+
+      after_run do
+        @after_run_called = true
+      end
+      after_run do
+        @second_after_run_called = true
+      end
+
+    end
 
-  def after_init
-    @after_init_called = true
   end
 
-  def before_run
-    @before_run_called = true
+  def init!
+    @init_bang_called = true
   end
 
   def run!
     @run_bang_called = true
   end
 
-  def after_run
-    @after_run_called = true
-  end
-
 end
 
-class RunOtherHandler
+class FlagServiceHandler
   include Sanford::ServiceHandler
+  include CallbackServiceHandler
 
-  def run!
-    response = run_handler(HaltServiceHandler, 'code' => 200, 'data' => 'RunOtherHandler')
-    response.data
-  end
 end
 
-class HaltServiceHandler
+class HaltingBehaviorServiceHandler
   include Sanford::ServiceHandler
+  include CallbackServiceHandler
 
-  def run!
-    halt params['code'], :message => params['message'], :data => params['data']
-  end
-
-end
-
-class HaltingBehaviorServiceHandler < FlagServiceHandler
-
-  def before_init
-    super
+  before_init do
     halt_when('before_init')
   end
 
@@ -74,13 +83,11 @@ class HaltingBehaviorServiceHandler < FlagServiceHandler
     halt_when('init!')
   end
 
-  def after_init
-    super
+  after_init do
     halt_when('after_init')
   end
 
-  def before_run
-    super
+  before_run do
     halt_when('before_run')
   end
 
@@ -89,8 +96,7 @@ class HaltingBehaviorServiceHandler < FlagServiceHandler
     halt_when('run!')
   end
 
-  def after_run
-    super
+  after_run do
     halt_when('after_run')
   end
 
@@ -110,3 +116,23 @@ class HaltingBehaviorServiceHandler < FlagServiceHandler
   end
 
 end
+
+class RunOtherHandler
+  include Sanford::ServiceHandler
+
+  def run!
+    response = run_handler(HaltServiceHandler, 'code' => 200, 'data' => 'RunOtherHandler')
+    response.data
+  end
+end
+
+class HaltServiceHandler
+  include Sanford::ServiceHandler
+
+  def run!
+    halt params['code'], :message => params['message'], :data => params['data']
+  end
+
+end
+
+class InvalidServiceHandler; end

data/test/support/services.rb

@@ -26,7 +26,7 @@ class TestHost
 
   service_handler_ns 'TestHost'
 
-  service 'echo',         'Echo'
+  service :echo,          'Echo'
   service 'bad',          'Bad'
   service 'multiply',     'Multiply'
   service 'halt_it',      '::TestHost::HaltIt'
@@ -76,7 +76,7 @@ class TestHost
   class Authorized
     include Sanford::ServiceHandler
 
-    def before_run
+    before_run do
       halt 401, :message => "Not authorized"
     end
 

data/test/support/simple_client.rb

@@ -1,4 +1,4 @@
-require 'sanford-protocol/test/fake_socket'
+require 'sanford-protocol/fake_socket'
 
 class SimpleClient
 
@@ -56,7 +56,7 @@ class SimpleClient
   protected
 
   def call_using_fake_socket(method, *args)
-    self.call(Sanford::Protocol::Test::FakeSocket.send(method, *args).in)
+    self.call(Sanford::Protocol::FakeSocket.send(method, *args).in)
   end
 
 end

data/test/system/request_handling_tests.rb

@@ -1,5 +1,5 @@
 require 'assert'
-require 'sanford-protocol/test/fake_socket'
+require 'sanford-protocol/fake_socket'
 
 # These tests are intended as a high level test against Sanford's server. They
 # use fake and real connections to test how Sanford behaves.
@@ -197,7 +197,7 @@ class RequestHandlingTests < Assert::Context
         :keep_alive    => true
       })
       @server.on_run
-      @socket = Sanford::Protocol::Test::FakeSocket.new
+      @socket = Sanford::Protocol::FakeSocket.new
       @fake_connection = FakeProtocolConnection.new(@socket)
       Sanford::Protocol::Connection.stubs(:new).with(@socket).returns(@fake_connection)
     end