sanford 0.1.0 → 0.2.0

data/test/unit/service_handler_test.rb

@@ -1,170 +1,181 @@
 require 'assert'
 
+require 'sanford/test_runner'
+
 module Sanford::ServiceHandler
 
   class BaseTest < Assert::Context
+    include Sanford::TestRunner::Helpers
+
     desc "Sanford::ServiceHandler"
     setup do
-      @handler = StaticServiceHandler.new
+      @handler = test_runner(TestServiceHandler).handler
     end
     subject{ @handler }
 
-    should have_instance_methods :logger, :request, :init, :init!, :run, :run!, :halt, :params
+    should have_instance_methods :init, :init!, :run, :run!
 
     should "raise a NotImplementedError if run! is not overwritten" do
       assert_raises(NotImplementedError){ subject.run! }
     end
-    should "return the request's params with #params" do
-      assert_equal subject.request.params, subject.params
-    end
+
   end
 
   class WithMethodFlagsTest < BaseTest
     setup do
-      @handler = FlaggedServiceHandler.new
+      @handler = test_runner(FlagServiceHandler).handler
     end
 
-    should "should call the `init!` method when `init` is called" do
-      subject.init
-
+    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
     end
-    should "run the `init` and `run!` method when `run` is called" do
-      subject.run
 
-      assert_equal true, subject.init_called
-      assert_equal true, subject.run_bang_called
+    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
     end
-    should "run it's callbacks when `run` is called" do
+
+    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
     end
+
   end
 
-  class ManualWithThrowTest < BaseTest
-    desc "run that manuallly throws `:halt`"
-    setup do
-      handler = ManualThrowServiceHandler.new
-      @returned = handler.run
-    end
+  class HaltTest < BaseTest
+    desc "halt"
 
-    should "catch `:halt` and return what was thrown" do
-      assert_equal 'halted!', @returned
-    end
-  end
+    should "return a response with the status code and the passed data" do
+      runner = test_runner(HaltServiceHandler, {
+        'code'    => 648,
+        'data'    => true
+      })
+      runner.run
 
-  class HaltWithAStatusNameAndMessageTest < BaseTest
-    desc "halt with a status name and a message"
-    setup do
-      @halt_with = { :code => :success, :message => "Just a test" }
-      handler = HaltWithServiceHandler.new(@halt_with)
-      @response_status, @data = handler.run
+      assert_equal 648,   runner.response.code
+      assert_equal true,  runner.response.data
+      assert_nil runner.response.status.message
     end
 
-    should "return a response with the status passed to halt and a nil data" do
-      assert_equal @halt_with[:code],     @response_status.first
-      assert_equal @halt_with[:message],  @response_status.last
-      assert_equal @halt_with[:data],     @data
-    end
-  end
+    should "return a response with the status code for the named status and the passed message" do
+      runner = test_runner(HaltServiceHandler, {
+        'code'    => 'ok',
+        'message' => 'test message'
+      })
+      runner.run
 
-  class HaltWithAStatusCodeAndDataTest < BaseTest
-    desc "halt with a status code and data"
-    setup do
-      @halt_with = { :code => 648, :data => true }
-      handler = HaltWithServiceHandler.new(@halt_with)
-      @response_status, @data = handler.run
+      assert_equal 200,             runner.response.code
+      assert_equal 'test message',  runner.response.status.message
+      assert_nil runner.response.data
     end
 
-    should "return a response status and data when passed a number and a data option" do
-      assert_equal @halt_with[:code],     @response_status.first
-      assert_equal @halt_with[:message],  @response_status.last
-      assert_equal @halt_with[:data],     @data
-    end
   end
 
-  class BeforeRunHaltsTest < BaseTest
-    desc "if 'before_run' halts"
-    setup do
-      @handler = ConfigurableServiceHandler.new({
-        :before_run => proc{ halt 601, :message => "before_run halted" }
+  class HaltingTest < BaseTest
+    desc "halting at different points"
+
+    should "not call `init!, `after_init`, `run!` or run's callbacks when `before_init` halts" do
+      runner = test_runner(HaltingBehaviorServiceHandler, {
+        'when' => 'before_init'
       })
-      @response_status, @data = @handler.run
+      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 'before_init halting', response.status.message
     end
 
-    should "only call 'before_run' and 'after_run'" do
-      assert_equal true,  subject.before_run_called
-      assert_equal false, subject.init_called
-      assert_equal false, subject.init_bang_called
-      assert_equal false, subject.run_bang_called
-      assert_equal true,  subject.after_run_called
+    should "not call `after_init`, `run!` or it's callbacks when `init!` halts" do
+      runner = test_runner(HaltingBehaviorServiceHandler, {
+        'when' => 'init!'
+      })
+      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 'init! halting', response.status.message
     end
 
-    should "return the 'before_run' response" do
-      assert_equal 601,                 @response_status.first
-      assert_equal "before_run halted", @response_status.last
-      assert_equal nil,                 @data
+    should "not call `run!` or it's callbacks when `after_init` halts" do
+      runner = test_runner(HaltingBehaviorServiceHandler, {
+        'when' => 'after_init'
+      })
+      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 'after_init halting', response.status.message
     end
-  end
 
-  class AfterRunHaltsTest < BaseTest
-    desc "if 'after_run' halts"
-    setup do
-      @after_run = proc{ halt 801, :message => "after_run halted" }
+    should "not call `run!` or `after_run` when `before_run` halts" do
+      runner = test_runner(HaltingBehaviorServiceHandler, {
+        'when' => 'before_run'
+      })
+      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 'before_run halting', runner.response.status.message
     end
 
-  end
+    should "not call `after_run` when `run!` halts" do
+      runner = test_runner(HaltingBehaviorServiceHandler, {
+        'when' => 'run!'
+      })
+      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]
 
-  class AndBeforeRunHaltsTest < AfterRunHaltsTest
-      desc "and 'before_run' halts"
-      setup do
-        @handler = ConfigurableServiceHandler.new({
-          :before_run => proc{ halt 601, :message => "before_run halted" },
-          :after_run  => @after_run
-        })
-        @response_status, @data = @handler.run
-      end
-
-      should "only call 'before_run' and 'after_run'" do
-        assert_equal true,  subject.before_run_called
-        assert_equal false, subject.init_called
-        assert_equal false, subject.init_bang_called
-        assert_equal false, subject.run_bang_called
-        assert_equal true,  subject.after_run_called
-      end
-
-      should "return the 'after_run' response" do
-        assert_equal 801,                 @response_status.first
-        assert_equal "after_run halted",  @response_status.last
-        assert_equal nil,                 @data
-      end
+      assert_equal 'run! halting', runner.response.status.message
     end
 
-    class AndRunBangHaltsTest < AfterRunHaltsTest
-      desc "and 'run!' halts"
-      setup do
-        @handler = ConfigurableServiceHandler.new({
-          :run!       => proc{ halt 601, :message => "run! halted" },
-          :after_run  => @after_run
-        })
-        @response_status, @data = @handler.run
-      end
-
-      should "call 'init!', 'run!' and the callbacks" do
-        assert_equal true,  subject.before_run_called
-        assert_equal true,  subject.init_called
-        assert_equal true,  subject.init_bang_called
-        assert_equal true,  subject.run_bang_called
-        assert_equal true,  subject.after_run_called
-      end
-
-      should "return the 'after_run' response" do
-        assert_equal 801,                 @response_status.first
-        assert_equal "after_run halted",  @response_status.last
-        assert_equal nil,                 @data
-      end
+    should "call `init`, `run` and their callbacks when `after_run` halts" do
+      runner = test_runner(HaltingBehaviorServiceHandler, {
+        'when' => 'after_run'
+      })
+      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 'after_run halting', runner.response.status.message
     end
 
+  end
+
 end

data/test/unit/worker_test.rb

@@ -0,0 +1,195 @@
+require 'assert'
+
+require 'sanford-protocol/test/helpers'
+
+class Sanford::Worker
+
+  # turn off the protocol's debugging (in case it's on) and turn on Sanford's
+  # debugging
+  class SetupContextToRaiseExceptions < Assert::Context
+    setup do
+      @env_sanford_protocol_debug = ENV['SANFORD_PROTOCOL_DEBUG']
+      @env_sanford_debug = ENV['SANFORD_DEBUG']
+      ENV.delete('SANFORD_PROTOCOL_DEBUG')
+      ENV['SANFORD_DEBUG'] = '1'
+    end
+    teardown do
+      ENV['SANFORD_DEBUG'] = @env_sanford_debug
+      ENV['SANFORD_PROTOCOL_DEBUG'] = @env_sanford_protocol_debug
+    end
+  end
+
+  class BaseTest < SetupContextToRaiseExceptions
+    include Sanford::Protocol::Test::Helpers
+
+    desc "Sanford::Worker"
+    setup do
+      @host_data = Sanford::HostData.new(TestHost)
+      @connection = FakeConnection.with_request('version', 'service', {})
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+    subject{ @worker }
+
+    should have_instance_methods :logger, :run
+
+  end
+
+  class EchoTest < BaseTest
+    desc "running a request for the echo server"
+    setup do
+      @connection = FakeConnection.with_request('v1', 'echo', { :message => 'test' })
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+
+    should "return a successful response and echo the params sent to it" do
+      assert_nothing_raised{ @worker.run }
+      response = @connection.response
+
+      assert_equal 200,     response.status.code
+      assert_equal nil,     response.status.message
+      assert_equal 'test',  response.data
+    end
+
+  end
+
+  class MissingServiceVersionTest < BaseTest
+    desc "running a request with no service version"
+    setup do
+      request_hash = Sanford::Protocol::Request.new('v1', 'what', {}).to_hash
+      request_hash.delete('version')
+      @connection = FakeConnection.new(request_hash)
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+
+    should "return a bad request response" do
+      assert_raises(Sanford::Protocol::BadRequestError) do
+        @worker.run
+      end
+      response = @connection.response
+
+      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
+
+  class MissingServiceNameTest < BaseTest
+    desc "running a request with no service name"
+    setup do
+      request_hash = Sanford::Protocol::Request.new('v1', 'what', {}).to_hash
+      request_hash.delete('name')
+      @connection = FakeConnection.new(request_hash)
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+
+    should "return a bad request response" do
+      assert_raises(Sanford::Protocol::BadRequestError) do
+        @worker.run
+      end
+      response = @connection.response
+
+      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
+
+  class NotFoundServiceTest < BaseTest
+    desc "running a request with no matching service name"
+    setup do
+      @connection = FakeConnection.with_request('v1', 'what', {})
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+
+    should "return a bad request response" do
+      assert_raises(Sanford::NotFoundError) do
+        @worker.run
+      end
+      response = @connection.response
+
+      assert_equal 404, response.status.code
+      assert_equal nil, response.status.message
+      assert_equal nil, response.data
+    end
+
+  end
+
+  class ErrorServiceTest < BaseTest
+    desc "running a request that errors on the server"
+    setup do
+      @connection = FakeConnection.with_request('v1', 'bad', {})
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+
+    should "return a bad request response" do
+      assert_raises(RuntimeError) do
+        @worker.run
+      end
+      response = @connection.response
+
+      assert_equal 500,     response.status.code
+      assert_match "error", response.status.message
+      assert_equal nil,     response.data
+    end
+
+  end
+
+  class HaltTest < BaseTest
+    desc "running a request that halts"
+    setup do
+      @connection = FakeConnection.with_request('v1', 'halt_it', {})
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+
+    should "return the response that was halted" do
+      assert_nothing_raised{ @worker.run }
+      response = @connection.response
+
+      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
+
+  class AuthorizeRequestTest < BaseTest
+    desc "running a request that halts in a callback"
+    setup do
+      @connection = FakeConnection.with_request('v1', 'authorized', {})
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+
+    should "return the response that was halted" do
+      assert_nothing_raised{ @worker.run }
+      response = @connection.response
+
+      assert_equal 401,               response.status.code
+      assert_equal "Not authorized",  response.status.message
+      assert_equal nil,               response.data
+    end
+
+  end
+
+  class WithCustomErrorHandlerTest < BaseTest
+    desc "running a request that triggers our custom error handler"
+    setup do
+      @connection = FakeConnection.with_request('v1', 'custom_error', {})
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+
+    should "return the response that was halted" do
+      assert_raises(::MyCustomError){ @worker.run }
+      response = @connection.response
+
+      assert_equal 987,               response.status.code
+      assert_equal "custom error!",   response.status.message
+      assert_equal nil,               response.data
+    end
+
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sanford
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Collin Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-12-04 00:00:00 Z
+date: 2013-01-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
@@ -55,12 +55,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 15
         segments: 
         - 1
         - 0
-        - 0
-        version: 1.0.0
+        version: "1.0"
   requirement: *id003
   name: ns-options
   type: :runtime
@@ -131,19 +130,23 @@ files:
 - bench/services.rb
 - bench/tasks.rb
 - lib/sanford.rb
-- lib/sanford/config.rb
-- lib/sanford/connection.rb
-- lib/sanford/exception_handler.rb
+- lib/sanford/error_handler.rb
 - lib/sanford/exceptions.rb
 - lib/sanford/host.rb
+- lib/sanford/host_data.rb
+- lib/sanford/logger.rb
 - lib/sanford/manager.rb
 - lib/sanford/rake.rb
+- lib/sanford/runner.rb
 - lib/sanford/server.rb
 - lib/sanford/service_handler.rb
+- lib/sanford/test_runner.rb
 - lib/sanford/version.rb
+- lib/sanford/worker.rb
 - log/.gitkeep
 - sanford.gemspec
 - test/helper.rb
+- test/support/fake_connection.rb
 - test/support/helpers.rb
 - test/support/service_handlers.rb
 - test/support/services.rb
@@ -151,13 +154,17 @@ files:
 - test/system/managing_test.rb
 - test/system/request_handling_test.rb
 - test/unit/config_test.rb
-- test/unit/connection_test.rb
-- test/unit/exception_handler_test.rb
-- test/unit/host/version_group_test.rb
+- test/unit/error_handler_test.rb
+- test/unit/host_configuration_test.rb
+- test/unit/host_data_test.rb
 - test/unit/host_test.rb
+- test/unit/host_version_group_test.rb
+- test/unit/hosts_test.rb
 - test/unit/manager_test.rb
+- test/unit/runner_test.rb
 - test/unit/server_test.rb
 - test/unit/service_handler_test.rb
+- test/unit/worker_test.rb
 homepage: https://github.com/redding/sanford
 licenses: []
 
@@ -193,6 +200,7 @@ specification_version: 3
 summary: Simple hosts for Sanford services.
 test_files: 
 - test/helper.rb
+- test/support/fake_connection.rb
 - test/support/helpers.rb
 - test/support/service_handlers.rb
 - test/support/services.rb
@@ -200,10 +208,14 @@ test_files:
 - test/system/managing_test.rb
 - test/system/request_handling_test.rb
 - test/unit/config_test.rb
-- test/unit/connection_test.rb
-- test/unit/exception_handler_test.rb
-- test/unit/host/version_group_test.rb
+- test/unit/error_handler_test.rb
+- test/unit/host_configuration_test.rb
+- test/unit/host_data_test.rb
 - test/unit/host_test.rb
+- test/unit/host_version_group_test.rb
+- test/unit/hosts_test.rb
 - test/unit/manager_test.rb
+- test/unit/runner_test.rb
 - test/unit/server_test.rb
 - test/unit/service_handler_test.rb
+- test/unit/worker_test.rb

data/lib/sanford/config.rb

@@ -1,33 +0,0 @@
-require 'ns-options'
-require 'pathname'
-require 'set'
-
-ENV['SANFORD_SERVICES_CONFIG'] ||= 'config/services'
-
-module Sanford
-
-  module Config
-    include NsOptions::Proxy
-
-    option :hosts,            Set,      :default => []
-    option :services_config,  Pathname, :default => ENV['SANFORD_SERVICES_CONFIG']
-
-    # 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 self.find_host(name)
-      self.find_host_by_class_name(name) || self.find_host_by_name(name)
-    end
-
-    protected
-
-    def self.find_host_by_class_name(class_name)
-      self.hosts.detect{|host_class| host_class.to_s == class_name.to_s }
-    end
-
-    def self.find_host_by_name(name)
-      self.hosts.detect{|host_class| host_class.name == name.to_s }
-    end
-
-  end
-
-end