sanford 0.14.0 → 0.15.0

data/test/unit/error_handler_tests.rb

@@ -1,6 +1,7 @@
 require 'assert'
 require 'sanford/error_handler'
 
+require 'sanford-protocol'
 require 'sanford/server_data'
 
 class Sanford::ErrorHandler
@@ -8,176 +9,311 @@ class Sanford::ErrorHandler
   class UnitTests < Assert::Context
     desc "Sanford::ErrorHandler"
     setup do
-      @exception = RuntimeError.new('test')
+      @exception   = Factory.exception
       @server_data = Sanford::ServerData.new
-      @error_handler = Sanford::ErrorHandler.new(@exception, @server_data)
+      @request     = Sanford::Protocol::Request.new(Factory.string, {
+        Factory.string => Factory.string
+      })
+      @response = Sanford::Protocol::Response.new(Factory.integer)
+      @context_hash = {
+        :server_data   => @server_data,
+        :request       => @request,
+        :handler_class => Factory.string,
+        :response      => @response
+      }
+
+      @handler_class = Sanford::ErrorHandler
     end
-    subject{ @error_handler }
+    subject{ @handler_class }
 
-    should have_imeths :exception, :server_data, :request, :run
+  end
 
-    should "return a Sanford::Protocol::Response with `run`" do
-      assert_instance_of Sanford::Protocol::Response, subject.run
+  class InitSetupTests < UnitTests
+    desc "when init"
+    setup do
+      # always make sure there are multiple error procs or tests can be false
+      # positives
+      @error_proc_spies = (1..(Factory.integer(3) + 1)).map{ ErrorProcSpy.new }
+      Assert.stub(@server_data, :error_procs){ @error_proc_spies }
     end
 
-    def generate_exception(exception_class, message = nil)
-      exception = nil
-      begin
-        raise exception_class, message
-      rescue Exception => exception
-      end
-      exception
+  end
+
+  class InitTests < InitSetupTests
+    desc "when init"
+    setup do
+      @handler = @handler_class.new(@exception, @context_hash)
+    end
+    subject{ @handler }
+
+    should have_readers :exception, :context
+    should have_imeths :run
+
+    should "know its exception and context" do
+      assert_equal @exception, subject.exception
+      exp = Sanford::ErrorContext.new(@context_hash)
+      assert_equal exp, subject.context
+    end
+
+    should "know its error procs" do
+      assert_equal @error_proc_spies.reverse, subject.error_procs
     end
 
   end
 
-  class ResponseFromProcTests < UnitTests
-    desc "generating a respone from an error proc"
+  class RunSetupTests < InitTests
+    desc "and run"
 
-    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
-      server_data = Sanford::ServerData.new(:error_procs => [ error_proc ])
-      response = Sanford::ErrorHandler.new(@exception, server_data).run
+  end
+
+  class RunTests < RunSetupTests
+    setup do
+      @handler.run
+    end
 
-      assert_equal 567, response.code
-      assert_equal 'custom message', response.status.message
-      assert_equal 'custom data', response.data
+    should "call each of its procs" do
+      subject.error_procs.each_with_index do |spy, index|
+        assert_true spy.called
+        assert_equal subject.exception, spy.exception
+        assert_equal subject.context,   spy.context
+      end
     end
 
-    should "use an integer returned by the error proc to generate a protocol response" do
-      server_data = Sanford::ServerData.new(:error_procs => [ proc{ 345 } ])
-      response = Sanford::ErrorHandler.new(@exception, server_data).run
+  end
 
-      assert_equal 345, response.code
-      assert_nil response.status.message
-      assert_nil response.data
+  class RunWithNoResponseFromErrorProcSetupTests < RunSetupTests
+    desc "without a response being returned from its error procs"
+    setup do
+      @error_proc_spies.each{ |s| s.response = nil }
     end
 
-    should "use a symbol returned by the error proc to generate a protocol response" do
-      server_data = Sanford::ServerData.new({
-        :error_procs => [ proc{ :not_found } ]
-      })
-      response = Sanford::ErrorHandler.new(@exception, server_data).run
+  end
+
+  class RunWithBadMessageErrorTests < RunWithNoResponseFromErrorProcSetupTests
+    desc "but with a bad message error exception"
+    setup do
+      @exception = Factory.exception(Sanford::Protocol::BadMessageError)
 
-      assert_equal 404, response.code
-      assert_nil response.status.message
-      assert_nil response.data
+      @handler  = @handler_class.new(@exception, @context_hash)
+      @response = @handler.run
     end
+    subject{ @response }
 
-    should "use the default behavior if the error proc doesn't return a valid response result" do
-      server_data = Sanford::ServerData.new(:error_procs => [ proc{ true } ])
-      response = Sanford::ErrorHandler.new(@exception, server_data).run
+    should "return a bad request response" do
+      exp = Sanford::Protocol::Response.new([:bad_request, @exception.message])
+      assert_equal exp, subject
+    end
+
+  end
 
-      assert_equal 500, response.code
-      assert_equal 'An unexpected error occurred.', response.status.message
+  class RunWithInvalidRequestErrorTests < RunWithNoResponseFromErrorProcSetupTests
+    desc "but with an invalid request error exception"
+    setup do
+      @exception = Factory.exception(Sanford::Protocol::Request::InvalidError)
+
+      @handler  = @handler_class.new(@exception, @context_hash)
+      @response = @handler.run
     end
+    subject{ @response }
 
-    should "use the default behavior for an exception raised by the error proc " \
-           "and ignore the original exception" do
-      server_data = Sanford::ServerData.new({
-        :error_procs => [ proc{ raise Sanford::NotFoundError } ]
-      })
-      response = Sanford::ErrorHandler.new(@exception, server_data).run
+    should "return a bad request response" do
+      exp = Sanford::Protocol::Response.new([:bad_request, @exception.message])
+      assert_equal exp, subject
+    end
 
-      assert_equal 404, response.code
-      assert_nil response.status.message
-      assert_nil response.data
+  end
+
+  class RunWithNotFoundErrorTests < RunWithNoResponseFromErrorProcSetupTests
+    desc "but with a not found error exception"
+    setup do
+      @exception = Factory.exception(Sanford::NotFoundError)
+
+      @handler  = @handler_class.new(@exception, @context_hash)
+      @response = @handler.run
+    end
+    subject{ @response }
+
+    should "return a not found response" do
+      exp = Sanford::Protocol::Response.new(:not_found)
+      assert_equal exp, subject
     end
 
   end
 
-  class ResponseFromExceptionTests < UnitTests
-    desc "generating a respone from an exception"
+  class RunWithTimeoutErrorTests < RunWithNoResponseFromErrorProcSetupTests
+    desc "but with a timeout error exception"
+    setup do
+      @exception = Factory.exception(Sanford::Protocol::TimeoutError)
 
-    should "build a 400 response with a protocol BadMessageError" do
-      exception = generate_exception(Sanford::Protocol::BadMessageError, 'bad message')
-      response = Sanford::ErrorHandler.new(exception, @server_data).run
+      @handler  = @handler_class.new(@exception, @context_hash)
+      @response = @handler.run
+    end
+    subject{ @response }
 
-      assert_equal 400, response.code
-      assert_equal 'bad message', response.status.message
+    should "return a timeout response" do
+      exp = Sanford::Protocol::Response.new(:timeout)
+      assert_equal exp, subject
     end
 
-    should "build a 400 response with a protocol request invalid error" do
-      exception = generate_exception(Sanford::Protocol::Request::InvalidError, 'bad request')
-      response = Sanford::ErrorHandler.new(exception, @server_data).run
+  end
+
+  class RunWithGenericErrorTests < RunWithNoResponseFromErrorProcSetupTests
+    desc "but with a generic error"
+    setup do
+      @exception = Factory.exception
+
+      @handler  = @handler_class.new(@exception, @context_hash)
+      @response = @handler.run
+    end
+    subject{ @response }
 
-      assert_equal 400, response.code
-      assert_equal 'bad request', response.status.message
+    should "return an error response" do
+      exp = Sanford::Protocol::Response.new([:error, "An unexpected error occurred."])
+      assert_equal exp, subject
     end
 
-    should "build a 404 response with a NotFoundError" do
-      exception = generate_exception(Sanford::NotFoundError, 'not found')
-      response = Sanford::ErrorHandler.new(exception, @server_data).run
+  end
+
+  class RunWithErrorProcExceptionsTests < InitSetupTests
+    desc "and run with error procs that throw exceptions"
+    setup do
+      @proc_exceptions = @error_proc_spies.reverse.map do |spy|
+        exception = Factory.exception(RuntimeError, @error_proc_spies.index(spy).to_s)
+        spy.raise_exception = exception
+        exception
+      end
 
-      assert_equal 404, response.code
-      assert_nil response.status.message
+      @handler  = @handler_class.new(@exception, @context_hash)
+      @response = @handler.run
     end
+    subject{ @handler }
 
-    should "build a 500 response with all other exceptions" do
-      response = Sanford::ErrorHandler.new(RuntimeError.new('test'), @server_data).run
+    should "pass the previously raised exception to the next proc" do
+      exp = [@exception] + @proc_exceptions[0..-2]
+      assert_equal exp, subject.error_procs.map(&:exception)
+    end
+
+    should "set its exception to the last exception thrown by the procs" do
+      assert_equal @proc_exceptions.last, subject.exception
+    end
 
-      assert_equal 500, response.code
-      assert_equal 'An unexpected error occurred.', response.status.message
+    should "return an error response" do
+      exp = Sanford::Protocol::Response.new([:error, "An unexpected error occurred."])
+      assert_equal exp, @response
     end
 
   end
 
-  class MultipleErrorProcsTests < ResponseFromProcTests
-    desc "with multiple error procs"
+  class RunWithProtocolResponseFromErrorProcTests < RunSetupTests
+    desc "with a protocol response returned from an error proc"
     setup do
-      @first_called, @second_called, @third_called = nil, nil, nil
-      @server_data = Sanford::ServerData.new({
-        :error_procs => [ first_proc, second_proc, third_proc ]
-      })
+      @proc_response = Sanford::Protocol::Response.new(Factory.integer)
+      @error_proc_spies.choice.response = @proc_response
+
+      @response = @handler.run
     end
+    subject{ @response }
 
-    should "call every error proc" do
-      exception = RuntimeError.new('test')
-      @error_handler = Sanford::ErrorHandler.new(exception, @server_data)
-      @error_handler.run
+    should "return the protocol response from the error proc" do
+      assert_equal @proc_response, subject
+    end
+
+  end
+
+  class RunWithResponseCodeFromErrorProcTests < RunSetupTests
+    desc "with a response code returned from an error proc"
+    setup do
+      @response_code = Factory.integer
+      @error_proc_spies.choice.response = @response_code
 
-      assert_equal true, @first_called
-      assert_equal true, @second_called
-      assert_equal true, @third_called
+      @response = @handler.run
     end
+    subject{ @response }
 
-    should "should return the response of the last configured error proc " \
-           "that returned a valid response" do
-      exception = RuntimeError.new('test')
-      @error_handler = Sanford::ErrorHandler.new(exception, @server_data)
-      response = @error_handler.run
+    should "use the response code to build a response and return it" do
+      exp = Sanford::Protocol::Response.new(@response_code)
+      assert_equal exp, subject
+    end
 
-      # use the second proc's generated response
-      assert_equal 987, response.code
+  end
 
-      exception = generate_exception(Sanford::NotFoundError, 'not found')
-      @error_handler = Sanford::ErrorHandler.new(exception, @server_data)
-      response = @error_handler.run
+  class RunWithSymbolFromErrorProcTests < RunSetupTests
+    desc "with a response symbol returned from an error proc"
+    setup do
+      @response_symbol = [:not_found, :bad_request, :error].choice
+      @error_proc_spies.choice.response = @response_symbol
 
-      # use the third proc's generated response
-      assert_equal 876, response.code
+      @response = @handler.run
     end
+    subject{ @response }
 
-    def first_proc
-      proc{ @first_called = true }
+    should "use the response symbol to build a response and return it" do
+      exp = Sanford::Protocol::Response.new(@response_symbol)
+      assert_equal exp, subject
     end
 
-    def second_proc
-      proc do |exception, server_data, request|
-        @second_called = true
-        987
+  end
+
+  class RunWithMultipleResponseFromErrorProcTests < RunSetupTests
+    desc "with responses from multiple error procs"
+    setup do
+      @error_proc_spies.each do |spy|
+        spy.response = Sanford::Protocol::Response.new(Factory.integer)
       end
+
+      @response = @handler.run
     end
+    subject{ @response }
 
-    def third_proc
-      proc do |exception, server_data, request|
-        @third_called = true
-        876 if exception.kind_of?(Sanford::NotFoundError)
-      end
+    should "return the last response from its error procs" do
+      assert_equal @error_proc_spies.last.response, subject
+    end
+
+  end
+
+  class ErrorContextTests < UnitTests
+    desc "ErrorContext"
+    setup do
+      @context = Sanford::ErrorContext.new(@context_hash)
+    end
+    subject{ @context }
+
+    should have_readers :server_data
+    should have_readers :request, :handler_class, :response
+
+    should "know its attributes" do
+      assert_equal @context_hash[:server_data],   subject.server_data
+      assert_equal @context_hash[:request],       subject.request
+      assert_equal @context_hash[:handler_class], subject.handler_class
+      assert_equal @context_hash[:response],      subject.response
     end
 
+    should "know if it equals another context" do
+      exp = Sanford::ErrorContext.new(@context_hash)
+      assert_equal exp, subject
+
+      exp = Sanford::ErrorContext.new({})
+      assert_not_equal exp, subject
+    end
+
+  end
+
+  class ErrorProcSpy
+    attr_reader :called, :exception, :context
+    attr_accessor :response, :raise_exception
+
+    def initialize
+      @called = false
+    end
+
+    def call(exception, context)
+      @called    = true
+      @exception = exception
+      @context   = context
+
+      raise self.raise_exception if self.raise_exception
+      @response
+    end
   end
 
 end

data/test/unit/process_tests.rb

@@ -18,13 +18,9 @@ class Sanford::Process
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @current_env_ip = ENV['SANFORD_IP']
-      @current_env_port = ENV['SANFORD_PORT']
-      @current_env_server_fd = ENV['SANFORD_SERVER_FD']
-      @current_env_client_fds = ENV['SANFORD_CLIENT_FDS']
+      @current_env_server_fd      = ENV['SANFORD_SERVER_FD']
+      @current_env_client_fds     = ENV['SANFORD_CLIENT_FDS']
       @current_env_skip_daemonize = ENV['SANFORD_SKIP_DAEMONIZE']
-      ENV.delete('SANFORD_IP')
-      ENV.delete('SANFORD_PORT')
       ENV.delete('SANFORD_SERVER_FD')
       ENV.delete('SANFORD_CLIENT_FDS')
       ENV.delete('SANFORD_SKIP_DAEMONIZE')
@@ -43,10 +39,8 @@ class Sanford::Process
     end
     teardown do
       ENV['SANFORD_SKIP_DAEMONIZE'] = @current_env_skip_daemonize
-      ENV['SANFORD_CLIENT_FDS'] = @current_env_client_fds
-      ENV['SANFORD_SERVER_FD'] = @current_env_server_fd
-      ENV['SANFORD_PORT'] = @current_env_ip
-      ENV['SANFORD_IP'] = @current_env_port
+      ENV['SANFORD_CLIENT_FDS']     = @current_env_client_fds
+      ENV['SANFORD_SERVER_FD']      = @current_env_server_fd
     end
     subject{ @process }
 
@@ -72,23 +66,17 @@ class Sanford::Process
       assert_nil subject.server_fd
     end
 
-    should "set its server ip, port and file descriptor using env vars" do
-      ENV['SANFORD_IP'] = Factory.string
-      ENV['SANFORD_PORT'] = Factory.integer.to_s
+    should "allow overriding its file descriptor using an env var" do
       ENV['SANFORD_SERVER_FD'] = Factory.integer.to_s
       process = @process_class.new(@server_spy)
-      assert_equal ENV['SANFORD_IP'], process.server_ip
-      assert_equal ENV['SANFORD_PORT'].to_i, process.server_port
       assert_equal ENV['SANFORD_SERVER_FD'].to_i, process.server_fd
-    end
 
-    should "ignore blank env values for its server ip, port and fd" do
-      ENV['SANFORD_IP'] = ''
-      ENV['SANFORD_PORT'] = ''
       ENV['SANFORD_SERVER_FD'] = ''
       process = @process_class.new(@server_spy)
-      assert_equal @server_spy.configured_ip, process.server_ip
-      assert_equal @server_spy.configured_port, process.server_port
+      assert_nil process.server_fd
+
+      ENV.delete('SANFORD_SERVER_FD')
+      process = @process_class.new(@server_spy)
       assert_nil process.server_fd
     end
 
@@ -97,7 +85,7 @@ class Sanford::Process
     end
 
     should "set its client file descriptors using an env var" do
-      client_fds = [ Factory.integer, Factory.integer ]
+      client_fds = [Factory.integer, Factory.integer]
       ENV['SANFORD_CLIENT_FDS'] = client_fds.join(',')
       process = @process_class.new(@server_spy)
       assert_equal client_fds, process.client_fds

data/test/unit/server_data_tests.rb

@@ -19,36 +19,47 @@ class Sanford::ServerData
       @logger          = Factory.string
       @template_source = Factory.string
 
-      @init_procs  = [ proc{} ]
-      @error_procs = [ proc{} ]
+      @init_procs  = Factory.integer(3).times.map{ proc{} }
+      @error_procs = Factory.integer(3).times.map{ proc{} }
+
+      @start_procs    = Factory.integer(3).times.map{ proc{} }
+      @shutdown_procs = Factory.integer(3).times.map{ proc{} }
+      @sleep_procs    = Factory.integer(3).times.map{ proc{} }
+      @wakeup_procs   = Factory.integer(3).times.map{ proc{} }
 
       @router = Factory.string
       @route  = Sanford::Route.new(Factory.string, TestHandler.to_s).tap(&:validate!)
 
       @server_data = Sanford::ServerData.new({
-        :name     => @name,
-        :ip       => @ip,
-        :port     => @port,
-        :pid_file => @pid_file,
-        :receives_keep_alive => @receives_keep_alive,
-        :verbose_logging => @verbose_logging,
-        :logger          => @logger,
-        :template_source => @template_source,
-        :init_procs  => @init_procs,
-        :error_procs => @error_procs,
-        :router => @router,
-        :routes => [ @route ]
+        :name                  => @name,
+        :ip                    => @ip,
+        :port                  => @port,
+        :pid_file              => @pid_file,
+        :receives_keep_alive   => @receives_keep_alive,
+        :verbose_logging       => @verbose_logging,
+        :logger                => @logger,
+        :template_source       => @template_source,
+        :init_procs            => @init_procs,
+        :error_procs           => @error_procs,
+        :worker_start_procs    => @start_procs,
+        :worker_shutdown_procs => @shutdown_procs,
+        :worker_sleep_procs    => @sleep_procs,
+        :worker_wakeup_procs   => @wakeup_procs,
+        :router                => @router,
+        :routes                => [@route]
       })
     end
     subject{ @server_data }
 
     should have_readers :name
-    should have_readers :ip, :port
     should have_readers :pid_file
     should have_readers :receives_keep_alive
     should have_readers :verbose_logging, :logger, :template_source
     should have_readers :init_procs, :error_procs
+    should have_readers :worker_start_procs, :worker_shutdown_procs
+    should have_readers :worker_sleep_procs, :worker_wakeup_procs
     should have_readers :router, :routes
+    should have_accessors :ip, :port
 
     should "know its attributes" do
       assert_equal @name,     subject.name
@@ -62,9 +73,14 @@ class Sanford::ServerData
       assert_equal @logger,          subject.logger
       assert_equal @template_source, subject.template_source
 
-      assert_equal @init_procs,  subject.error_procs
+      assert_equal @init_procs,  subject.init_procs
       assert_equal @error_procs, subject.error_procs
 
+      assert_equal @start_procs,    subject.worker_start_procs
+      assert_equal @shutdown_procs, subject.worker_shutdown_procs
+      assert_equal @sleep_procs,    subject.worker_sleep_procs
+      assert_equal @wakeup_procs,   subject.worker_wakeup_procs
+
       assert_equal @router, subject.router
     end