mcproc 2016.2.20

data/test/test_god_system.rb

@@ -0,0 +1,201 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,29 @@
+#!/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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,263 @@
+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