monitr 0.0.1

data/test/test_contact.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestContact < Test::Unit::TestCase
+  def test_exists
+    Monitr::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,45 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestEmail < Test::Unit::TestCase
+  def test_exists
+    Monitr::Contacts::Email
+  end
+
+  def test_unknown_delivery_method_for_notify
+    assert_nothing_raised do
+      Monitr::Contacts::Email.any_instance.expects(:notify_smtp).never
+      Monitr::Contacts::Email.any_instance.expects(:notify_sendmail).never
+      Monitr::Contacts::Email.delivery_method = :foo_protocol
+      LOG.expects(:log).times(2)
+ 
+      g = Monitr::Contacts::Email.new
+      g.notify(:a, :b, :c, :d, :e)
+      assert_nil g.info
+    end
+  end
+
+  def test_smtp_delivery_method_for_notify
+    assert_nothing_raised do
+      Monitr::Contacts::Email.any_instance.expects(:notify_sendmail).never
+      Monitr::Contacts::Email.any_instance.expects(:notify_smtp).once.returns(nil)
+      Monitr::Contacts::Email.delivery_method = :smtp
+      g = Monitr::Contacts::Email.new
+      g.email = 'joe@example.com'
+      g.notify(:a, :b, :c, :d, :e)
+      assert_equal "sent email to joe@example.com", g.info
+    end
+  end
+  
+  def test_sendmail_delivery_method_for_notify
+    assert_nothing_raised do
+      Monitr::Contacts::Email.any_instance.expects(:notify_smtp).never
+      Monitr::Contacts::Email.any_instance.expects(:notify_sendmail).once.returns(nil)
+      Monitr::Contacts::Email.delivery_method = :sendmail
+      g = Monitr::Contacts::Email.new
+      g.email = 'joe@example.com'
+      g.notify(:a, :b, :c, :d, :e)
+      assert_equal "sent email to joe@example.com", g.info
+    end
+  end
+  
+end

data/test/test_event_handler.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/helper'
+
+module Monitr
+  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 = Monitr::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
+    Monitr::EventHandler.start
+    assert Monitr::EventHandler.loaded?
+  end
+end

data/test/test_handlers_kqueue_handler.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/helper'
+
+if Monitr::EventHandler.event_system == "kqueue"
+  
+  class TestHandlersKqueueHandler < Test::Unit::TestCase
+    def test_register_process
+      KQueueHandler.expects(:monitor_process).with(1234, 2147483648)
+      KQueueHandler.register_process(1234, [:proc_exit])
+    end
+  
+    def test_events_mask
+      assert_equal 2147483648, KQueueHandler.events_mask([:proc_exit])
+    end
+  end
+  
+end

data/test/test_logger.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestLogger < Test::Unit::TestCase
+  def setup
+    @log = Monitr::Logger.new
+  end
+  
+  # log
+  
+  def test_log
+    @log.expects(:info).with("qux")
+    
+    no_stdout do
+      @log.log(stub(:name => 'foo'), :info, "qux")
+    end
+    
+    assert_equal 1, @log.logs.size
+    assert_instance_of Time, @log.logs['foo'][0][0]
+    assert_match(/qux/, @log.logs['foo'][0][1])
+  end
+  
+  def test_log_should_send_to_syslog
+    Syslog.expects(:crit).with('foo')
+    
+    no_stdout do
+      @log.log(stub(:name => 'foo'), :fatal, "foo")
+    end
+  end
+  
+  # watch_log_since
+  
+  def test_watch_log_since
+    t1 = Time.now
+    
+    no_stdout do
+      @log.log(stub(:name => 'foo'), :info, "one")
+      @log.log(stub(:name => 'foo'), :info, "two")
+    end
+    
+    assert_match(/one.*two/m, @log.watch_log_since('foo', t1))
+    
+    t2 = Time.now
+    
+    no_stdout do
+      @log.log(stub(:name => 'foo'), :info, "three")
+    end
+    
+    out = @log.watch_log_since('foo', t2)
+    
+    assert_no_match(/one/, out)
+    assert_no_match(/two/, out)
+    assert_match(/three/, out)
+  end
+  
+  # regular methods
+  
+  def test_fatal
+    no_stdout do
+      @log.fatal('foo')
+    end
+    assert_equal 0, @log.logs.size
+  end
+end

data/test/test_metric.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestMetric < Test::Unit::TestCase
+  def setup
+    @metric = Metric.new(stub(:interval => 10), nil)
+  end
+  
+  # watch
+  
+  def test_watch
+    w = stub()
+    m = Metric.new(w, nil)
+    assert_equal w, m.watch
+  end
+  
+  # destination
+  
+  def test_destination
+    d = stub()
+    m = Metric.new(nil, d)
+    assert_equal d, m.destination
+  end
+  
+  # condition
+  
+  def test_condition_should_be_block_optional
+    @metric.condition(:fake_poll_condition)
+    assert_equal 1, @metric.conditions.size
+  end
+  
+  def test_poll_condition_should_inherit_interval_from_watch_if_not_specified
+    @metric.condition(:fake_poll_condition)
+    assert_equal 10, @metric.conditions.first.interval
+  end
+  
+  def test_poll_condition_should_abort_if_no_interval_and_no_watch_interval
+    metric = Metric.new(stub(:name => 'foo', :interval => nil), nil)
+    
+    assert_abort do
+      metric.condition(:fake_poll_condition)
+    end
+  end
+  
+  def test_condition_should_allow_generation_of_subclasses_of_poll_or_event
+    metric = Metric.new(stub(:name => 'foo', :interval => 10), nil)
+    
+    assert_nothing_raised do
+      metric.condition(:fake_poll_condition)
+      metric.condition(:fake_event_condition)
+    end
+  end
+  
+  def test_condition_should_abort_if_not_subclass_of_poll_or_event
+    metric = Metric.new(stub(:name => 'foo', :interval => 10), nil)
+    
+    assert_abort do
+      metric.condition(:fake_condition) { |c| }
+    end
+  end
+  
+  def test_condition_should_abort_on_invalid_condition
+    assert_abort do
+      @metric.condition(:fake_poll_condition) { |c| c.stubs(:valid?).returns(false) }
+    end
+  end
+  
+  def test_condition_should_abort_on_no_such_condition
+    assert_abort do
+      @metric.condition(:invalid) { }
+    end
+  end
+end