resurrected_god 0.14.0 → 1.0.0

data/test/test_conditions_http_response_code.rb

@@ -1,109 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestHttpResponseCode < Minitest::Test
-  def valid_condition
-    c = Conditions::HttpResponseCode.new()
-    c.watch = stub(:name => 'foo')
-    c.host = 'localhost'
-    c.port = 8080
-    c.path = '/'
-    c.timeout = 10
-    c.code_is = 200
-    c.times = 1
-    yield(c) if block_given?
-    c.prepare
-    c
-  end
-
-  # valid?
-
-  def test_valid_condition_is_valid
-    c = valid_condition
-    assert c.valid?
-  end
-
-  def test_valid_should_return_false_if_both_code_is_and_code_is_not_are_set
-    c = valid_condition do |cc|
-      cc.code_is_not = 500
-    end
-    assert !c.valid?
-  end
-
-  def test_valid_should_return_false_if_no_host_set
-    c = valid_condition do |cc|
-      cc.host = nil
-    end
-    assert !c.valid?
-  end
-
-  # test
-
-  def test_test_should_return_false_if_code_is_is_set_to_200_but_response_is_500
-    c = valid_condition
-    Net::HTTP.any_instance.expects(:start).yields(mock(:read_timeout= => nil, :get => mock(:code => 500)))
-    assert_equal false, c.test
-  end
-
-  def test_test_should_return_false_if_code_is_not_is_set_to_200_and_response_is_200
-    c = valid_condition do |cc|
-      cc.code_is = nil
-      cc.code_is_not = [200]
-    end
-    Net::HTTP.any_instance.expects(:start).yields(mock(:read_timeout= => nil, :get => mock(:code => 200)))
-    assert_equal false, c.test
-  end
-
-  def test_test_should_return_true_if_code_is_is_set_to_200_and_response_is_200
-    c = valid_condition
-    Net::HTTP.any_instance.expects(:start).yields(mock(:read_timeout= => nil, :get => mock(:code => 200)))
-    assert_equal true, c.test
-  end
-
-  def test_test_should_return_false_if_code_is_not_is_set_to_200_but_response_is_500
-    c = valid_condition do |cc|
-      cc.code_is = nil
-      cc.code_is_not = [200]
-    end
-    Net::HTTP.any_instance.expects(:start).yields(mock(:read_timeout= => nil, :get => mock(:code => 500)))
-    assert_equal true, c.test
-  end
-
-  def test_test_should_return_false_if_code_is_is_set_to_200_but_response_times_out
-    c = valid_condition
-    Net::HTTP.any_instance.expects(:start).raises(Timeout::Error, '')
-    assert_equal false, c.test
-  end
-
-  def test_test_should_return_true_if_code_is_not_is_set_to_200_and_response_times_out
-    c = valid_condition do |cc|
-      cc.code_is = nil
-      cc.code_is_not = [200]
-    end
-    Net::HTTP.any_instance.expects(:start).raises(Timeout::Error, '')
-    assert_equal true, c.test
-  end
-
-  def test_test_should_return_false_if_code_is_is_set_to_200_but_cant_connect
-    c = valid_condition
-    Net::HTTP.any_instance.expects(:start).raises(Errno::ECONNREFUSED, '')
-    assert_equal false, c.test
-  end
-
-  def test_test_should_return_true_if_code_is_not_is_set_to_200_and_cant_connect
-    c = valid_condition do |cc|
-      cc.code_is = nil
-      cc.code_is_not = [200]
-    end
-    Net::HTTP.any_instance.expects(:start).raises(Errno::ECONNREFUSED, '')
-    assert_equal true, c.test
-  end
-
-  def test_test_should_return_true_if_code_is_is_set_to_200_and_response_is_200_twice_for_times_two_of_two
-    c = valid_condition do |cc|
-      cc.times = [2, 2]
-    end
-    Net::HTTP.any_instance.expects(:start).yields(stub(:read_timeout= => nil, :get => stub(:code => 200))).times(2)
-    assert_equal false, c.test
-    assert_equal true, c.test
-  end
-end

data/test/test_conditions_process_running.rb

@@ -1,40 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestConditionsProcessRunning < Minitest::Test
-  def test_missing_pid_file_returns_opposite
-    [true, false].each do |r|
-      c = Conditions::ProcessRunning.new
-      c.running = r
-      c.stubs(:watch).returns(stub(:pid => 99999999, :name => 'foo'))
-      assert_equal !r, c.test
-    end
-  end
-
-  def test_not_running_returns_opposite
-    [true, false].each do |r|
-      c = Conditions::ProcessRunning.new
-      c.running = r
-
-      File.stubs(:exist?).returns(true)
-      c.stubs(:watch).returns(stub(:pid => 123))
-      File.stubs(:read).returns('5')
-      System::Process.any_instance.stubs(:exists?).returns(false)
-
-      assert_equal !r, c.test
-    end
-  end
-
-  def test_running_returns_same
-    [true, false].each do |r|
-      c = Conditions::ProcessRunning.new
-      c.running = r
-
-      File.stubs(:exist?).returns(true)
-      c.stubs(:watch).returns(stub(:pid => 123))
-      File.stubs(:read).returns('5')
-      System::Process.any_instance.stubs(:exists?).returns(true)
-
-      assert_equal r, c.test
-    end
-  end
-end

data/test/test_conditions_socket_responding.rb

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

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

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

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

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

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