dosire-god 0.7.9

data/test/helper.rb

@@ -0,0 +1,151 @@
+require File.join(File.dirname(__FILE__), *%w[.. lib god])
+God::EventHandler.load
+
+require 'test/unit'
+require 'set'
+
+include God
+
+if Process.uid != 0
+  abort <<-EOF
+\n
+*********************************************************************
+*                                                                   *
+*               You need to run these tests as root                 *
+*           chroot and netlink (linux only) require it              *
+*                                                                   *
+*********************************************************************
+EOF
+end
+
+begin
+  require 'mocha'
+rescue LoadError
+  unless gems ||= false
+    require 'rubygems'
+    gems = true
+    retry
+  else
+    abort "=> You need the Mocha gem to run these tests."
+  end
+end
+
+module God
+  module Conditions
+    class FakeCondition < Condition
+      def test
+        true
+      end
+    end
+  
+    class FakePollCondition < PollCondition
+      def test
+        true
+      end
+    end
+  
+    class FakeEventCondition < EventCondition
+      def register
+      end
+      def deregister
+      end
+    end
+  end
+  
+  module Behaviors
+    class FakeBehavior < Behavior
+      def before_start
+        'foo'
+      end
+      def after_start
+        'bar'
+      end
+    end
+  end
+  
+  module Contacts
+    class FakeContact < Contact
+    end
+    
+    class InvalidContact
+    end
+  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
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+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 Kernel
+  def abort(text)
+    raise SystemExit
+  end
+  def exit(code)
+    raise SystemExit
+  end
+end
+
+module Test::Unit::Assertions
+  def assert_abort
+    assert_raise SystemExit do
+      yield
+    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
+#
+#   obj.bypass.private_thingie(arg1, arg2)
+#
+# Which is easier on the eye than
+#
+#   obj.send(:private_thingie, arg1, arg2)
+#
+class Object
+  class Bypass
+    instance_methods.each do |m|
+      undef_method m unless m =~ /^__/
+    end
+
+    def initialize(ref)
+      @ref = ref
+    end
+  
+    def method_missing(sym, *args)
+      @ref.__send__(sym, *args)
+    end
+  end
+
+  def bypass
+    Bypass.new(self)
+  end
+end

data/test/suite.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+
+tests = Dir["#{File.dirname(__FILE__)}/test_*.rb"]
+tests.each do |file|
+  require file
+end

data/test/test_behavior.rb

@@ -0,0 +1,21 @@
+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, nil).class
+  end
+  
+  def test_generate_should_raise_on_invalid_type
+    assert_raise NoSuchBehaviorError do
+      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

@@ -0,0 +1,50 @@
+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, nil).class
+  end
+  
+  def test_generate_should_raise_on_invalid_type
+    assert_raise NoSuchConditionError do
+      Condition.generate(:foo, nil)
+    end
+  end
+  
+  def test_generate_should_abort_on_event_condition_without_loaded_event_system
+    God::EventHandler.stubs(:operational?).returns(false)
+    assert_abort do
+      God::EventHandler.start
+      Condition.generate(:process_exits, nil).class
+    end
+  end
+  
+  def test_generate_should_return_a_good_error_message_for_invalid_types
+    emsg = "No Condition found with the class name God::Conditions::FooBar"
+    rmsg = nil
+    
+    begin
+      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_disk_usage.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestConditionsDiskUsage < Test::Unit::TestCase
+  # valid?
+  
+  def test_valid_should_return_false_if_no_above_given
+    c = Conditions::DiskUsage.new
+    c.mount_point = '/'
+    c.watch = stub(:name => 'foo')
+    
+    no_stdout do
+      assert_equal false, c.valid?
+    end
+  end
+  
+  def test_valid_should_return_false_if_no_mount_point_given
+    c = Conditions::DiskUsage.new
+    c.above = 90
+    c.watch = stub(:name => 'foo')
+    
+    no_stdout do
+      assert_equal false, c.valid?
+    end
+  end
+  
+  def test_valid_should_return_true_if_required_options_all_set
+    c = Conditions::DiskUsage.new
+    c.above = 90
+    c.mount_point = '/'
+    c.watch = stub(:name => 'foo')
+    
+    assert_equal true, c.valid?
+  end
+  
+  # test
+  
+  def test_test_should_return_true_if_above_limit
+    c = Conditions::DiskUsage.new
+    c.above = 90
+    c.mount_point = '/'
+    
+    c.expects(:`).returns('91')
+    
+    assert_equal true, c.test
+  end
+  
+  def test_test_should_return_false_if_below_limit
+    c = Conditions::DiskUsage.new
+    c.above = 90
+    c.mount_point = '/'
+    
+    c.expects(:`).returns('90')
+    
+    assert_equal false, c.test
+  end
+end

data/test/test_conditions_http_response_code.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestHttpResponseCode < Test::Unit::TestCase
+  def valid_condition
+    c = Conditions::HttpResponseCode.new()
+    c.watch = stub(:name => 'foo')
+    c.host = 'localhost'
+    c.port = 8080
+    c.path = '/'
+    c.timeout = 10
+    c.code_is = 200
+    c.times = 1
+    yield(c) if block_given?
+    c.prepare
+    c
+  end
+  
+  # valid?
+  
+  def test_valid_condition_is_valid
+    c = valid_condition
+    assert c.valid?
+  end
+  
+  def test_valid_should_return_false_if_both_code_is_and_code_is_not_are_set
+    c = valid_condition do |cc|
+      cc.code_is_not = 500
+    end
+    no_stdout { assert !c.valid? }
+  end
+  
+  def test_valid_should_return_false_if_no_host_set
+    c = valid_condition do |cc|
+      cc.host = nil
+    end
+    no_stdout { assert !c.valid? }
+  end
+  
+  # test
+  
+  def test_test_should_return_false_if_code_is_is_set_to_200_but_response_is_500
+    c = valid_condition
+    Net::HTTP.expects(:start).yields(stub(:read_timeout= => nil, :get => stub(:code => 500)))
+    assert_equal false, c.test
+  end
+  
+  def test_test_should_return_false_if_code_is_not_is_set_to_200_and_response_is_200
+    c = valid_condition do |cc|
+      cc.code_is = nil
+      cc.code_is_not = [200]
+    end
+    Net::HTTP.expects(:start).yields(stub(:read_timeout= => nil, :get => stub(:code => 200)))
+    assert_equal false, c.test
+  end
+  
+  def test_test_should_return_true_if_code_is_is_set_to_200_and_response_is_200
+    c = valid_condition
+    Net::HTTP.expects(:start).yields(stub(:read_timeout= => nil, :get => stub(:code => 200)))
+    assert_equal true, c.test
+  end
+  
+  def test_test_should_return_false_if_code_is_not_is_set_to_200_but_response_is_500
+    c = valid_condition do |cc|
+      cc.code_is = nil
+      cc.code_is_not = [200]
+    end
+    Net::HTTP.expects(:start).yields(stub(:read_timeout= => nil, :get => stub(:code => 500)))
+    assert_equal true, c.test
+  end
+  
+  def test_test_should_return_false_if_code_is_is_set_to_200_but_response_times_out
+    c = valid_condition
+    Net::HTTP.expects(:start).raises(Timeout::Error, '')
+    assert_equal false, c.test
+  end
+  
+  def test_test_should_return_true_if_code_is_not_is_set_to_200_and_response_times_out
+    c = valid_condition do |cc|
+      cc.code_is = nil
+      cc.code_is_not = [200]
+    end
+    Net::HTTP.expects(:start).raises(Timeout::Error, '')
+    assert_equal true, c.test
+  end
+  
+  def test_test_should_return_false_if_code_is_is_set_to_200_but_cant_connect
+    c = valid_condition
+    Net::HTTP.expects(:start).raises(Errno::ECONNREFUSED, '')
+    assert_equal false, c.test
+  end
+  
+  def test_test_should_return_true_if_code_is_not_is_set_to_200_and_cant_connect
+    c = valid_condition do |cc|
+      cc.code_is = nil
+      cc.code_is_not = [200]
+    end
+    Net::HTTP.expects(:start).raises(Errno::ECONNREFUSED, '')
+    assert_equal true, c.test
+  end
+  
+  def test_test_should_return_true_if_code_is_is_set_to_200_and_response_is_200_twice_for_times_two_of_two
+    c = valid_condition do |cc|
+      cc.times = [2, 2]
+    end
+    Net::HTTP.expects(:start).yields(stub(:read_timeout= => nil, :get => stub(:code => 200))).times(2)
+    assert_equal false, c.test
+    assert_equal true, c.test
+  end
+end

data/test/test_conditions_process_running.rb

@@ -0,0 +1,44 @@
+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 => 123, :name => 'foo'))
+    
+      # no_stdout do
+        assert_equal !r, c.test
+      # end
+    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 => 123))
+      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 => 123))
+      File.stubs(:read).returns('5')
+      System::Process.any_instance.stubs(:exists?).returns(true)
+    
+      assert_equal r, c.test
+    end
+  end
+end

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')
+    no_stdout { 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