flapjack 0.5.1 → 0.5.3

data/spec/inifile_spec.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby 
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'flapjack', 'inifile')
+require File.join(File.dirname(__FILE__), 'helpers')
+
+describe "inifile reader" do 
+
+  it "should turn sections into keys" do 
+    example = "[forks]\nhello = world\n[spoons]\nfoo = bar\n[splades]\nbar = baz"
+    ini = Flapjack::Inifile.new(example)
+    ini.keys.sort.should == %w{forks splades spoons}
+  end
+
+  it "should nest parameters under a section" do
+    example = "[forks]\nhello = world\n[spoons]\nfoo = bar\n[splades]\nbar = baz"
+    ini = Flapjack::Inifile.new(example)
+    ini['forks']['hello'].should == "world"
+    ini['spoons']['foo'].should == "bar"
+    ini['splades']['bar'].should == "baz"
+  end
+
+  it "should read a file" do 
+    filename = File.join(File.dirname(__FILE__), 'simple.ini')
+    ini = Flapjack::Inifile.read(filename)
+    ini['forks']['hello'].should == "world"
+    ini['spoons']['foo'].should == "bar"
+    ini['splades']['bar'].should == "baz"
+  end
+
+  it "should ignore commented lines" do 
+    example = "[forks]\nhello = world\n[spoons]\nfoo = bar\n# comment goes here\n[splades]\nbar = baz"
+    ini = Flapjack::Inifile.new(example)
+    ini['spoons'].keys.include?(/#/).should be_false
+    ini['spoons'].keys.include?(/comment goes here/).should be_false
+    ini['spoons'].values.include?(/#/).should be_false
+    ini['spoons'].values.include?(/comment goes here/).should be_false
+  end
+
+  it "should ignore blank lines" do 
+    example = "\n\n\n\n\n\n\n[spoons]\n\n\n\n[of]\n[doom]"
+    ini = Flapjack::Inifile.new(example)
+    ini.keys.sort.should == %w(doom of spoons)
+  end
+
+  it "should ignore mid-line comments" do 
+    example = "[forks] ; a comment \nhello = world ; another comment\n\n"
+    ini = Flapjack::Inifile.new(example)
+    ini.keys.include?("forks").should be_true
+    ini['forks']['hello'].should == 'world'
+  end
+
+  it "should append re-opened sections" do 
+    example = "[forks]\nhello = world\n[forks]\nfoo = bar\n\n[forks]\nbar = baz"
+    ini = Flapjack::Inifile.new(example)
+    ini.keys.include?("forks").should be_true
+    ini["forks"].keys.sort.should == %w(bar foo hello)
+  end
+
+  it "should dump the raw config" do 
+    example = "[forks]\nhello = world\n[spoons]\nfoo = bar\n[splades]\nbar = baz"
+    ini = Flapjack::Inifile.new(example)
+    ini.all.size.should == 3
+  end
+
+
+end

data/spec/mock-notifiers/mock/init.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), 'mock')

data/spec/mock-notifiers/mock/mock.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'xmpp4r-simple'
+
+module Flapjack
+  module Notifiers
+    class Mock
+    
+      attr_accessor :log, :website_uri
+
+      def initialize(opts={})
+        @log = opts[:log]
+        @website_uri = opts[:website_uri]
+      end
+    
+    end
+  end
+end
+

data/spec/notifier-directories/spoons/testmailer/init.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby 
+
+module Flapjack
+  module Notifiers
+    class Testmailer
+
+      def initialize(opts={})
+        @log = opts[:log]
+      end
+
+      def notify(opts={})
+        @log.debug("TestMailer notifying #{opts[:who].name}")
+      end
+    
+    end
+  end
+end
+
+
+

data/spec/notifier_application_spec.rb

@@ -0,0 +1,222 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'flapjack', 'applications', 'notifier')
+require File.join(File.dirname(__FILE__), 'helpers')
+
+describe "notifier application" do 
+
+  # 
+  # booting interface
+  #
+
+  it "should have a simple interface to start the notifier" do 
+    options = { :notifiers => {},
+                :filters => [],
+                :log => MockLogger.new,
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+  end
+
+  it "should log when loading a notifier" do 
+    options = { :notifiers => {:testmailer => {}}, 
+                :filters => [],
+                :log => MockLogger.new,
+                :notifier_directories => [File.join(File.dirname(__FILE__),'notifier-directories', 'spoons')],
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+    app.log.messages.find {|msg| msg =~ /loading the testmailer notifier/i}.should_not be_nil
+  end
+
+  it "should warn if a specified notifier doesn't exist" do 
+    options = { :notifiers => {:nonexistant => {}}, 
+                :filters => [],
+                :log => MockLogger.new,
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+    app.log.messages.find {|msg| msg =~ /Flapjack::Notifiers::Nonexistant doesn't exist/}.should_not be_nil
+  end
+
+  it "should give precedence to notifiers in user-specified notifier directories" do 
+    options = { :notifiers => {:testmailer => {}}, 
+                :filters => [],
+                :log => MockLogger.new,
+                :notifier_directories => [File.join(File.dirname(__FILE__),'notifier-directories', 'spoons')],
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+    app.log.messages.find {|msg| msg =~ /spoons/i}.should_not be_nil
+    # this will raise an exception if the notifier directory isn't specified,
+    # as the mailer notifier requires several arguments anyhow
+  end
+
+  it "should pass global notifier config options to each notifier"
+
+  it "should setup recipients from a list" do
+    options = { :notifiers => {},
+                :filters => [],
+                :log => MockLogger.new,
+                :recipients => [{:name => "Spoons McDoom"}],
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+    # 1 passed recipient should be here
+    app.recipients.size.should == 1
+  end
+
+  #
+  # transports
+  #
+
+  it "should use beanstalkd as the default transport" do 
+    options = { :notifiers => {}, 
+                :filters => [],
+                :log => MockLogger.new,
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+    app.log.messages.find {|msg| msg =~ /loading.+beanstalkd.+transport/i}.should_not be_nil
+  end
+
+  it "should use a transport as specified in options" do 
+    options = { :notifiers => {},
+                :filters => [],
+                :log => MockLogger.new,
+                :transport => {:backend => :beanstalkd},
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+    app.log.messages.find {|msg| msg =~ /loading.+beanstalkd.+transport/i}.should_not be_nil
+  end
+
+  it "should error if the specified transport doesn't exist" do
+    options = { :notifiers => {}, 
+                :filters => [],
+                :log => MockLogger.new,
+                :transport => {:backend => :nonexistant} }
+    lambda {
+      app = Flapjack::Notifier::Application.run(options)
+      #app.log.messages.find {|msg| msg =~ /attempted to load nonexistant/i}.should_not be_nil
+    }.should raise_error
+  end
+
+  it "should use a limited interface for dealing with the results queue" do
+    
+    # Interface for a Flapjack::Transport::<transport> is as follows: 
+    # 
+    #  methods: next, delete
+    #
+
+    options = { :notifiers => {}, 
+                :filters => [],
+                :log => MockLogger.new,
+                :transport => {:backend => :mock_transport, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'transports')},
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+
+    # processes a single result
+    app.process_result
+
+    # check that allowed methods were called
+    allowed_methods = %w(next delete)
+    allowed_methods.each do |method|
+      app.log.messages.find {|msg| msg =~ /#{method.gsub(/\?/,'\?')} was called on MockTransport/i}.should_not be_nil
+    end
+
+    # check that no other methods were
+    called_methods = app.log.messages.find_all {|msg| msg =~ /^method .+ was called on MockTransport$/i }.map {|msg| msg.split(' ')[1]}
+    (allowed_methods - called_methods).size.should == 0
+  end
+
+  it "should use a limited interface for dealing with results" do
+
+    # Interface for a Flapjack::Transport::Result is as follows: 
+    # 
+    #  methods: id, warning?, critical?
+    #
+
+    options = { :notifiers => {}, 
+                :filters => ['ok'],
+                :log => MockLogger.new,
+                :transport => {:backend => :mock_transport, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'transports')},
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+
+    # processes a single result
+    app.process_result
+
+    # check that allowed methods were called
+    allowed_methods = %w(check_id warning?)
+    allowed_methods.each do |method|
+      app.log.messages.find {|msg| msg =~ /#{method.gsub(/\?/,'\?')} was called/i}.should_not be_nil
+    end
+
+    # check that no other methods were called
+    called_methods = app.log.messages.find_all {|msg| msg =~ /^method .+ was called on MockResult$/i }.map {|msg| msg.split(' ')[1]}.uniq
+    (allowed_methods - called_methods).size.should == 0
+  end
+
+  it "should use a limited interface for dealing with the persistence backend" do
+    
+    # Interface for a Flapjack::Persistence::<backend> is as follows: 
+    # 
+    #  methods: any_parents_failed?, save
+    #
+
+    options = { :notifiers => {}, 
+                :filters => ['any_parents_failed'],
+                :log => MockLogger.new,
+                :transport => {:backend => :mock_transport, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'transports')},
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+
+    # processes a single result
+    app.process_result
+
+    # check that allowed methods were called
+    allowed_methods = %w(any_parents_failed? save)
+    allowed_methods.each do |method|
+      app.log.messages.find {|msg| msg =~ /#{method.gsub(/\?/,'\?')} was called/i}.should_not be_nil
+    end
+
+    # check that no other methods were called
+    called_methods = app.log.messages.find_all {|msg| msg =~ /^method .+ was called on MockPersistenceBackend$/i }.map {|msg| msg.split(' ')[1]}
+    (allowed_methods - called_methods).size.should == 0
+  end
+
+
+  #
+  # persistence backend
+  #
+
+  it "should load couchdb as the default persistence backend"
+
+  it "should load a persistence backend as specified in options" do 
+    options = { :notifiers => {},
+                :filters => [],
+                :log => MockLogger.new,
+                :persistence => {:backend => :mock_persistence_backend, 
+                                   :basedir => File.join(File.dirname(__FILE__), 'persistence')} }
+    app = Flapjack::Notifier::Application.run(options)
+    app.log.messages.find {|msg| msg =~ /loading.+MockPersistenceBackend.+backend/i}.should_not be_nil
+  end
+
+  it "should raise if the specified persistence backend doesn't exist" do
+    options = { :notifiers => {}, 
+                :filters => [],
+                :log => MockLogger.new,
+                :persistence => {:backend => :nonexistant} }
+    lambda {
+      app = Flapjack::Notifier::Application.run(options)
+    }.should raise_error(LoadError)
+  end
+
+end
+
+def puts(*args) ; end

data/spec/notifier_filters_spec.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'flapjack', 'applications', 'notifier')
+require File.join(File.dirname(__FILE__), '..', 'lib', 'flapjack', 'transports', 'result')
+require File.join(File.dirname(__FILE__), 'helpers')
+
+describe "running the notifier" do 
+  
+  before(:all) do 
+    @options = { :notifiers => {:testmailer => {}},
+                 :notifier_directories => [File.join(File.dirname(__FILE__),'notifier-directories', 'spoons')],
+                 :recipients => [{:name => "Spoons McDoom"}],
+                 :transport => {:backend => :mock_transport, 
+                                :basedir => File.join(File.dirname(__FILE__), 'transports')},
+                 :persistence => {:backend => :mock_persistence_backend, 
+                                  :basedir => File.join(File.dirname(__FILE__), 'persistence')},
+                 :filter_directories => [File.join(File.dirname(__FILE__),'test-filters')]
+               }
+  end
+
+  it "should notify by default" do 
+    @options[:filters] = []
+    @options[:log] = MockLogger.new
+
+    app = Flapjack::Notifier::Application.run(@options)
+    # processes a MockResult, as defined in spec/transports/mock_transport.rb
+    app.process_result
+
+    app.log.messages.find {|m| m =~ /testmailer notifying/i}.should be_true
+  end
+
+  it "should not notify if any filters fail" do 
+    @options[:filters] = ['blocker']
+    @options[:log] = MockLogger.new
+    
+    app = Flapjack::Notifier::Application.run(@options)
+    # processes a MockResult, as defined in spec/transports/mock_transport.rb
+    app.process_result
+
+    app.log.messages.find {|m| m =~ /testmailer notifying/i}.should be_nil
+  end
+
+  it "should notify if all filters pass" do
+    @options[:filters] = ['mock']
+    @options[:log] = MockLogger.new
+
+    app = Flapjack::Notifier::Application.run(@options)
+    # processes a MockResult, as defined in spec/transports/mock_transport.rb
+    app.process_result
+
+    app.log.messages.find {|m| m =~ /testmailer notifying/i}.should be_true
+  end
+
+end

data/spec/notifier_options_multiplexer_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'flapjack', 'cli', 'notifier')
+require File.join(File.dirname(__FILE__), '..', 'lib', 'flapjack', 'patches')
+
+
+describe "notifier options multiplexer" do 
+
+  before(:all) do
+    @config_filename     = File.join(File.dirname(__FILE__), 'configs', 'flapjack-notifier.ini')
+    @recipients_filename = File.join(File.dirname(__FILE__), 'configs', 'recipients.ini')
+    
+    @couchdb_config_filename = File.join(File.dirname(__FILE__), 'configs', 'flapjack-notifier-couchdb.ini')
+  end
+
+  it "should setup notifier options from specified config file" do 
+    args = ["-c", @config_filename, "-r", @recipients_filename]
+    config = Flapjack::Notifier::Options.parse(args)
+    config.notifiers.each do |key, value|
+      %w(mailer xmpp).include?(key)
+    end
+
+    config.notifier_directories.each do |dir|
+      %w(/usr/lib/flapjack/notifiers/ /path/to/my/notifiers).include?(dir)
+    end
+  end
+
+  it "should setup beanstalkd transport options from specified config file" do 
+    args = ["-c", @config_filename, "-r", @recipients_filename]
+    config = Flapjack::Notifier::Options.parse(args)
+    config.transport[:backend].should == "beanstalkd"
+    config.transport[:host].should == "localhost"
+    config.transport[:port].should == "11300"
+  end
+
+  it "should setup datamapper persistence options from specified config file" do 
+    args = ["-c", @config_filename, "-r", @recipients_filename]
+    config = Flapjack::Notifier::Options.parse(args)
+    config.persistence[:backend].should == "data_mapper"
+    config.persistence[:uri].should == "sqlite3:///tmp/flapjack.db"
+  end
+
+  it "should setup couchdb persistence backend from specified config file" do 
+    args = [ "-c", @couchdb_config_filename, "-r", @recipients_filename ]
+    config = Flapjack::Notifier::Options.parse(args)
+    config.persistence[:backend].should == "couchdb"
+    config.persistence[:host].should == "localhost"
+    config.persistence[:port].should == "5984"
+    config.persistence[:version].should == "0.8"
+    config.persistence[:database].should == "flapjack_production"
+  end
+
+  it "should setup individual notifiers from a specified config file" do 
+    args = [ "-c", @config_filename, "-r", @recipients_filename ]
+    config = Flapjack::Notifier::Options.parse(args)
+    config.notifiers.size.should > 0
+  end
+  
+  it "should setup notifier directories options from a specified config file" do 
+    args = [ "-c", @config_filename, "-r", @recipients_filename ]
+    config = Flapjack::Notifier::Options.parse(args)
+    config.notifier_directories.size.should > 0
+  end
+
+  it "should setup recipients from a specified config file" do 
+    args = [ "-c", @config_filename, "-r", @recipients_filename ]
+    config = Flapjack::Notifier::Options.parse(args)
+    config.recipients.size.should > 0
+  end
+
+end
+
+