flapjack 0.6.43 → 0.6.44

data/spec.old/notifier_spec.rb

@@ -1,57 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'lib', 'flapjack', 'notifier_engine')
-require File.join(File.dirname(__FILE__), '..', 'lib', 'flapjack', 'transports', 'result')
-require File.join(File.dirname(__FILE__), 'helpers')
-
-describe "running the notifier" do 
- 
-  before(:each) do 
-  end
- 
-  it "should complain if no logger has been specified" do 
-    lambda {
-      n = Flapjack::NotifierEngine.new
-    }.should raise_error(RuntimeError)
-  end
-  
-  it "should warn if no notifiers have been specified" do 
-    n = Flapjack::NotifierEngine.new(:log => MockLogger.new)
-    n.log.messages.last.should =~ /no notifiers/
-  end
-
-  it "should log when adding a new notifier" do
-    mock_notifier = mock("MockFlapjack::NotifierEngine")
-    n = Flapjack::NotifierEngine.new(:log => MockLogger.new, 
-                     :notifiers => [mock_notifier])
-    n.log.messages.last.should =~ /using the (.+) notifier/
-  end
-
-  it "should call notify on each notifier when notifying" do 
-    mock_notifier = mock("MockFlapjack::NotifierEngine")
-    mock_notifier.should_receive(:notify)
-
-    result = Flapjack::Transport::Result.new(:result => {:check_id => 12345})
-
-    n = Flapjack::NotifierEngine.new(:log => MockLogger.new, 
-                                     :notifiers => [mock_notifier])
-    n.notify!(:result => result, 
-              :event => true, 
-              :recipients => [OpenStruct.new({:name => "John Doe"})])
-  end
-
-  it "should log notification on each notifier" do 
-    mock_notifier = mock("MockFlapjack::NotifierEngine")
-    mock_notifier.stub!(:notify)
-
-    result = Flapjack::Transport::Result.new(:result => {:check_id => 12345})
-
-    n = Flapjack::NotifierEngine.new(:log => MockLogger.new, 
-                                     :notifiers => [mock_notifier])
-    n.notify!(:result => result, 
-              :event => true,
-              :recipients => [OpenStruct.new({:name => "John Doe"})])
-    n.log.messages.last.should =~ /12345/
-    n.log.messages.last.should =~ /John Doe/
-  end
-end
-
-

data/spec.old/notifiers/mailer_spec.rb

@@ -1,36 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'flapjack', 'notifiers', 'mailer', 'init')
-require File.join(File.dirname(__FILE__), '..', 'helpers')
-
-describe "mailing notifier" do 
-
-  it "should error if no from address is provided" do 
-    lambda {
-      mailer = Flapjack::Notifiers::Mailer.new(:log => MockLogger.new)
-    }.should raise_error(ArgumentError, /from address/)
-  end
-
-  it "should error if no recipient is provided" do
-    mailer = Flapjack::Notifiers::Mailer.new(:from_address => "test@example.org")
-    lambda {
-      mailer.notify()
-    }.should raise_error(ArgumentError, /recipient/)
-  end
-
-  it "should error if no result is provided" do
-    mailer = Flapjack::Notifiers::Mailer.new(:from_address => "test@example.org")
-    lambda {
-      mailer.notify(:who => 'foo')
-    }.should raise_error(ArgumentError, /result/)
-  end
-
-  it "should deliver mail to a recipient" do 
-    mailer = Flapjack::Notifiers::Mailer.new(:from_address => "test@example.org")
-    response = mailer.notify(:who => OpenStruct.new(:email => "nobody@example.org"), 
-                             :result => OpenStruct.new(:id => 11, :status => 2, :output => "foo"))
-    response.status.should == '250'
-  end
-
-  it "should have a configurable server to send through"
-end
-
-

data/spec.old/notifiers/xmpp_spec.rb

@@ -1,36 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'flapjack', 'notifiers', 'xmpp', 'init')
-require File.join(File.dirname(__FILE__), '..', 'helpers')
-
-describe "xmpp notifier" do 
-
-  it "should error if no login details provided" do 
-    lambda {
-      xmpp = Flapjack::Notifiers::Xmpp.new
-    }.should raise_error(ArgumentError)
-  end
-
-  it "should error if no recipient is provided" do
-    xmpp = Flapjack::Notifiers::Xmpp.new(:jid => "5b73a016c5c644e9bf1601a241fc27f5@jabber.org", :password => "5b73a016c5c644e9bf1601a241fc27f5")
-    lambda {
-      xmpp.notify(:result => 'foo')
-    }.should raise_error(ArgumentError, /recipient/)
-  end
-
-  it "should error if no result is provided" do
-    xmpp = Flapjack::Notifiers::Xmpp.new(:jid => "5b73a016c5c644e9bf1601a241fc27f5@jabber.org", :password => "5b73a016c5c644e9bf1601a241fc27f5")
-    lambda {
-      xmpp.notify(:who => 'foo')
-    }.should raise_error(ArgumentError, /result/)
-  end
-
-  it "should deliver message to a recipient" do 
-    xmpp = Flapjack::Notifiers::Xmpp.new(:jid => "5b73a016c5c644e9bf1601a241fc27f5@jabber.org", :password => "5b73a016c5c644e9bf1601a241fc27f5")
-    lambda {
-      response = xmpp.notify(:who => OpenStruct.new(:jid => "5b73a016c5c644e9bf1601a241fc27f5@jabber.org"), 
-                             :result => OpenStruct.new(:id => 11, :status => 2, :output => "foo"))
-    }.should_not raise_error
-  end
-
-end
-
-

data/spec.old/persistence/datamapper_spec.rb

@@ -1,74 +0,0 @@
-#!/usr/bin/env ruby 
-
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'flapjack', 'applications', 'notifier')
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'flapjack', 'persistence', 'data_mapper')
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'flapjack', 'transports', 'result')
-require File.join(File.dirname(__FILE__), '..', 'helpers')
-require 'tmpdir'
-
-describe "datamapper persistence backend" do 
-
-  it "should query its parent's statuses" do
-    backend_options = { :uri => "sqlite3://#{Dir.mktmpdir}/flapjack.db", :log => MockLogger.new }
-    DataMapper.setup(:default, backend_options[:uri])
-    DataMapper.auto_migrate!
-
-    bad = Check.new(:command => "exit 1", :name => "bad")
-    bad.save.should be_true
-
-    good = Check.new(:command => "exit 0", :name => "good")
-    good.save.should be_true
-
-    relation = RelatedCheck.new(:parent_check => bad, :child_check => good)
-    relation.save.should be_true
-
-    # the bad check doesn't have failing parents
-    raw_result = {:check_id => bad.id, :retval => 2}
-    result = Flapjack::Transport::Result.new(:result => raw_result)
-
-    backend = Flapjack::Persistence::DataMapper.new(backend_options)
-    backend.any_parents_failed?(result).should be_false
-
-    bad.status = 2
-    bad.save
-    
-    # the good check has a failing parent (bad)
-    raw_result = {:check_id => good.id, :retval => 0}
-    result = Flapjack::Transport::Result.new(:result => raw_result)
-    backend.any_parents_failed?(result).should be_true
-  end
-
-  it "should persist a result" do 
-    backend_options = { :uri => "sqlite3://#{Dir.mktmpdir}/flapjack.db", :log => MockLogger.new }
-    DataMapper.setup(:default, backend_options[:uri])
-    DataMapper.auto_migrate!
-    
-    backend = Flapjack::Persistence::DataMapper.new(backend_options)
-
-    check = Check.new(:command => "exit 0", :name => "good")
-    check.save.should be_true
-
-    raw_result = {:check_id => check.id, :retval => 2}
-    result = Flapjack::Transport::Result.new(:result => raw_result)
-
-    backend.save(result).should be_true
-  end
-
-  it "should create an event" do 
-    backend_options = { :uri => "sqlite3://#{Dir.mktmpdir}/flapjack.db", :log => MockLogger.new }
-    DataMapper.setup(:default, backend_options[:uri])
-    DataMapper.auto_migrate!
-    
-    backend = Flapjack::Persistence::DataMapper.new(backend_options)
-
-    check = Check.new(:command => "exit 0", :name => "good")
-    check.save.should be_true
-
-    raw_result = {:check_id => check.id, :retval => 2}
-    result = Flapjack::Transport::Result.new(:result => raw_result)
-
-    backend.create_event(result).should be_true
-  end
-
-end
-

data/spec.old/persistence/mock_persistence_backend.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby 
-
-
-module Flapjack
-  module Persistence
-    class MockPersistenceBackend
-      def initialize(options={})
-        @options = options
-        @config = OpenStruct.new(@options)
-        @queue = []
-        @log = @config.log
-      end
-
-      # log if the method is called (essentially, these are dodgy mocks)
-      %w(any_parents_failed? save create_event).each do |method|
-        class_eval <<-HERE
-          def #{method}(*args)
-            @log.info("method #{method} was called on MockPersistenceBackend")
-          end
-        HERE
-      end
-    
-    end
-  end
-end
-

data/spec.old/simple.ini

@@ -1,6 +0,0 @@
-[forks]
-hello = world
-[spoons]
-foo = bar
-[splades]
-bar = baz

data/spec.old/spec.opts

@@ -1,4 +0,0 @@
---color
---format
-progress
---diff

data/spec.old/test-filters/blocker.rb

@@ -1,13 +0,0 @@
-module Flapjack
-  module Filters
-    class Blocker
-      def initialize(opts={})
-        @log = opts[:log]
-      end
-
-      def block?(result)
-        true
-      end
-    end
-  end
-end

data/spec.old/test-filters/mock.rb

@@ -1,13 +0,0 @@
-module Flapjack
-  module Filters
-    class Mock
-      def initialize(opts={})
-        @log = opts[:log]
-      end
-
-      def block?(result)
-        false
-      end
-    end
-  end
-end

data/spec.old/transports/beanstalkd_spec.rb

@@ -1,44 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'flapjack', 'applications', 'notifier')
-require File.join(File.dirname(__FILE__), '..', 'helpers')
-require 'beanstalk-client'
-
-describe "notifier application" do 
-
-  before(:each) do
-    lambda {
-      begin
-        @beanstalk = Beanstalk::Connection.new('localhost:11300', 'results')
-      rescue => e
-        # give helpful error messages to people unfamiliar with the test suite
-        puts
-        puts "You need to have an instance of beanstalkd running locally to run these tests!"
-        puts
-        raise
-      end
-    }.should_not raise_error
-  end
-
-  it "should handle good, bad, and ugly test result" do 
-    [ {:output => "", :id => 1, :retval => 0},
-      {:output => "", :id => 2, :retval => 1},
-      {:output => "", :id => 3, :retval => 2} ].each do |result|
-      @beanstalk.yput(result)
-    end
-
-    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)
-
-    3.times do |n|
-      lambda {
-        app.process_result
-      }.should_not raise_error
-    end
-  end
-
-end
-

data/spec.old/transports/mock_transport.rb

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby 
-
-
-module Flapjack
-  module Transport
-    class MockTransport
-      def initialize(options={})
-        @options = options
-        @config = OpenStruct.new(@options)
-        @queue = []
-        @log = @config.log
-      end
-
-      %w(delete put).each do |method|
-        class_eval <<-HERE
-          def #{method}(*args)
-            @log.info("method #{method} was called on MockTransport")
-          end
-        HERE
-      end
-
-      # exactly the same as above, just returns a real object
-      def next
-        @log.info("method next was called on MockTransport")
-        MockResult.new(@options)
-      end
-
-
-    end
-  end
-end
-
-module Flapjack
-  module Transport
-    class MockResult
-      def initialize(options={})
-        @options = options
-        @config = OpenStruct.new(@options)
-        @log = @config.log
-      end
-
-      # log if the method is called (essentially, these are dodgy mocks)
-      %w(warning? critical? any_parents_failed? save check_id frequency).each do |method|
-        class_eval <<-HERE
-          def #{method}(*args)
-            @log.info("method #{method} was called on MockResult")
-          end
-        HERE
-      end
-
-      # exactly the same as above, just returns a real object
-      def command(*args)
-        @log.info("method command was called on MockResult")
-        "echo foo"
-      end
-    end
-  end
-end

data/spec.old/worker_application_spec.rb

@@ -1,62 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'lib', 'flapjack', 'applications', 'worker')
-require File.join(File.dirname(__FILE__), 'helpers')
-
-describe "worker application" do 
-
-  it "should have a simple booting interface " do 
-    options = {:log => MockLogger.new}
-    app = Flapjack::Worker::Application.run(options)
-  end
-
-  it "should load beanstalkd as the default transport" do 
-    options = {:log => MockLogger.new}
-    app = Flapjack::Worker::Application.run(options)
-
-    app.log.messages.find {|msg| msg =~ /loading.+beanstalkd.+transport/i}.should_not be_nil
-  end
-
-  it "should setup two transports (checks + results)" do 
-    options = {:log => MockLogger.new}
-    app = Flapjack::Worker::Application.run(options)
-
-    app.log.messages.find_all {|msg| msg =~ /loading.+beanstalkd.+transport/i}.size.should == 2
-    app.log.messages.find {|msg| msg =~ /loading.+beanstalkd.+transport.+checks/i}.should be_true
-    app.log.messages.find {|msg| msg =~ /loading.+beanstalkd.+transport.+results/i}.should be_true
-  end
-
-  it "should load a transport as specified in options" do 
-    options = {:log => MockLogger.new, :transport => {:backend => :beanstalkd}}
-    app = Flapjack::Worker::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 dosen't exist" do 
-    options = {:log => MockLogger.new, :transport => {:backend => :nonexistant}}
-    lambda {
-      app = Flapjack::Worker::Application.run(options)
-    }.should raise_error
-  end
-
-  it "should execute checks in a sandbox"
-
-  it "should use a limited interface for dealing with transports" do 
-    options = { :log => MockLogger.new, 
-                :transport => {:backend => :mock_transport, 
-                               :basedir => File.join(File.dirname(__FILE__), 'transports')} }
-    app = Flapjack::Worker::Application.run(options)
-    app.process_check
-
-    # check allowed methods were called
-    allowed_methods = %w(next)
-    allowed_methods.each do |method|
-      app.log.messages.find {|msg| msg =~ /#{method} was called/}.should_not be_nil 
-    end
-
-    # check no other methods were called
-    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
-
-
-end