resurrected_god 0.14.0

data/test/test_conditions_socket_responding.rb

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestConditionsSocketResponding < Minitest::Test
+  # valid?
+
+  def test_valid_should_return_false_if_no_options_set
+    c = Conditions::SocketResponding.new
+    c.watch = stub(:name => 'foo')
+    assert_equal false, c.valid?
+
+  end
+
+  def test_valid_should_return_true_if_required_options_set_for_default
+    c = Conditions::SocketResponding.new
+    c.port = 443
+    assert_equal true, c.valid?
+  end
+
+  def test_valid_should_return_true_if_required_options_set_for_tcp
+    c = Conditions::SocketResponding.new
+    c.family = 'tcp'
+    c.port = 443
+    assert_equal true, c.valid?
+  end
+
+  def test_valid_should_return_true_if_required_options_set_for_unix
+    c = Conditions::SocketResponding.new
+    c.path = 'some-path'
+    c.family = 'unix'
+    assert_equal true, c.valid?
+  end
+
+  def test_valid_should_return_true_if_family_is_tcp
+    c = Conditions::SocketResponding.new
+    c.port = 443
+    c.family = 'tcp'
+    assert_equal true, c.valid?
+  end
+
+  def test_valid_should_return_true_if_family_is_unix
+    c = Conditions::SocketResponding.new
+    c.path = 'some-path'
+    c.family = 'unix'
+    c.watch = stub(:name => 'foo')
+    assert_equal true, c.valid?
+  end
+
+  # socket method
+  def test_socket_should_return_127_0_0_1_for_default_addr
+    c = Conditions::SocketResponding.new
+    c.socket = 'tcp:443'
+    assert_equal c.addr, '127.0.0.1'
+  end
+
+  def test_socket_should_set_properties_for_tcp
+    c = Conditions::SocketResponding.new
+    c.socket = 'tcp:127.0.0.1:443'
+    assert_equal c.family, 'tcp'
+    assert_equal c.addr, '127.0.0.1'
+    assert_equal c.port, 443
+    assert_equal c.responding, false
+    # path should not be set for tcp sockets
+    assert_equal c.path, nil
+  end
+
+  def test_socket_should_set_properties_for_unix
+    c = Conditions::SocketResponding.new
+    c.socket = 'unix:/tmp/process.sock'
+    assert_equal c.family, 'unix'
+    assert_equal c.path, '/tmp/process.sock'
+    assert_equal c.responding, false
+    # path should not be set for unix domain sockets
+    assert_equal c.port, 0
+  end
+
+  # test : responding = false
+
+  def test_test_tcp_should_return_false_if_socket_is_listening
+    c = Conditions::SocketResponding.new
+    c.prepare
+
+    TCPSocket.expects(:new).returns(0)
+    assert_equal false, c.test
+  end
+
+  def test_test_tcp_should_return_true_if_no_socket_is_listening
+    c = Conditions::SocketResponding.new
+    c.prepare
+
+    TCPSocket.expects(:new).returns(nil)
+    assert_equal true, c.test
+  end
+
+  def test_test_unix_should_return_false_if_socket_is_listening
+    c = Conditions::SocketResponding.new
+    c.socket = 'unix:/some/path'
+
+    c.prepare
+    UNIXSocket.expects(:new).returns(0)
+    assert_equal false, c.test
+  end
+
+  def test_test_unix_should_return_true_if_no_socket_is_listening
+
+    c = Conditions::SocketResponding.new
+    c.socket = 'unix:/some/path'
+    c.prepare
+
+    UNIXSocket.expects(:new).returns(nil)
+    assert_equal true, c.test
+  end
+
+  def test_test_unix_should_return_true_if_socket_is_listening_2_times
+
+    c = Conditions::SocketResponding.new
+    c.socket = 'unix:/some/path'
+    c.times = [2, 2]
+    c.prepare
+
+    UNIXSocket.expects(:new).returns(nil).times(2)
+    assert_equal false, c.test
+    assert_equal true, c.test
+  end
+
+  # test : responding = true
+
+  def test_test_tcp_should_return_true_if_socket_is_listening_with_responding_true
+    c = Conditions::SocketResponding.new
+    c.responding = true
+    c.prepare
+
+    TCPSocket.expects(:new).returns(0)
+    assert_equal true, c.test
+  end
+
+  def test_test_tcp_should_return_false_if_no_socket_is_listening_with_responding_true
+    c = Conditions::SocketResponding.new
+    c.responding = true
+    c.prepare
+
+    TCPSocket.expects(:new).returns(nil)
+    assert_equal false, c.test
+  end
+
+  def test_test_unix_should_return_true_if_socket_is_listening_with_responding_true
+    c = Conditions::SocketResponding.new
+    c.responding = true
+    c.socket = 'unix:/some/path'
+
+    c.prepare
+    UNIXSocket.expects(:new).returns(0)
+    assert_equal true, c.test
+  end
+
+  def test_test_unix_should_return_false_if_no_socket_is_listening_with_responding_true
+    c = Conditions::SocketResponding.new
+    c.socket = 'unix:/some/path'
+    c.responding = true
+    c.prepare
+
+    UNIXSocket.expects(:new).returns(nil)
+    assert_equal false, c.test
+  end
+
+  def test_test_unix_should_return_false_if_socket_is_listening_2_times_with_responding_true
+    c = Conditions::SocketResponding.new
+    c.socket = 'unix:/some/path'
+    c.responding = true
+    c.times = [2, 2]
+    c.prepare
+
+    UNIXSocket.expects(:new).returns(nil).times(2)
+    assert_equal false, c.test
+    assert_equal false, c.test
+  end
+end

data/test/test_conditions_tries.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestConditionsTries < Minitest::Test
+  # valid?
+
+  def test_valid_should_return_false_if_times_not_set
+    c = Conditions::Tries.new
+    c.watch = stub(:name => 'foo')
+    assert !c.valid?
+  end
+end
+
+
+class TestConditionsTries < Minitest::Test
+  def setup
+    @c = Conditions::Tries.new
+    @c.times = 3
+    @c.prepare
+  end
+
+  # prepare
+
+  def test_prepare_should_create_timeline
+    assert_equal 3, @c.instance_variable_get(:@timeline).instance_variable_get(:@max_size)
+  end
+
+  # test
+
+  def test_test_should_return_true_if_called_three_times_within_one_second
+    assert !@c.test
+    assert !@c.test
+    assert @c.test
+  end
+
+  # reset
+
+  def test_test_should_return_false_on_fourth_call_if_called_three_times_within_one_second
+    3.times { @c.test }
+    @c.reset
+    assert !@c.test
+  end
+end
+
+
+class TestConditionsTriesWithin < Minitest::Test
+  def setup
+    @c = Conditions::Tries.new
+    @c.times = 3
+    @c.within = 1.seconds
+    @c.prepare
+  end
+
+  # test
+
+  def test_test_should_return_true_if_called_three_times_within_one_second
+    assert !@c.test
+    assert !@c.test
+    assert @c.test
+  end
+
+  def test_test_should_return_false_if_called_three_times_within_two_seconds
+    assert !@c.test
+    assert !@c.test
+    assert sleep(1.1)
+    assert !@c.test
+  end
+end

data/test/test_contact.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestContact < Minitest::Test
+  def test_exists
+    God::Contact
+  end
+
+  # generate
+
+  def test_generate_should_raise_on_invalid_kind
+    assert_raises(NoSuchContactError) do
+      Contact.generate(:invalid)
+    end
+  end
+
+  def test_generate_should_abort_on_invalid_contact
+    assert_abort do
+      Contact.generate(:invalid_contact)
+    end
+  end
+
+  # normalize
+
+  def test_normalize_should_accept_a_string
+    input = 'tom'
+    output = {:contacts => ['tom']}
+    assert_equal(output, Contact.normalize(input))
+  end
+
+  def test_normalize_should_accept_an_array_of_strings
+    input = ['tom', 'kevin']
+    output = {:contacts => ['tom', 'kevin']}
+    assert_equal(output, Contact.normalize(input))
+  end
+
+  def test_normalize_should_accept_a_hash_with_contacts_string
+    input = {:contacts => 'tom'}
+    output = {:contacts => ['tom']}
+    assert_equal(output, Contact.normalize(input))
+  end
+
+  def test_normalize_should_accept_a_hash_with_contacts_array_of_strings
+    input = {:contacts => ['tom', 'kevin']}
+    output = {:contacts => ['tom', 'kevin']}
+    assert_equal(output, Contact.normalize(input))
+  end
+
+  def test_normalize_should_stringify_priority
+    input = {:contacts => 'tom', :priority => 1}
+    output = {:contacts => ['tom'], :priority => '1'}
+    assert_equal(output, Contact.normalize(input))
+  end
+
+  def test_normalize_should_stringify_category
+    input = {:contacts => 'tom', :category => :product}
+    output = {:contacts => ['tom'], :category => 'product'}
+    assert_equal(output, Contact.normalize(input))
+  end
+
+  def test_normalize_should_raise_on_non_string_array_hash
+    input = 1
+    assert_raises ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+
+  def test_normalize_should_raise_on_non_string_array_contacts_key
+    input = {:contacts => 1}
+    assert_raises ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+
+  def test_normalize_should_raise_on_non_string_containing_array
+    input = [1]
+    assert_raises ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+
+  def test_normalize_should_raise_on_non_string_containing_array_contacts_key
+    input = {:contacts => [1]}
+    assert_raises ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+
+  def test_normalize_should_raise_on_absent_contacts_key
+    input = {}
+    assert_raises ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+
+  def test_normalize_should_raise_on_extra_keys
+    input = {:contacts => ['tom'], :priority => 1, :category => 'product', :extra => 'foo'}
+    assert_raises ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+
+  # notify
+
+  def test_notify_should_be_abstract
+    assert_raises(AbstractMethodNotOverriddenError) do
+      Contact.new.notify(:a, :b, :c, :d, :e)
+    end
+  end
+end

data/test/test_driver.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestDriver < Minitest::Test
+  def setup
+
+  end
+
+  def test_push_pop_wait
+
+    eq = God::DriverEventQueue.new
+    cond = eq.instance_variable_get(:@resource)
+    cond.expects(:wait).times(1)
+
+    eq.push(God::TimedEvent.new(0))
+    eq.push(God::TimedEvent.new(0.1))
+    t = Thread.new do
+      # This pop will see an event immediately available, so no wait.
+      assert_equal TimedEvent, eq.pop.class
+
+      # This pop will happen before the next event is due, so wait.
+      assert_equal TimedEvent, eq.pop.class
+    end
+
+    t.join
+  end
+end

data/test/test_email.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestEmail < Minitest::Test
+  def setup
+    God::Contacts::Email.to_email = 'dev@example.com'
+    God::Contacts::Email.from_email = 'god@example.com'
+    @email = God::Contacts::Email.new
+  end
+
+  def test_validity_delivery
+    @email.delivery_method = :brainwaves
+    assert_equal false, @email.valid?
+  end
+
+  def test_smtp_delivery_method_for_notify
+    @email.delivery_method = :smtp
+
+    God::Contacts::Email.any_instance.expects(:notify_sendmail).never
+    God::Contacts::Email.any_instance.expects(:notify_smtp).once.returns(nil)
+
+    @email.notify('msg', Time.now, 'prio', 'cat', 'host')
+    assert_equal "sent email to dev@example.com via smtp", @email.info
+  end
+
+  def test_sendmail_delivery_method_for_notify
+    @email.delivery_method = :sendmail
+
+    God::Contacts::Email.any_instance.expects(:notify_smtp).never
+    God::Contacts::Email.any_instance.expects(:notify_sendmail).once.returns(nil)
+
+    @email.notify('msg', Time.now, 'prio', 'cat', 'host')
+    assert_equal "sent email to dev@example.com via sendmail", @email.info
+  end
+end

data/test/test_event_handler.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/helper'
+
+module God
+  class EventHandler
+
+    def self.actions=(value)
+      @@actions = value
+    end
+
+    def self.actions
+      @@actions
+    end
+
+    def self.handler=(value)
+      @@handler = value
+    end
+  end
+end
+
+class TestEventHandler < Minitest::Test
+  def setup
+    @h = God::EventHandler
+  end
+
+  def test_register_one_event
+    pid = 4445
+    event = :proc_exit
+    block = lambda {
+      puts "Hi"
+    }
+
+    mock_handler = mock()
+    mock_handler.expects(:register_process).with(pid, [event])
+    @h.handler = mock_handler
+
+    @h.register(pid, event, &block)
+    assert_equal @h.actions, {pid => {event => block}}
+  end
+
+  def test_register_multiple_events_per_process
+    pid = 4445
+    exit_block = lambda { puts "Hi" }
+    @h.actions = {pid => {:proc_exit => exit_block}}
+
+    mock_handler = mock()
+    mock_handler.expects(:register_process).with do |a, b|
+      a == pid &&
+      b.to_set == [:proc_exit, :proc_fork].to_set
+    end
+    @h.handler = mock_handler
+
+    fork_block = lambda { puts "Forking" }
+    @h.register(pid, :proc_fork, &fork_block)
+    assert_equal @h.actions, {pid => {:proc_exit => exit_block,
+                                     :proc_fork => fork_block }}
+  end
+
+  # JIRA PLATFORM-75
+  def test_call_should_check_for_pid_and_action_before_executing
+    exit_block = mock()
+    exit_block.expects(:call).times 1
+    @h.actions = {4445 => {:proc_exit => exit_block}}
+    @h.call(4446, :proc_exit) # shouldn't call, bad pid
+    @h.call(4445, :proc_fork) # shouldn't call, bad event
+    @h.call(4445, :proc_exit) # should call
+  end
+
+  def teardown
+    # Reset handler
+    @h.actions = {}
+    @h.load
+  end
+end
+
+# This doesn't currently work:
+#
+# class TestEventHandlerOperational < Minitest::Test
+#   def test_operational
+#     God::EventHandler.start
+#     assert God::EventHandler.loaded?
+#   end
+# end