resurrected_god 0.14.0 → 1.0.0

data/test/test_god_system.rb

@@ -1,201 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestGodSystem < MiniTest::Test
-  def assert_watch_running(watch_name)
-    assert_equal true, God.watches[watch_name].alive?
-  end
-
-  def with_god_cleanup
-    old_terminate = God.method(:terminate)
-    # necessary cuz actual god terminate will do exit(0) will stops tests
-    God.class_eval do
-      def self.terminate
-        FileUtils.rm_f(self.pid) if self.pid
-        self.server.stop if self.server
-      end
-    end
-    begin
-      yield
-    ensure
-      God.stop_all
-      God.terminate # use our monkeypatched terminate
-      God.watches.each do |name, w|
-        w.stop_signal = 'KILL'
-        w.action(:stop)
-      end
-      God.inited = false
-      God.terminate_timeout = ::God::TERMINATE_TIMEOUT_DEFAULT
-      God.internal_init # reset config, set running to false, etc.
-      # set termiante back to old method, for other tests
-      God.define_singleton_method(:terminate, old_terminate)
-    end
-  end
-
-  def test_start_running
-    with_god_cleanup do
-      God.start
-      assert_equal(God.running, true)
-    end
-  end
-
-  def test_add_watch
-    with_god_cleanup do
-      God.start
-      God.watch do |w|
-        w.name = 'add_watch'
-        w.start = File.join(GOD_ROOT, *%w[test configs complex simple_server.rb])
-      end
-      assert God.watches['add_watch'] != nil
-    end
-  end
-
-  def test_start_watch
-    with_god_cleanup do
-      God.start
-      God.watch do |w|
-        w.name = 'start_watch'
-        w.start = File.join(GOD_ROOT, *%w[test configs complex simple_server.rb])
-      end
-      God.watches['start_watch'].action(:start)
-      sleep 2
-      assert_equal true, God.watches['start_watch'].alive?
-    end
-  end
-
-  def test_start_watch
-    with_god_cleanup do
-      God.start
-      God.watch do |w|
-        w.name = 'start_watch'
-        w.start = File.join(GOD_ROOT, *%w[test configs complex simple_server.rb])
-      end
-      God.watches['start_watch'].action(:start)
-      sleep 2
-      assert_equal true, God.watches['start_watch'].alive?
-    end
-  end
-
-  def test_stop_all_with_one
-    with_god_cleanup do
-      God.start
-      God.watch do |w|
-        w.name = 'start_watch'
-        w.start = File.join(GOD_ROOT, *%w[test configs complex simple_server.rb])
-      end
-      God.watches['start_watch'].action(:start)
-      sleep 2
-      assert_equal true, God.watches['start_watch'].alive?
-      God.stop_all
-      assert_equal false, God.watches.any? { |name, w| w.alive? }
-    end
-  end
-
-  # default 10s timeout will expire before SIGKILL sent
-  def test_stop_all_with_non_killing_signal_long_timeout
-    with_god_cleanup do
-      God.start
-      God.watch do |w|
-        w.name = 'long_timeout'
-        w.stop_signal = 'USR1'
-        w.stop_timeout = ::God::STOP_TIMEOUT_DEFAULT + 1
-        w.start = File.join(GOD_ROOT, *%w[test configs usr1_trapper.rb])
-      end
-      God.watches['long_timeout'].action(:start)
-      sleep 2
-      assert_equal true, God.watches['long_timeout'].alive?
-      God.stop_all
-      assert_watch_running('long_timeout')
-    end
-  end
-
-  # use short timeout to send SIGKILL before 10s timeout
-  def test_stop_all_with_non_killing_signal_short_timeout
-    with_god_cleanup do
-      God.start
-      God.watch do |w|
-        w.name = 'short_timeout'
-        w.stop_signal = 'USR1'
-        w.stop_timeout = ::God::STOP_TIMEOUT_DEFAULT - 1
-        w.start = File.join(GOD_ROOT, *%w[test configs usr1_trapper.rb])
-      end
-      God.watches['short_timeout'].action(:start)
-      sleep 2
-      assert_equal true, God.watches['short_timeout'].alive?
-      God.stop_all
-      assert_equal false, God.watches.any? { |name, w| w.alive? }
-    end
-  end
-
-  # should be able to stop many simple watches within default timeout
-  def test_stop_all_with_many_watches
-    with_god_cleanup do
-      God.start
-      20.times do |i|
-        God.watch do |w|
-          w.name = "many_watches_#{i}"
-          w.start = File.join(GOD_ROOT, *%w[test configs complex simple_server.rb])
-        end
-        God.watches["many_watches_#{i}"].action(:start)
-      end
-      while true do
-        all_running = God.watches.select{ |name, w| name =~ /many_watches_/ }.all?{ |name, w| w.alive? }
-        size = God.watches.size
-        break if all_running && size >= 20
-        sleep 2
-      end
-      God.stop_all
-      assert_equal false, God.watches.any? { |name, w| w.alive? }
-    end
-  end
-
-  # should be able to stop many simple watches within short timeout
-  def test_stop_all_with_many_watches_short_timeout
-    with_god_cleanup do
-      God.start
-      God.terminate_timeout = 1
-      100.times do |i|
-        God.watch do |w|
-          w.name = "tons_of_watches_#{i}"
-          w.start = File.join(GOD_ROOT, *%w[test configs complex simple_server.rb])
-          w.keepalive
-        end
-        God.watches["tons_of_watches_#{i}"].action(:start)
-      end
-      while true do
-        all_running = God.watches.select{ |name, w| name =~ /tons_of_watches_/ }.all?{ |name, w| w.alive? }
-        size = God.watches.size
-        break if all_running && size >= 100
-        sleep 2
-      end
-      God.stop_all
-      assert_equal false, God.watches.any? { |name, w| w.alive? }
-    end
-  end
-
-  def test_god_terminate_with_many_watches_short_timeout
-    with_god_cleanup do
-      God.start
-      God.terminate_timeout = 1
-      100.times do |i|
-        God.watch do |w|
-          w.name = "tons_of_watches_#{i}"
-          w.start = File.join(GOD_ROOT, *%w[test configs complex simple_server.rb])
-          w.keepalive
-        end
-        God.watches["tons_of_watches_#{i}"].action(:start)
-      end
-      while true do
-        all_running = God.watches.select{ |name, w| name =~ /tons_of_watches_/ }.all?{ |name, w| w.alive? }
-        size = God.watches.size
-        break if all_running && size >= 100
-        sleep 2
-      end
-      begin
-        God::CLI::Command.new('terminate', {port: 17165}, [])
-      rescue SystemExit
-      ensure
-        assert_equal false, God.watches.any? { |name, w| w.alive? }
-      end
-    end
-  end
-end

data/test/test_handlers_kqueue_handler.rb

@@ -1,16 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-if God::EventHandler.event_system == "kqueue"
-
-  class TestHandlersKqueueHandler < Minitest::Test
-    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_hipchat.rb

@@ -1,23 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestHipchat < Minitest::Test
-  def setup
-    @hipchat = God::Contacts::Hipchat.new
-  end
-
-  def test_exists
-    God::Contacts::Hipchat
-  end
-
-  def test_notify
-    @hipchat.token = 'ee64d6e2337310af'
-    @hipchat.ssl = 'true'
-    @hipchat.room = 'testroom'
-    @hipchat.from = 'test'
-
-    time = Time.now
-    body = "[#{time.strftime('%H:%M:%S')}] host - msg"
-    Marshmallow::Connection.any_instance.expects(:speak).with('testroom', body)
-    @hipchat.notify('msg', time, 'prio', 'cat', 'host')
-  end
-end

data/test/test_jabber.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
-
-class TestJabber < Minitest::Test
-
-  def setup
-    @jabber = God::Contacts::Jabber.new
-  end
-
-  def test_notify
-    @jabber.host = 'talk.google.com'
-    @jabber.from_jid = 'god@jabber.org'
-    @jabber.password = 'secret'
-    @jabber.to_jid = 'dev@jabber.org'
-
-    time = Time.now
-    body = God::Contacts::Jabber.format.call('msg', time, 'prio', 'cat', 'host')
-
-    assert_equal "Message: msg\nHost: host\nPriority: prio\nCategory: cat\n", body
-
-    Jabber::Client.any_instance.expects(:connect).with('talk.google.com', 5222)
-    Jabber::Client.any_instance.expects(:auth).with('secret')
-    Jabber::Client.any_instance.expects(:send)
-    Jabber::Client.any_instance.expects(:close)
-
-    @jabber.notify('msg', Time.now, 'prio', 'cat', 'host')
-    assert_equal "sent jabber message to dev@jabber.org", @jabber.info
-  end
-end

data/test/test_logger.rb

@@ -1,55 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestLogger < Minitest::Test
-  def setup
-    @log = God::Logger.new(StringIO.new('/dev/null'))
-  end
-
-  # log
-
-  def test_log_should_keep_logs_when_wanted
-    @log.watch_log_since('foo', Time.now)
-    @log.expects(:info).with("qux")
-
-    @log.log(stub(:name => 'foo'), :info, "qux")
-
-    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
-    SysLogger.expects(:log).with(:fatal, 'foo')
-    @log.log(stub(:name => 'foo'), :fatal, "foo")
-  end
-
-  # watch_log_since
-
-  def test_watch_log_since
-    t1 = Time.now
-
-    @log.watch_log_since('foo', t1)
-
-    @log.log(stub(:name => 'foo'), :info, "one")
-    @log.log(stub(:name => 'foo'), :info, "two")
-
-    assert_match(/one.*two/m, @log.watch_log_since('foo', t1))
-
-    t2 = Time.now
-
-    @log.log(stub(:name => 'foo'), :info, "three")
-
-    out = @log.watch_log_since('foo', t2)
-
-    assert(/one/ !~ out)
-    assert(/two/ !~ out)
-    assert_match(/three/, out)
-  end
-
-  # regular methods
-
-  def test_fatal
-    @log.fatal('foo')
-    assert_equal 0, @log.logs.size
-  end
-end

data/test/test_metric.rb

@@ -1,74 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestMetric < Minitest::Test
-  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
-
-  # This doesn't currently work:
-  #
-  # 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

@@ -1,263 +0,0 @@
-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 < Minitest::Test
-  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'
-
-    ::Process.stubs(:groups=)
-    ::Process.stubs(:initgroups)
-
-    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'
-
-    assert !@p.valid?
-  end
-
-  def test_valid_should_return_true_if_gid_exists
-    @p.start = 'qux'
-    @p.log = '/tmp/foo.log'
-    @p.gid = Etc.getgrgid(::Process.gid).name
-
-    ::Process.stubs(:groups=)
-
-    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'
-
-    assert !@p.valid?
-  end
-
-  def test_valid_should_return_true_if_dir_exists
-    @p.start = 'qux'
-    @p.log = '/tmp/foo.log'
-    @p.dir = '/tmp'
-
-    assert @p.valid?
-  end
-
-  def test_valid_should_return_false_if_dir_does_not_exists
-    @p.start = 'qux'
-    @p.log = '/tmp/foo.log'
-    @p.dir = '/tmp/doesnotexist'
-
-    assert !@p.valid?
-  end
-
-  def test_valid_should_return_false_if_dir_is_not_a_dir
-    @p.start = 'qux'
-    @p.log = '/tmp/foo.log'
-    @p.dir = '/etc/passwd'
-
-    assert !@p.valid?
-  end
-
-  def test_valid_should_return_false_with_bogus_chroot
-    @p.chroot = '/bogusroot'
-
-    assert !@p.valid?
-  end
-
-  def test_valid_should_return_true_with_chroot_and_valid_log
-    @p.start = 'qux'
-    @p.chroot = Dir.pwd
-    @p.log = "#{@p.chroot}/foo.log"
-
-    File.expects(:exist?).with(@p.chroot).returns(true)
-    File.expects(:exist?).with(@p.log).returns(true)
-    File.expects(:exist?).with("#{@p.chroot}/dev/null").returns(true)
-
-    File.stubs(:writable?).with('/foo.log').returns(true)
-
-    ::Dir.stubs(:chroot)
-
-    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 < Minitest::Test
-  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
-    God::System::Process.stubs(:fetch_system_poller).returns(God::System::PortablePoller)
-    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'
-    assert !@p.valid?
-  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
-
-  # umask
-  def test_umask_should_return_umask_specified
-    @p.umask = 002
-    assert_equal 002, @p.umask
-  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_raises 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_prowl.rb

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
-
-class TestProwl < Minitest::Test
-  def test_live_notify
-    prowl = God::Contacts::Prowl.new
-    prowl.name = "Prowly"
-    prowl.apikey = 'put_your_apikey_here'
-
-    Prowly.expects(:notify).returns(mock(:succeeded? => true))
-
-    prowl.notify("Test", Time.now, "Test", "Test", "")
-    assert_equal "sent prowl notification to #{prowl.name}", prowl.info
-  end
-end

data/test/test_registry.rb

@@ -1,15 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestRegistry < Minitest::Test
-  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_sensu.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestSensu < Minitest::Test
-  def test_sensu_notify
-    sensu = God::Contacts::Sensu.new
-    sensu.check_name = "TestSensuContact"
-
-    UDPSocket.any_instance.expects(:send)
-    sensu.notify("Test", Time.now, "Test", "Test", "")
-  end
-end