sanford 0.10.1 → 0.11.0

data/test/support/simple_client.rb

@@ -1,62 +0,0 @@
-require 'sanford-protocol/fake_socket'
-
-class SimpleClient
-
-  def self.call_with_request(service_host, name, params)
-    self.new(service_host).call_with_request(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_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)
-    connection = Sanford::Protocol::Connection.new(socket)
-    sleep(@delay) if @delay
-    socket.send(bytes, 0)
-    socket.close_write
-    Sanford::Protocol::Response.parse(connection.read)
-  ensure
-    socket.close rescue false
-  end
-
-  protected
-
-  def call_using_fake_socket(method, *args)
-    self.call(Sanford::Protocol::FakeSocket.send(method, *args).in)
-  end
-
-end

data/test/system/request_handling_tests.rb

@@ -1,306 +0,0 @@
-require 'assert'
-require 'sanford-protocol/fake_socket'
-
-# These tests are intended as a high level test against Sanford's server. They
-# use fake and real connections to test how Sanford behaves.
-
-class RequestHandlingTests < Assert::Context
-  desc "Sanford's handling of requests"
-  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
-
-  class FakeConnectionTests < RequestHandlingTests
-    setup do
-      @host_data = Sanford::HostData.new(TestHost)
-    end
-  end
-
-  class EchoTests < FakeConnectionTests
-    desc "running a request for the echo server"
-    setup do
-      @connection = FakeConnection.with_request('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
-
-    should "have cloased the connection's write stream" do
-      assert_nothing_raised{ @worker.run }
-
-      assert_equal true, @connection.write_stream_closed
-    end
-
-  end
-
-  class MissingServiceNameTests < FakeConnectionTests
-    desc "running a request with no service name"
-    setup do
-      request_hash = Sanford::Protocol::Request.new('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 NotFoundServiceTests < FakeConnectionTests
-    desc "running a request with no matching service name"
-    setup do
-      @connection = FakeConnection.with_request('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 ErrorServiceTests < FakeConnectionTests
-    desc "running a request that errors on the server"
-    setup do
-      @connection = FakeConnection.with_request('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 HaltTests < FakeConnectionTests
-    desc "running a request that halts"
-    setup do
-      @connection = FakeConnection.with_request('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 AuthorizeRequestTests < FakeConnectionTests
-    desc "running a request that halts in a callback"
-    setup do
-      @connection = FakeConnection.with_request('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 WithCustomErrorHandlerTests < FakeConnectionTests
-    desc "running a request that triggers our custom error handler"
-    setup do
-      @connection = FakeConnection.with_request('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 WithBadResponseHashTests < FakeConnectionTests
-    desc "running a request that builds an object that can't be encoded"
-    setup do
-      @connection = FakeConnection.with_request('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 WithAKeepAliveTests < FakeConnectionTests
-    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::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 ForkedServerTests < RequestHandlingTests
-    include Test::SpawnServerHelper
-  end
-
-  # Simple service test that echos back the params sent to it
-  class EchoServerTests < ForkedServerTests
-    desc "when hitting an echo service"
-
-    should "return a successful response and echo the params sent to it" do
-      self.start_server(TestHost) do
-        response = SimpleClient.call_with_request(TestHost, 'echo', {
-          :message => 'test'
-        })
-
-        assert_equal 200,     response.code
-        assert_equal nil,     response.status.message
-        assert_equal 'test',  response.data
-      end
-    end
-  end
-
-  # Sending the server a completely wrong stream of bytes
-  class BadMessageTests < ForkedServerTests
-    desc "when sent a invalid request stream"
-
-    should "return a bad request response with an error message" do
-      self.start_server(TestHost) do
-        bytes = [ Sanford::Protocol.msg_version, "\000" ].join
-        response = SimpleClient.call_with(TestHost, bytes)
-
-        assert_equal 400,     response.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 its version
-  class WrongProtocolVersionTests < ForkedServerTests
-    desc "when sent a request with a wrong protocol version"
-
-    should "return a bad request response with an error message" 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.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 BadBodyTests < ForkedServerTests
-    desc "when sent a request with an invalid body"
-
-    should "return a bad request response with an error message" do
-      self.start_server(TestHost) do
-        response = SimpleClient.call_with_encoded_msg_body(TestHost, "\000\001\010\011" * 2)
-
-        assert_equal 400,     response.code
-        assert_match "body",  response.status.message
-        assert_equal nil,     response.data
-      end
-    end
-  end
-
-  class HangingRequestTests < ForkedServerTests
-    desc "when a client connects but doesn't send anything for to long"
-    setup do
-      ENV['SANFORD_TIMEOUT'] = '0.1'
-    end
-    teardown do
-      ENV.delete('SANFORD_TIMEOUT')
-    end
-
-    should "timeout" do
-      self.start_server(TestHost) do
-        client = SimpleClient.new(TestHost, :with_delay => 1)
-        response = client.call_with_request('echo', { :message => 'test' })
-
-        assert_equal 408,   response.code
-        assert_equal nil,   response.status.message
-        assert_equal nil,   response.data
-      end
-    end
-  end
-
-end

data/test/unit/config_tests.rb

@@ -1,56 +0,0 @@
-require 'assert'
-require 'sanford/config'
-
-require 'ns-options/assert_macros'
-require 'ns-options/proxy'
-require 'sanford/logger'
-require 'sanford/runner'
-require 'sanford/template_source'
-require 'test/support/factory'
-
-class Sanford::Config
-
-  class UnitTests < Assert::Context
-    include NsOptions::AssertMacros
-
-    desc "Sanford::Config"
-    setup do
-      @config = Sanford::Config.new
-    end
-    subject{ @config }
-
-    should have_options :services_file, :logger
-    should have_readers :template_source
-    should have_imeths :set_template_source
-
-    should "be an NsOptions::Proxy" do
-      assert_includes NsOptions::Proxy, subject.class
-    end
-
-    should "default its services file" do
-      exp = Pathname.new(ENV['SANFORD_SERVICES_FILE'])
-      assert_equal exp, subject.services_file
-    end
-
-    should "default its logger to a NullLogger" do
-      assert_kind_of Sanford::NullLogger, subject.logger
-    end
-
-    should "have a null template source by default" do
-      assert_kind_of Sanford::NullTemplateSource, subject.template_source
-    end
-
-    should "set a new template source" do
-      path = '/path/to/app/assets'
-      block_called = false
-      subject.set_template_source(path) { |s| block_called = true}
-
-      assert_not_nil subject.template_source
-      assert_kind_of Sanford::TemplateSource, subject.template_source
-      assert_equal path, subject.template_source.path
-      assert_true block_called
-    end
-
-  end
-
-end

data/test/unit/host_data_tests.rb

@@ -1,71 +0,0 @@
-require 'assert'
-require 'sanford/host_data'
-
-class Sanford::HostData
-
-  class UnitTests < Assert::Context
-    desc "Sanford::HostData"
-    setup do
-      TestHost.init_has_been_called = false
-      @host_data = Sanford::HostData.new(TestHost)
-    end
-    teardown do
-      TestHost.init_has_been_called = false
-    end
-    subject{ @host_data }
-
-    should have_readers :name, :logger, :verbose, :keep_alive, :error_procs
-    should have_imeths :handler_class_for, :run
-
-    should "call the init procs" do
-      assert_equal true, TestHost.init_has_been_called
-    end
-
-    should "default its attrs from the host configuration" do
-      assert_equal TestHost.configuration.name,                subject.name
-      assert_equal TestHost.configuration.logger.class,        subject.logger.class
-      assert_equal TestHost.configuration.verbose_logging,     subject.verbose
-      assert_equal TestHost.configuration.receives_keep_alive, subject.keep_alive
-      assert_equal TestHost.configuration.error_procs,         subject.error_procs
-    end
-
-    should "allow overriding host configuration attrs" do
-      host_data = Sanford::HostData.new(TestHost, :verbose_logging => false)
-
-      assert_false host_data.verbose
-      assert_equal TestHost.receives_keep_alive, host_data.keep_alive
-    end
-
-    should "ignore nil values passed as overrides" do
-      host_data = Sanford::HostData.new(TestHost, :verbose_logging => nil)
-      assert_not_nil host_data.verbose
-    end
-
-    should "constantize a host's handlers" do
-      handlers = subject.instance_variable_get("@handlers")
-      assert_equal TestHost::Authorized, handlers['authorized']
-      assert_equal TestHost::Bad,        handlers['bad']
-      assert_equal TestHost::Echo,       handlers['echo']
-      assert_equal TestHost::HaltIt,     handlers['halt_it']
-      assert_equal TestHost::Multiply,   handlers['multiply']
-    end
-
-    should "look up handler classes with #handler_class_for" do
-      assert_equal TestHost::Echo, subject.handler_class_for('echo')
-    end
-
-    should "raise a custom error when handler_class_for is called with an unknown service" do
-      assert_raises(Sanford::NotFoundError) do
-        subject.handler_class_for('not_defined')
-      end
-    end
-
-    should "raise a custom error when a service is configured with an undefined class" do
-      assert_raises(Sanford::NoHandlerClassError) do
-        Sanford::HostData.new(UndefinedHandlersHost).setup
-      end
-    end
-
-  end
-
-end

data/test/unit/host_tests.rb

@@ -1,141 +0,0 @@
-require 'assert'
-require 'sanford/host'
-
-require 'sanford/logger'
-require 'sanford/runner'
-
-module Sanford::Host
-
-  class UnitTests < Assert::Context
-    desc "Sanford::Host"
-    setup do
-      @host_class = Class.new{ include Sanford::Host }
-    end
-    subject{ @host_class.instance }
-
-    should have_readers :configuration, :services
-    should have_imeths :name, :ip, :port, :pid_file, :logger, :verbose_logging
-    should have_imeths :error, :init, :service_handler_ns, :service
-
-    should "know its configuration" do
-      assert_kind_of Configuration, subject.configuration
-    end
-
-    should "have no services by default" do
-      assert_empty subject.services
-    end
-
-    should "get/set its configuration options" do
-      subject.name 'my_awesome_host'
-      assert_equal 'my_awesome_host', subject.name
-      assert_equal subject.name, subject.configuration.name
-
-      subject.ip '127.0.0.1'
-      assert_equal '127.0.0.1', subject.ip
-      assert_equal subject.ip, subject.configuration.ip
-
-      subject.port '10100'
-      assert_equal 10100, subject.port
-      assert_equal subject.port, subject.configuration.port
-
-      subject.pid_file '/path/to/file'
-      assert_equal Pathname.new('/path/to/file'), subject.pid_file
-      assert_equal subject.pid_file, subject.configuration.pid_file
-
-      logger = Sanford::NullLogger.new
-      subject.logger logger
-      assert_equal logger, subject.logger
-      assert_equal subject.logger, subject.configuration.logger
-
-      subject.verbose_logging false
-      assert_equal false, subject.verbose_logging
-      assert_equal subject.verbose_logging, subject.configuration.verbose_logging
-
-      subject.receives_keep_alive true
-      assert_equal true, subject.receives_keep_alive
-      assert_equal subject.receives_keep_alive, subject.configuration.receives_keep_alive
-    end
-
-    should "add error procs to the configuration" do
-      assert_empty subject.configuration.error_procs
-      subject.error &proc{}
-      assert_not_empty subject.configuration.error_procs
-    end
-
-    should "add init procs to the configuration" do
-      assert_empty subject.configuration.init_procs
-      subject.init &proc{}
-      assert_not_empty subject.configuration.init_procs
-    end
-
-    should "get/set its service_handler_ns" do
-      assert_nil subject.service_handler_ns
-      subject.service_handler_ns 'a-ns'
-      assert_equal 'a-ns', subject.service_handler_ns
-    end
-
-    should "add services" do
-      subject.service_handler_ns 'MyNamespace'
-      subject.service('test', 'MyServiceHandler')
-
-      assert_equal 'MyNamespace::MyServiceHandler', subject.services['test']
-    end
-
-    should "force string names when adding services" do
-      subject.service(:another_service, 'MyServiceHandler')
-      assert_nil subject.services[:another_service]
-      assert_equal 'MyServiceHandler', subject.services['another_service']
-    end
-
-    should "ignore a namespace when a service class has leading colons" do
-      subject.service_handler_ns 'MyNamespace'
-      subject.service('test', '::MyServiceHandler')
-
-      assert_equal '::MyServiceHandler', subject.services['test']
-    end
-
-  end
-
-  class ClassMethodsTests < UnitTests
-    desc "class"
-    subject{ @host_class }
-
-    should "proxy its method to its instance" do
-      assert_equal subject.instance.name, subject.name
-      assert subject.respond_to?(:pid_file)
-    end
-
-    should "have registered the class with sanford's known hosts" do
-      assert_includes subject, Sanford.hosts
-    end
-
-  end
-
-  class ConfigurationTests < UnitTests
-    desc "Configuration"
-    setup do
-      @configuration = Configuration.new(@host_class.instance)
-    end
-    subject{ @configuration }
-
-    should have_imeths :name, :ip, :port, :pid_file, :logger, :verbose_logging
-    should have_imeths :receives_keep_alive, :error_procs, :init_procs
-
-    should "default name to the class name of the host" do
-      assert_equal @host_class.name, subject.name
-    end
-
-    should "default its other attrs" do
-      assert_equal '0.0.0.0', subject.ip
-      assert_nil subject.port
-      assert_nil subject.pid_file
-      assert_equal Sanford.config.logger.class, subject.logger.class
-      assert_true  subject.verbose_logging
-      assert_false subject.receives_keep_alive
-      assert_empty subject.error_procs
-      assert_empty subject.init_procs
-    end
-
-  end
-
-end

data/test/unit/hosts_tests.rb

@@ -1,50 +0,0 @@
-require 'assert'
-require 'sanford/hosts'
-
-require 'sanford/host'
-
-class Sanford::Hosts
-
-  class UnitTests < Assert::Context
-    desc "Sandford::Hosts"
-    setup do
-      @hosts = Sanford::Hosts.new
-    end
-    subject{ @hosts }
-
-    should have_instance_methods :add, :first, :find
-
-  end
-
-  class FindTests < UnitTests
-    desc "find method"
-    setup do
-      @hosts.add ::NotNamedHost
-      @hosts.add ::NamedHost
-      @hosts.add ::BadlyNamedHost
-    end
-
-    should "allow finding hosts by their class name or configured name" do
-      assert_includes ::NotNamedHost, subject
-      assert_includes ::NamedHost, subject
-
-      assert_equal ::NotNamedHost, subject.find('NotNamedHost')
-      assert_equal ::NamedHost, subject.find('NamedHost')
-      assert_equal ::NamedHost, subject.find('named_host')
-    end
-
-    should "prefer hosts with a matching class name over configured name" do
-      assert_includes ::BadlyNamedHost, subject
-      assert_equal NotNamedHost, subject.find('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{ include Sanford::Host }
-  ::NamedHost      = Class.new{ include Sanford::Host; name 'named_host' }
-  ::BadlyNamedHost = Class.new{ include Sanford::Host; name 'NotNamedHost' }
-
-end