sanford 0.8.0 → 0.9.0

data/test/unit/service_handler_tests.rb

@@ -1,23 +1,28 @@
 require 'assert'
-require 'sanford/test_runner'
+require 'sanford/service_handler'
+
+require 'bson'
+require 'sanford/test_helpers'
+require 'test/support/service_handlers'
 
 module Sanford::ServiceHandler
 
-  class BaseTests < Assert::Context
-    include Sanford::TestRunner::Helpers
+  class UnitTests < Assert::Context
+    include Sanford::TestHelpers
 
     desc "Sanford::ServiceHandler"
     setup do
-      @handler = test_runner(TestServiceHandler).handler
+      @handler_class = Class.new{ include Sanford::ServiceHandler }
     end
-    subject{ @handler }
+    subject{ @handler_class }
 
-    should have_instance_methods :init, :init!, :run, :run!
-    should have_class_methods :run
-
-    should "raise a NotImplementedError if run! is not overwritten" do
-      assert_raises(NotImplementedError){ subject.run! }
-    end
+    should have_imeths :run
+    should have_imeths :before_init_callbacks, :after_init_callbacks
+    should have_imeths :before_run_callbacks,  :after_run_callbacks
+    should have_imeths :before_init, :after_init
+    should have_imeths :before_run,  :after_run
+    should have_imeths :prepend_before_init, :prepend_after_init
+    should have_imeths :prepend_before_run,  :prepend_after_run
 
     should "allow running a handler class with the class method #run" do
       response = HaltServiceHandler.run({
@@ -28,46 +33,130 @@ module Sanford::ServiceHandler
       assert_equal true,  response.data
     end
 
-  end
+    should "return an empty array by default using `before_init_callbacks`" do
+      assert_equal [], subject.before_init_callbacks
+    end
 
-  class RunHandlerTests < BaseTests
-    desc "run_handler helper"
+    should "return an empty array by default using `after_init_callbacks`" do
+      assert_equal [], subject.after_init_callbacks
+    end
 
-    should "allow easily running another handler" do
-      response = test_runner(RunOtherHandler).run
-      assert_equal 'RunOtherHandler', response.data
+    should "return an empty array by default using `before_run_callbacks`" do
+      assert_equal [], subject.before_run_callbacks
+    end
+
+    should "return an empty array by default using `after_run_callbacks`" do
+      assert_equal [], subject.after_run_callbacks
+    end
+
+    should "append a block to the before init callbacks using `before_init`" do
+      subject.before_init_callbacks << proc{ }
+      block = Proc.new{}
+      subject.before_init(&block)
+      assert_equal block, subject.before_init_callbacks.last
+    end
+
+    should "append a block to the after init callbacks using `after_init`" do
+      subject.after_init_callbacks << proc{ }
+      block = Proc.new{}
+      subject.after_init(&block)
+      assert_equal block, subject.after_init_callbacks.last
+    end
+
+    should "append a block to the before run callbacks using `before_run`" do
+      subject.before_run_callbacks << proc{ }
+      block = Proc.new{}
+      subject.before_run(&block)
+      assert_equal block, subject.before_run_callbacks.last
+    end
+
+    should "append a block to the after run callbacks using `after_run`" do
+      subject.after_run_callbacks << proc{ }
+      block = Proc.new{}
+      subject.after_run(&block)
+      assert_equal block, subject.after_run_callbacks.last
+    end
+
+    should "prepend a block to the before init callbacks using `prepend_before_init`" do
+      subject.before_init_callbacks << proc{ }
+      block = Proc.new{}
+      subject.prepend_before_init(&block)
+      assert_equal block, subject.before_init_callbacks.first
+    end
+
+    should "prepend a block to the after init callbacks using `prepend_after_init`" do
+      subject.after_init_callbacks << proc{ }
+      block = Proc.new{}
+      subject.prepend_after_init(&block)
+      assert_equal block, subject.after_init_callbacks.first
+    end
+
+    should "prepend a block to the before run callbacks using `prepend_before_run`" do
+      subject.before_run_callbacks << proc{ }
+      block = Proc.new{}
+      subject.prepend_before_run(&block)
+      assert_equal block, subject.before_run_callbacks.first
+    end
+
+    should "prepend a block to the after run callbacks using `prepend_after_run`" do
+      subject.after_run_callbacks << proc{ }
+      block = Proc.new{}
+      subject.prepend_after_run(&block)
+      assert_equal block, subject.after_run_callbacks.first
     end
+
   end
 
-  class WithMethodFlagsTests < BaseTests
+  class InitTests < UnitTests
+    desc "when init"
     setup do
       @handler = test_runner(FlagServiceHandler).handler
     end
+    subject{ @handler }
+
+    should have_imeths :init, :init!, :run, :run!
+
+    should "raise a NotImplementedError if run! is not overwritten" do
+      handler = test_handler(@handler_class)
+      assert_raises(NotImplementedError){ handler.run! }
+    end
 
     should "have called `init!` and it's callbacks" do
-      assert_equal true, subject.before_init_called
-      assert_equal true, subject.init_bang_called
-      assert_equal true, subject.after_init_called
+      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
       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
       subject.run
 
-      assert_equal true, subject.before_run_called
-      assert_equal true, subject.run_bang_called
-      assert_equal true, subject.after_run_called
+      assert_true subject.before_run_called
+      assert_true subject.run_bang_called
+      assert_true subject.after_run_called
+      assert_true subject.second_after_run_called
     end
 
   end
 
-  class HaltTests < BaseTests
-    desc "halt"
+  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 HaltTests < UnitTests
+    desc "when halted"
 
     should "return a response with the status code and the passed data" do
       runner = test_runner(HaltServiceHandler, {
@@ -76,8 +165,8 @@ module Sanford::ServiceHandler
       })
       runner.run
 
-      assert_equal 648,   runner.response.code
-      assert_equal true,  runner.response.data
+      assert_equal 648, runner.response.code
+      assert_true runner.response.data
       assert_nil runner.response.status.message
     end
 
@@ -88,15 +177,15 @@ module Sanford::ServiceHandler
       })
       runner.run
 
-      assert_equal 200,             runner.response.code
-      assert_equal 'test message',  runner.response.status.message
+      assert_equal 200, runner.response.code
+      assert_equal 'test message', runner.response.status.message
       assert_nil runner.response.data
     end
 
   end
 
-  class HaltingTests < BaseTests
-    desc "halting at different points"
+  class HaltingTests < UnitTests
+    desc "when halted at different points"
 
     should "not call `init!, `after_init`, `run!` or run's callbacks when `before_init` halts" do
       runner = test_runner(HaltingBehaviorServiceHandler, {
@@ -104,12 +193,12 @@ module Sanford::ServiceHandler
       })
       response = runner.response
 
-      assert_equal true,  response.data[:before_init_called]
-      assert_equal nil,   response.data[:init_bang_called]
-      assert_equal nil,   response.data[:after_init_called]
-      assert_equal nil,   response.data[:before_run_called]
-      assert_equal nil,   response.data[:run_bang_called]
-      assert_equal nil,   response.data[:after_run_called]
+      assert_equal true, response.data[:before_init_called]
+      assert_equal nil,  response.data[:init_bang_called]
+      assert_equal nil,  response.data[:after_init_called]
+      assert_equal nil,  response.data[:before_run_called]
+      assert_equal nil,  response.data[:run_bang_called]
+      assert_equal nil,  response.data[:after_run_called]
 
       assert_equal 'before_init halting', response.status.message
     end
@@ -120,12 +209,12 @@ module Sanford::ServiceHandler
       })
       response = runner.response
 
-      assert_equal true,  response.data[:before_init_called]
-      assert_equal true,  response.data[:init_bang_called]
-      assert_equal nil,   response.data[:after_init_called]
-      assert_equal nil,   response.data[:before_run_called]
-      assert_equal nil,   response.data[:run_bang_called]
-      assert_equal nil,   response.data[:after_run_called]
+      assert_equal true, response.data[:before_init_called]
+      assert_equal true, response.data[:init_bang_called]
+      assert_equal nil,  response.data[:after_init_called]
+      assert_equal nil,  response.data[:before_run_called]
+      assert_equal nil,  response.data[:run_bang_called]
+      assert_equal nil,  response.data[:after_run_called]
 
       assert_equal 'init! halting', response.status.message
     end
@@ -136,12 +225,12 @@ module Sanford::ServiceHandler
       })
       response = runner.response
 
-      assert_equal true,  response.data[:before_init_called]
-      assert_equal true,  response.data[:init_bang_called]
-      assert_equal true,  response.data[:after_init_called]
-      assert_equal nil,   response.data[:before_run_called]
-      assert_equal nil,   response.data[:run_bang_called]
-      assert_equal nil,   response.data[:after_run_called]
+      assert_equal true, response.data[:before_init_called]
+      assert_equal true, response.data[:init_bang_called]
+      assert_equal true, response.data[:after_init_called]
+      assert_equal nil,  response.data[:before_run_called]
+      assert_equal nil,  response.data[:run_bang_called]
+      assert_equal nil,  response.data[:after_run_called]
 
       assert_equal 'after_init halting', response.status.message
     end
@@ -152,12 +241,12 @@ module Sanford::ServiceHandler
       })
       response = runner.run
 
-      assert_equal true,  response.data[:before_init_called]
-      assert_equal true,  response.data[:init_bang_called]
-      assert_equal true,  response.data[:after_init_called]
-      assert_equal true,  response.data[:before_run_called]
-      assert_equal nil,   response.data[:run_bang_called]
-      assert_equal nil,   response.data[:after_run_called]
+      assert_equal true, response.data[:before_init_called]
+      assert_equal true, response.data[:init_bang_called]
+      assert_equal true, response.data[:after_init_called]
+      assert_equal true, response.data[:before_run_called]
+      assert_equal nil,  response.data[:run_bang_called]
+      assert_equal nil,  response.data[:after_run_called]
 
       assert_equal 'before_run halting', runner.response.status.message
     end
@@ -168,12 +257,12 @@ module Sanford::ServiceHandler
       })
       response = runner.run
 
-      assert_equal true,  response.data[:before_init_called]
-      assert_equal true,  response.data[:init_bang_called]
-      assert_equal true,  response.data[:after_init_called]
-      assert_equal true,  response.data[:before_run_called]
-      assert_equal true,  response.data[:run_bang_called]
-      assert_equal nil,   response.data[:after_run_called]
+      assert_equal true, response.data[:before_init_called]
+      assert_equal true, response.data[:init_bang_called]
+      assert_equal true, response.data[:after_init_called]
+      assert_equal true, response.data[:before_run_called]
+      assert_equal true, response.data[:run_bang_called]
+      assert_equal nil,  response.data[:after_run_called]
 
       assert_equal 'run! halting', runner.response.status.message
     end
@@ -184,16 +273,38 @@ module Sanford::ServiceHandler
       })
       response = runner.run
 
-      assert_equal true,  response.data[:before_init_called]
-      assert_equal true,  response.data[:init_bang_called]
-      assert_equal true,  response.data[:after_init_called]
-      assert_equal true,  response.data[:before_run_called]
-      assert_equal true,  response.data[:run_bang_called]
-      assert_equal true,  response.data[:after_run_called]
+      assert_equal true, response.data[:before_init_called]
+      assert_equal true, response.data[:init_bang_called]
+      assert_equal true, response.data[:after_init_called]
+      assert_equal true, response.data[:before_run_called]
+      assert_equal true, response.data[:run_bang_called]
+      assert_equal true, response.data[:after_run_called]
 
       assert_equal 'after_run halting', runner.response.status.message
     end
 
   end
 
+  class InvalidHandlerTests < UnitTests
+    desc "that is invalid"
+
+    should "raise a custom error when initialized in a test" do
+      assert_raises Sanford::InvalidServiceHandlerError do
+        test_handler(InvalidServiceHandler)
+      end
+    end
+
+  end
+
+  class SerializeErrorTests < UnitTests
+    desc "that failse to serialize to BSON"
+
+    should "raise a BSON error when run in a test" do
+      assert_raises BSON::InvalidDocument do
+        test_runner(SerializeErrorServiceHandler).run
+      end
+    end
+
+  end
+
 end

data/test/unit/worker_tests.rb

@@ -1,11 +1,12 @@
 require 'assert'
-require 'sanford-protocol/test/helpers'
+require 'sanford/worker'
 
-class Sanford::Worker
+require 'sanford/host_data'
+require 'test/support/fake_connection'
 
-  class BaseTests < Assert::Context
-    include Sanford::Protocol::Test::Helpers
+class Sanford::Worker
 
+  class UnitTests < Assert::Context
     desc "Sanford::Worker"
     setup do
       @host_data = Sanford::HostData.new(TestHost)
@@ -14,7 +15,7 @@ class Sanford::Worker
     end
     subject{ @worker }
 
-    should have_instance_methods :logger, :run
+    should have_imeths :logger, :run
 
   end
 

metadata

@@ -1,13 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sanford
 version: !ruby/object:Gem::Version 
-  hash: 63
-  prerelease: 
-  segments: 
-  - 0
-  - 8
-  - 0
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Collin Redding
@@ -16,83 +10,58 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-10-14 00:00:00 Z
+date: 2014-06-06 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
-    none: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        - 4
         version: "0.4"
   type: :runtime
-  requirement: *id001
-  prerelease: false
+  version_requirements: *id001
   name: dat-tcp
+  prerelease: false
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
-    none: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        version: "1.0"
+        version: "1.1"
   type: :runtime
-  requirement: *id002
-  prerelease: false
+  version_requirements: *id002
   name: ns-options
+  prerelease: false
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
-    none: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 0
-        - 6
-        version: "0.6"
+        version: "0.7"
   type: :runtime
-  requirement: *id003
-  prerelease: false
+  version_requirements: *id003
   name: sanford-protocol
+  prerelease: false
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
-    none: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 2
-        - 3
-        version: "2.3"
+        version: "2.10"
   type: :development
-  requirement: *id004
-  prerelease: false
+  version_requirements: *id004
   name: assert
+  prerelease: false
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
-    none: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        version: "1.0"
+        version: "1.1"
   type: :development
-  requirement: *id005
-  prerelease: false
+  version_requirements: *id005
   name: assert-mocha
+  prerelease: false
 description: Sanford TCP protocol server for hosting services
 email: 
 - collin.redding@me.com
@@ -121,9 +90,11 @@ files:
 - lib/sanford/host.rb
 - lib/sanford/host_data.rb
 - lib/sanford/logger.rb
+- lib/sanford/manager.rb
 - lib/sanford/runner.rb
 - lib/sanford/server.rb
 - lib/sanford/service_handler.rb
+- lib/sanford/test_helpers.rb
 - lib/sanford/test_runner.rb
 - lib/sanford/version.rb
 - lib/sanford/worker.rb
@@ -136,15 +107,12 @@ files:
 - test/support/services.rb
 - test/support/simple_client.rb
 - test/system/request_handling_tests.rb
-- test/unit/config_tests.rb
 - test/unit/error_handler_tests.rb
-- test/unit/host_configuration_tests.rb
 - test/unit/host_data_tests.rb
 - test/unit/host_tests.rb
-- test/unit/hosts_tests.rb
-- test/unit/manager_pid_file_tests.rb
 - test/unit/manager_tests.rb
 - test/unit/runner_tests.rb
+- test/unit/sanford_tests.rb
 - test/unit/server_tests.rb
 - test/unit/service_handler_tests.rb
 - test/unit/worker_tests.rb
@@ -152,35 +120,28 @@ files:
 homepage: https://github.com/redding/sanford
 licenses: 
 - MIT
+metadata: {}
+
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
+  - &id006 
+    - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  - *id006
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Sanford TCP protocol server for hosting services
 test_files: 
 - test/helper.rb
@@ -190,15 +151,12 @@ test_files:
 - test/support/services.rb
 - test/support/simple_client.rb
 - test/system/request_handling_tests.rb
-- test/unit/config_tests.rb
 - test/unit/error_handler_tests.rb
-- test/unit/host_configuration_tests.rb
 - test/unit/host_data_tests.rb
 - test/unit/host_tests.rb
-- test/unit/hosts_tests.rb
-- test/unit/manager_pid_file_tests.rb
 - test/unit/manager_tests.rb
 - test/unit/runner_tests.rb
+- test/unit/sanford_tests.rb
 - test/unit/server_tests.rb
 - test/unit/service_handler_tests.rb
 - test/unit/worker_tests.rb

data/test/unit/config_tests.rb

@@ -1,12 +0,0 @@
-require 'assert'
-
-module Sanford::Config
-
-  class BaseTests < Assert::Context
-    desc "Sanford::Config"
-    subject{ Sanford::Config }
-
-    should have_instance_methods :services_file, :logger
-  end
-
-end

data/test/unit/host_configuration_tests.rb

@@ -1,37 +0,0 @@
-require 'assert'
-
-class Sanford::Host::Configuration
-
-  class BaseTests < 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_file, :logger,
-      :verbose_logging, :logger, :error_procs
-
-    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 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