resurrected_god 0.14.0

data/test/configs/task/task.god

@@ -0,0 +1,26 @@
+LOG_DIR = File.join(File.dirname(__FILE__), *%w[logs])
+
+God.task do |t|
+  t.name = 'task'
+  t.valid_states = [:ok, :clean]
+  t.initial_state = :ok
+  t.interval = 5
+
+  # t.clean = lambda do
+  #   Dir[File.join(LOG_DIR, '*.log')].each do |f|
+  #     File.delete(f)
+  #   end
+  # end
+
+  t.clean = "rm #{File.join(LOG_DIR, '*.log')}"
+
+  t.transition(:clean, :ok)
+
+  t.transition(:ok, :clean) do |on|
+    on.condition(:lambda) do |c|
+      c.lambda = lambda do
+        Dir[File.join(LOG_DIR, '*.log')].size > 1
+      end
+    end
+  end
+end

data/test/configs/test.rb

@@ -0,0 +1,61 @@
+ENV['GOD_TEST_RAILS_ROOT'] || abort("Set a rails root for testing in an environment variable called GOD_TEST_RAILS_ROOT")
+
+RAILS_ROOT = ENV['GOD_TEST_RAILS_ROOT']
+
+port = 5000
+
+God.watch do |w|
+  w.name = "local-#{port}"
+  w.interval = 5.seconds
+  w.start = "mongrel_rails start -P ./log/mongrel.pid -c #{RAILS_ROOT} -p #{port} -d"
+  w.restart = "mongrel_rails restart -P ./log/mongrel.pid -c #{RAILS_ROOT}"
+  w.stop = "mongrel_rails stop -P ./log/mongrel.pid -c #{RAILS_ROOT}"
+  w.group = 'mongrels'
+  w.pid_file = File.join(RAILS_ROOT, "log/mongrel.pid")
+
+  # clean pid files before start if necessary
+  w.behavior(:clean_pid_file)
+
+  # determine the state on startup
+  w.transition(:init, { true => :up, false => :start }) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+  end
+
+  # determine when process has finished starting
+  w.transition([:start, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+  end
+
+  # start if process is not running
+  w.transition(:up, :start) do |on|
+    on.condition(:process_exits)
+  end
+
+  # restart if memory or cpu is too high
+  w.transition(:up, :restart) do |on|
+    on.condition(:memory_usage) do |c|
+      c.interval = 1
+      c.above = 50.megabytes
+      c.times = [3, 5]
+    end
+
+    on.condition(:cpu_usage) do |c|
+      c.interval = 1
+      c.above = 10.percent
+      c.times = [3, 5]
+    end
+
+    on.condition(:http_response_code) do |c|
+      c.host = 'localhost'
+      c.port = port
+      c.path = '/'
+      c.code_is_not = 200
+      c.timeout = 10.seconds
+      c.times = [3, 5]
+    end
+  end
+end

data/test/configs/usr1_trapper.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+
+Signal.trap 'USR1' do
+  puts "can't stop won't stop"
+end
+
+loop do
+  puts 'server'
+  sleep 1
+end

data/test/helper.rb

@@ -0,0 +1,172 @@
+$:.unshift File.expand_path('../../lib', __FILE__) # For use/testing when no gem is installed
+
+# Use this flag to actually load all of the god infrastructure
+$load_god = true
+
+require File.join(File.dirname(__FILE__), *%w[.. lib god sys_logger])
+require File.join(File.dirname(__FILE__), *%w[.. lib god])
+God::EventHandler.load
+
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'set'
+
+include God
+
+if Process.uid != 0 and RbConfig::CONFIG['host_os'] == "linux"
+  abort <<-EOF
+\n
+*********************************************************************
+*                                                                   *
+*               You need to run these tests as root                 *
+*           chroot and netlink (linux only) require it              *
+*                                                                   *
+*********************************************************************
+EOF
+end
+
+begin
+  require 'mocha/setup'
+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
+
+LOG.instance_variable_set(:@io, StringIO.new())
+
+def output_logs
+  io = LOG.instance_variable_get(:@io)
+  LOG.instance_variable_set(:@io, $stderr)
+  yield
+ensure
+  LOG.instance_variable_set(:@io, io)
+end
+
+# module Kernel
+#   def abort(text)
+#     raise SystemExit, text
+#   end
+#   def exit(code)
+#     raise SystemExit, "Exit code: #{code}"
+#   end
+# end
+
+module Minitest::Assertions
+  def assert_abort
+    assert_raises SystemExit do
+      yield
+    end
+  end
+
+  def assert_nothing_raised
+    yield
+  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 =~ /^(__|object_id)/
+    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
+
+# Make sure we return valid exit codes
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION >= "1.9"
+  module Kernel
+    alias :__at_exit :at_exit
+    def at_exit(&block)
+      __at_exit do
+        exit_status = $!.status if $!.is_a?(SystemExit)
+        block.call
+        exit exit_status if exit_status
+      end
+    end
+  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_airbrake.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/helper'
+
+class TestAirbrake < Minitest::Test
+  def test_notify
+    airbrake = God::Contacts::Airbrake.new
+    airbrake.apikey = "put_your_apikey_here"
+    airbrake.name = "Airbrake"
+
+    Airbrake.expects(:notify).returns "123"
+
+    airbrake.notify("Test message for airbrake", Time.now, "airbrake priority", "airbrake category", "")
+  end
+end

data/test/test_behavior.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestBehavior < Minitest::Test
+  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_raises NoSuchBehaviorError do
+      Behavior.generate(:foo, nil)
+    end
+  end
+
+  def test_complain
+    SysLogger.expects(:log).with(:error, 'foo')
+    assert !Behavior.allocate.bypass.complain('foo')
+  end
+end

data/test/test_campfire.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestCampfire < Minitest::Test
+  def setup
+    @campfire = God::Contacts::Campfire.new
+  end
+
+  def test_exists
+    God::Contacts::Campfire
+  end
+
+  def test_notify
+    @campfire.subdomain = 'github'
+    @campfire.token = 'abc'
+    @campfire.room = 'danger'
+
+    time = Time.now
+    body = "[#{time.strftime('%H:%M:%S')}] host - msg"
+    Marshmallow::Connection.any_instance.expects(:speak).with('danger', body)
+    @campfire.notify('msg', time, 'prio', 'cat', 'host')
+  end
+end

data/test/test_condition.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/helper'
+
+class BadlyImplementedCondition < PollCondition
+end
+
+class TestCondition < Minitest::Test
+
+  # 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_raises 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
+  ensure
+    God::EventHandler.stop
+  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_raises AbstractMethodNotOverriddenError do
+      c.test
+    end
+  end
+end

data/test/test_conditions_disk_usage.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestConditionsDiskUsage < Minitest::Test
+  # valid?
+
+  def test_valid_should_return_false_if_no_above_given
+    c = Conditions::DiskUsage.new
+    c.mount_point = '/'
+    c.watch = stub(:name => 'foo')
+    assert_equal false, c.valid?
+  end
+
+  def test_valid_should_return_false_if_no_mount_point_given
+    c = Conditions::DiskUsage.new
+    c.above = 90
+    c.watch = stub(:name => 'foo')
+    assert_equal false, c.valid?
+  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 < Minitest::Test
+  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
+    assert !c.valid?
+  end
+
+  def test_valid_should_return_false_if_no_host_set
+    c = valid_condition do |cc|
+      cc.host = nil
+    end
+    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.any_instance.expects(:start).yields(mock(:read_timeout= => nil, :get => mock(: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.any_instance.expects(:start).yields(mock(:read_timeout= => nil, :get => mock(: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.any_instance.expects(:start).yields(mock(:read_timeout= => nil, :get => mock(: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.any_instance.expects(:start).yields(mock(:read_timeout= => nil, :get => mock(: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.any_instance.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.any_instance.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.any_instance.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.any_instance.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.any_instance.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,40 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestConditionsProcessRunning < Minitest::Test
+  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 => 99999999, :name => 'foo'))
+      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 => 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