god 0.2.0 → 0.3.0

data/test/helper.rb

@@ -1,7 +1,7 @@
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. ext kqueue_handler])
 require File.join(File.dirname(__FILE__), *%w[.. lib god])
 
 require 'test/unit'
+require 'set'
 
 begin
   require 'mocha'
@@ -18,19 +18,6 @@ end
 include God
 
 module God
-  class AbortCalledError < StandardError
-  end
-
-  class Base
-    def abort(msg)
-      raise AbortCalledError.new("abort called")
-    end
-    
-    def self.abort(msg)
-      raise AbortCalledError.new("abort called")
-    end
-  end
-
   module Conditions
     class FakeCondition < Condition
       def test
@@ -55,6 +42,25 @@ module God
     class FakeBehavior < Behavior
     end
   end
+  
+  class << self
+    alias :at_exit_orig :at_exit
+  end
+  
+  def self.at_exit
+    # disable at_exit
+  end
+  
+  def self.reset
+    self.watches = nil
+    self.groups = nil
+    self.server = nil
+    self.inited = nil
+    self.host = nil
+    self.port = nil
+    self.pid_file_directory = nil
+    self.registry.reset
+  end
 end
 
 def silence_warnings
@@ -64,6 +70,30 @@ ensure
   $VERBOSE = old_verbose
 end
 
+def no_stdout
+  old_stdout = $stdout.dup
+  $stdout.reopen(File.open((PLATFORM =~ /mswin/ ? "NUL" : "/dev/null"), 'w'))
+  yield
+  $stdout.reopen(old_stdout)
+end
+
+def no_stderr
+  old_stderr = $stderr.dup
+  $stderr.reopen(File.open((PLATFORM =~ /mswin/ ? "NUL" : "/dev/null"), 'w'))
+  yield
+  $stderr.reopen(old_stderr)
+end
+
+module Test::Unit::Assertions
+  def assert_abort
+    assert_raise SystemExit do
+      no_stderr do
+        yield
+      end
+    end
+  end
+end
+
 # This allows you to be a good OOP citizen and honor encapsulation, but
 # still make calls to private methods (for testing) by doing
 #

data/test/test_behavior.rb

@@ -2,12 +2,20 @@ require File.dirname(__FILE__) + '/helper'
 
 class TestBehavior < Test::Unit::TestCase
   def test_generate_should_return_an_object_corresponding_to_the_given_type
-    assert_equal Behaviors::FakeBehavior, Behavior.generate(:fake_behavior).class
+    assert_equal Behaviors::FakeBehavior, Behavior.generate(:fake_behavior, nil).class
   end
   
   def test_generate_should_raise_on_invalid_type
     assert_raise NoSuchBehaviorError do
-      Behavior.generate(:foo)
+      Behavior.generate(:foo, nil)
+    end
+  end
+  
+  def test_complain
+    Syslog.expects(:err).with('foo')
+    # Kernel.expects(:puts).with('foo')
+    no_stdout do
+      assert !Behavior.allocate.bypass.complain('foo')
     end
   end
 end

data/test/test_condition.rb

@@ -1,13 +1,19 @@
 require File.dirname(__FILE__) + '/helper'
 
+class BadlyImplementedCondition < PollCondition
+end
+
 class TestCondition < Test::Unit::TestCase
+  
+  # generate
+  
   def test_generate_should_return_an_object_corresponding_to_the_given_type
-    assert_equal Conditions::ProcessRunning, Condition.generate(:process_running).class
+    assert_equal Conditions::ProcessRunning, Condition.generate(:process_running, nil).class
   end
   
   def test_generate_should_raise_on_invalid_type
     assert_raise NoSuchConditionError do
-      Condition.generate(:foo)
+      Condition.generate(:foo, nil)
     end
   end
   
@@ -16,11 +22,21 @@ class TestCondition < Test::Unit::TestCase
     rmsg = nil
     
     begin
-      Condition.generate(:foo_bar)
+      Condition.generate(:foo_bar, nil)
     rescue => e
       rmsg = e.message
     end
     
     assert_equal emsg, rmsg
   end
+  
+  # test
+  
+  def test_test_should_raise_if_not_defined_in_subclass
+    c = BadlyImplementedCondition.new
+    
+    assert_raise AbstractMethodNotOverriddenError do
+      c.test
+    end
+  end
 end

data/test/test_conditions_process_running.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestConditionsProcessRunning < Test::Unit::TestCase
+  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_file => ''))
+    
+      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_file => ''))
+      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_file => ''))
+      File.stubs(:read).returns('5')
+      System::Process.any_instance.stubs(:exists?).returns(true)
+    
+      assert_equal r, c.test
+    end
+  end
+end

data/test/test_event_handler.rb

@@ -0,0 +1,73 @@
+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 < Test::Unit::TestCase
+  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

data/test/test_god.rb

@@ -1,16 +1,213 @@
 require File.dirname(__FILE__) + '/helper'
 
 class TestGod < Test::Unit::TestCase
-  def test_should_create_new_meddle
-    Meddle.expects(:new).with(:port => 1).returns(mock(:monitor => true))
-    Timer.expects(:get).returns(stub(:join => nil)).times(2)
+  def setup
+    Server.stubs(:new).returns(true)
+    God.reset
+  end
+  
+  def teardown
+    Timer.get.timer.kill
+  end
+  
+  # init
+  
+  def test_init_should_initialize_watches_to_empty_array
+    God.init { }
+    assert_equal Hash.new, God.watches
+  end
+  
+  def test_init_should_kick_off_a_server_instance
+    Server.expects(:new).returns(true)
+    God.init
+  end
+  
+  # pid_file_directory
+  
+  def test_pid_file_directory_should_return_default_if_not_set_explicitly
+    assert_equal '/var/run/god', God.pid_file_directory
+  end
+  
+  def test_pid_file_directory_equals_should_set
+    God.pid_file_directory = '/foo'
+    assert_equal '/foo', God.pid_file_directory
+  end
+  
+  # watch
+  
+  def test_watch_should_get_stored
+    watch = nil
+    God.watch { |w| watch = w }
+    
+    assert_equal 1, God.watches.size
+    assert_equal watch, God.watches.values.first
     
-    God.meddle(:port => 1) {}
+    assert_equal 0, God.groups.size
   end
-
-  def test_should_start_monitoring
-    Meddle.any_instance.expects(:monitor)
-    Timer.expects(:get).returns(stub(:join => nil)).times(2)
-    God.meddle {}
+  
+  def test_watch_should_register_processes
+    assert_nil God.registry['foo']
+    God.watch { |w| w.name = 'foo' }
+    assert_kind_of God::Process, God.registry['foo']
+  end
+  
+  def test_watch_should_get_stored_by_group
+    God.watch do |w|
+      w.name = 'foo'
+      w.group = 'test'
+    end
+    
+    assert_equal({'test' => ['foo']}, God.groups)
+  end
+  
+  def test_watches_should_get_stored_by_group
+    God.watch do |w|
+      w.name = 'foo'
+      w.group = 'test'
+    end
+    
+    God.watch do |w|
+      w.name = 'bar'
+      w.group = 'test'
+    end
+    
+    assert_equal({'test' => ['foo', 'bar']}, God.groups)
+  end
+      
+  def test_watch_should_allow_multiple_watches
+    God.watch { |w| w.name = 'foo' }
+    
+    assert_nothing_raised do
+      God.watch { |w| w.name = 'bar' }
+    end
+  end
+  
+  def test_watch_should_disallow_duplicate_watch_names
+    God.watch { |w| w.name = 'foo' }
+    
+    assert_abort do
+      God.watch { |w| w.name = 'foo' }
+    end
+  end
+  
+  def test_watch_should_disallow_identical_watch_and_group_names
+    God.watch { |w| w.name = 'foo'; w.group = 'bar' }
+    
+    assert_abort do
+      God.watch { |w| w.name = 'bar' }
+    end
+  end
+  
+  def test_watch_should_disallow_identical_watch_and_group_names_other_way
+    God.watch { |w| w.name = 'bar' }
+    
+    assert_abort do
+      God.watch { |w| w.name = 'foo'; w.group = 'bar' }
+    end
+  end
+  
+  # control
+  
+  def test_control_should_monitor_on_start
+    God.watch { |w| w.name = 'foo' }
+    
+    w = God.watches['foo']
+    w.expects(:monitor)
+    God.control('foo', 'start')
+  end
+  
+  def test_control_should_move_to_restart_on_restart
+    God.watch { |w| w.name = 'foo' }
+    
+    w = God.watches['foo']
+    w.expects(:move).with(:restart)
+    God.control('foo', 'restart')
+  end
+  
+  def test_control_should_unmonitor_and_stop_on_stop
+    God.watch { |w| w.name = 'foo' }
+    
+    w = God.watches['foo']
+    w.expects(:unmonitor).returns(w)
+    w.expects(:action).with(:stop)
+    God.control('foo', 'stop')
+  end
+  
+  def test_control_should_unmonitor_on_unmonitor
+    God.watch { |w| w.name = 'foo' }
+    
+    w = God.watches['foo']
+    w.expects(:unmonitor).returns(w)
+    God.control('foo', 'unmonitor')
+  end
+  
+  def test_control_should_raise_on_invalid_command
+    God.watch { |w| w.name = 'foo' }
+    
+    assert_raise InvalidCommandError do
+      God.control('foo', 'invalid')
+    end
+  end
+  
+  # start
+  
+  def test_start_should_check_for_at_least_one_watch
+    assert_abort do
+      God.start
+    end
+  end
+  
+  def test_start_should_start_event_handler
+    God.watch { |w| w.name = 'foo' }
+    Timer.any_instance.expects(:join)
+    EventHandler.expects(:start).once
+    no_stdout do
+      God.start
+    end
+  end
+  
+  def test_start_should_begin_monitoring_autostart_watches
+    God.watch do |w|
+      w.name = 'foo'
+    end
+    
+    Timer.any_instance.expects(:join)
+    Watch.any_instance.expects(:monitor).once
+    God.start
+  end
+  
+  def test_start_should_not_begin_monitoring_non_autostart_watches
+    God.watch do |w|
+      w.name = 'foo'
+      w.autostart = false
+    end
+    
+    Timer.any_instance.expects(:join)
+    Watch.any_instance.expects(:monitor).never
+    God.start
+  end
+  
+  def test_start_should_get_and_join_timer
+    God.watch { |w| w.name = 'foo' }
+    Timer.any_instance.expects(:join)
+    no_stdout do
+      God.start
+    end
+  end
+  
+  # at_exit
+  
+  def test_at_exit_should_call_start
+    God.expects(:start).once
+    God.at_exit_orig
+  end
+  
+  # load
+  
+  def test_load_should_collect_and_load_globbed_path
+    Dir.expects(:[]).with('/path/to/*.thing').returns(['a', 'b'])
+    Kernel.expects(:load).with('a').once
+    Kernel.expects(:load).with('b').once
+    God.load('/path/to/*.thing')
   end
 end