sanford 0.10.1 → 0.11.0

data/test/unit/cli_tests.rb

@@ -0,0 +1,187 @@
+require 'assert'
+require 'sanford/cli'
+
+class Sanford::CLI
+
+  class UnitTests < Assert::Context
+    desc "Sanford::CLI"
+    setup do
+      @kernel_spy = KernelSpy.new
+      @file_path = Factory.file_path
+
+      @server = TestServer.new
+
+      @config_file = FakeConfigFile.new(@server)
+      Assert.stub(Sanford::ConfigFile, :new).with(@file_path){ @config_file }
+
+      @cli = Sanford::CLI.new(@kernel_spy)
+    end
+    subject{ @cli }
+
+    should have_cmeths :run
+    should have_imeths :run
+
+  end
+
+  class CommandTests < UnitTests
+    setup do
+      @process_spy = ProcessSpy.new
+      @process_signal_spy = ProcessSignalSpy.new
+    end
+
+  end
+
+  class DefaultsTests < CommandTests
+    desc "with no command or file path"
+    setup do
+      file_path = 'config.sanford'
+      Assert.stub(Sanford::ConfigFile, :new).with(file_path){ @config_file }
+      Assert.stub(Sanford::Process, :new).with(@server, :daemonize => false) do
+        @process_spy
+      end
+
+      @cli.run
+    end
+
+    should "have defaulted the command and file path" do
+      assert_true @process_spy.run_called
+    end
+
+  end
+
+  class RunTests < CommandTests
+    desc "with the run command"
+    setup do
+      Assert.stub(Sanford::Process, :new).with(@server, :daemonize => false) do
+        @process_spy
+      end
+
+      @cli.run(@file_path, 'run')
+    end
+
+    should "have built and run a non-daemonized process" do
+      assert_true @process_spy.run_called
+    end
+
+  end
+
+  class StartTests < CommandTests
+    desc "with the start command"
+    setup do
+      Assert.stub(Sanford::Process, :new).with(@server, :daemonize => true) do
+        @process_spy
+      end
+
+      @cli.run(@file_path, 'start')
+    end
+
+    should "have built and run a daemonized process" do
+      assert_true @process_spy.run_called
+    end
+
+  end
+
+  class StopTests < CommandTests
+    desc "with the stop command"
+    setup do
+      Assert.stub(Sanford::ProcessSignal, :new).with(@server, 'TERM') do
+        @process_signal_spy
+      end
+
+      @cli.run(@file_path, 'stop')
+    end
+
+    should "have built and sent a TERM signal" do
+      assert_true @process_signal_spy.send_called
+    end
+
+  end
+
+  class RestartTests < CommandTests
+    desc "with the restart command"
+    setup do
+      Assert.stub(Sanford::ProcessSignal, :new).with(@server, 'USR2') do
+        @process_signal_spy
+      end
+
+      @cli.run(@file_path, 'restart')
+    end
+
+    should "have built and sent a USR2 signal" do
+      assert_true @process_signal_spy.send_called
+    end
+
+  end
+
+  class InvalidCommandTests < UnitTests
+    desc "with an invalid command"
+    setup do
+      @command = Factory.string
+      @cli.run(@file_path, @command)
+    end
+
+    should "output the error with the help" do
+      expected = "#{@command.inspect} is not a valid command"
+      assert_includes expected, @kernel_spy.output
+      assert_includes "Usage: sanford", @kernel_spy.output
+    end
+
+  end
+
+  class KernelSpy
+    attr_reader :exit_status
+
+    def initialize
+      @output = StringIO.new
+      @exit_status = nil
+    end
+
+    def output
+      @output.rewind
+      @output.read
+    end
+
+    def puts(message)
+      @output.puts(message)
+    end
+
+    def exit(code)
+      @exit_status = code
+    end
+  end
+
+  class TestServer
+    include Sanford::Server
+
+    name Factory.string
+    ip Factory.string
+    port Factory.integer
+  end
+
+  FakeConfigFile = Struct.new(:server)
+
+  class ProcessSpy
+    attr_reader :run_called
+
+    def initialize
+      @run_called = false
+    end
+
+    def run
+      @run_called = true
+    end
+  end
+
+  class ProcessSignalSpy
+    attr_reader :send_called
+
+    def initialize
+      @send_called = false
+    end
+
+    def send
+      @send_called = true
+    end
+  end
+
+end

data/test/unit/config_file_tests.rb

@@ -0,0 +1,59 @@
+require 'assert'
+require 'sanford/config_file'
+
+class Sanford::ConfigFile
+
+  class UnitTests < Assert::Context
+    desc "Sanford::ConfigFile"
+    setup do
+      @file_path = ROOT_PATH.join('test/support/config.sanford')
+      @config_file = Sanford::ConfigFile.new(@file_path)
+    end
+    subject{ @config_file }
+
+    should have_readers :server
+    should have_imeths :run
+
+    should "know its server" do
+      assert_instance_of AppServer, subject.server
+    end
+
+    should "define constants in the file at the top-level binding" do
+      assert_not_nil defined?(::TestConstant)
+    end
+
+    should "set its server using run" do
+      fake_server = Factory.string
+      subject.run fake_server
+      assert_equal fake_server, subject.server
+    end
+
+    should "allow passing a path without the extension" do
+      file_path = ROOT_PATH.join('test/support/config')
+      config_file = nil
+
+      assert_nothing_raised do
+        config_file = Sanford::ConfigFile.new(file_path)
+      end
+      assert_instance_of AppServer, config_file.server
+    end
+
+    should "raise no config file error when the file doesn't exist" do
+      assert_raises(NoConfigFileError) do
+        Sanford::ConfigFile.new(Factory.file_path)
+      end
+    end
+
+    should "raise a no server error when the file doesn't call run" do
+      file_path = ROOT_PATH.join('test/support/config_no_run.sanford')
+      assert_raises(NoServerError){ Sanford::ConfigFile.new(file_path) }
+    end
+
+    should "raise a no server error when the file provides an invalid server" do
+      file_path = ROOT_PATH.join('test/support/config_invalid_run.sanford')
+      assert_raises(NoServerError){ Sanford::ConfigFile.new(file_path) }
+    end
+
+  end
+
+end

data/test/unit/connection_handler_tests.rb

@@ -0,0 +1,254 @@
+require 'assert'
+require 'sanford/connection_handler'
+
+require 'sanford/route'
+require 'sanford/server_data'
+require 'test/support/fake_server_connection'
+
+class Sanford::ConnectionHandler
+
+  class UnitTests < Assert::Context
+    desc "Sanford::ConnectionHandler"
+    setup do
+      @route = Sanford::Route.new(Factory.string, TestHandler.to_s).tap(&:validate!)
+      @server_data = Sanford::ServerData.new({
+        :logger => Sanford::NullLogger.new,
+        :verbose_logging => Factory.boolean,
+        :routes => [ @route ]
+      })
+      @connection = FakeServerConnection.with_request(@route.name)
+      @request = @connection.request
+      @response = Sanford::Protocol::Response.new(Factory.integer, Factory.string)
+      @exception = RuntimeError.new(Factory.string)
+
+      @handler_class = Sanford::ConnectionHandler
+    end
+    subject{ @handler_class }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @connection_handler = @handler_class.new(@server_data, @connection)
+    end
+    subject{ @connection_handler }
+
+    should have_readers :server_data, :connection
+    should have_readers :logger
+    should have_imeths :run
+
+    should "know its server data and connection" do
+      assert_equal @server_data, subject.server_data
+      assert_equal @connection, subject.connection
+    end
+
+    should "know its logger" do
+      assert_instance_of Sanford::Logger, subject.logger
+    end
+
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @route_called_with = nil
+      Assert.stub(@route, :run) do |*args|
+        @route_called_with = args
+        @response
+      end
+
+      @processed_service = @connection_handler.run
+    end
+    subject{ @processed_service }
+
+    should "return a processed service" do
+      assert_instance_of ProcessedService, subject
+      assert_equal @request, subject.request
+      assert_equal @route.handler_class, subject.handler_class
+      assert_equal @response, subject.response
+      assert_nil subject.exception
+      assert_not_nil subject.time_taken
+    end
+
+    should "run the route" do
+      assert_not_nil @route_called_with
+      assert_includes @request, @route_called_with
+      assert_includes @server_data, @route_called_with
+    end
+
+    should "have written the response to the connection" do
+      assert_equal @response, @connection.response
+      assert_true @connection.write_closed
+    end
+
+  end
+
+  class RunWithExceptionTests < InitTests
+    desc "and run with a route that throws an exception"
+    setup do
+      Assert.stub(@route, :run){ raise @exception }
+
+      error_handler = Sanford::ErrorHandler.new(
+        @exception,
+        @server_data,
+        @request
+      )
+      @expected_response = error_handler.run
+      @expected_exception = error_handler.exception
+
+      @processed_service = @connection_handler.run
+    end
+    subject{ @processed_service }
+
+    should "return a processed service with an exception" do
+      assert_instance_of ProcessedService, subject
+      assert_equal @expected_response,  subject.response
+      assert_equal @expected_exception, subject.exception
+    end
+
+    should "have written the error response to the connection" do
+      assert_equal @expected_response, @connection.response
+      assert_true @connection.write_closed
+    end
+
+  end
+
+  class RunWithExceptionWhileWritingTests < InitTests
+    desc "and run with an exception thrown while writing the response"
+    setup do
+      Assert.stub(@route, :run){ @response }
+
+      @connection.raise_on_write = true
+
+      error_handler = Sanford::ErrorHandler.new(
+        @connection.write_exception,
+        @server_data,
+        @request
+      )
+      @expected_response = error_handler.run
+      @expected_exception = error_handler.exception
+
+      @processed_service = @connection_handler.run
+    end
+    subject{ @processed_service }
+
+    should "return a processed service with an exception" do
+      assert_instance_of ProcessedService, subject
+      assert_equal @expected_response,  subject.response
+      assert_equal @expected_exception, subject.exception
+    end
+
+    should "have written the error response to the connection" do
+      assert_equal @expected_response, @connection.response
+      assert_true @connection.write_closed
+    end
+
+  end
+
+  class RunWithExceptionWhileDebuggingTests < InitTests
+    desc "and run with a route that throws an exception in debug mode"
+    setup do
+      ENV['SANFORD_DEBUG'] = '1'
+      Assert.stub(@route, :run){ raise @exception }
+    end
+    teardown do
+      ENV.delete('SANFORD_DEBUG')
+    end
+
+    should "raise the exception" do
+      assert_raises(@exception.class){ @connection_handler.run }
+    end
+
+  end
+
+  class RunWithVerboseLoggingTests < UnitTests
+    desc "run with verbose logging"
+    setup do
+      @spy_logger = SpyLogger.new
+      @server_data = Sanford::ServerData.new({
+        :logger => @spy_logger,
+        :verbose_logging => true,
+        :routes => [ @route ]
+      })
+      Assert.stub(@route, :run){ raise @exception }
+
+      @connection_handler = @handler_class.new(@server_data, @connection)
+      @processed_service = @connection_handler.run
+    end
+    subject{ @spy_logger }
+
+    should "have logged the service" do
+      time_taken = @processed_service.time_taken
+      status = @processed_service.response.status.to_s
+      expected = "[Sanford] ===== Received request =====" \
+                 "[Sanford]   Service: #{@request.name.inspect}" \
+                 "[Sanford]   Params:  #{@request.params.inspect}" \
+                 "[Sanford]   Handler: #{@route.handler_class}" \
+                 "[Sanford] ===== Completed in #{time_taken}ms #{status} ====="
+      assert_equal expected, subject.info_logged.join
+    end
+
+    should "log an exception when one is thrown" do
+      err = @processed_service.exception
+      backtrace = err.backtrace.join("\n")
+      expected = "[Sanford] #{err.class}: #{err.message}\n#{backtrace}"
+      assert_equal expected, subject.error_logged.join
+    end
+
+  end
+
+  class RunWithSummaryLoggingTests < UnitTests
+    desc "run with summary logging"
+    setup do
+      @spy_logger = SpyLogger.new
+      @server_data = Sanford::ServerData.new({
+        :logger => @spy_logger,
+        :verbose_logging => false,
+        :routes => [ @route ]
+      })
+      Assert.stub(@route, :run){ raise @exception }
+
+      @connection_handler = @handler_class.new(@server_data, @connection)
+      @processed_service = @connection_handler.run
+    end
+    subject{ @spy_logger }
+
+    should "have logged the service" do
+      time_taken = @processed_service.time_taken
+      status = @processed_service.response.status.to_i
+      expected = "[Sanford] " \
+                 "time=#{time_taken} " \
+                 "status=#{status} " \
+                 "handler=#{@route.handler_class} " \
+                 "service=#{@request.name.inspect} " \
+                 "params=#{@request.params.inspect}"
+      assert_equal expected, subject.info_logged.join
+    end
+
+    should "not have logged the exception" do
+      assert_empty @spy_logger.error_logged
+    end
+
+  end
+
+  TestHandler = Class.new
+
+  class SpyLogger
+    attr_reader :info_logged, :error_logged
+
+    def initialize
+      @info_logged = []
+      @error_logged = []
+    end
+
+    def info(message)
+      @info_logged << message
+    end
+
+    def error(message)
+      @error_logged << message
+    end
+  end
+
+end

data/test/unit/error_handler_tests.rb

@@ -1,18 +1,20 @@
 require 'assert'
 require 'sanford/error_handler'
 
+require 'sanford/server_data'
+
 class Sanford::ErrorHandler
 
   class UnitTests < Assert::Context
     desc "Sanford::ErrorHandler"
     setup do
       @exception = RuntimeError.new('test')
-      @host_data = Sanford::HostData.new(EmptyHost, { :ip => "localhost", :port => 8000 })
-      @error_handler = Sanford::ErrorHandler.new(@exception, @host_data)
+      @server_data = Sanford::ServerData.new
+      @error_handler = Sanford::ErrorHandler.new(@exception, @server_data)
     end
     subject{ @error_handler }
 
-    should have_imeths :exception, :host_data, :request, :run
+    should have_imeths :exception, :server_data, :request, :run
 
     should "return a Sanford::Protocol::Response with `run`" do
       assert_instance_of Sanford::Protocol::Response, subject.run
@@ -31,18 +33,13 @@ class Sanford::ErrorHandler
 
   class ResponseFromProcTests < UnitTests
     desc "generating a respone from an error proc"
-    setup do
-      @host_defaults = { :ip => "localhost", :port => 8000 }
-    end
 
     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
-      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
-        :error_procs => [ error_proc ]
-      }))
-      response = Sanford::ErrorHandler.new(@exception, host_data).run
+      server_data = Sanford::ServerData.new(:error_procs => [ error_proc ])
+      response = Sanford::ErrorHandler.new(@exception, server_data).run
 
       assert_equal 567, response.code
       assert_equal 'custom message', response.status.message
@@ -50,10 +47,8 @@ class Sanford::ErrorHandler
     end
 
     should "use an integer returned by the error proc to generate a protocol response" do
-      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
-        :error_procs => [ proc{ 345 } ]
-      }))
-      response = Sanford::ErrorHandler.new(@exception, host_data).run
+      server_data = Sanford::ServerData.new(:error_procs => [ proc{ 345 } ])
+      response = Sanford::ErrorHandler.new(@exception, server_data).run
 
       assert_equal 345, response.code
       assert_nil response.status.message
@@ -61,10 +56,10 @@ class Sanford::ErrorHandler
     end
 
     should "use a symbol returned by the error proc to generate a protocol response" do
-      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
+      server_data = Sanford::ServerData.new({
         :error_procs => [ proc{ :not_found } ]
-      }))
-      response = Sanford::ErrorHandler.new(@exception, host_data).run
+      })
+      response = Sanford::ErrorHandler.new(@exception, server_data).run
 
       assert_equal 404, response.code
       assert_nil response.status.message
@@ -72,10 +67,8 @@ class Sanford::ErrorHandler
     end
 
     should "use the default behavior if the error proc doesn't return a valid response result" do
-      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
-        :error_procs => [ proc{ true } ]
-      }))
-      response = Sanford::ErrorHandler.new(@exception, host_data).run
+      server_data = Sanford::ServerData.new(:error_procs => [ proc{ true } ])
+      response = Sanford::ErrorHandler.new(@exception, server_data).run
 
       assert_equal 500, response.code
       assert_equal 'An unexpected error occurred.', response.status.message
@@ -83,10 +76,10 @@ class Sanford::ErrorHandler
 
     should "use the default behavior for an exception raised by the error proc " \
            "and ignore the original exception" do
-      host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
+      server_data = Sanford::ServerData.new({
         :error_procs => [ proc{ raise Sanford::NotFoundError } ]
-      }))
-      response = Sanford::ErrorHandler.new(@exception, host_data).run
+      })
+      response = Sanford::ErrorHandler.new(@exception, server_data).run
 
       assert_equal 404, response.code
       assert_nil response.status.message
@@ -100,7 +93,7 @@ class Sanford::ErrorHandler
 
     should "build a 400 response with a protocol BadMessageError" do
       exception = generate_exception(Sanford::Protocol::BadMessageError, 'bad message')
-      response = Sanford::ErrorHandler.new(exception, @host_data).run
+      response = Sanford::ErrorHandler.new(exception, @server_data).run
 
       assert_equal 400, response.code
       assert_equal 'bad message', response.status.message
@@ -108,7 +101,7 @@ class Sanford::ErrorHandler
 
     should "build a 400 response with a protocol BadRequestError" do
       exception = generate_exception(Sanford::Protocol::BadRequestError, 'bad request')
-      response = Sanford::ErrorHandler.new(exception, @host_data).run
+      response = Sanford::ErrorHandler.new(exception, @server_data).run
 
       assert_equal 400, response.code
       assert_equal 'bad request', response.status.message
@@ -116,14 +109,14 @@ class Sanford::ErrorHandler
 
     should "build a 404 response with a NotFoundError" do
       exception = generate_exception(Sanford::NotFoundError, 'not found')
-      response = Sanford::ErrorHandler.new(exception, @host_data).run
+      response = Sanford::ErrorHandler.new(exception, @server_data).run
 
       assert_equal 404, response.code
       assert_nil response.status.message
     end
 
     should "build a 500 response with all other exceptions" do
-      response = Sanford::ErrorHandler.new(RuntimeError.new('test'), @host_data).run
+      response = Sanford::ErrorHandler.new(RuntimeError.new('test'), @server_data).run
 
       assert_equal 500, response.code
       assert_equal 'An unexpected error occurred.', response.status.message
@@ -135,13 +128,14 @@ class Sanford::ErrorHandler
     desc "with multiple error procs"
     setup do
       @first_called, @second_called, @third_called = nil, nil, nil
-      @host_data = Sanford::HostData.new(EmptyHost, @host_defaults.merge({
+      @server_data = Sanford::ServerData.new({
         :error_procs => [ first_proc, second_proc, third_proc ]
-      }))
+      })
     end
 
     should "call every error proc" do
-      @error_handler = Sanford::ErrorHandler.new(RuntimeError.new('test'), @host_data)
+      exception = RuntimeError.new('test')
+      @error_handler = Sanford::ErrorHandler.new(exception, @server_data)
       @error_handler.run
 
       assert_equal true, @first_called
@@ -151,14 +145,15 @@ class Sanford::ErrorHandler
 
     should "should return the response of the last configured error proc " \
            "that returned a valid response" do
-      @error_handler = Sanford::ErrorHandler.new(RuntimeError.new('test'), @host_data)
+      exception = RuntimeError.new('test')
+      @error_handler = Sanford::ErrorHandler.new(exception, @server_data)
       response = @error_handler.run
 
       # use the second proc's generated response
       assert_equal 987, response.code
 
       exception = generate_exception(Sanford::NotFoundError, 'not found')
-      @error_handler = Sanford::ErrorHandler.new(exception, @host_data)
+      @error_handler = Sanford::ErrorHandler.new(exception, @server_data)
       response = @error_handler.run
 
       # use the third proc's generated response
@@ -170,14 +165,14 @@ class Sanford::ErrorHandler
     end
 
     def second_proc
-      proc do |exception, host_data, request|
+      proc do |exception, server_data, request|
         @second_called = true
         987
       end
     end
 
     def third_proc
-      proc do |exception, host_data, request|
+      proc do |exception, server_data, request|
         @third_called = true
         876 if exception.kind_of?(Sanford::NotFoundError)
       end