firenxis-god 0.11.0

data/test/test_conditions_tries.rb

@@ -0,0 +1,67 @@
+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')
+    assert !c.valid?
+  end
+end
+
+
+class TestConditionsTries < Test::Unit::TestCase
+  def setup
+    @c = Conditions::Tries.new
+    @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)
+  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
+    @c.times = 3
+    @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

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_dependency_graph.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestDependencyGraph < Test::Unit::TestCase
+  def setup
+    @dg = DependencyGraph.new
+  end
+  
+  # new
+  
+  def test_new_should_accept_zero_arguments
+    assert @dg.instance_of?(DependencyGraph)
+  end
+  
+  # add
+  
+  def test_add_should_create_and_store_two_new_nodes
+    @dg.add('foo', 'bar')
+    assert_equal 2, @dg.nodes.size
+    assert @dg.nodes['foo'].instance_of?(DependencyGraph::Node)
+    assert @dg.nodes['bar'].instance_of?(DependencyGraph::Node)
+  end
+  
+  def test_add_should_record_dependency
+    @dg.add('foo', 'bar')
+    assert_equal 1, @dg.nodes['foo'].dependencies.size
+    assert_equal @dg.nodes['bar'], @dg.nodes['foo'].dependencies.first
+  end
+  
+  def test_add_should_ignore_dups
+    @dg.add('foo', 'bar')
+    @dg.add('foo', 'bar')
+    assert_equal 2, @dg.nodes.size    
+    assert_equal 1, @dg.nodes['foo'].dependencies.size
+  end
+end
+
+
+class TestDependencyGraphNode < Test::Unit::TestCase
+  def setup
+    @foo = DependencyGraph::Node.new('foo')
+    @bar = DependencyGraph::Node.new('bar')
+  end
+  
+  # new
+  
+  def test_new_should_accept_zero_arguments
+    assert @foo.instance_of?(DependencyGraph::Node)
+  end
+  
+  # add
+  
+  def test_add_should_store_node_as_dependency
+    @foo.add(@bar)
+    assert_equal 1, @foo.dependencies.size
+  end
+  
+  # has_node?
+  
+  def test_has_node
+    assert @foo.has_node?(@foo)
+  end
+end

data/test/test_driver.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestDriver < Test::Unit::TestCase
+  def setup
+    
+  end
+
+  def test_
+    
+  end
+end

data/test/test_email.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestEmail < Test::Unit::TestCase
+  def setup
+    God::Contacts::Email.to_email = 'dev@example.com'
+    God::Contacts::Email.from_email = 'god@example.com'
+    @email = God::Contacts::Email.new
+  end
+
+  def test_validity_delivery
+    @email.delivery_method = :brainwaves
+    assert_equal false, @email.valid?
+  end
+
+  def test_smtp_delivery_method_for_notify
+    @email.delivery_method = :smtp
+
+    God::Contacts::Email.any_instance.expects(:notify_sendmail).never
+    God::Contacts::Email.any_instance.expects(:notify_smtp).once.returns(nil)
+
+    @email.notify('msg', Time.now, 'prio', 'cat', 'host')
+    assert_equal "sent email to dev@example.com via smtp", @email.info
+  end
+
+  def test_sendmail_delivery_method_for_notify
+    @email.delivery_method = :sendmail
+
+    God::Contacts::Email.any_instance.expects(:notify_smtp).never
+    God::Contacts::Email.any_instance.expects(:notify_sendmail).once.returns(nil)
+
+    @email.notify('msg', Time.now, 'prio', 'cat', 'host')
+    assert_equal "sent email to dev@example.com via sendmail", @email.info
+  end
+end

data/test/test_event_handler.rb

@@ -0,0 +1,80 @@
+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
+
+class TestEventHandlerOperational < Test::Unit::TestCase
+  def test_operational
+    God::EventHandler.start
+    assert God::EventHandler.loaded?
+  end
+end

data/test/test_god.rb

@@ -0,0 +1,570 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestGod < Test::Unit::TestCase
+  def setup
+    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
+      God.watches.each do |k, w|
+        w.driver.thread.kill
+      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|
+      w.name = 'foo'
+      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|
+      w.name = 'foo'
+      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|
+      w.name = 'foo'
+      w.start = 'bar'
+    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']
+    w.state = :up
+    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'
+      w.start = 'baz'
+      w.group = 'test'
+    end
+    w = God.watches['bar']
+    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
+  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
+    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|
+        c.name = 'tom'
+        c.stubs(:valid?).returns(false)
+      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)
+  end
+
+  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|
+        w.name = 'foo'
+        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|
+        w.name = 'foo'
+        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|
+        w.name = 'foo'
+        w.start = 'go'
+        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|
+        w.name = 'foo'
+        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|
+        w.name = 'foo'
+        w.start = 'go'
+      end
+    EOF
+    
+    God.running_load(code, '/foo/bar.god')
+    assert_equal 0, God.pending_watches.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)
+    assert_equal %w{ mysql }, God.pattern_match('sql', list)
+  end
+end
+
+
+# class TestGodOther < Test::Unit::TestCase
+#   def setup
+#     God::Socket.stubs(:new).returns(true)
+#     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
+#       God.validater
+#     end
+#   end
+# end