god 0.2.0 → 0.3.0

data/test/test_handlers_kqueue_handler.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestHandlersKqueueHandler < Test::Unit::TestCase
+  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

data/test/test_hub.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestHub < Test::Unit::TestCase
+  def setup
+    Server.stubs(:new).returns(true)
+    God.reset
+    
+    God.watch do |w|
+      w.name = 'foo'
+      w.interval = 10
+    end
+    
+    @watch = God.watches['foo']
+  end
+  
+  # attach
+  
+  def test_attach_should_store_condition_metric_association
+    c = Conditions::FakePollCondition.new
+    m = Metric.new(@watch, :foo)
+    Hub.attach(c, m)
+    
+    assert_equal m, Hub.directory[c]
+  end
+  
+  def test_attach_should_schedule_for_poll_condition
+    c = Conditions::FakePollCondition.new
+    m = Metric.new(@watch, :foo)
+    
+    Timer.any_instance.expects(:schedule).with(c, 0)
+    
+    Hub.attach(c, m)
+  end
+  
+  def test_attach_should_regsiter_for_event_condition
+    c = Conditions::FakeEventCondition.new
+    m = Metric.new(@watch, :foo)
+    
+    c.expects(:register)
+    
+    Hub.attach(c, m)
+  end
+  
+  # detach
+  
+  def test_detach_should_remove_condition_metric_association
+    c = Conditions::FakePollCondition.new
+    m = Metric.new(@watch, :foo)
+    
+    Hub.attach(c, m)
+    Hub.detach(c)
+    
+    assert_nil Hub.directory[c]
+  end
+  
+  def test_detach_should_unschedule_poll_conditions
+    c = Conditions::FakePollCondition.new
+    m = Metric.new(@watch, :foo)
+    Hub.attach(c, m)
+    
+    Timer.any_instance.expects(:unschedule).with(c)
+    c.expects(:deregister).never
+    
+    Hub.detach(c)
+  end
+  
+  def test_detach_should_deregister_event_conditions
+    c = Conditions::FakeEventCondition.new
+    m = Metric.new(@watch, :foo)
+    Hub.attach(c, m)
+    
+    c.expects(:deregister).once
+    
+    Hub.detach(c)
+  end
+  
+  # trigger
+  
+  def test_trigger_should_handle_poll_for_poll_condition
+    c = Conditions::FakePollCondition.new
+    Hub.expects(:handle_poll).with(c)
+    
+    Hub.trigger(c)
+  end
+  
+  def test_trigger_should_handle_event_for_event_condition
+    c = Conditions::FakeEventCondition.new
+    Hub.expects(:handle_event).with(c)
+    
+    Hub.trigger(c)
+  end
+  
+  # handle_poll
+  
+  def test_handle_poll_no_change_should_reschedule
+    c = Conditions::FakePollCondition.new
+    c.interval = 10
+    
+    m = Metric.new(@watch, {true => :up})
+    Hub.attach(c, m)
+    
+    c.expects(:test).returns(false)
+    Timer.any_instance.expects(:schedule)
+    
+    no_stdout do
+      t = Hub.handle_poll(c)
+      t.join
+    end
+  end
+  
+  def test_handle_poll_change_should_move
+    c = Conditions::FakePollCondition.new
+    c.interval = 10
+    
+    m = Metric.new(@watch, {true => :up})
+    Hub.attach(c, m)
+    
+    c.expects(:test).returns(true)
+    @watch.expects(:move).with(:up)
+    
+    no_stdout do
+      t = Hub.handle_poll(c)
+      t.join
+    end
+  end
+  
+  def test_handle_poll_should_abort_on_exception
+    c = Conditions::FakePollCondition.new
+    c.interval = 10
+    
+    m = Metric.new(@watch, {true => :up})
+    Hub.attach(c, m)
+    
+    c.expects(:test).raises(StandardError.new)
+    
+    assert_abort do
+      t = Hub.handle_poll(c)
+      t.join
+    end
+  end
+  
+  # handle_event
+  
+  def test_handle_event_should_move
+    c = Conditions::FakeEventCondition.new
+    
+    m = Metric.new(@watch, {true => :up})
+    Hub.attach(c, m)
+    
+    @watch.expects(:move).with(:up)
+    
+    no_stdout do
+      t = Hub.handle_event(c)
+      t.join
+    end
+  end
+end

data/test/test_metric.rb

@@ -36,7 +36,7 @@ class TestMetric < Test::Unit::TestCase
   def test_poll_condition_should_abort_if_no_interval_and_no_watch_interval
     metric = Metric.new(stub(:name => 'foo', :interval => nil), nil)
     
-    assert_raise AbortCalledError do
+    assert_abort do
       metric.condition(:fake_poll_condition)
     end
   end
@@ -53,8 +53,36 @@ class TestMetric < Test::Unit::TestCase
   def test_condition_should_abort_if_not_subclass_of_poll_or_event
     metric = Metric.new(stub(:name => 'foo', :interval => 10), nil)
     
-    assert_raise AbortCalledError do
+    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
+  
+  # enable
+  
+  def test_enable_should_attach_conditions
+    @metric.condition(:fake_poll_condition)
+    Hub.expects(:attach).with(@metric.conditions.first, @metric)
+    @metric.enable
+  end
+  
+  # disable
+  
+  def test_disable_should_detach_conditions
+    @metric.condition(:fake_poll_condition)
+    Hub.expects(:detach).with(@metric.conditions.first)
+    @metric.disable
+  end
 end

data/test/test_process.rb

@@ -0,0 +1,84 @@
+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 TestProcess < Test::Unit::TestCase
+  def setup
+    @p = God::Process.new(:name => 'foo', :pid_file => 'blah.pid')
+    @p.stubs(:test).returns true # so we don't try to mkdir_p
+    Process.stubs(:detach) # because we stub fork
+  end
+  
+  # These actually excercise call_action in the back at this point - Kev
+  def test_call_action_with_string_should_fork_exec 
+    @p.start = "do something"
+    IO.expects(:pipe).returns([StringIO.new('1234'), StringIO.new])
+    @p.expects(:fork)
+    Process.expects(:waitpid)
+    @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_default_pid_file
+    assert_equal File.join(God.pid_file_directory, 'foo.pid'), @p.default_pid_file
+  end
+  
+  def test_call_action_without_pid_should_write_pid
+    # Only for start, restart
+    [:start, :restart].each do |action|
+      @p = God::Process.new(:name => 'foo')
+      @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
+  
+  def test_call_action_should_not_write_pid_for_stop
+    @p.pid_file = nil
+    IO.expects(:pipe).returns([StringIO.new('1234'), StringIO.new])
+    @p.expects(:fork)
+    Process.expects(:waitpid)
+    File.expects(:open).times(0)
+    @p.stop = "stopping"
+    @p.call_action(:stop)
+  end
+  
+  def test_call_action_should_mkdir_p_if_pid_file_dir_existence_test_fails
+    @p.pid_file = nil
+    IO.expects(:pipe).returns([StringIO.new('1234'), StringIO.new])
+    @p.expects(:fork)
+    Process.expects(:waitpid)
+    @p.expects(:test).returns(false, true)
+    FileUtils.expects(:mkdir_p).with(God.pid_file_directory)
+    File.expects(:open)
+    @p.start = "starting"
+    @p.call_action(:start)
+  end
+  
+  def test_start_stop_restart_bang
+    [:start, :stop, :restart].each do |x|
+      @p.expects(:call_action).with(x)
+      @p.send("#{x}!")
+    end
+  end
+end

data/test/test_registry.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestRegistry < Test::Unit::TestCase
+  def setup
+    God.registry.reset
+  end
+  
+  def test_add
+    foo = God::Process.new(:name => 'foo')
+    God.registry.add(foo)
+    assert_equal 1, God.registry.size
+    assert_equal foo, God.registry['foo']
+  end
+end

data/test/test_server.rb

@@ -14,11 +14,12 @@ class TestServer < Test::Unit::TestCase
 
   def test_should_use_supplied_port_and_host
     DRb.expects(:start_service).with { |uri, object| uri == "druby://host:port" && object.is_a?(Server) }
-    server = Server.new(nil, 'host', 'port')
+    server = Server.new('host', 'port')
   end
 
   def test_should_forward_foreign_method_calls_to_meddle
-    server = Server.new(mock(:something_random => true))
+    server = Server.new
+    God.expects(:send).with(:something_random)
     server.something_random
   end
 end

data/test/test_sugar.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestSugar < Test::Unit::TestCase
+  def test_seconds
+    assert_equal 1, 1.seconds
+    assert_equal 1, 1.second
+  end
+  
+  def test_minutes
+    assert_equal 60, 1.minutes
+    assert_equal 60, 1.minute
+  end
+  
+  def test_hours
+    assert_equal 3600, 1.hours
+    assert_equal 3600, 1.hour
+  end
+  
+  def test_days
+    assert_equal 86400, 1.days
+    assert_equal 86400, 1.day
+  end
+  
+  def test_kilobytes
+    assert_equal 1, 1.kilobytes
+    assert_equal 1, 1.kilobyte
+  end
+  
+  def test_megabytes
+    assert_equal 1024, 1.megabytes
+    assert_equal 1024, 1.megabyte
+  end
+  
+  def test_gigabytes
+    assert_equal 1024 ** 2, 1.gigabytes
+    assert_equal 1024 ** 2, 1.gigabyte
+  end
+  
+  def test_percent
+    assert_equal 1, 1.percent
+  end
+end

data/test/test_system_process.rb

@@ -11,7 +11,7 @@ class TestSystemProcess < Test::Unit::TestCase
   end
   
   def test_exists_should_return_false_for_non_existant_process
-    assert_equal false, System::Process.new(0).exists?
+    assert_equal false, System::Process.new(9999999).exists?
   end
   
   def test_memory

data/test/test_timer.rb

@@ -13,7 +13,7 @@ class TestTimer < Test::Unit::TestCase
   def test_schedule_should_queue_event
     Time.stubs(:now).returns(0)
     
-    w = Watch.new(nil)
+    w = Watch.new
     @t.schedule(stub(:interval => 20))
     
     assert_equal 1, @t.events.size
@@ -50,4 +50,11 @@ class TestTimer < Test::Unit::TestCase
     @t.unschedule(a)
     assert_equal 1, @t.events.size
   end
+  
+  # join
+  
+  def test_join_should_join
+    Thread.any_instance.expects(:join)
+    @t.join
+  end
 end

data/test/test_watch.rb

@@ -2,7 +2,10 @@ require File.dirname(__FILE__) + '/helper'
 
 class TestWatch < Test::Unit::TestCase
   def setup
-    @watch = Watch.new(nil)
+    @watch = Watch.new
+    @watch.name = 'foo'
+    @watch.start = lambda { }
+    @watch.stop = lambda { }
   end
   
   # new
@@ -47,10 +50,16 @@ class TestWatch < Test::Unit::TestCase
     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_raise AbortCalledError do
+    assert_abort do
       @watch.transition(:foo, :bar)
     end
   end
@@ -82,6 +91,132 @@ class TestWatch < Test::Unit::TestCase
     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) { }
+    end
+    @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(nil)
+    @watch.unmonitor
+  end
+  
+  # move
+  
+  def test_move_should_not_clean_up_if_from_state_is_nil
+    metric = nil
+    
+    @watch.instance_eval do
+      transition(:init, :up) do |on|
+        metric = on
+        on.condition(:process_running) do |c|
+          c.running = true
+          c.interval = 10
+        end
+      end
+    end
+    
+    metric.expects(:disable).never
+    
+    no_stdout { @watch.move(:init) }
+  end
+  
+  def test_move_should_clean_up_from_state_if_not_nil
+    metric = nil
+    
+    @watch.instance_eval do
+      transition(:init, :up) do |on|
+        metric = on
+        on.condition(:process_running) do |c|
+          c.running = true
+          c.interval = 10
+        end
+      end
+    end
+    
+    no_stdout { @watch.move(:init) }
+    
+    metric.expects(:disable)
+    
+    no_stdout { @watch.move(:up) }
+  end
+  
+  def test_move_should_call_action
+    @watch.expects(:action).with(:start)
+    
+    no_stdout { @watch.move(:start) }
+  end
+  
+  def test_move_should_move_to_up_state_if_no_start_or_restart_metric
+    [:start, :restart].each do |state|
+      @watch.expects(:action)
+      no_stdout { @watch.move(state) }
+      assert_equal :up, @watch.state
+    end
+  end
+  
+  def test_move_should_enable_destination_metric
+    metric = nil
+    
+    @watch.instance_eval do
+      transition(:init, :up) do |on|
+        metric = on
+        on.condition(:process_running) do |c|
+          c.running = true
+          c.interval = 10
+        end
+      end
+    end
+    
+    metric.expects(:enable)
+    
+    no_stdout { @watch.move(:init) }
+  end
+  
+  # action
+  
+  def test_action_should_pass_start_and_stop_actions_to_call_action
+    c = Conditions::FakePollCondition.new
+    [:start, :stop].each do |cmd|
+      @watch.expects(:call_action).with(c, cmd)
+      no_stdout { @watch.action(cmd, c) }
+    end
+  end
+  
+  def test_action_should_do_stop_then_start_if_no_restart_command
+    c = Conditions::FakePollCondition.new
+    @watch.expects(:call_action).with(c, :stop)
+    @watch.expects(:call_action).with(c, :start)
+    no_stdout { @watch.action(:restart, c) }
+  end
+  
+  def test_action_should_restart_to_call_action_if_present
+    @watch.restart = lambda { }
+    c = Conditions::FakePollCondition.new
+    @watch.expects(:call_action).with(c, :restart)
+    no_stdout { @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
+  
   # canonical_hash_form
   
   def test_canonical_hash_form_should_convert_symbol_to_hash