sanford 0.1.0

data/test/support/services.rb

@@ -0,0 +1,72 @@
+require 'logger'
+
+class DummyHost
+  include Sanford::Host
+
+  ip      'localhost'
+  port    12000
+  pid_dir File.expand_path('../../../tmp/', __FILE__)
+
+  logger = Logger.new(File.expand_path("../../../log/test.log", __FILE__))
+  logger.level = Logger::DEBUG
+
+  version 'v1' do
+    service_handler_ns 'DummyHost'
+
+    service 'echo',       'Echo'
+    service 'bad',        'Bad'
+    service 'multiply',   'Multiply'
+    service 'halt_it',    '::DummyHost::HaltIt'
+    service 'authorized', 'Authorized'
+  end
+
+  class Echo
+    include Sanford::ServiceHandler
+
+    def run!
+      params['message']
+    end
+
+  end
+
+  class Bad
+    include Sanford::ServiceHandler
+
+    def run!
+      raise "hahaha"
+    end
+  end
+
+  class Multiply
+    include Sanford::ServiceHandler
+
+    def init!
+      @number = params['number'] || 1
+    end
+
+    def run!
+      @number * 2
+    end
+  end
+
+  class HaltIt
+    include Sanford::ServiceHandler
+
+    def run!
+      halt 728, {
+        :message  => "I do what I want",
+        :data     => [ 1, true, 'yes' ]
+      }
+    end
+  end
+
+  class Authorized
+    include Sanford::ServiceHandler
+
+    def before_run
+      halt 401, :message => "Not authorized"
+    end
+
+  end
+
+end

data/test/support/simple_client.rb

@@ -0,0 +1,55 @@
+require 'sanford-protocol/test/fake_socket'
+
+class SimpleClient
+
+  def self.call_with_request(service_host, version, name, params)
+    self.new(service_host).call_with_request(version, name, params)
+  end
+
+  def self.call_with_msg_body(service_host, *args)
+    self.new(service_host).call_with_msg_body(*args)
+  end
+
+  def self.call_with_encoded_msg_body(service_host, *args)
+    self.new(service_host).call_with_encoded_msg_body(*args)
+  end
+
+  def self.call_with(service_host, bytes)
+    self.new(service_host).call(bytes)
+  end
+
+  def initialize(service_host, options = {})
+    @host, @port = service_host.ip, service_host.port
+    @delay = options[:with_delay]
+  end
+
+  def call_with_request(*args)
+    self.call_using_fake_socket(:with_request, *args)
+  end
+
+  def call_with_msg_body(*args)
+    self.call_using_fake_socket(:with_msg_body, *args)
+  end
+
+  def call_with_encoded_msg_body(*args)
+    self.call_using_fake_socket(:with_encoded_msg_body, *args)
+  end
+
+  def call(bytes)
+    socket = TCPSocket.new(@host, @port)
+    socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
+    connection = Sanford::Protocol::Connection.new(socket)
+    sleep(@delay) if @delay
+    socket.send(bytes, 0)
+    Sanford::Protocol::Response.parse(connection.read)
+  ensure
+    socket.close rescue false
+  end
+
+  protected
+
+  def call_using_fake_socket(method, *args)
+    self.call(Sanford::Protocol::Test::FakeSocket.send(method, *args).in)
+  end
+
+end

data/test/system/managing_test.rb

@@ -0,0 +1,105 @@
+require 'assert'
+
+class ManagingTest < Assert::Context
+  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
+  end
+  teardown do
+    Test::Environment.restore_hosts
+  end
+
+  class CallTest < ManagingTest
+    include Test::ForkManagerHelper
+
+    setup do
+      Sanford.config.hosts.add(DummyHost)
+    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
+      host = Sanford.config.hosts.first
+
+      self.call_sanford_manager(:run) do
+        assert_nothing_raised{ self.open_socket(host.config.ip, host.config.port) }
+        assert File.exists?(self.expected_pid_file(host, host.config.ip, host.config.port))
+      end
+    end
+  end
+
+  class RunWithOptionsTest < CallTest
+    desc "to run a service host and passing options"
+    setup do
+      # make sure that DummyHost isn't the only 'host'
+      Sanford.config.hosts.add(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.config.find_host('DummyHost')
+
+      self.call_sanford_manager(:run, { :host => 'DummyHost', :port => 12345 }) do
+        assert_nothing_raised{ self.open_socket(host.config.ip, 12345) }
+        assert File.exists?(self.expected_pid_file(host, host.config.ip, 12345))
+      end
+    end
+  end
+
+  class RunWithEnvVarsTest < CallTest
+    desc "to run a service host and setting env vars"
+    setup do
+      @current = ENV.delete('SANFORD_HOST'), ENV.delete('SANFORD_IP'), ENV.delete('SANFORD_PORT')
+      ENV['SANFORD_HOST'] = 'DummyHost'
+      ENV['SANFORD_IP'], ENV['SANFORD_PORT'] = 'localhost', '54321'
+      # make sure that DummyHost isn't the only 'host'
+      Sanford.config.hosts.add(Class.new)
+    end
+    teardown do
+      ENV['SANFORD_HOST'], ENV['SANFORD_IP'], ENV['SANFORD_PORT'] = @current
+    end
+
+    should "start a sanford server for the specified service host and " \
+           "use the env vars to override it's configuration" do
+      host = Sanford.config.find_host(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))
+      end
+    end
+  end
+
+  class BadHostTest < ManagingTest
+    desc "with a bad host name"
+    setup do
+      Sanford.config.hosts.clear
+      Sanford.config.hosts.add(Class.new)
+    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')
+      end
+    end
+  end
+
+  class NoHostsTest < ManagingTest
+    desc "with no hosts"
+    setup do
+      Sanford.config.hosts.clear
+    end
+
+    should "raise an exception when there aren't any service hosts" do
+      assert_raises(Sanford::NoHostError) do
+        Sanford::Manager.call(:run)
+      end
+    end
+  end
+
+end

data/test/system/request_handling_test.rb

@@ -0,0 +1,202 @@
+# 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.
+#
+require 'assert'
+
+class RequestHandlingTest < Assert::Context
+  include Test::ForkServerHelper
+
+  desc "Sanford's handling of requests"
+  setup do
+    @service_host = DummyHost.new
+    @server = Sanford::Server.new(@service_host, { :ready_timeout => 0 })
+  end
+
+  # Simple service test that echos back the params sent to it
+  class EchoTest < RequestHandlingTest
+    desc "when hitting an echo service"
+
+    should "return a successful response and echo the params sent to it" do
+      self.start_server(@server) do
+        response = SimpleClient.call_with_request(@service_host, 'v1', 'echo', {
+          :message => 'test'
+        })
+
+        assert_equal 200,     response.status.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
+    desc "when sent a invalid request stream"
+
+    should "return a bad request response with an error message" do
+      self.start_server(@server) do
+        bytes = [ Sanford::Protocol.msg_version, "\000" ].join
+        response = SimpleClient.call_with(@service_host, bytes)
+
+        assert_equal 400,     response.status.code
+        assert_match "size",  response.status.message
+        assert_equal nil,     response.data
+      end
+    end
+  end
+
+  # Sending the server a protocol version that doesn't match it's version
+  class WrongProtocolVersionTest < ErroringRequestTest
+    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
+        bytes = [ Sanford::Protocol.msg_version, "\000" ].join
+        response = SimpleClient.call_with_msg_body(@service_host, {}, nil, "\000")
+
+        assert_equal 400,                 response.status.code
+        assert_match "Protocol version",  response.status.message
+        assert_equal nil,                 response.data
+      end
+    end
+  end
+
+  # Sending the server a body that it can't parse
+  class BadBodyTest < ErroringRequestTest
+    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
+        response = SimpleClient.call_with_encoded_msg_body(@service_host, "\000\001\010\011" * 2)
+
+        assert_equal 400,     response.status.code
+        assert_match "body",  response.status.message
+        assert_equal nil,     response.data
+      end
+    end
+  end
+
+  class MissingServiceNameTest < ErroringRequestTest
+    desc "when sent a request with no service name"
+
+    should "return a bad request response" do
+      self.start_server(@server) do
+        request_hash = Sanford::Protocol::Request.new('v1', 'what', {}).to_hash
+        request_hash.delete('name')
+        response = SimpleClient.call_with_msg_body(@service_host, request_hash)
+
+        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
+  end
+
+  class MissingServiceVersionTest < ErroringRequestTest
+    desc "when sent a request with no service version"
+
+    should "return a bad request response" do
+      self.start_server(@server) do
+        request_hash = Sanford::Protocol::Request.new('v1', 'what', {}).to_hash
+        request_hash.delete('version')
+        response = SimpleClient.call_with_msg_body(@service_host, request_hash)
+
+        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
+  end
+
+  # Requesting a service that is not defined
+  class NotFoundServiceTest < ErroringRequestTest
+    desc "when sent a request with no matching service name"
+
+    should "return a bad request response" do
+      self.start_server(@server) do
+        response = SimpleClient.call_with_request(@service_host, 'v1', 'what', {})
+
+        assert_equal 404, response.status.code
+        assert_equal nil, response.status.message
+        assert_equal nil, response.data
+      end
+    end
+  end
+
+  # Hitting a service that throws an exception
+  class ErrorServiceTest < ErroringRequestTest
+    desc "when sent a request that errors on the server"
+
+    should "return a bad request response" do
+      self.start_server(@server) do
+        response = SimpleClient.call_with_request(@service_host, 'v1', 'bad', {})
+
+        assert_equal 500,     response.status.code
+        assert_match "error", response.status.message
+        assert_equal nil,     response.data
+      end
+    end
+  end
+
+  class HaltTest < RequestHandlingTest
+    desc "when sent a request that halts"
+
+    should "return the response that was halted" do
+      self.start_server(@server) do
+        response = SimpleClient.call_with_request(@service_host, 'v1', 'halt_it', {})
+
+        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
+  end
+
+  class AuthorizeRequestTest < RequestHandlingTest
+    desc "when sent a request that halts in a callback"
+
+    should "return the response that was halted" do
+      self.start_server(@server) do
+        response = SimpleClient.call_with_request(@service_host, 'v1', 'authorized', {})
+
+        assert_equal 401,               response.status.code
+        assert_equal "Not authorized",  response.status.message
+        assert_equal nil,               response.data
+      end
+    end
+  end
+
+  class HangingRequestTest < ErroringRequestTest
+    desc "when a client connects but doesn't send anything"
+    setup do
+      ENV['SANFORD_TIMEOUT'] = '0.1'
+    end
+    teardown do
+      ENV.delete('SANFORD_TIMEOUT')
+    end
+
+    should "timeout" do
+      self.start_server(@server) do
+        client = SimpleClient.new(@service_host, :with_delay => 0.2)
+        response = client.call_with_request('v1', 'echo', { :message => 'test' })
+
+        assert_equal 408,   response.status.code
+        assert_equal nil,   response.status.message
+        assert_equal nil,   response.data
+      end
+    end
+  end
+
+end

data/test/unit/config_test.rb

@@ -0,0 +1,54 @@
+require 'assert'
+
+module Sanford::Config
+
+  class BaseTest < Assert::Context
+    desc "Sanford::Config"
+    subject{ Sanford::Config }
+
+    should have_instance_methods :hosts, :services_config, :find_host
+  end
+
+  class FindHostTest < BaseTest
+    desc "find_host"
+    setup do
+      Test::Environment.store_and_clear_hosts
+      Sanford::Config.hosts.add(NotNamedHost)
+      Sanford::Config.hosts.add(NamedHost)
+      Sanford::Config.hosts.add(BadlyNamedHost)
+    end
+    teardown do
+      Test::Environment.restore_hosts
+    end
+
+    should "allow finding hosts by their class name or configured name" do
+      assert_includes NotNamedHost, subject.hosts
+      assert_includes NamedHost,    subject.hosts
+      assert_equal NotNamedHost,  subject.find_host('NotNamedHost')
+      assert_equal NamedHost,     subject.find_host('NamedHost')
+      assert_equal NamedHost,     subject.find_host('named_host')
+    end
+    should "check class name before configured name" do
+      assert_includes BadlyNamedHost, subject.hosts
+      assert_equal NotNamedHost, subject.find_host('NotNamedHost')
+    end
+  end
+
+  # Using this syntax because these classes need to be defined as top-level
+  # constants for ease in using their class names in the tests
+
+  ::NotNamedHost = Class.new do
+    include Sanford::Host
+  end
+
+  ::NamedHost = Class.new do
+    include Sanford::Host
+    name 'named_host'
+  end
+
+  ::BadlyNamedHost = Class.new do
+    include Sanford::Host
+    name 'NotNamedHost'
+  end
+
+end

data/test/unit/connection_test.rb

@@ -0,0 +1,23 @@
+require 'assert'
+
+require 'sanford-protocol/test/helpers'
+
+class Sanford::Connection
+
+  class BaseTest < Assert::Context
+    include Sanford::Protocol::Test::Helpers
+
+    desc "Sanford::Connection"
+    setup do
+      @fake_socket = self.fake_socket_with_request('v1', 'echo', { :message => 'test' })
+      @connection = Sanford::Connection.new(DummyHost.new, @fake_socket)
+    end
+    subject{ @connection }
+
+    should have_instance_methods :service_host, :exception_handler, :logger, :process, :timeout
+  end
+
+  # The system test `test/system/request_handling_test.rb`, covers all the
+  # special requests that can occur when given all sorts of invalid requests.
+
+end

data/test/unit/exception_handler_test.rb

@@ -0,0 +1,69 @@
+require 'assert'
+
+class Sanford::ExceptionHandler
+
+  class BaseTest < Assert::Context
+    desc "Sanford::Server::ExceptionHandler"
+    setup do
+      @exception = nil
+      begin
+        raise "test"
+      rescue Exception => @exception
+      end
+      @logger = Sanford::NullLogger.new
+      @exception_handler = Sanford::ExceptionHandler.new(@exception, @logger)
+    end
+    subject{ @exception_handler }
+
+    should have_instance_methods :exception
+
+    should "have built a 500 Sanford::Response" do
+      response = subject.response
+
+      assert_instance_of Sanford::Protocol::Response, response
+      assert_equal 500, response.status.code
+      assert_equal "An unexpected error occurred.", response.status.message
+    end
+  end
+
+  class BadRequestTest < BaseTest
+    desc "with a Sanford::BadRequest exception"
+    setup do
+      @exception = nil
+      begin
+        raise Sanford::Protocol::BadMessageError, "test"
+      rescue Exception => @exception
+      end
+      @exception_handler = Sanford::ExceptionHandler.new(@exception, @logger)
+    end
+
+    should "have built a 400 Sanford::Response" do
+      response = subject.response
+
+      assert_instance_of Sanford::Protocol::Response, response
+      assert_equal 400, response.status.code
+      assert_equal "test", response.status.message
+    end
+  end
+
+  class NotFoundTest < BaseTest
+    desc "with a Sanford::NotFound exception"
+    setup do
+      @exception = nil
+      begin
+        raise Sanford::NotFoundError, "test"
+      rescue Exception => @exception
+      end
+      @exception_handler = Sanford::ExceptionHandler.new(@exception, @logger)
+    end
+
+    should "have built a 404 Sanford::Response" do
+      response = subject.response
+
+      assert_instance_of Sanford::Protocol::Response, response
+      assert_equal 404, response.status.code
+      assert_equal nil, response.status.message
+    end
+  end
+
+end

data/test/unit/host/version_group_test.rb

@@ -0,0 +1,39 @@
+require 'assert'
+
+class Sanford::Host::VersionGroup
+
+  class BaseTest < Assert::Context
+    desc "Sanford::Host::VersionGroup"
+    setup do
+      @version_group = Sanford::Host::VersionGroup.new('v1'){ }
+    end
+    subject{ @version_group }
+
+    should have_instance_methods :name, :services, :service, :to_hash
+
+    should "add a key-value to it's services hash with #service" do
+      subject.service('test', 'MyServiceHandler')
+
+      assert_equal 'MyServiceHandler', subject.services['test']
+    end
+    should "allow setting a namespace and use it when a service is added" do
+      subject.service_handler_ns 'MyNamespace'
+      subject.service('test', 'MyServiceHandler')
+
+      assert_equal 'MyNamespace::MyServiceHandler', subject.services['test']
+    end
+    should "ignore a namespace and when a service class has leading colons" do
+      subject.service_handler_ns 'MyNamespace'
+      subject.service('test', '::MyServiceHandler')
+
+      assert_equal '::MyServiceHandler', subject.services['test']
+    end
+    should "return a hash with it's name as a key and its services as the value with #to_hash" do
+      subject.service('test', 'MyServiceHandler')
+      expected = { subject.name => subject.services }
+
+      assert_equal expected, subject.to_hash
+    end
+  end
+
+end