god 0.11.0 → 0.12.0

data/test/test_system_portable_poller.rb

@@ -5,7 +5,7 @@ class TestSystemPortablePoller < Test::Unit::TestCase
     pid = Process.pid
     @process = System::PortablePoller.new(pid)
   end
-  
+
   def test_time_string_to_seconds
     assert_equal 0, @process.bypass.time_string_to_seconds('0:00:00')
     assert_equal 0, @process.bypass.time_string_to_seconds('0:00:55')

data/test/test_system_process.rb

@@ -5,24 +5,24 @@ class TestSystemProcess < Test::Unit::TestCase
     pid = Process.pid
     @process = System::Process.new(pid)
   end
-  
+
   def test_exists_should_return_true_for_running_process
     assert_equal true, @process.exists?
   end
-  
+
   def test_exists_should_return_false_for_non_existant_process
     assert_equal false, System::Process.new(9999999).exists?
   end
-  
+
   def test_memory
     assert_kind_of Integer, @process.memory
     assert @process.memory > 0
   end
-  
+
   def test_percent_memory
     assert_kind_of Float, @process.percent_memory
   end
-  
+
   def test_percent_cpu
     assert_kind_of Float, @process.percent_cpu
   end

data/test/test_task.rb

@@ -10,69 +10,69 @@ class TestTask < Test::Unit::TestCase
     @task.interval = 5
     @task.prepare
   end
-  
+
   # valid?
-  
+
   def test_valid_should_return_false_if_no_name
     @task.name = nil
     assert !@task.valid?
   end
-  
+
   def test_valid_should_return_false_if_no_valid_states
     @task.valid_states = nil
     assert !@task.valid?
   end
-  
+
   def test_valid_should_return_false_if_no_initial_state
     @task.initial_state = nil
     assert !@task.valid?
   end
-  
+
   # transition
-  
+
   def test_transition_should_be_always_if_no_block_was_given
     @task.transition(:foo, :bar)
-    
-    assert 1, @task.metrics.size
-    assert Conditions::Always, @task.metrics.keys.first.class
+
+    assert_equal 5, @task.metrics.size
+    assert_equal Conditions::Always, @task.metrics[:foo].first.conditions.first.class
   end
-  
+
   # method_missing
-  
+
   def test_method_missing_should_create_accessor_for_states
     assert_nothing_raised do
       @task.foo = 'testing'
     end
   end
-  
+
   def test_method_missing_should_raise_for_non_states
     assert_raise NoMethodError do
       @task.baz = 5
     end
   end
-  
+
   def test_method_missing_should_raise_for_non_setters
     assert_raise NoMethodError do
       @task.baz
     end
   end
-  
+
   # action
-  
+
   def test_action_should_send_string_commands_to_system
     @task.foo = 'foo'
     @task.driver.stubs(:in_driver_context?).returns(true)
     @task.expects(:system).with('foo')
     @task.action(:foo, nil)
   end
-  
+
   def test_action_should_call_lambda_commands
     @task.foo = lambda { }
     @task.driver.stubs(:in_driver_context?).returns(true)
     @task.foo.expects(:call)
     @task.action(:foo, nil)
   end
-  
+
   def test_action_should_raise_not_implemented_on_non_string_or_lambda_action
     @task.driver.stubs(:in_driver_context?).returns(true)
     assert_raise NotImplementedError do
@@ -80,167 +80,167 @@ class TestTask < Test::Unit::TestCase
       @task.action(:foo, nil)
     end
   end
-  
+
   def test_action_from_outside_driver_should_send_message_to_driver
     @task.foo = 'foo'
     @task.driver.expects(:message).with(:action, [:foo, nil])
     @task.action(:foo, nil)
   end
-  
+
   # attach
-  
+
   def test_attach_should_schedule_for_poll_condition
     c = Conditions::FakePollCondition.new
     @task.driver.expects(:schedule).with(c, 0)
     @task.attach(c)
   end
-  
+
   def test_attach_should_regsiter_for_event_condition
     c = Conditions::FakeEventCondition.new
     c.expects(:register)
     @task.attach(c)
   end
-  
+
   # detach
-  
+
   def test_detach_should_reset_poll_condition
     c = Conditions::FakePollCondition.new
     c.expects(:reset)
     c.expects(:deregister).never
     @task.detach(c)
   end
-  
+
   def test_detach_should_deregister_event_conditions
     c = Conditions::FakeEventCondition.new
     c.expects(:deregister).once
     @task.detach(c)
   end
-  
+
   # trigger
-  
+
   def test_trigger_should_send_message_to_driver
     c = Conditions::FakePollCondition.new
     @task.driver.expects(:message).with(:handle_event, [c])
     @task.trigger(c)
   end
-  
+
   # handle_poll
-  
+
   def test_handle_poll_no_change_should_reschedule
     c = Conditions::FakePollCondition.new
     c.watch = @task
     c.interval = 10
-    
+
     m = Metric.new(@task, {true => :up})
     @task.directory[c] = m
-    
+
     c.expects(:test).returns(false)
     @task.driver.expects(:schedule)
     @task.handle_poll(c)
   end
-  
+
   def test_handle_poll_change_should_move
     c = Conditions::FakePollCondition.new
     c.watch = @task
     c.interval = 10
-    
+
     m = Metric.new(@task, {true => :up})
     @task.directory[c] = m
-    
+
     c.expects(:test).returns(true)
     @task.expects(:move).with(:up)
     @task.handle_poll(c)
   end
-  
+
   def test_handle_poll_should_use_overridden_transition
     c = Conditions::Tries.new
     c.watch = @task
     c.times = 1
     c.transition = :start
     c.prepare
-    
+
     m = Metric.new(@task, {true => :up})
     @task.directory[c] = m
-    
+
     @task.expects(:move).with(:start)
     @task.handle_poll(c)
   end
-  
+
   def test_handle_poll_should_notify_if_triggering
     c = Conditions::FakePollCondition.new
     c.watch = @task
     c.interval = 10
     c.notify = 'tom'
-    
+
     m = Metric.new(@task, {true => :up})
     @task.directory[c] = m
-    
+
     c.expects(:test).returns(true)
     @task.expects(:notify)
     @task.handle_poll(c)
   end
-  
+
   def test_handle_poll_should_not_notify_if_not_triggering
     c = Conditions::FakePollCondition.new
     c.watch = @task
     c.interval = 10
     c.notify = 'tom'
-    
+
     m = Metric.new(@task, {true => :up})
     @task.directory[c] = m
-    
+
     c.expects(:test).returns(false)
     @task.expects(:notify).never
     @task.handle_poll(c)
   end
-  
+
   def test_handle_poll_unexpected_exception_should_reschedule
     c = Conditions::FakePollCondition.new
     c.watch = @task
     c.interval = 10
-    
+
     m = Metric.new(@task, {true => :up})
     @task.directory[c] = m
-    
+
     c.expects(:test).raises(StandardError)
     @task.driver.expects(:schedule)
-    
+
     @task.handle_poll(c)
   end
-  
+
   # handle_event
-  
+
   def test_handle_event_should_move
     c = Conditions::FakeEventCondition.new
     c.watch = @task
-    
+
     m = Metric.new(@task, {true => :up})
     @task.directory[c] = m
-    
+
     @task.expects(:move).with(:up)
     @task.handle_event(c)
   end
-  
+
   def test_handle_event_should_notify_if_triggering
     c = Conditions::FakeEventCondition.new
     c.watch = @task
     c.notify = 'tom'
-    
+
     m = Metric.new(@task, {true => :up})
     @task.directory[c] = m
-    
+
     @task.expects(:notify)
     @task.handle_event(c)
   end
-  
+
   def test_handle_event_should_not_notify_if_no_notify_set
     c = Conditions::FakeEventCondition.new
     c.watch = @task
-    
+
     m = Metric.new(@task, {true => :up})
     @task.directory[c] = m
-    
+
     @task.expects(:notify).never
     @task.handle_event(c)
   end
-end
+end

data/test/test_timeline.rb

@@ -4,32 +4,32 @@ class TestTimeline < Test::Unit::TestCase
   def setup
     @timeline = Timeline.new(5)
   end
-  
+
   def test_new_should_be_empty
     assert_equal 0, @timeline.size
   end
-  
+
   def test_should_not_grow_to_more_than_size
     (1..10).each do |i|
       @timeline.push(i)
     end
-    
+
     assert_equal [6, 7, 8, 9, 10], @timeline
   end
-  
+
   def test_clear_should_clear_array
     @timeline << 1
     assert_equal [1], @timeline
     assert_equal [], @timeline.clear
   end
-  
+
   # def test_benchmark
   #   require 'benchmark'
-  # 
+  #
   #   count = 1_000_000
-  # 
+  #
   #   t = Timeline.new(10)
-  # 
+  #
   #   Benchmark.bmbm do |x|
   #     x.report("go") { count.times { t.push(5) } }
   #   end

data/test/test_trigger.rb

@@ -4,56 +4,56 @@ class TestTrigger < Test::Unit::TestCase
   def setup
     Trigger.reset
   end
-  
+
   # base case
-  
+
   def test_should_have_empty_triggers
     assert_equal({}, Trigger.triggers)
   end
-  
+
   # register
-  
+
   def test_register_should_add_condition_to_triggers
     c = Condition.new
     c.watch = stub(:name => 'foo')
     Trigger.register(c)
-    
+
     assert_equal({'foo' => [c]}, Trigger.triggers)
   end
-  
+
   def test_register_should_add_condition_to_triggers_twice
     watch = stub(:name => 'foo')
     c = Condition.new
     c.watch = watch
     Trigger.register(c)
-    
+
     c2 = Condition.new
     c2.watch = watch
     Trigger.register(c2)
-    
+
     assert_equal({'foo' => [c, c2]}, Trigger.triggers)
   end
-  
+
   # deregister
-  
+
   def test_deregister_should_remove_condition_from_triggers
     c = Condition.new
     c.watch = stub(:name => 'foo')
     Trigger.register(c)
     Trigger.deregister(c)
-    
+
     assert_equal({}, Trigger.triggers)
   end
-  
+
   # broadcast
-  
+
   def test_broadcast_should_call_process_on_each_condition
     c = Condition.new
     c.watch = stub(:name => 'foo')
     Trigger.register(c)
-    
+
     c.expects(:process).with(:state_change, [:up, :start])
-    
+
     Trigger.broadcast(c.watch, :state_change, [:up, :start])
   end
-end
+end

data/test/test_watch.rb

@@ -9,19 +9,19 @@ class TestWatch < Test::Unit::TestCase
     @watch.stop = lambda { }
     @watch.prepare
   end
-  
+
   # new
-  
+
   def test_new_should_have_no_behaviors
     assert_equal [], @watch.behaviors
   end
-  
+
   def test_new_should_have_no_metrics
     Watch::VALID_STATES.each do |state|
       assert_equal [], @watch.metrics[state]
     end
   end
-    
+
   def test_new_should_have_standard_attributes
     assert_nothing_raised do
       @watch.name = 'foo'
@@ -32,41 +32,41 @@ class TestWatch < Test::Unit::TestCase
       @watch.grace = 5
     end
   end
-  
+
   def test_new_should_have_unmonitored_state
     assert_equal :unmonitored, @watch.state
   end
-  
+
   # valid?
-  
+
   def test_valid?
     God::Process.any_instance.expects(:valid?)
     @watch.valid?
   end
-  
+
   # behavior
-  
+
   def test_behavior_should_record_behavior
     beh = nil
     @watch.behavior(:fake_behavior) { |b| beh = b }
     assert_equal 1, @watch.behaviors.size
     assert_equal beh, @watch.behaviors.first
   end
-  
+
   def test_invalid_behavior_should_abort
     assert_abort do
       @watch.behavior(:invalid)
     end
   end
-  
+
   # transition
-  
+
   def test_transition_should_abort_on_invalid_start_state
     assert_abort do
       @watch.transition(:foo, :bar)
     end
   end
-  
+
   def test_transition_should_accept_all_valid_start_states
     assert_nothing_raised do
       Watch::VALID_STATES.each do |state|
@@ -74,35 +74,42 @@ class TestWatch < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_transition_should_create_and_record_a_metric_for_the_given_start_state
     @watch.transition(:init, :start) { }
     assert_equal 1, @watch.metrics[:init].size
   end
-  
+
   # lifecycle
-  
+
   def test_lifecycle_should_create_and_record_a_metric_for_nil_start_state
     @watch.lifecycle { }
     assert_equal 1, @watch.metrics[nil].size
   end
-  
+
+  # keepalive
+
+  def test_keepalive_should_place_metrics_on_up_state
+    @watch.keepalive(:memory_max => 5.megabytes, :cpu_max => 50.percent)
+    assert_equal 2, @watch.metrics[:up].size
+  end
+
   # start_if
-  
+
   def test_start_if_should_place_a_metric_on_up_state
     @watch.start_if { }
     assert_equal 1, @watch.metrics[:up].size
   end
-  
+
   # restart_if
-  
+
   def test_restart_if_should_place_a_metric_on_up_state
     @watch.restart_if { }
     assert_equal 1, @watch.metrics[:up].size
   end
-  
+
   # monitor
-  
+
   def test_monitor_should_move_to_init_if_available
     @watch.instance_eval do
       transition(:init, :up) { }
@@ -110,27 +117,27 @@ class TestWatch < Test::Unit::TestCase
     @watch.expects(:move).with(:init)
     @watch.monitor
   end
-  
+
   def test_monitor_should_move_to_up_if_no_init_available
     @watch.expects(:move).with(:up)
     @watch.monitor
   end
-  
+
   # unmonitor
-  
+
   def test_unmonitor_should_move_to_nil
     @watch.expects(:move).with(:unmonitored)
     @watch.unmonitor
   end
-  
+
   # move
-  
+
   def test_move_should_not_clean_up_if_from_state_is_nil
     @watch.driver.stubs(:in_driver_context?).returns(true)
     @watch.driver.expects(:message).never
-    
+
     metric = nil
-    
+
     @watch.instance_eval do
       transition(:init, :up) do |on|
         metric = on
@@ -140,18 +147,18 @@ class TestWatch < Test::Unit::TestCase
         end
       end
     end
-    
+
     metric.expects(:disable).never
-    
+
     @watch.move(:init)
   end
-  
+
   def test_move_should_clean_up_from_state_if_not_nil
     @watch.driver.stubs(:in_driver_context?).returns(true)
     @watch.driver.expects(:message).never
-    
+
     metric = nil
-    
+
     @watch.instance_eval do
       transition(:init, :up) do |on|
         metric = on
@@ -161,40 +168,40 @@ class TestWatch < Test::Unit::TestCase
         end
       end
     end
-    
+
     @watch.move(:init)
-    
+
     metric.expects(:disable)
-    
+
     @watch.move(:up)
   end
-  
+
   def test_move_should_call_action
     @watch.driver.stubs(:in_driver_context?).returns(true)
     @watch.driver.expects(:message).never
-    
+
     @watch.expects(:action).with(:start)
-    
+
     @watch.move(:start)
   end
-  
+
   def test_move_should_move_to_up_state_if_no_start_or_restart_metric
     @watch.driver.stubs(:in_driver_context?).returns(true)
     @watch.driver.expects(:message).never
-    
+
     [:start, :restart].each do |state|
       @watch.expects(:action)
       @watch.move(state)
       assert_equal :up, @watch.state
     end
   end
-  
+
   def test_move_should_enable_destination_metric
     @watch.driver.stubs(:in_driver_context?).returns(true)
     @watch.driver.expects(:message).never
-    
+
     metric = nil
-    
+
     @watch.instance_eval do
       transition(:init, :up) do |on|
         metric = on
@@ -204,53 +211,53 @@ class TestWatch < Test::Unit::TestCase
         end
       end
     end
-    
+
     metric.expects(:enable)
-    
+
     @watch.move(:init)
   end
-  
+
   # action
-  
+
   def test_action_should_pass_start_and_stop_actions_to_call_action
     @watch.driver.stubs(:in_driver_context?).returns(true)
     @watch.driver.expects(:message).never
-    
+
     c = Conditions::FakePollCondition.new
     [:start, :stop].each do |cmd|
       @watch.expects(:call_action).with(c, cmd)
       @watch.action(cmd, c)
     end
   end
-  
+
   def test_action_should_do_stop_then_start_if_no_restart_command
     @watch.driver.stubs(:in_driver_context?).returns(true)
     @watch.driver.expects(:message).never
-    
+
     c = Conditions::FakePollCondition.new
     @watch.expects(:call_action).with(c, :stop)
     @watch.expects(:call_action).with(c, :start)
     @watch.action(:restart, c)
   end
-  
+
   def test_action_should_restart_to_call_action_if_present
     @watch.driver.stubs(:in_driver_context?).returns(true)
     @watch.driver.expects(:message).never
-    
+
     @watch.restart = lambda { }
     c = Conditions::FakePollCondition.new
     @watch.expects(:call_action).with(c, :restart)
     @watch.action(:restart, c)
   end
-  
+
   # call_action
-  
+
   def test_call_action
     c = Conditions::FakePollCondition.new
     God::Process.any_instance.expects(:call_action).with(:start)
     @watch.call_action(c, :start)
   end
-  
+
   def test_call_action_should_call_before_start_when_behavior_has_that
     @watch.behavior(:fake_behavior)
     c = Conditions::FakePollCondition.new
@@ -258,7 +265,7 @@ class TestWatch < Test::Unit::TestCase
     Behaviors::FakeBehavior.any_instance.expects(:before_start)
     @watch.call_action(c, :start)
   end
-  
+
   def test_call_action_should_call_after_start_when_behavior_has_that
     @watch.behavior(:fake_behavior)
     c = Conditions::FakePollCondition.new
@@ -266,14 +273,14 @@ class TestWatch < Test::Unit::TestCase
     Behaviors::FakeBehavior.any_instance.expects(:after_start)
     @watch.call_action(c, :start)
   end
-  
+
   # canonical_hash_form
-  
+
   def test_canonical_hash_form_should_convert_symbol_to_hash
     assert_equal({true => :foo}, @watch.canonical_hash_form(:foo))
   end
-  
+
   def test_canonical_hash_form_should_convert_hash_to_hash
     assert_equal({true => :foo}, @watch.canonical_hash_form(true => :foo))
   end
-end
+end