sanford 0.4.0 → 0.6.0

data/test/unit/config_test.rb

@@ -6,7 +6,7 @@ module Sanford::Config
     desc "Sanford::Config"
     subject{ Sanford::Config }
 
-    should have_instance_methods :services_file
+    should have_instance_methods :services_file, :logger
   end
 
 end

data/test/unit/host_configuration_test.rb

@@ -9,8 +9,8 @@ class Sanford::Host::Configuration
     end
     subject{ @configuration }
 
-    should have_instance_methods :name, :ip, :port, :pid_dir, :logger, :verbose_logging, :logger,
-      :error_proc
+    should have_instance_methods :name, :ip, :port, :pid_file, :logger,
+      :verbose_logging, :logger, :error_proc
 
     should "default name to the class name of the host" do
       assert_equal 'EmptyHost', subject.name
@@ -24,10 +24,6 @@ class Sanford::Host::Configuration
       assert_nil subject.port
     end
 
-    should "default pid_dir to the current working directory" do
-      assert_equal Pathname.new(Dir.pwd), subject.pid_dir
-    end
-
     should "default logger to a null logger" do
       assert_instance_of Sanford::NullLogger, subject.logger
     end

data/test/unit/host_data_test.rb

@@ -1,52 +1,35 @@
 require 'assert'
 
-require 'sanford/manager'
-
 class Sanford::HostData
 
   class BaseTest < 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_instance_methods :name, :ip, :port, :pid_dir, :logger, :verbose,
-      :error_proc, :handler_class_for, :setup
+    should have_instance_methods :name, :logger, :verbose, :error_proc,
+      :handler_class_for
 
     should "default it's configuration from the service host, but allow overrides" do
-      host_data = Sanford::HostData.new(TestHost, :ip => '1.2.3.4', :port => 12345)
+      host_data = Sanford::HostData.new(TestHost, :verbose_logging => false)
 
-      assert_equal 'TestHost',  host_data.name
-      assert_equal '1.2.3.4',   host_data.ip
-      assert_equal 12345,       host_data.port
+      assert_equal TestHost.receives_keep_alive, host_data.keep_alive
+      assert_equal false, host_data.verbose
     end
 
     should "ignore nil values passed as overrides" do
-      host_data = Sanford::HostData.new(TestHost, :ip => nil)
-
-      assert_not_nil host_data.ip
-    end
-
-    should "raise a custom exception when passed invalid host" do
-      assert_raises(Sanford::InvalidHostError) do
-        Sanford::Manager.new(InvalidHost)
-      end
-    end
-
-  end
-
-  class SetupTest < BaseTest
-    desc "after calling setup"
-    setup do
-      TestHost.setup_has_been_called = false
-      @host_data.setup
+      host_data = Sanford::HostData.new(TestHost, :verbose_logging => nil)
+      assert_not_nil host_data.verbose
     end
 
     should "have called the setup proc" do
-      assert_equal true, TestHost.setup_has_been_called
-
-      TestHost.setup_has_been_called = false
+      assert_equal true, TestHost.init_has_been_called
     end
 
     should "constantize a host's handlers" do
@@ -58,7 +41,7 @@ class Sanford::HostData
       assert_equal TestHost::Multiply,    handlers['v1']['multiply']
     end
 
-        should "look up handler classes with #handler_class_for" do
+    should "look up handler classes with #handler_class_for" do
       assert_equal TestHost::Echo, subject.handler_class_for('v1', 'echo')
     end
 

data/test/unit/host_test.rb

@@ -12,8 +12,8 @@ module Sanford::Host
     end
     subject{ MyHost.instance }
 
-    should have_instance_methods :configuration, :name, :ip, :port, :pid_dir, :logger,
-      :verbose_logging, :error, :setup, :version, :versioned_services
+    should have_instance_methods :configuration, :name, :ip, :port, :pid_file,
+      :logger, :verbose_logging, :error, :init, :version, :versioned_services
 
     should "get and set it's configuration options with their matching methods" do
       subject.name 'my_awesome_host'
@@ -36,7 +36,7 @@ module Sanford::Host
 
     should "proxy it's method to it's instance" do
       assert_equal subject.instance.name, subject.name
-      assert subject.respond_to?(:pid_dir)
+      assert subject.respond_to?(:pid_file)
     end
 
     should "have registered the class with sanford's known hosts" do

data/test/unit/manager_pid_file_test.rb

@@ -0,0 +1,45 @@
+require 'assert'
+
+require 'sanford/cli'
+
+class Sanford::Manager::PIDFile
+
+  class BaseTest < Assert::Context
+    desc "Sanford::Manager::PIDFile"
+    setup do
+      @pid_file = Sanford::Manager::PIDFile.new("tmp/my.pid")
+    end
+    teardown do
+      FileUtils.rm_rf("tmp/my.pid")
+    end
+    subject{ @pid_file }
+
+    should have_instance_methods :pid, :to_s, :write, :remove
+
+    should "return it's path with #to_s" do
+      assert_equal "tmp/my.pid", subject.to_s
+    end
+
+    should "write the pid file with #write" do
+      subject.write
+
+      assert File.exists?("tmp/my.pid")
+      assert_equal "#{Process.pid}\n", File.read("tmp/my.pid")
+    end
+
+    should "return the value stored in the pid value with #pid" do
+      subject.write
+
+      assert_equal Process.pid, subject.pid
+    end
+
+    should "remove the file with #remove" do
+      subject.write
+      subject.remove
+
+      assert_not File.exists?("tmp/my.pid")
+    end
+
+  end
+
+end

data/test/unit/manager_test.rb

@@ -1,21 +1,146 @@
 require 'assert'
 
-require 'sanford/manager'
+require 'sanford/cli'
 
-class Sanford::Manager
+module Sanford::Manager
 
   class BaseTest < Assert::Context
     desc "Sanford::Manager"
+    subject{ Sanford::Manager }
+
+    should have_instance_methods :call, :get_handler_class
+
+    should "return ServerHandler or SignalHandler with get_handler_class" do
+      assert_equal Sanford::Manager::ServerHandler, subject.get_handler_class('run')
+      assert_equal Sanford::Manager::ServerHandler, subject.get_handler_class('start')
+      assert_equal Sanford::Manager::SignalHandler, subject.get_handler_class('stop')
+      assert_equal Sanford::Manager::SignalHandler, subject.get_handler_class('restart')
+    end
+
+  end
+
+  class ServerHandlerTest < BaseTest
+    desc "ServerHandler"
+    setup do
+      @handler = Sanford::Manager::ServerHandler.new({ :host => 'TestHost' })
+    end
+    subject{ @handler }
+
+    should have_instance_methods :run, :start
+
+    should "raise an error when a host can't be found matching the `host` option" do
+      assert_raises(Sanford::NoHostError) do
+        Sanford::Manager::ServerHandler.new({ :host => 'poop' })
+      end
+    end
+
+    should "raise an error when a host is invalid for running a server" do
+      assert_raises(Sanford::InvalidHostError) do
+        Sanford::Manager::ServerHandler.new({ :host => 'InvalidHost' })
+      end
+    end
+
+  end
+
+  class SignalHandlertest < BaseTest
+    desc "SignalHandler"
+    setup do
+      @handler = Sanford::Manager::SignalHandler.new({ :pid => -1 })
+    end
+    subject{ @handler }
+
+    should have_instance_methods :stop, :restart
+
+    should "raise an error when a pid can't be found" do
+      assert_raises(Sanford::NoPIDError) do
+        Sanford::Manager::SignalHandler.new
+      end
+    end
+  end
+
+  class ConfigTest < BaseTest
+    desc "Config"
     setup do
-      @manager = Sanford::Manager.new(TestHost)
+      @config = Sanford::Manager::Config.new({ :host => 'TestHost' })
+    end
+    subject{ @config }
+
+    should have_instance_methods :host_name, :host, :ip, :port, :pid, :pid_file
+    should have_instance_methods :file_descriptor, :client_file_descriptors
+    should have_instance_methods :restart_dir
+    should have_instance_methods :listen_args, :has_listen_args?, :found_host?
+
+    should "find a host based on the `host` option" do
+      assert_equal TestHost, subject.host
+      assert_equal true, subject.found_host?
+    end
+
+    should "set the ip, port and pid file based on the host's configuration" do
+      assert_equal TestHost.ip,            subject.ip
+      assert_equal TestHost.port,          subject.port
+      assert_equal TestHost.pid_file.to_s, subject.pid_file.to_s
+    end
+
+    should "use the first host if no host option is provided" do
+      manager = Sanford::Manager::Config.new({ :port => 1 })
+      assert_equal Sanford.hosts.first, manager.host
+    end
+
+    should "return the file descriptor or ip and port with listen_args" do
+      config = Sanford::Manager::Config.new({
+        :file_descriptor => 1,
+        :ip => 'localhost', :port => 1234
+      })
+      assert_equal [ config.file_descriptor ], config.listen_args
+      assert_equal true, subject.has_listen_args?
+
+      config = Sanford::Manager::Config.new({ :ip => 'localhost', :port => 1234 })
+      assert_equal [ config.ip, config.port ], config.listen_args
+      assert_equal true, subject.has_listen_args?
+
+      config = Sanford::Manager::Config.new({ :host => 'InvalidHost' })
+      assert_equal false, config.has_listen_args?
+    end
+
+    should "build a NullHost when a host can't be found" do
+      config = Sanford::Manager::Config.new({ :host => 'poop' })
+      assert_instance_of Sanford::Manager::NullHost, config.host
+      assert_equal false, config.found_host?
+    end
+
+    should "split a string list of client file descriptors into an array" do
+      config = Sanford::Manager::Config.new({ :client_fds => '1,2,3' })
+      assert_equal [ 1, 2, 3 ], config.client_file_descriptors
+    end
+
+  end
+
+  class EnvVarsTest < ConfigTest
+    desc "with env vars set"
+    setup do
+      ENV['SANFORD_HOST'] = 'TestHost'
+      ENV['SANFORD_IP']   = '127.0.0.1'
+      ENV['SANFORD_PORT'] = '12345'
+      @config = Sanford::Manager::Config.new({
+        :host => 'InvalidHost',
+        :port => 54678
+      })
+    end
+    teardown do
+      ENV.delete('SANFORD_HOST')
+      ENV.delete('SANFORD_IP')
+      ENV.delete('SANFORD_PORT')
+    end
+
+    should "use the env vars over passed in options or the host's configuration" do
+      assert_equal TestHost,    subject.host
+      assert_equal '127.0.0.1', subject.ip
+      assert_equal 12345,       subject.port
     end
-    subject{ @manager }
 
-    should have_instance_methods :host_data, :process_name, :call
-    should have_class_methods :call
   end
 
-  # Sanford::Manager#call methods are tested in the test/system/managing_test.rb
-  # they require mocking the Daemons gem
+  # ServerHandler run/start and SignalHandler stop/restart are tested with
+  # system tests: test/system/managing_test.rb
 
 end

data/test/unit/runner_test.rb

@@ -11,6 +11,7 @@ class Sanford::Runner
     subject{ @runner }
 
     should have_instance_methods :handler_class, :request, :logger, :run
+    should have_class_methods :run
 
     should "run the handler and return the response it generates when `run` is called" do
       response = subject.run
@@ -21,6 +22,15 @@ class Sanford::Runner
       assert_equal 'joe.test@example.com',  response.data['email']
     end
 
+    should "be able to build a runner with a handler class and params" do
+      response = nil
+      assert_nothing_raised do
+        response = Sanford::Runner.run(BasicServiceHandler, {})
+      end
+
+      assert_equal 200, response.code
+    end
+
   end
 
 end

data/test/unit/server_test.rb

@@ -1,24 +1,43 @@
 require 'assert'
 
 require 'sanford/server'
-require 'sanford/manager'
 
 class Sanford::Server
 
   class BaseTest < Assert::Context
     desc "Sanford::Server"
     setup do
-      @server = Sanford::Server.new(TestHost)
+      @server = Sanford::Server.new(TestHost, { :keep_alive => true })
     end
     subject{ @server }
 
+    should have_instance_methods :sanford_host, :sanford_host_data, :sanford_host_options
+    should have_instance_methods :on_run
+
     should "include DatTCP::Server" do
       assert_includes DatTCP::Server, subject.class.included_modules
     end
 
-    should "use the service host's ip and port" do
-      assert_equal TestHost.ip,   subject.host
-      assert_equal TestHost.port, subject.port
+    should "save it's host and host options but not initialize a host data yet" do
+      assert_equal TestHost, subject.sanford_host
+      assert_equal true, subject.sanford_host_options[:receives_keep_alive]
+      assert_nil subject.sanford_host_data
+    end
+
+  end
+
+  class RunTest < BaseTest
+    desc "run"
+    setup do
+      @server.listen(TestHost.ip, TestHost.port)
+      @server.run
+    end
+    teardown do
+      @server.stop
+    end
+
+    should "have initialized a host data instance" do
+      assert_instance_of Sanford::HostData, subject.sanford_host_data
     end
 
   end

data/test/unit/service_handler_test.rb

@@ -14,11 +14,30 @@ module Sanford::ServiceHandler
     subject{ @handler }
 
     should have_instance_methods :init, :init!, :run, :run!
+    should have_class_methods :run
 
     should "raise a NotImplementedError if run! is not overwritten" do
       assert_raises(NotImplementedError){ subject.run! }
     end
 
+    should "allow running a handler class with the class method #run" do
+      response = HaltServiceHandler.run({
+        'code'    => 648,
+        'data'    => true
+      })
+      assert_equal 648,   response.code
+      assert_equal true,  response.data
+    end
+
+  end
+
+  class RunHandlerTest < BaseTest
+    desc "run_handler helper"
+
+    should "allow easily running another handler" do
+      response = test_runner(RunOtherHandler).run
+      assert_equal 'RunOtherHandler', response.data
+    end
   end
 
   class WithMethodFlagsTest < BaseTest

data/test/unit/worker_test.rb

@@ -4,27 +4,12 @@ require 'sanford-protocol/test/helpers'
 
 class Sanford::Worker
 
-  # turn off the protocol's debugging (in case it's on) and turn on Sanford's
-  # debugging
-  class SetupContextToRaiseExceptions < Assert::Context
-    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
-  end
-
-  class BaseTest < SetupContextToRaiseExceptions
+  class BaseTest < Assert::Context
     include Sanford::Protocol::Test::Helpers
 
     desc "Sanford::Worker"
     setup do
-      @host_data = Sanford::HostData.new(TestHost).tap{|hd| hd.setup }
+      @host_data = Sanford::HostData.new(TestHost)
       @connection = FakeConnection.with_request('version', 'service', {})
       @worker = Sanford::Worker.new(@host_data, @connection)
     end
@@ -34,180 +19,6 @@ class Sanford::Worker
 
   end
 
-  class EchoTest < BaseTest
-    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.status.code
-      assert_equal nil,     response.status.message
-      assert_equal 'test',  response.data
-    end
-
-  end
-
-  class MissingServiceVersionTest < BaseTest
-    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.status.code
-      assert_match "request", response.status.message
-      assert_match "version", response.status.message
-      assert_equal nil,       response.data
-    end
-
-  end
-
-  class MissingServiceNameTest < BaseTest
-    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.status.code
-      assert_match "request", response.status.message
-      assert_match "name",    response.status.message
-      assert_equal nil,       response.data
-    end
-
-  end
-
-  class NotFoundServiceTest < BaseTest
-    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.status.code
-      assert_equal nil, response.status.message
-      assert_equal nil, response.data
-    end
-
-  end
-
-  class ErrorServiceTest < BaseTest
-    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.status.code
-      assert_match "error", response.status.message
-      assert_equal nil,     response.data
-    end
-
-  end
-
-  class HaltTest < BaseTest
-    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.status.code
-      assert_equal "I do what I want",  response.status.message
-      assert_equal [ 1, true, 'yes' ],  response.data
-    end
-
-  end
-
-  class AuthorizeRequestTest < BaseTest
-    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.status.code
-      assert_equal "Not authorized",  response.status.message
-      assert_equal nil,               response.data
-    end
-
-  end
-
-  class WithCustomErrorHandlerTest < BaseTest
-    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.status.code
-      assert_equal "custom error!",   response.status.message
-      assert_equal nil,               response.data
-    end
-
-  end
-
-  class WithBadResponseHashTest < BaseTest
-    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.status.code
-      assert_equal "An unexpected error occurred.", response.status.message
-      assert_equal nil,                             response.data
-    end
-
-  end
+  # `Worker`'s logic is tested in the system test: `request_handling_test.rb`
 
 end