god 0.4.3 → 0.5.0

data/test/helper.rb

@@ -42,23 +42,30 @@ module God
     end
   
     class FakeEventCondition < EventCondition
-      def test
-        true
+      def register
+      end
+      def deregister
       end
     end
   end
   
   module Behaviors
     class FakeBehavior < Behavior
+      def before_start
+        'foo'
+      end
+      def after_start
+        'bar'
+      end
     end
   end
   
-  class << self
-    alias :at_exit_orig :at_exit
-  end
-  
-  def self.at_exit
-    # disable at_exit
+  module Contacts
+    class FakeContact < Contact
+    end
+    
+    class InvalidContact
+    end
   end
   
   def self.reset
@@ -98,14 +105,15 @@ module Kernel
   def abort(text)
     raise SystemExit
   end
+  def exit(code)
+    raise SystemExit
+  end
 end
 
 module Test::Unit::Assertions
   def assert_abort
     assert_raise SystemExit do
-      no_stderr do
-        yield
-      end
+      yield
     end
   end
 end

data/test/test_conditions_http_response_code.rb

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestHttpResponseCode < Test::Unit::TestCase
+  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
+    no_stdout { assert !c.valid? }
+  end
+  
+  def test_valid_should_return_false_if_no_host_set
+    c = valid_condition do |cc|
+      cc.host = nil
+    end
+    no_stdout { assert !c.valid? }
+  end
+  
+  def test_valid_should_return_false_if_no_port_set
+    c = valid_condition do |cc|
+      cc.port = nil
+    end
+    no_stdout { assert !c.valid? }
+  end
+  
+  def test_valid_should_return_false_if_no_path_set
+    c = valid_condition do |cc|
+      cc.path = nil
+    end
+    no_stdout { assert !c.valid? }
+  end
+  
+  def test_valid_should_return_false_if_no_timeout_set
+    c = valid_condition do |cc|
+      cc.timeout = nil
+    end
+    no_stdout { 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.expects(:start).yields(stub(:read_timeout= => nil, :head => stub(: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.expects(:start).yields(stub(:read_timeout= => nil, :head => stub(: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.expects(:start).yields(stub(:read_timeout= => nil, :head => stub(: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.expects(:start).yields(stub(:read_timeout= => nil, :head => stub(: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.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.expects(:start).raises(Timeout::Error, '')
+    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.expects(:start).yields(stub(:read_timeout= => nil, :head => stub(:code => 200))).times(2)
+    assert_equal false, c.test
+    assert_equal true, c.test
+  end
+end

data/test/test_conditions_process_running.rb

@@ -6,9 +6,9 @@ class TestConditionsProcessRunning < Test::Unit::TestCase
       c = Conditions::ProcessRunning.new
       c.running = r
     
-      c.stubs(:watch).returns(stub(:pid_file => ''))
+      c.stubs(:watch).returns(stub(:pid_file => '', :name => 'foo'))
     
-      assert_equal !r, c.test
+      no_stdout { assert_equal !r, c.test }
     end
   end
   

data/test/test_conditions_tries.rb

@@ -1,5 +1,16 @@
 require File.dirname(__FILE__) + '/helper'
 
+class TestConditionsTries < Test::Unit::TestCase
+  # valid?
+  
+  def test_valid_should_return_false_if_times_not_set
+    c = Conditions::Tries.new
+    c.watch = stub(:name => 'foo')
+    no_stdout { assert !c.valid? }
+  end
+end
+
+
 class TestConditionsTries < Test::Unit::TestCase
   def setup
     @c = Conditions::Tries.new
@@ -7,22 +18,30 @@ class TestConditionsTries < Test::Unit::TestCase
     @c.prepare
   end
   
+  # prepare
+  
   def test_prepare_should_create_timeline
     assert 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 < Test::Unit::TestCase
   def setup
     @c = Conditions::Tries.new
@@ -31,6 +50,8 @@ class TestConditionsTriesWithin < Test::Unit::TestCase
     @c.prepare
   end
   
+  # test
+  
   def test_test_should_return_true_if_called_three_times_within_one_second
     assert !@c.test
     assert !@c.test

data/test/test_contact.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestContact < Test::Unit::TestCase
+  def test_exists
+    God::Contact
+  end
+  
+  # generate
+  
+  def test_generate_should_raise_on_invalid_kind
+    assert_raise(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_raise ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+  
+  def test_normalize_should_raise_on_non_string_array_contacts_key
+    input = {:contacts => 1}
+    assert_raise ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+  
+  def test_normalize_should_raise_on_non_string_containing_array
+    input = [1]
+    assert_raise ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+  
+  def test_normalize_should_raise_on_non_string_containing_array_contacts_key
+    input = {:contacts => [1]}
+    assert_raise ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+  
+  def test_normalize_should_raise_on_absent_contacts_key
+    input = {}
+    assert_raise 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_raise ArgumentError do
+      Contact.normalize(input)
+    end
+  end
+  
+  # notify
+  
+  def test_notify_should_be_abstract
+    assert_raise(AbstractMethodNotOverriddenError) do
+      Contact.new.notify(:a, :b, :c, :d, :e)
+    end
+  end
+end

data/test/test_god.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/helper'
 
 class TestGod < Test::Unit::TestCase
   def setup
-    Server.stubs(:new).returns(true)
+    God::Socket.stubs(:new).returns(true)
     God.stubs(:setup).returns(true)
     God.stubs(:validater).returns(true)
     God.reset
@@ -12,31 +12,33 @@ class TestGod < Test::Unit::TestCase
     Timer.get.timer.kill
   end
   
-  # init
+  # internal_init
   
   def test_init_should_initialize_watches_to_empty_array
-    God.init { }
+    God.internal_init { }
     assert_equal Hash.new, God.watches
   end
   
-  def test_init_should_abort_if_called_after_watch
+  # init
+  
+  def test_pid_file_directory_should_abort_if_called_after_watch
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
     
     assert_abort do
-      God.init { }
+      God.pid_file_directory = 'foo'
     end
   end
   
   # pid_file_directory
   
   def test_pid_file_directory_should_return_default_if_not_set_explicitly
-    God.init
+    God.internal_init
     assert_equal '/var/run/god', God.pid_file_directory
   end
   
   def test_pid_file_directory_equals_should_set
-    God.init
     God.pid_file_directory = '/foo'
+    God.internal_init
     assert_equal '/foo', God.pid_file_directory
   end
   
@@ -159,6 +161,7 @@ class TestGod < Test::Unit::TestCase
   def test_unwatch_should_unmonitor_watch
     God.watch { |w| w.name = 'bar'; w.start = 'bar' }
     w = God.watches['bar']
+    w.state = :up
     w.expects(:unmonitor)
     God.unwatch(w)
   end
@@ -194,6 +197,69 @@ class TestGod < Test::Unit::TestCase
     assert !God.groups[w.group].include?(w)
   end
   
+  # contact
+  
+  def test_contact_should_ensure_init_is_called
+    God.contact(:fake_contact) { |c| c.name = 'tom' }
+    assert God.inited
+  end
+  
+  def test_contact_should_abort_on_invalid_contact_kind
+    assert_abort do
+      God.contact(:foo) { |c| c.name = 'tom' }
+    end
+  end
+  
+  def test_contact_should_create_and_store_contact
+    contact = nil
+    God.contact(:fake_contact) { |c| c.name = 'tom'; contact = c }
+    assert [contact], God.contacts
+  end
+  
+  def test_contact_should_add_to_group
+    God.contact(:fake_contact) { |c| c.name = 'tom'; c.group = 'devs' }
+    God.contact(:fake_contact) { |c| c.name = 'chris'; c.group = 'devs' }
+    assert 2, God.contact_groups.size
+  end
+  
+  def test_contact_should_abort_on_no_name
+    no_stdout do
+      assert_abort do
+        God.contact(:fake_contact) { |c| }
+      end
+    end
+  end
+  
+  def test_contact_should_abort_on_duplicate_contact_name
+    God.contact(:fake_contact) { |c| c.name = 'tom' }
+    assert_abort do
+      God.contact(:fake_contact) { |c| c.name = 'tom' }
+    end
+  end
+  
+  def test_contact_should_abort_on_contact_with_same_name_as_group
+    God.contact(:fake_contact) { |c| c.name = 'tom'; c.group = 'devs' }
+    assert_abort do
+      God.contact(:fake_contact) { |c| c.name = 'devs' }
+    end
+  end
+  
+  def test_contact_should_abort_on_contact_with_same_group_as_name
+    God.contact(:fake_contact) { |c| c.name = 'tom' }
+    assert_abort do
+      God.contact(:fake_contact) { |c| c.name = 'chris'; c.group = 'tom' }
+    end
+  end
+  
+  def test_contact_should_abort_if_contact_is_invalid
+    assert_abort do
+      God.contact(:fake_contact) do |c|
+        c.name = 'tom'
+        c.stubs(:valid?).returns(false)
+      end
+    end
+  end
+  
   # control
   
   def test_control_should_monitor_on_start
@@ -216,6 +282,7 @@ class TestGod < Test::Unit::TestCase
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
     
     w = God.watches['foo']
+    w.state = :up
     w.expects(:unmonitor).returns(w)
     w.expects(:action).with(:stop)
     God.control('foo', 'stop')
@@ -225,6 +292,7 @@ class TestGod < Test::Unit::TestCase
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
     
     w = God.watches['foo']
+    w.state = :up
     w.expects(:unmonitor).returns(w)
     God.control('foo', 'unmonitor')
   end
@@ -261,7 +329,7 @@ class TestGod < Test::Unit::TestCase
   # terminate
   
   def test_terminate_should_exit
-    God.expects(:exit!).with(0)
+    God.expects(:exit!)
     God.terminate
   end
   
@@ -282,6 +350,22 @@ class TestGod < Test::Unit::TestCase
     assert_equal({'foo' => {:state => :unmonitored}}, God.status)
   end
   
+  # running_log
+  
+  def test_running_log_should_call_watch_log_since_on_main_log
+    God.watch { |w| w.name = 'foo'; w.start = 'bar' }
+    t = Time.now
+    LOG.expects(:watch_log_since).with('foo', t)
+    God.running_log('foo', t)
+  end
+  
+  def test_running_log_should_raise_on_unknown_watch
+    God.internal_init
+    assert_raise(NoSuchWatchError) do
+      God.running_log('foo', Time.now)
+    end
+  end
+  
   # running_load
   
   def test_running_load_should_eval_code
@@ -293,7 +377,7 @@ class TestGod < Test::Unit::TestCase
     EOF
     
     no_stdout do
-      God.running_load(code)
+      God.running_load(code, '/foo/bar.god')
     end
     
     assert_equal 1, God.watches.size
@@ -309,7 +393,7 @@ class TestGod < Test::Unit::TestCase
     
     Watch.any_instance.expects(:monitor)
     no_stdout do
-      God.running_load(code)
+      God.running_load(code, '/foo/bar.god')
     end
   end
   
@@ -324,7 +408,7 @@ class TestGod < Test::Unit::TestCase
     
     Watch.any_instance.expects(:monitor).never
     no_stdout do
-      God.running_load(code)
+      God.running_load(code, '/foo/bar.god')
     end
   end
   
@@ -338,10 +422,10 @@ class TestGod < Test::Unit::TestCase
     
     w = nil
     no_stdout do
-      w = God.running_load(code)
+      w, e = *God.running_load(code, '/foo/bar.god')
     end
     assert_equal 1, w.size
-    assert_equal 'foo', w.first.name
+    assert_equal 'foo', w.first
   end
   
   def test_running_load_should_clear_pending_watches
@@ -353,7 +437,7 @@ class TestGod < Test::Unit::TestCase
     EOF
     
     no_stdout do
-      God.running_load(code)
+      God.running_load(code, '/foo/bar.god')
     end
     assert_equal 0, God.pending_watches.size
   end
@@ -370,7 +454,7 @@ class TestGod < Test::Unit::TestCase
   # start
   
   def test_start_should_kick_off_a_server_instance
-    Server.expects(:new).returns(true)
+    God::Socket.expects(:new).returns(true)
     God.start
   end
     
@@ -418,14 +502,14 @@ class TestGod < Test::Unit::TestCase
   
   def test_at_exit_should_call_start
     God.expects(:start).once
-    God.at_exit_orig
+    God.at_exit
   end
 end
 
 
 class TestGodOther < Test::Unit::TestCase
   def setup
-    Server.stubs(:new).returns(true)
+    God::Socket.stubs(:new).returns(true)
     God.internal_init
     God.reset
   end

data/test/test_hub.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/helper'
 
 class TestHub < Test::Unit::TestCase
   def setup
-    Server.stubs(:new).returns(true)
+    God::Socket.stubs(:new).returns(true)
     God.reset
     
     God.watch do |w|
@@ -157,6 +157,40 @@ class TestHub < Test::Unit::TestCase
     end
   end
   
+  def test_handle_poll_should_notify_if_triggering
+    c = Conditions::FakePollCondition.new
+    c.interval = 10
+    c.notify = 'tom'
+    
+    m = Metric.new(@watch, {true => :up})
+    Hub.attach(c, m)
+    
+    c.expects(:test).returns(true)
+    Hub.expects(:notify)
+    
+    no_stdout do
+      t = Hub.handle_poll(c)
+      t.join
+    end
+  end
+  
+  def test_handle_poll_should_not_notify_if_not_triggering
+    c = Conditions::FakePollCondition.new
+    c.interval = 10
+    c.notify = 'tom'
+    
+    m = Metric.new(@watch, {true => :up})
+    Hub.attach(c, m)
+    
+    c.expects(:test).returns(false)
+    Hub.expects(:notify).never
+    
+    no_stdout do
+      t = Hub.handle_poll(c)
+      t.join
+    end
+  end
+  
   # handle_event
   
   def test_handle_event_should_move
@@ -172,4 +206,33 @@ class TestHub < Test::Unit::TestCase
       t.join
     end
   end
+  
+  def test_handle_event_should_notify_if_triggering
+    c = Conditions::FakeEventCondition.new
+    c.notify = 'tom'
+    
+    m = Metric.new(@watch, {true => :up})
+    Hub.attach(c, m)
+    
+    Hub.expects(:notify)
+    
+    no_stdout do
+      t = Hub.handle_event(c)
+      t.join
+    end
+  end
+  
+  def test_handle_event_should_not_notify_if_no_notify_set
+    c = Conditions::FakeEventCondition.new
+    
+    m = Metric.new(@watch, {true => :up})
+    Hub.attach(c, m)
+    
+    Hub.expects(:notify).never
+    
+    no_stdout do
+      t = Hub.handle_event(c)
+      t.join
+    end
+  end
 end