samhendley-god 0.7.13

data/test/test_handlers_kqueue_handler.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/helper'
+
+if God::EventHandler.event_system == "kqueue"
+  
+  class TestHandlersKqueueHandler < Test::Unit::TestCase
+    def test_register_process
+      KQueueHandler.expects(:monitor_process).with(1234, 2147483648)
+      KQueueHandler.register_process(1234, [:proc_exit])
+    end
+  
+    def test_events_mask
+      assert_equal 2147483648, KQueueHandler.events_mask([:proc_exit])
+    end
+  end
+  
+end

data/test/test_logger.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestLogger < Test::Unit::TestCase
+  def setup
+    @log = God::Logger.new
+  end
+  
+  # log
+  
+  def test_log
+    @log.expects(:info).with("qux")
+    
+    no_stdout do
+      @log.log(stub(:name => 'foo'), :info, "qux")
+    end
+    
+    assert_equal 1, @log.logs.size
+    assert_instance_of Time, @log.logs['foo'][0][0]
+    assert_match(/qux/, @log.logs['foo'][0][1])
+  end
+  
+  def test_log_should_send_to_syslog
+    Syslog.expects(:crit).with('foo')
+    
+    no_stdout do
+      @log.log(stub(:name => 'foo'), :fatal, "foo")
+    end
+  end
+  
+  # watch_log_since
+  
+  def test_watch_log_since
+    t1 = Time.now
+    
+    no_stdout do
+      @log.log(stub(:name => 'foo'), :info, "one")
+      @log.log(stub(:name => 'foo'), :info, "two")
+    end
+    
+    assert_match(/one.*two/m, @log.watch_log_since('foo', t1))
+    
+    t2 = Time.now
+    
+    no_stdout do
+      @log.log(stub(:name => 'foo'), :info, "three")
+    end
+    
+    out = @log.watch_log_since('foo', t2)
+    
+    assert_no_match(/one/, out)
+    assert_no_match(/two/, out)
+    assert_match(/three/, out)
+  end
+  
+  # regular methods
+  
+  def test_fatal
+    no_stdout do
+      @log.fatal('foo')
+    end
+    assert_equal 0, @log.logs.size
+  end
+end

data/test/test_metric.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestMetric < Test::Unit::TestCase
+  def setup
+    @metric = Metric.new(stub(:interval => 10), nil)
+  end
+  
+  # watch
+  
+  def test_watch
+    w = stub()
+    m = Metric.new(w, nil)
+    assert_equal w, m.watch
+  end
+  
+  # destination
+  
+  def test_destination
+    d = stub()
+    m = Metric.new(nil, d)
+    assert_equal d, m.destination
+  end
+  
+  # condition
+  
+  def test_condition_should_be_block_optional
+    @metric.condition(:fake_poll_condition)
+    assert_equal 1, @metric.conditions.size
+  end
+  
+  def test_poll_condition_should_inherit_interval_from_watch_if_not_specified
+    @metric.condition(:fake_poll_condition)
+    assert_equal 10, @metric.conditions.first.interval
+  end
+  
+  def test_poll_condition_should_abort_if_no_interval_and_no_watch_interval
+    metric = Metric.new(stub(:name => 'foo', :interval => nil), nil)
+    
+    assert_abort do
+      metric.condition(:fake_poll_condition)
+    end
+  end
+  
+  def test_condition_should_allow_generation_of_subclasses_of_poll_or_event
+    metric = Metric.new(stub(:name => 'foo', :interval => 10), nil)
+    
+    assert_nothing_raised do
+      metric.condition(:fake_poll_condition)
+      metric.condition(:fake_event_condition)
+    end
+  end
+  
+  def test_condition_should_abort_if_not_subclass_of_poll_or_event
+    metric = Metric.new(stub(:name => 'foo', :interval => 10), nil)
+    
+    assert_abort do
+      metric.condition(:fake_condition) { |c| }
+    end
+  end
+  
+  def test_condition_should_abort_on_invalid_condition
+    assert_abort do
+      @metric.condition(:fake_poll_condition) { |c| c.stubs(:valid?).returns(false) }
+    end
+  end
+  
+  def test_condition_should_abort_on_no_such_condition
+    assert_abort do
+      @metric.condition(:invalid) { }
+    end
+  end
+end

data/test/test_process.rb

@@ -0,0 +1,246 @@
+require File.dirname(__FILE__) + '/helper'
+
+module God
+  class Process
+    # def fork
+    #   raise "You forgot to stub fork"
+    # end
+    
+    def exec(*args)
+      raise "You forgot to stub exec"
+    end
+  end
+end
+
+class TestProcessChild < Test::Unit::TestCase
+  def setup
+    God.internal_init
+    @p = God::Process.new
+    @p.name = 'foo'
+    @p.stubs(:test).returns true # so we don't try to mkdir_p
+    Process.stubs(:detach) # because we stub fork
+    
+    ::Process::Sys.stubs(:setuid).returns(true)
+    ::Process::Sys.stubs(:setgid).returns(true)
+  end
+  
+  # valid?
+  
+  def test_valid_should_return_true_if_auto_daemonized_and_log
+    @p.start = 'qux'
+    @p.log = 'bar'
+    
+    assert @p.valid?
+  end
+  
+  def test_valid_should_return_true_if_auto_daemonized_and_no_stop
+    @p.start = 'qux'
+    @p.log = 'bar'
+    
+    assert @p.valid?
+  end
+  
+  def test_valid_should_return_true_if_uid_exists
+    @p.start = 'qux'
+    @p.log = '/tmp/foo.log'
+    @p.uid = 'root'
+    
+    assert @p.valid?
+  end
+  
+  def test_valid_should_return_true_if_uid_does_not_exists
+    @p.start = 'qux'
+    @p.log = '/tmp/foo.log'
+    @p.uid = 'foobarbaz'
+    
+    no_stdout do
+      no_stderr do
+        assert !@p.valid?
+      end
+    end
+  end
+  
+  def test_valid_should_return_true_if_gid_exists
+    @p.start = 'qux'
+    @p.log = '/tmp/foo.log'
+    @p.gid = 'wheel'
+    
+    assert @p.valid?
+  end
+  
+  def test_valid_should_return_false_if_gid_does_not_exists
+    @p.start = 'qux'
+    @p.log = '/tmp/foo.log'
+    @p.gid = 'foobarbaz'
+    
+    no_stdout do
+      no_stderr do
+        assert !@p.valid?
+      end
+    end
+  end
+
+  def test_valid_should_return_false_with_bogus_chroot
+    @p.chroot = '/bogusroot'
+
+    no_stdout do
+      no_stderr do
+        assert !@p.valid?
+      end
+    end
+  end
+
+  def test_valid_should_return_true_with_chroot_and_valid_log
+    @p.start = 'qux'
+    @p.chroot = '/tmp'
+    @p.log = '/tmp/foo.log'
+
+    File.expects(:exist?).with('/tmp').returns(true)
+    File.expects(:exist?).with('/tmp/foo.log').returns(true)
+    File.expects(:exist?).with('/tmp/dev/null').returns(true)
+
+    assert @p.valid?
+  end
+  
+  # call_action
+  
+  def test_call_action_should_write_pid
+    # Only for start, restart
+    [:start, :restart].each do |action|
+      @p.stubs(:test).returns true
+      IO.expects(:pipe).returns([StringIO.new('1234'), StringIO.new])
+      @p.expects(:fork)
+      Process.expects(:waitpid)
+      File.expects(:open).with(@p.default_pid_file, 'w')
+      @p.send("#{action}=", "run")
+      @p.call_action(action)
+    end
+  end
+end
+
+###############################################################################
+#
+# Daemon
+#
+###############################################################################
+
+class TestProcessDaemon < Test::Unit::TestCase
+  def setup
+    God.internal_init
+    @p = God::Process.new
+    @p.name = 'foo'
+    @p.pid_file = 'blah.pid'
+    @p.stubs(:test).returns true # so we don't try to mkdir_p
+    Process.stubs(:detach) # because we stub fork
+  end
+  
+  # alive?
+  
+  def test_alive_should_call_system_process_exists
+    File.expects(:read).with('blah.pid').times(2).returns('1234')
+    System::Process.any_instance.expects(:exists?).returns(false)
+    assert !@p.alive?
+  end
+  
+  def test_alive_should_return_false_if_no_such_file
+    File.expects(:read).with('blah.pid').raises(Errno::ENOENT)
+    assert !@p.alive?
+  end
+  
+  # valid?
+  
+  def test_valid_should_return_false_if_no_start
+    @p.name = 'foo'
+    @p.stop = 'baz'
+    no_stdout do
+      assert !@p.valid?
+    end
+  end
+  
+  def test_valid_should_return_false_if_self_daemonized_and_no_stop
+    @p.start = 'bar'
+    @p.pid_file = 'foo'
+    
+    no_stdout do
+      assert !@p.valid?
+    end
+  end
+  
+  # pid
+  
+  def test_pid_should_return_integer_for_valid_pid_files
+    File.stubs(:read).returns("123")
+    assert_equal 123, @p.pid
+  end
+  
+  def test_pid_should_return_nil_for_missing_files
+    @p.pid_file = ''
+    assert_equal nil, @p.pid
+  end
+  
+  def test_pid_should_return_nil_for_invalid_pid_files
+    File.stubs(:read).returns("four score and seven years ago")
+    assert_equal nil, @p.pid
+  end
+  
+  def test_pid_should_retain_last_pid_value_if_pid_file_is_removed
+    File.stubs(:read).returns("123")
+    assert_equal 123, @p.pid
+    
+    File.stubs(:read).raises(Errno::ENOENT)
+    assert_equal 123, @p.pid
+    
+    File.stubs(:read).returns("246")
+    assert_equal 246, @p.pid
+  end
+  
+  # default_pid_file
+  
+  def test_default_pid_file
+    assert_equal File.join(God.pid_file_directory, 'foo.pid'), @p.default_pid_file
+  end
+  
+  # unix socket
+  
+  def test_unix_socket_should_return_path_specified
+    @p.unix_socket = '/path/to-socket'
+    assert_equal '/path/to-socket', @p.unix_socket
+  end
+  
+  # call_action
+  # These actually excercise call_action in the back at this point - Kev
+  
+  def test_call_action_with_string_should_call_system
+    @p.start = "do something"
+    @p.expects(:fork)
+    Process.expects(:waitpid2).returns([123, 0])
+    @p.call_action(:start)
+  end
+  
+  def test_call_action_with_lambda_should_call
+    cmd = lambda { puts "Hi" }
+    cmd.expects(:call)
+    @p.start = cmd
+    @p.call_action(:start)
+  end
+  
+  def test_call_action_with_invalid_command_class_should_raise
+    @p.start = 5
+    @p.stop = 'baz'
+    
+    assert @p.valid?
+    
+    assert_raise NotImplementedError do
+      @p.call_action(:start)
+    end
+  end
+  
+  # start!/stop!/restart!
+  
+  def test_start_stop_restart_bang
+    [:start, :stop, :restart].each do |x|
+      @p.expects(:call_action).with(x)
+      @p.send("#{x}!")
+    end
+  end
+end

data/test/test_registry.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestRegistry < Test::Unit::TestCase
+  def setup
+    God.registry.reset
+  end
+  
+  def test_add
+    foo = God::Process.new
+    foo.name = 'foo'
+    God.registry.add(foo)
+    assert_equal 1, God.registry.size
+    assert_equal foo, God.registry['foo']
+  end
+end

data/test/test_socket.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestSocket < Test::Unit::TestCase
+  def setup
+    silence_warnings do 
+      Object.const_set(:DRb, stub_everything)
+    end
+  end
+
+  def test_should_start_a_drb_server
+    DRb.expects(:start_service)
+    no_stdout do
+      God::Socket.new
+    end
+  end
+
+  def test_should_use_supplied_port_and_host
+    DRb.expects(:start_service).with { |uri, object| uri == "drbunix:///tmp/god.9999.sock" && object.is_a?(God::Socket) }
+    no_stdout do
+      server = God::Socket.new(9999)
+    end
+  end
+
+  def test_should_forward_foreign_method_calls_to_god
+    server = nil
+    no_stdout do
+      server = God::Socket.new
+    end
+    God.expects(:send).with(:something_random)
+    server.something_random
+  end
+  
+  # ping
+  
+  def test_ping_should_return_true
+    server = nil
+    no_stdout do
+      server = God::Socket.new
+    end
+    assert server.ping
+  end
+end