god 0.11.0 → 0.12.0

data/test/test_conditions_tries.rb

@@ -2,7 +2,7 @@ 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')
@@ -17,23 +17,23 @@ class TestConditionsTries < Test::Unit::TestCase
     @c.times = 3
     @c.prepare
   end
-  
+
   # prepare
-  
+
   def test_prepare_should_create_timeline
-    assert 3, @c.instance_variable_get(:@timeline).instance_variable_get(:@max_size)
+    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
@@ -49,19 +49,19 @@ class TestConditionsTriesWithin < Test::Unit::TestCase
     @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
+end

data/test/test_contact.rb

@@ -4,106 +4,106 @@ 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
+end

data/test/test_driver.rb

@@ -2,10 +2,24 @@ require File.dirname(__FILE__) + '/helper'
 
 class TestDriver < Test::Unit::TestCase
   def setup
-    
+
   end
 
-  def test_
-    
+  def test_push_pop_wait
+    eq = God::DriverEventQueue.new
+
+    MonitorMixin::ConditionVariable.any_instance.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_event_handler.rb

@@ -2,15 +2,15 @@ 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
@@ -21,40 +21,40 @@ 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()
@@ -64,7 +64,7 @@ class TestEventHandler < Test::Unit::TestCase
     @h.call(4445, :proc_fork) # shouldn't call, bad event
     @h.call(4445, :proc_exit) # should call
   end
-  
+
   def teardown
     # Reset handler
     @h.actions = {}
@@ -77,4 +77,4 @@ class TestEventHandlerOperational < Test::Unit::TestCase
     God::EventHandler.start
     assert God::EventHandler.loaded?
   end
-end
+end

data/test/test_god.rb

@@ -5,11 +5,10 @@ class TestGod < Test::Unit::TestCase
     God::Socket.stubs(:new).returns(true)
     God.stubs(:setup).returns(true)
     God.stubs(:validater).returns(true)
-    Thread.any_instance.stubs(:join).returns(true)
     God.reset
     God.pid_file_directory = '/var/run/god'
   end
-  
+
   def teardown
     God.main && God.main.kill
     if God.watches
@@ -18,46 +17,46 @@ class TestGod < Test::Unit::TestCase
       end
     end
   end
-  
+
   # applog
-  
+
   def test_applog
     LOG.expects(:log).with(nil, :debug, 'foo')
     applog(nil, :debug, 'foo')
   end
-  
+
   # internal_init
-  
+
   def test_init_should_initialize_watches_to_empty_array
     God.internal_init { }
     assert_equal Hash.new, God.watches
   end
-  
+
   # 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.pid_file_directory = 'foo'
     end
   end
-  
+
   # pid_file_directory
-  
+
   def test_pid_file_directory_should_return_default_if_not_set_explicitly
     God.internal_init
     assert_equal '/var/run/god', God.pid_file_directory
   end
-  
+
   def test_pid_file_directory_equals_should_set
     God.pid_file_directory = '/foo'
     God.internal_init
     assert_equal '/foo', God.pid_file_directory
   end
-  
+
   # watch
-  
+
   def test_watch_should_get_stored
     watch = nil
     God.watch do |w|
@@ -65,13 +64,13 @@ class TestGod < Test::Unit::TestCase
       w.start = 'bar'
       watch = w
     end
-    
+
     assert_equal 1, God.watches.size
     assert_equal watch, God.watches.values.first
-    
+
     assert_equal 0, God.groups.size
   end
-  
+
   def test_watch_should_get_stored_in_pending_watches
     watch = nil
     God.watch do |w|
@@ -79,11 +78,11 @@ class TestGod < Test::Unit::TestCase
       w.start = 'bar'
       watch = w
     end
-    
+
     assert_equal 1, God.pending_watches.size
     assert_equal watch, God.pending_watches.first
   end
-  
+
   def test_watch_should_register_processes
     assert_nil God.registry['foo']
     God.watch do |w|
@@ -92,84 +91,84 @@ class TestGod < Test::Unit::TestCase
     end
     assert_kind_of God::Process, God.registry['foo']
   end
-  
+
   def test_watch_should_get_stored_by_group
     a = nil
-    
+
     God.watch do |w|
       a = w
       w.name = 'foo'
       w.start = 'bar'
       w.group = 'test'
     end
-    
+
     assert_equal({'test' => [a]}, God.groups)
   end
-  
+
   def test_watches_should_get_stored_by_group
     a = nil
     b = nil
-    
+
     God.watch do |w|
       a = w
       w.name = 'foo'
       w.start = 'bar'
       w.group = 'test'
     end
-    
+
     God.watch do |w|
       b = w
       w.name = 'bar'
       w.start = 'baz'
       w.group = 'test'
     end
-    
+
     assert_equal({'test' => [a, b]}, God.groups)
   end
-      
+
   def test_watch_should_allow_multiple_watches
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
-    
+
     assert_nothing_raised do
       God.watch { |w| w.name = 'bar'; w.start = 'bar' }
     end
   end
-  
+
   def test_watch_should_disallow_duplicate_watch_names
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
-    
+
     assert_abort do
       God.watch { |w| w.name = 'foo'; w.start = 'bar' }
     end
   end
-  
+
   def test_watch_should_disallow_identical_watch_and_group_names
     God.watch { |w| w.name = 'foo'; w.group = 'bar'; w.start = 'bar' }
-    
+
     assert_abort do
       God.watch { |w| w.name = 'bar'; w.start = 'bar' }
     end
   end
-  
+
   def test_watch_should_disallow_identical_watch_and_group_names_other_way
     God.watch { |w| w.name = 'bar'; w.start = 'bar' }
-    
+
     assert_abort do
       God.watch { |w| w.name = 'foo'; w.group = 'bar'; w.start = 'bar' }
     end
   end
-  
+
   def test_watch_should_unwatch_new_watch_if_running_and_duplicate_watch
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
     God.running = true
-    
+
     assert_nothing_raised do
       God.watch { |w| w.name = 'foo'; w.start = 'bar' }
     end
   end
-  
+
   # unwatch
-  
+
   def test_unwatch_should_unmonitor_watch
     God.watch { |w| w.name = 'bar'; w.start = 'bar' }
     w = God.watches['bar']
@@ -177,21 +176,21 @@ class TestGod < Test::Unit::TestCase
     w.expects(:unmonitor)
     God.unwatch(w)
   end
-  
+
   def test_unwatch_should_unregister_watch
     God.watch { |w| w.name = 'bar'; w.start = 'bar' }
     w = God.watches['bar']
     w.expects(:unregister!)
     God.unwatch(w)
   end
-  
+
   def test_unwatch_should_remove_same_name_watches
     God.watch { |w| w.name = 'bar'; w.start = 'bar' }
     w = God.watches['bar']
     God.unwatch(w)
     assert_equal 0, God.watches.size
   end
-  
+
   def test_unwatch_should_remove_from_group
     God.watch do |w|
       w.name = 'bar'
@@ -202,59 +201,60 @@ class TestGod < Test::Unit::TestCase
     God.unwatch(w)
     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
+    assert_equal({"tom" => 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
+    assert_equal 2, God.contacts.size
+    assert_equal 1, God.contact_groups.size
   end
-  
+
   def test_contact_should_abort_on_no_name
     assert_abort do
       God.contact(:fake_contact) { |c| }
     end
   end
-  
+
   def test_contact_should_abort_on_duplicate_contact_name
     God.contact(:fake_contact) { |c| c.name = 'tom' }
     assert_nothing_raised 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_nothing_raised 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|
@@ -263,111 +263,111 @@ class TestGod < Test::Unit::TestCase
       end
     end
   end
-  
+
   # control
-  
+
   def test_control_should_monitor_on_start
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
-    
+
     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.start = 'bar' }
-    
+
     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.start = 'bar' }
-    
+
     w = God.watches['foo']
     w.state = :up
     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.start = 'bar' }
-    
+
     w = God.watches['foo']
     w.state = :up
     w.expects(:unmonitor).returns(w)
     God.control('foo', 'unmonitor')
   end
-  
+
   def test_control_should_unwatch_on_remove
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
-    
+
     w = God.watches['foo']
     w.state = :up
     God.expects(:unwatch)
     God.control('foo', 'remove')
   end
-  
+
   def test_control_should_raise_on_invalid_command
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
-    
+
     assert_raise InvalidCommandError do
       God.control('foo', 'invalid')
     end
   end
-  
+
   def test_control_should_operate_on_each_watch_in_group
     God.watch do |w|
       w.name = 'foo1'
       w.start = 'go'
       w.group = 'bar'
     end
-    
+
     God.watch do |w|
       w.name = 'foo2'
       w.start = 'go'
       w.group = 'bar'
     end
-    
+
     God.watches['foo1'].expects(:monitor)
     God.watches['foo2'].expects(:monitor)
-    
+
     God.control('bar', 'start')
   end
-  
+
   # stop_all
-  
+
   # terminate
-  
+
   def test_terminate_should_exit
     God.pid = nil
     FileUtils.expects(:rm_f).never
     God.expects(:exit!)
     God.terminate
   end
-  
+
   def test_terminate_should_delete_pid
     God.pid = '/foo/bar'
     FileUtils.expects(:rm_f).with("/foo/bar")
     God.expects(:exit!)
     God.terminate
   end
-  
+
   # status
-  
+
   def test_status_should_show_state
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
-    
+
     w = God.watches['foo']
     w.state = :up
     assert_equal({'foo' => {:state => :up, :group => nil}}, God.status)
   end
-  
+
   def test_status_should_show_state_with_group
     God.watch { |w| w.name = 'foo'; w.start = 'bar'; w.group = 'g' }
-    
+
     w = God.watches['foo']
     w.state = :up
     assert_equal({'foo' => {:state => :up, :group => 'g'}}, God.status)
@@ -375,29 +375,29 @@ class TestGod < Test::Unit::TestCase
 
   def test_status_should_show_unmonitored_for_nil_state
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
-    
+
     w = God.watches['foo']
     assert_equal({'foo' => {:state => :unmonitored, :group => nil}}, 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
     code = <<-EOF
       God.watch do |w|
@@ -405,12 +405,12 @@ class TestGod < Test::Unit::TestCase
         w.start = 'go'
       end
     EOF
-    
+
     God.running_load(code, '/foo/bar.god')
-    
+
     assert_equal 1, God.watches.size
   end
-  
+
   def test_running_load_should_monitor_new_watches
     code = <<-EOF
       God.watch do |w|
@@ -418,11 +418,11 @@ class TestGod < Test::Unit::TestCase
         w.start = 'go'
       end
     EOF
-    
+
     Watch.any_instance.expects(:monitor)
     God.running_load(code, '/foo/bar.god')
   end
-  
+
   def test_running_load_should_not_monitor_new_watches_with_autostart_false
     code = <<-EOF
       God.watch do |w|
@@ -431,11 +431,11 @@ class TestGod < Test::Unit::TestCase
         w.autostart = false
       end
     EOF
-    
+
     Watch.any_instance.expects(:monitor).never
     God.running_load(code, '/foo/bar.god')
   end
-  
+
   def test_running_load_should_return_array_of_affected_watches
     code = <<-EOF
       God.watch do |w|
@@ -443,13 +443,13 @@ class TestGod < Test::Unit::TestCase
         w.start = 'go'
       end
     EOF
-    
+
     w = nil
     w, e = *God.running_load(code, '/foo/bar.god')
     assert_equal 1, w.size
     assert_equal 'foo', w.first
   end
-  
+
   def test_running_load_should_clear_pending_watches
     code = <<-EOF
       God.watch do |w|
@@ -457,65 +457,143 @@ class TestGod < Test::Unit::TestCase
         w.start = 'go'
       end
     EOF
-    
+
     God.running_load(code, '/foo/bar.god')
     assert_equal 0, God.pending_watches.size
   end
-  
+
+  def test_running_load_with_stop
+    code_one = <<-EOF
+      God.watch do |w|
+        w.name = 'foo'
+        w.start = 'go'
+      end
+    EOF
+
+    code_two = <<-EOF
+      God.watch do |w|
+        w.name = 'bar'
+        w.start = 'go'
+      end
+    EOF
+
+    a, e, r = *God.running_load(code_one, '/foo/one.god', 'stop')
+
+    assert_equal 1, a.size
+    assert_equal 0, r.size
+
+    a, e, r = *God.running_load(code_two, '/foo/two.god', 'stop')
+
+    assert_equal 1, a.size
+    assert_equal 1, r.size
+  end
+
+  def test_running_load_with_remove
+    code_one = <<-EOF
+      God.watch do |w|
+        w.name = 'foo'
+        w.start = 'go'
+      end
+    EOF
+
+    code_two = <<-EOF
+      God.watch do |w|
+        w.name = 'bar'
+        w.start = 'go'
+      end
+    EOF
+
+    a, e, r = *God.running_load(code_one, '/foo/one.god', 'remove')
+
+    assert_equal 1, a.size
+    assert_equal 0, r.size
+
+    a, e, r = *God.running_load(code_two, '/foo/two.god', 'remove')
+
+    assert_equal 1, a.size
+    assert_equal 1, r.size
+  end
+
+  def test_running_load_with_leave
+    code_one = <<-EOF
+      God.watch do |w|
+        w.name = 'foo'
+        w.start = 'go'
+      end
+    EOF
+
+    code_two = <<-EOF
+      God.watch do |w|
+        w.name = 'bar'
+        w.start = 'go'
+      end
+    EOF
+
+    a, e, r = *God.running_load(code_one, '/foo/one.god', 'leave')
+
+    assert_equal 1, a.size
+    assert_equal 0, r.size
+
+    a, e, r = *God.running_load(code_two, '/foo/two.god', 'leave')
+
+    assert_equal 1, a.size
+    assert_equal 0, r.size
+  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
-  
+
   # start
-  
+
   def test_start_should_kick_off_a_server_instance
     God::Socket.expects(:new).returns(true)
     God.start
   end
-  
+
   def test_start_should_begin_monitoring_autostart_watches
     God.watch do |w|
       w.name = 'foo'
       w.start = 'go'
     end
-    
+
     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.start = 'go'
       w.autostart = false
     end
-    
+
     Watch.any_instance.expects(:monitor).never
     God.start
   end
-  
+
   def test_start_should_get_and_join_timer
     God.watch { |w| w.name = 'foo'; w.start = 'bar' }
     God.start
   end
-  
+
   # at_exit
-  
+
   def test_at_exit_should_call_start
     God.expects(:start).once
     God.at_exit
   end
-  
+
   # pattern_match
-  
+
   def test_pattern_match
     list = %w{ mongrel-3000 mongrel-3001 fuzed22 fuzed fuzed2 apache mysql}
-    
+
     assert_equal %w{ mongrel-3000 }, God.pattern_match('m3000', list)
     assert_equal %w{ mongrel-3001 }, God.pattern_match('m31', list)
     assert_equal %w{ fuzed fuzed2 fuzed22}, God.pattern_match('fu', list)
@@ -530,37 +608,37 @@ end
 #     God.internal_init
 #     God.reset
 #   end
-#   
+#
 #   def teardown
 #     God.main && God.main.kill
 #   end
-#   
+#
 #   # setup
-#   
+#
 #   def test_setup_should_create_pid_file_directory_if_it_doesnt_exist
 #     God.expects(:test).returns(false)
 #     FileUtils.expects(:mkdir_p).with(God.pid_file_directory)
 #     God.setup
 #   end
-#   
+#
 #   def test_setup_should_raise_if_no_permissions_to_create_pid_file_directory
 #     God.expects(:test).returns(false)
 #     FileUtils.expects(:mkdir_p).raises(Errno::EACCES)
-#     
+#
 #     assert_abort do
 #       God.setup
 #     end
 #   end
-#   
+#
 #   # validate
-#     
+#
 #   def test_validate_should_abort_if_pid_file_directory_is_unwriteable
 #     God.expects(:test).returns(false)
 #     assert_abort do
 #       God.validater
 #     end
 #   end
-#   
+#
 #   def test_validate_should_not_abort_if_pid_file_directory_is_writeable
 #     God.expects(:test).returns(true)
 #     assert_nothing_raised do