sanford 0.17.0 → 0.18.0

data/test/unit/io_pipe_tests.rb

@@ -0,0 +1,84 @@
+require 'assert'
+require 'sanford/io_pipe'
+
+require 'thread'
+
+class Sanford::IOPipe
+
+  class UnitTests < Assert::Context
+    desc "Sanford::IOPipe"
+    setup do
+      # mimic how IO.select responds
+      @io_select_response    = Factory.boolean ? [[NULL], [], []] : nil
+      @io_select_called_with = nil
+      Assert.stub(IO, :select) do |*args|
+        @io_select_called_with = args
+        @io_select_response
+      end
+
+      @io_pipe = Sanford::IOPipe.new
+    end
+    subject{ @io_pipe }
+
+    should have_readers :reader, :writer
+    should have_imeths :setup, :teardown
+    should have_imeths :read, :write, :wait
+
+    should "default its reader and writer" do
+      assert_same NULL, subject.reader
+      assert_same NULL, subject.writer
+    end
+
+    should "change its reader/writer to an IO pipe when setup" do
+      subject.setup
+      assert_not_same NULL, subject.reader
+      assert_not_same NULL, subject.writer
+      assert_instance_of IO, subject.reader
+      assert_instance_of IO, subject.writer
+    end
+
+    should "close its reader/writer and set them to defaults when torn down" do
+      subject.setup
+      reader = subject.reader
+      writer = subject.writer
+
+      subject.teardown
+      assert_true reader.closed?
+      assert_true writer.closed?
+      assert_same NULL, subject.reader
+      assert_same NULL, subject.writer
+    end
+
+    should "be able to read/write values" do
+      subject.setup
+
+      value = Factory.string(NUMBER_OF_BYTES)
+      subject.write(value)
+      assert_equal value, subject.read
+    end
+
+    should "only read/write a fixed number of bytes" do
+      subject.setup
+
+      value = Factory.string
+      subject.write(value)
+      assert_equal value[0, NUMBER_OF_BYTES], subject.read
+    end
+
+    should "be able to wait until there is something to read" do
+      subject.setup
+
+      result = subject.wait
+      exp = [[subject.reader], nil, nil, nil]
+      assert_equal exp, @io_select_called_with
+      assert_equal !!@io_select_response, result
+
+      timeout = Factory.integer
+      subject.wait(timeout)
+      exp = [[subject.reader], nil, nil, timeout]
+      assert_equal exp, @io_select_called_with
+    end
+
+  end
+
+end

data/test/unit/process_tests.rb

@@ -1,6 +1,7 @@
 require 'assert'
 require 'sanford/process'
 
+require 'sanford/io_pipe'
 require 'sanford/server'
 require 'test/support/pid_file_spy'
 
@@ -9,22 +10,37 @@ class Sanford::Process
   class UnitTests < Assert::Context
     desc "Sanford::Process"
     setup do
+      @current_env_server_fd      = ENV['SANFORD_SERVER_FD']
+      @current_env_client_fds     = ENV['SANFORD_CLIENT_FDS']
+      @current_env_skip_daemonize = ENV['SANFORD_SKIP_DAEMONIZE']
+      ENV.delete('SANFORD_SERVER_FD')
+      ENV.delete('SANFORD_CLIENT_FDS')
+      ENV.delete('SANFORD_SKIP_DAEMONIZE')
+
       @process_class = Sanford::Process
     end
+    teardown do
+      ENV['SANFORD_SKIP_DAEMONIZE'] = @current_env_skip_daemonize
+      ENV['SANFORD_CLIENT_FDS']     = @current_env_client_fds
+      ENV['SANFORD_SERVER_FD']      = @current_env_server_fd
+    end
     subject{ @process_class }
 
+    should "know its wait for signals timeout" do
+      assert_equal 15, WAIT_FOR_SIGNALS_TIMEOUT
+    end
+
+    should "know its signal strings" do
+      assert_equal 'H', HALT
+      assert_equal 'S', STOP
+      assert_equal 'R', RESTART
+    end
+
   end
 
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @current_env_server_fd      = ENV['SANFORD_SERVER_FD']
-      @current_env_client_fds     = ENV['SANFORD_CLIENT_FDS']
-      @current_env_skip_daemonize = ENV['SANFORD_SKIP_DAEMONIZE']
-      ENV.delete('SANFORD_SERVER_FD')
-      ENV.delete('SANFORD_CLIENT_FDS')
-      ENV.delete('SANFORD_SKIP_DAEMONIZE')
-
       @server_spy = ServerSpy.new
 
       @pid_file_spy = PIDFileSpy.new(Factory.integer)
@@ -37,14 +53,9 @@ class Sanford::Process
 
       @process = @process_class.new(@server_spy)
     end
-    teardown do
-      ENV['SANFORD_SKIP_DAEMONIZE'] = @current_env_skip_daemonize
-      ENV['SANFORD_CLIENT_FDS']     = @current_env_client_fds
-      ENV['SANFORD_SERVER_FD']      = @current_env_server_fd
-    end
     subject{ @process }
 
-    should have_readers :server, :name, :pid_file, :restart_cmd
+    should have_readers :server, :name, :pid_file, :signal_io, :restart_cmd
     should have_readers :server_ip, :server_port, :server_fd, :client_fds
     should have_imeths :run, :daemonize?
 
@@ -52,16 +63,17 @@ class Sanford::Process
       assert_equal @server_spy, subject.server
     end
 
-    should "know its name, pid file and restart cmd" do
-      expected = "sanford-#{@server_spy.name}-" \
-                 "#{@server_spy.configured_ip}-#{@server_spy.configured_port}"
-      assert_equal expected, subject.name
-      assert_equal @pid_file_spy, subject.pid_file
-      assert_equal @restart_cmd_spy, subject.restart_cmd
+    should "know its name, pid file, signal io and restart cmd" do
+      exp = "sanford: #{@server_spy.process_label}"
+      assert_equal exp, subject.name
+
+      assert_equal @pid_file_spy,         subject.pid_file
+      assert_instance_of Sanford::IOPipe, subject.signal_io
+      assert_equal @restart_cmd_spy,      subject.restart_cmd
     end
 
     should "know its server ip, port and file descriptor" do
-      assert_equal @server_spy.configured_ip, subject.server_ip
+      assert_equal @server_spy.configured_ip,   subject.server_ip
       assert_equal @server_spy.configured_port, subject.server_port
       assert_nil subject.server_fd
     end
@@ -124,28 +136,14 @@ class Sanford::Process
 
       @current_process_name = $0
 
-      @term_signal_trap_block = nil
-      @term_signal_trap_called = false
-      Assert.stub(::Signal, :trap).with("TERM") do |&block|
-        @term_signal_trap_block = block
-        @term_signal_trap_called = true
-      end
-
-      @int_signal_trap_block = nil
-      @int_signal_trap_called = false
-      Assert.stub(::Signal, :trap).with("INT") do |&block|
-        @int_signal_trap_block = block
-        @int_signal_trap_called = true
-      end
-
-      @usr2_signal_trap_block = nil
-      @usr2_signal_trap_called = false
-      Assert.stub(::Signal, :trap).with("USR2") do |&block|
-        @usr2_signal_trap_block = block
-        @usr2_signal_trap_called = true
+      @signal_traps = []
+      Assert.stub(::Signal, :trap) do |signal, &block|
+        @signal_traps << SignalTrap.new(signal, block)
       end
     end
     teardown do
+      @process.signal_io.write(HALT)
+      @thread.join if @thread
       $0 = @current_process_name
     end
 
@@ -154,58 +152,74 @@ class Sanford::Process
   class RunTests < RunSetupTests
     desc "and run"
     setup do
-      @process.run
+      @wait_timeout = nil
+      Assert.stub(@process.signal_io, :wait) do |timeout|
+        @wait_timeout = timeout
+        sleep 2*JOIN_SECONDS
+        false
+      end
+
+      @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
+    end
+    teardown do
+      # manually unstub or the process thread will hang forever
+      Assert.unstub(@process.signal_io, :wait)
     end
 
-    should "not have daemonized the process" do
+    should "not daemonize the process" do
       assert_false @daemonize_called
     end
 
-    should "have started the server listening" do
+    should "start the server listening" do
       assert_true @server_spy.listen_called
-      expected = [ subject.server_ip, subject.server_port ]
-      assert_equal expected, @server_spy.listen_args
+      exp = [subject.server_ip, subject.server_port]
+      assert_equal exp, @server_spy.listen_args
     end
 
-    should "have set the process name" do
+    should "set the process name" do
       assert_equal $0, subject.name
     end
 
-    should "have written the PID file" do
+    should "write its PID file" do
       assert_true @pid_file_spy.write_called
     end
 
-    should "have trapped signals" do
-      assert_true @term_signal_trap_called
-      assert_false @server_spy.stop_called
-      @term_signal_trap_block.call
-      assert_true @server_spy.stop_called
-
-      assert_true @int_signal_trap_called
-      assert_false @server_spy.halt_called
-      @int_signal_trap_block.call
-      assert_true @server_spy.halt_called
-
-      assert_true @usr2_signal_trap_called
-      assert_false @server_spy.pause_called
-      @usr2_signal_trap_block.call
-      assert_true @server_spy.pause_called
+    should "trap signals" do
+      assert_equal 3, @signal_traps.size
+      assert_equal ['INT', 'TERM', 'USR2'], @signal_traps.map(&:signal)
     end
 
-    should "have started the server" do
+    should "start the server" do
       assert_true @server_spy.start_called
     end
 
-    should "have joined the server thread" do
-      assert_true @server_spy.thread.join_called
+    should "sleep its thread waiting for signals" do
+      assert_equal WAIT_FOR_SIGNALS_TIMEOUT, @wait_timeout
+      assert_equal 'sleep', @thread.status
     end
 
     should "not run the restart cmd" do
-      assert_false @restart_cmd_spy.run_called
+      assert_nil @restart_cmd_spy.run_called_for
     end
 
-    should "have removed the PID file" do
-      assert_true @pid_file_spy.remove_called
+  end
+
+  class SignalTrapsTests < RunSetupTests
+    desc "signal traps"
+    setup do
+      # setup the io pipe so we can see whats written to it
+      @process.signal_io.setup
+    end
+    teardown do
+      @process.signal_io.teardown
+    end
+
+    should "write the signals to processes signal IO" do
+      @signal_traps.each do |signal_trap|
+        signal_trap.block.call
+        assert_equal signal_trap.signal, subject.signal_io.read
+      end
     end
 
   end
@@ -214,7 +228,8 @@ class Sanford::Process
     desc "that should daemonize is run"
     setup do
       Assert.stub(@process, :daemonize?){ true }
-      @process.run
+      @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
     end
 
     should "have daemonized the process" do
@@ -228,13 +243,14 @@ class Sanford::Process
     setup do
       ENV['SANFORD_SERVER_FD'] = Factory.integer.to_s
       @process = @process_class.new(@server_spy)
-      @process.run
+      @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
     end
 
     should "have used the file descriptor when listening" do
       assert_true @server_spy.listen_called
-      expected = [ @process.server_fd ]
-      assert_equal expected, @server_spy.listen_args
+      exp = [@process.server_fd]
+      assert_equal exp, @server_spy.listen_args
     end
 
   end
@@ -245,7 +261,8 @@ class Sanford::Process
       @client_fds = [ Factory.integer, Factory.integer ]
       ENV['SANFORD_CLIENT_FDS'] = @client_fds.join(',')
       @process = @process_class.new(@server_spy)
-      @process.run
+      @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
     end
 
     should "have used the client file descriptors when starting" do
@@ -255,25 +272,120 @@ class Sanford::Process
 
   end
 
-  class RunAndServerPausedTests < RunSetupTests
-    desc "then run and then paused"
+  class RunAndHaltTests < RunSetupTests
+    desc "and run with a halt signal"
     setup do
-      server_fd = Factory.integer
-      Assert.stub(@server_spy, :file_descriptor){ server_fd }
-      client_fds = [ Factory.integer, Factory.integer ]
-      Assert.stub(@server_spy, :client_file_descriptors){ client_fds }
+      @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
+      @process.signal_io.write(HALT)
+      @thread.join(JOIN_SECONDS)
+    end
+
+    should "halt its server" do
+      assert_true @server_spy.halt_called
+      assert_equal [true], @server_spy.halt_args
+    end
+
+    should "not set the env var to skip daemonize" do
+      assert_equal @current_env_skip_daemonize, ENV['SANFORD_SKIP_DAEMONIZE']
+    end
+
+    should "not run the restart cmd" do
+      assert_nil @restart_cmd_spy.run_called_for
+    end
+
+    should "remove the PID file" do
+      assert_true @pid_file_spy.remove_called
+    end
+
+  end
+
+  class RunAndStopTests < RunSetupTests
+    desc "and run with a stop signal"
+    setup do
+      @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
+      @process.signal_io.write(STOP)
+      @thread.join(JOIN_SECONDS)
+    end
+
+    should "stop its server" do
+      assert_true @server_spy.stop_called
+      assert_equal [true], @server_spy.stop_args
+    end
+
+    should "not set the env var to skip daemonize" do
+      assert_equal @current_env_skip_daemonize, ENV['SANFORD_SKIP_DAEMONIZE']
+    end
+
+    should "not run the restart cmd" do
+      assert_nil @restart_cmd_spy.run_called_for
+    end
+
+    should "remove the PID file" do
+      assert_true @pid_file_spy.remove_called
+    end
+
+  end
 
-      # mimicing pause being called by a signal, after the thread is joined
-      @server_spy.thread.on_join{ @server_spy.pause }
-      @process.run
+  class RunAndRestartTests < RunSetupTests
+    desc "and run with a restart signal"
+    setup do
+      @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
+      @process.signal_io.write(RESTART)
+      @thread.join(JOIN_SECONDS)
     end
 
-    should "set env vars for restarting and run the restart cmd" do
-      assert_equal @server_spy.file_descriptor.to_s, ENV['SANFORD_SERVER_FD']
-      expected = @server_spy.client_file_descriptors.join(',')
-      assert_equal expected, ENV['SANFORD_CLIENT_FDS']
-      assert_equal 'yes', ENV['SANFORD_SKIP_DAEMONIZE']
-      assert_true @restart_cmd_spy.run_called
+    should "pause its server" do
+      assert_true @server_spy.pause_called
+      assert_equal [true], @server_spy.pause_args
+    end
+
+    should "run the restart cmd" do
+      assert_equal @server_spy, @restart_cmd_spy.run_called_for
+    end
+
+  end
+
+  class RunWithServerCrashTests < RunSetupTests
+    desc "and run with the server crashing"
+    setup do
+      Assert.stub(@process.signal_io, :wait) do |timeout|
+        sleep JOIN_SECONDS * 0.5 # ensure this has time to run before the thread
+                                 # joins below
+        false
+      end
+
+      @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
+      @server_spy.start_called = false
+      @thread.join(JOIN_SECONDS)
+    end
+    teardown do
+      # manually unstub or the process thread will hang forever
+      Assert.unstub(@process.signal_io, :wait)
+    end
+
+    should "re-start its server" do
+      assert_true @server_spy.start_called
+    end
+
+  end
+
+  class RunWithInvalidSignalTests < RunSetupTests
+    desc "and run with unsupported signals"
+    setup do
+      # ruby throws an argument error if the OS doesn't support a signal
+      Assert.stub(::Signal, :trap){ raise ArgumentError }
+
+      @thread = Thread.new{ @process.run }
+      @thread.join(JOIN_SECONDS)
+    end
+
+    should "start normally" do
+      assert_true @server_spy.start_called
+      assert_equal 'sleep', @thread.status
     end
 
   end
@@ -289,6 +401,12 @@ class Sanford::Process
       Assert.stub(File, :stat).with(Dir.pwd){ @ruby_pwd_stat }
       Assert.stub(File, :stat).with(ENV['PWD']){ env_pwd_stat }
 
+      @server_spy = ServerSpy.new
+      server_fd = Factory.integer
+      Assert.stub(@server_spy, :file_descriptor){ server_fd }
+      client_fds = Factory.integer(3).times.map{ Factory.integer }
+      Assert.stub(@server_spy, :client_file_descriptors){ client_fds }
+
       @chdir_called_with = nil
       Assert.stub(Dir, :chdir){ |*args| @chdir_called_with = args }
 
@@ -317,10 +435,38 @@ class Sanford::Process
       assert_equal [Gem.ruby, $0, ARGV].flatten, subject.argv
     end
 
-    should "change the dir and run a kernel exec when run" do
-      subject.run
-      assert_equal [subject.dir], @chdir_called_with
-      assert_equal subject.argv,  @exec_called_with
+    if RUBY_VERSION == '1.8.7'
+
+      should "set env vars, change the dir and kernel exec when run" do
+        subject.run(@server_spy)
+
+        assert_equal @server_spy.file_descriptor.to_s, ENV['SANFORD_SERVER_FD']
+        exp = @server_spy.client_file_descriptors.join(',')
+        assert_equal exp, ENV['SANFORD_CLIENT_FDS']
+        assert_equal 'yes', ENV['SANFORD_SKIP_DAEMONIZE']
+
+        assert_equal [subject.dir], @chdir_called_with
+        assert_equal subject.argv,  @exec_called_with
+      end
+
+    else
+
+      should "kernel exec when run" do
+        subject.run(@server_spy)
+
+        env = {
+          'SANFORD_SERVER_FD'      => @server_spy.file_descriptor.to_s,
+          'SANFORD_CLIENT_FDS'     => @server_spy.client_file_descriptors.join(','),
+          'SANFORD_SKIP_DAEMONIZE' => 'yes'
+        }
+        fd_redirects = (
+          [@server_spy.file_descriptor] +
+          @server_spy.client_file_descriptors
+        ).inject({}){ |h, fd| h.merge!(fd => fd) }
+        options = { :chdir => subject.dir }.merge!(fd_redirects)
+        assert_equal ([env] + subject.argv + [options]), @exec_called_with
+      end
+
     end
 
   end
@@ -364,31 +510,35 @@ class Sanford::Process
 
   end
 
+  SignalTrap = Struct.new(:signal, :block)
+
   class ServerSpy
     include Sanford::Server
 
-    name Factory.string
-    ip Factory.string
-    port Factory.integer
+    name     Factory.string
+    ip       Factory.string
+    port     Factory.integer
     pid_file Factory.file_path
 
-    attr_reader :listen_called, :start_called
-    attr_reader :stop_called, :halt_called, :pause_called
-    attr_reader :listen_args, :start_args
-    attr_reader :thread
+    attr_accessor :process_label, :listen_called
+    attr_accessor :start_called, :stop_called, :halt_called, :pause_called
+    attr_reader :listen_args, :start_args, :stop_args, :halt_args, :pause_args
 
     def initialize(*args)
       super
-      @listen_called = false
-      @start_called = false
-      @stop_called = false
-      @halt_called = false
-      @pause_called = false
 
-      @listen_args = nil
-      @start_args = nil
+      @process_label = Factory.string
 
-      @thread = ThreadSpy.new
+      @listen_args   = nil
+      @listen_called = false
+      @start_args    = nil
+      @start_called  = false
+      @stop_args     = nil
+      @stop_called   = false
+      @halt_args     = nil
+      @halt_called   = false
+      @pause_args    = nil
+      @pause_called  = false
     end
 
     def listen(*args)
@@ -399,53 +549,38 @@ class Sanford::Process
     def start(*args)
       @start_args = args
       @start_called = true
-      @thread
     end
 
     def stop(*args)
+      @stop_args   = args
       @stop_called = true
     end
 
     def halt(*args)
+      @halt_args   = args
       @halt_called = true
     end
 
+
     def pause(*args)
+      @pause_args   = args
       @pause_called = true
     end
 
-    def paused?
-      @pause_called
-    end
-  end
-
-  class ThreadSpy
-    attr_reader :join_called, :on_join_proc
-
-    def initialize
-      @join_called = false
-      @on_join_proc = proc{ }
-    end
-
-    def on_join(&block)
-      @on_join_proc = block
-    end
-
-    def join
-      @join_called = true
-      @on_join_proc.call
+    def running?
+      !!@start_called
     end
   end
 
   class RestartCmdSpy
-    attr_reader :run_called
+    attr_reader :run_called_for
 
     def initialize
-      @run_called = false
+      @run_called_for = nil
     end
 
-    def run
-      @run_called = true
+    def run(server)
+      @run_called_for = server
     end
   end