sanford 0.4.0 → 0.6.0

data/test/support/service_handlers.rb

@@ -44,6 +44,15 @@ class FlagServiceHandler
 
 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
 

data/test/support/services.rb

@@ -3,15 +3,15 @@ require 'logger'
 class TestHost
   include Sanford::Host
 
-  attr_accessor :setup_has_been_called
+  attr_accessor :init_has_been_called
 
-  setup do
-    self.setup_has_been_called = true
+  init do
+    self.init_has_been_called = true
   end
 
-  ip      'localhost'
-  port    12000
-  pid_dir File.expand_path('../../../tmp/', __FILE__)
+  ip       'localhost'
+  port     12000
+  pid_file File.expand_path('../../../tmp/test_host.pid', __FILE__)
 
   logger(Logger.new(File.expand_path("../../../log/test.log", __FILE__)).tap do |logger|
     logger.level = Logger::DEBUG
@@ -100,8 +100,9 @@ end
 class MyHost
   include Sanford::Host
 
-  name  'my_host'
-  ip    'my.local'
+  name     'my_host'
+  ip       'my.local'
+  pid_file File.expand_path('../../../tmp/my_host.pid', __FILE__)
 end
 
 class InvalidHost

data/test/support/simple_client.rb

@@ -35,6 +35,12 @@ class SimpleClient
     self.call_using_fake_socket(:with_encoded_msg_body, *args)
   end
 
+  def call_with_keep_alive
+    socket = TCPSocket.new(@host, @port)
+  ensure
+    socket.close rescue false
+  end
+
   def call(bytes)
     socket = TCPSocket.new(@host, @port)
     socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)

data/test/system/managing_test.rb

@@ -1,103 +1,92 @@
 require 'assert'
 
-require 'sanford/manager'
+require 'sanford/cli'
 
 class ManagingTest < Assert::Context
-  desc "Using Sanford's manager"
+  include Test::ManagerHelper
+  desc "Using Sanford's Manager"
   setup do
-    # preserve the global service hosts configuration, no matter how we
-    # manipulate it
-    Test::Environment.store_and_clear_hosts
+    @start_options = { :host => 'MyHost', :ip => 'localhost', :port => 12345 }
   end
-  teardown do
-    Test::Environment.restore_hosts
-  end
-
-  class CallTest < ManagingTest
-    include Test::ForkManagerHelper
 
+  class RunTest < ManagingTest
+    desc "to run a server"
     setup do
-      Sanford.register(TestHost)
+      @proc = proc{ Sanford::Manager.call(:run, @start_options) }
     end
-  end
-
-  class RunTest < CallTest
-    desc "to run a service host"
 
-    should "start a sanford server for the only service host that is configured" do
-      self.call_sanford_manager(:run) do
-        assert_nothing_raised{ self.open_socket(TestHost.ip, TestHost.port) }
-        assert File.exists?(self.expected_pid_file(TestHost, TestHost.ip, TestHost.port))
+    should "run the server specified and write a PID file" do
+      self.fork_and_call(@proc) do
+        assert_nothing_raised{ self.open_socket('localhost', 12345) }
+        assert File.exists?('tmp/my_host.pid')
       end
     end
-  end
-
-  class RunWithOptionsTest < CallTest
-    desc "to run a service host and passing options"
-    setup do
-      # make sure that TestHost isn't the only 'host'
-      Sanford.register(Class.new)
-    end
 
-    should "start a sanford server for the specified service host and " \
-           "use the passed options to override it's configuration" do
-      host = Sanford.hosts.find('TestHost')
-
-      self.call_sanford_manager(:run, { :host => 'TestHost', :port => 12345 }) do
-        assert_nothing_raised{ self.open_socket(host.ip, 12345) }
-        assert File.exists?(self.expected_pid_file(host, host.ip, 12345))
-      end
-    end
   end
 
-  class RunWithEnvVarsTest < CallTest
-    desc "to run a service host and setting env vars"
+  class StartTest < ManagingTest
+    desc "to start a daemonized server"
     setup do
-      @current = ENV.delete('SANFORD_HOST'), ENV.delete('SANFORD_IP'), ENV.delete('SANFORD_PORT')
-      ENV['SANFORD_HOST'] = 'TestHost'
-      ENV['SANFORD_IP'], ENV['SANFORD_PORT'] = 'localhost', '54321'
-      # make sure that TestHost isn't the only 'host'
-      Sanford.register(Class.new)
+      @proc = proc{ Sanford::Manager.call(:start, @start_options) }
     end
     teardown do
-      ENV['SANFORD_HOST'], ENV['SANFORD_IP'], ENV['SANFORD_PORT'] = @current
+      Sanford::Manager.call(:stop, @start_options)
     end
 
-    should "start a sanford server for the specified service host and " \
-           "use the env vars to override it's configuration" do
-      host = Sanford.hosts.find(ENV['SANFORD_HOST'])
-      port = ENV['SANFORD_PORT'].to_i
-
-      self.call_sanford_manager(:run) do
-        assert_nothing_raised{ self.open_socket(ENV['SANFORD_IP'], port) }
-        assert File.exists?(self.expected_pid_file(host, ENV['SANFORD_IP'], port))
+    should "run the server specified and write a PID file" do
+      self.fork_and_call(@proc) do
+        assert_nothing_raised{ self.open_socket('localhost', 12345) }
+        assert File.exists?('tmp/my_host.pid')
       end
     end
+
   end
 
-  class BadHostTest < ManagingTest
-    desc "with a bad host name"
+  class StopTest < ManagingTest
+    desc "to stop a daemonized server"
     setup do
-      Sanford.hosts.clear
-      Sanford.register(Class.new)
+      @start_proc = proc{ Sanford::Manager.call(:start, @start_options) }
     end
 
-    should "raise an exception when a service host can't be found" do
-      assert_raises(Sanford::NoHostError) do
-        Sanford::Manager.call(:run, :host => 'not_a_real_host')
+    should "stop the server specified and remove the PID file" do
+      self.fork_and_call(@start_proc) do
+        Sanford::Manager.call(:stop, @start_options)
+        sleep 1
+
+        assert_raises{ self.open_socket('localhost', 12345) }
+        assert_not File.exists?('tmp/my_host_localhost_12345.pid')
       end
     end
+
   end
 
-  class NoHostsTest < ManagingTest
-    desc "with no hosts"
+  class RestartTest < ManagingTest
+    desc "to restart a daemonized server"
     setup do
-      Sanford.hosts.clear
+      @start_proc = proc{ Sanford::Manager.call(:start, @start_options) }
     end
 
-    should "raise an exception when there aren't any service hosts" do
-      assert_raises(Sanford::NoHostError) do
-        Sanford::Manager.call(:run)
+    should "stop the server specified and remove the PID file" do
+      self.fork_and_call(@start_proc) do
+        exception = nil
+        stop = false
+        thread = Thread.new do
+          while !stop do
+            begin
+              self.open_socket('localhost', 12345)
+              sleep 0.1
+            rescue Exception => exception
+            end
+          end
+        end
+        Sanford::Manager.call(:restart, @start_options)
+        thread.join(1)
+
+        # make sure we didn't lost the ability to connect
+        assert_nil exception
+
+        stop = true
+        thread.join
       end
     end
   end

data/test/system/request_handling_test.rb

@@ -1,57 +1,268 @@
-# This test is intended as a high level test against Sanford's server. This will
-# use multiple request scenarios to test out Sanford's behavior and how it
-# responds. These tests depend on a socket (or the protocol's connection) and
-# thus are a system level test.
-#
+# These tests are intended as a high level test against Sanford's server. They
+# use fake and real connections to test how Sanford behaves.
+
 require 'assert'
 
-require 'sanford/manager'
+require 'sanford-protocol/test/fake_socket'
 
 class RequestHandlingTest < Assert::Context
-  include Test::ForkServerHelper
-
   desc "Sanford's handling of requests"
   setup do
-    @server = Sanford::Server.new(TestHost, { :ready_timeout => 0 })
+    @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
+
+  class FakeConnectionTest < RequestHandlingTest
+    setup do
+      @host_data = Sanford::HostData.new(TestHost)
+    end
+  end
+
+  class EchoTest < FakeConnectionTest
+    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.code
+      assert_equal nil,     response.status.message
+      assert_equal 'test',  response.data
+    end
+
+  end
+
+  class MissingServiceVersionTest < FakeConnectionTest
+    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.code
+      assert_match "request", response.status.message
+      assert_match "version", response.status.message
+      assert_equal nil,       response.data
+    end
+
+  end
+
+  class MissingServiceNameTest < FakeConnectionTest
+    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.code
+      assert_match "request", response.status.message
+      assert_match "name",    response.status.message
+      assert_equal nil,       response.data
+    end
+
+  end
+
+  class NotFoundServiceTest < FakeConnectionTest
+    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.code
+      assert_equal nil, response.status.message
+      assert_equal nil, response.data
+    end
+
+  end
+
+  class ErrorServiceTest < FakeConnectionTest
+    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.code
+      assert_match "error", response.status.message
+      assert_equal nil,     response.data
+    end
+
+  end
+
+  class HaltTest < FakeConnectionTest
+    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.code
+      assert_equal "I do what I want",  response.status.message
+      assert_equal [ 1, true, 'yes' ],  response.data
+    end
+
+  end
+
+  class AuthorizeRequestTest < FakeConnectionTest
+    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.code
+      assert_equal "Not authorized",  response.status.message
+      assert_equal nil,               response.data
+    end
+
+  end
+
+  class WithCustomErrorHandlerTest < FakeConnectionTest
+    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.code
+      assert_equal "custom error!",   response.status.message
+      assert_equal nil,               response.data
+    end
+
+  end
+
+  class WithBadResponseHashTest < FakeConnectionTest
+    desc "running a request that builds an object that can't be encoded"
+    setup do
+      @connection = FakeConnection.with_request('v1', 'echo', { :message => 'cant encode' }, true)
+      @worker = Sanford::Worker.new(@host_data, @connection)
+    end
+
+    should "return the response that was halted" do
+      assert_raises(RuntimeError){ @worker.run }
+      response = @connection.response
+
+      assert_equal 500,                             response.code
+      assert_equal "An unexpected error occurred.", response.status.message
+      assert_equal nil,                             response.data
+    end
+
+  end
+
+  # essentially, don't call `IO.select`
+  class FakeProtocolConnection < Sanford::Protocol::Connection
+    def wait_for_data(*args)
+      true
+    end
+  end
+
+  class WithAKeepAliveTest < FakeConnectionTest
+    desc "receiving a keep-alive connection"
+    setup do
+      @server = Sanford::Server.new(TestHost, {
+        :ready_timeout => 0.1,
+        :keep_alive    => true
+      })
+      @server.on_run
+      @socket = Sanford::Protocol::Test::FakeSocket.new
+      @fake_connection = FakeProtocolConnection.new(@socket)
+      Sanford::Protocol::Connection.stubs(:new).with(@socket).returns(@fake_connection)
+    end
+    teardown do
+      Sanford::Protocol::Connection.unstub(:new)
+    end
+
+    should "not error and nothing should be written" do
+      assert_nothing_raised do
+        @server.serve(@socket)
+        assert_equal "", @socket.out
+      end
+    end
+
+  end
+
+  class ForkedServerTest < RequestHandlingTest
+    include Test::ForkServerHelper
   end
 
   # Simple service test that echos back the params sent to it
-  class EchoTest < RequestHandlingTest
+  class EchoServerTest < ForkedServerTest
     desc "when hitting an echo service"
 
     should "return a successful response and echo the params sent to it" do
-      self.start_server(@server) do
+      self.start_server(TestHost) do
         response = SimpleClient.call_with_request(TestHost, 'v1', 'echo', {
           :message => 'test'
         })
 
-        assert_equal 200,     response.status.code
+        assert_equal 200,     response.code
         assert_equal nil,     response.status.message
         assert_equal 'test',  response.data
       end
     end
   end
 
-  class ErroringRequestTest < RequestHandlingTest
-    setup do
-      @env_sanford_protocol_debug = ENV['SANFORD_PROTOCOL_DEBUG']
-      ENV.delete('SANFORD_PROTOCOL_DEBUG')
-    end
-    teardown do
-      ENV['SANFORD_PROTOCOL_DEBUG'] = @env_sanford_protocol_debug
-    end
-  end
-
   # Sending the server a completely wrong stream of bytes
-  class BadMessageTest < ErroringRequestTest
+  class BadMessageTest < ForkedServerTest
     desc "when sent a invalid request stream"
 
     should "return a bad request response with an error message" do
-      self.start_server(@server) do
+      self.start_server(TestHost) do
         bytes = [ Sanford::Protocol.msg_version, "\000" ].join
         response = SimpleClient.call_with(TestHost, bytes)
 
-        assert_equal 400,     response.status.code
+        assert_equal 400,     response.code
         assert_match "size",  response.status.message
         assert_equal nil,     response.data
       end
@@ -59,15 +270,15 @@ class RequestHandlingTest < Assert::Context
   end
 
   # Sending the server a protocol version that doesn't match it's version
-  class WrongProtocolVersionTest < ErroringRequestTest
+  class WrongProtocolVersionTest < ForkedServerTest
     desc "when sent a request with a wrong protocol version"
 
     should "return a bad request response with an error message" do
-      self.start_server(@server) do
+      self.start_server(TestHost) do
         bytes = [ Sanford::Protocol.msg_version, "\000" ].join
         response = SimpleClient.call_with_msg_body(TestHost, {}, nil, "\000")
 
-        assert_equal 400,                 response.status.code
+        assert_equal 400,                 response.code
         assert_match "Protocol version",  response.status.message
         assert_equal nil,                 response.data
       end
@@ -75,21 +286,22 @@ class RequestHandlingTest < Assert::Context
   end
 
   # Sending the server a body that it can't parse
-  class BadBodyTest < ErroringRequestTest
+  class BadBodyTest < ForkedServerTest
     desc "when sent a request with an invalid body"
+
     should "return a bad request response with an error message" do
-      self.start_server(@server) do
+      self.start_server(TestHost) do
         response = SimpleClient.call_with_encoded_msg_body(TestHost, "\000\001\010\011" * 2)
 
-        assert_equal 400,     response.status.code
+        assert_equal 400,     response.code
         assert_match "body",  response.status.message
         assert_equal nil,     response.data
       end
     end
   end
 
-  class HangingRequestTest < ErroringRequestTest
-    desc "when a client connects but doesn't send anything"
+  class HangingRequestTest < ForkedServerTest
+    desc "when a client connects but doesn't send anything for to long"
     setup do
       ENV['SANFORD_TIMEOUT'] = '0.1'
     end
@@ -98,11 +310,11 @@ class RequestHandlingTest < Assert::Context
     end
 
     should "timeout" do
-      self.start_server(@server) do
-        client = SimpleClient.new(TestHost, :with_delay => 0.2)
+      self.start_server(TestHost) do
+        client = SimpleClient.new(TestHost, :with_delay => 1)
         response = client.call_with_request('v1', 'echo', { :message => 'test' })
 
-        assert_equal 408,   response.status.code
+        assert_equal 408,   response.code
         assert_equal nil,   response.status.message
         assert_equal nil,   response.data
       end