flapjack 0.6.53 → 0.6.54

data/spec/lib/flapjack/gateways/web_spec.rb

@@ -1,35 +1,36 @@
 require 'spec_helper'
 require 'flapjack/gateways/web'
 
-# TODO move the rest of the redis operations down to data models, then this
-# test won't need read/write redis data
-
-describe Flapjack::Gateways::Web, :sinatra => true, :redis => true do
+describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
 
   def app
     Flapjack::Gateways::Web
   end
 
   let(:entity_name)     { 'example.com'}
-  let(:entity_name_esc) { URI.escape(entity_name) }
+  let(:entity_name_esc) { CGI.escape(entity_name) }
   let(:check)           { 'ping' }
 
   let(:entity)          { mock(Flapjack::Data::Entity) }
   let(:entity_check)    { mock(Flapjack::Data::EntityCheck) }
 
+  let(:redis) { mock('redis') }
+
   before(:each) do
-    Flapjack::RedisPool.should_receive(:new).and_return(@redis)
-    Flapjack::Gateways::Web.bootstrap(:config => {})
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    Flapjack::Gateways::Web.instance_variable_set('@config', {})
+    Flapjack::Gateways::Web.instance_variable_set('@logger', @logger)
+    Flapjack::Gateways::Web.start
   end
 
   def expect_stats
-    @redis.should_receive(:keys).with('*').and_return([])
-    @redis.should_receive(:zcard).with('failed_checks')
-    @redis.should_receive(:keys).with('check:*:*').and_return([])
-    @redis.should_receive(:zscore).with('executive_instances', anything).and_return(Time.now.to_i)
-    @redis.should_receive(:hgetall).twice.and_return({'all' => '8001', 'ok' => '8002'},
-      {'all' => '9001', 'ok' => '9002'}) #
-    @redis.should_receive(:llen).with('events')
+    redis.should_receive(:keys).with('*').and_return([])
+    redis.should_receive(:zcard).with('failed_checks')
+    redis.should_receive(:keys).with('check:*:*').and_return([])
+    redis.should_receive(:zscore).with('executive_instances', anything).and_return(Time.now.to_i)
+    redis.should_receive(:hgetall).twice.and_return({'all' => '8001', 'ok' => '8002'},
+      {'all' => '9001', 'ok' => '9002'})
+    redis.should_receive(:llen).with('events')
   end
 
   def expect_entity_check_status(ec)
@@ -49,41 +50,44 @@ describe Flapjack::Gateways::Web, :sinatra => true, :redis => true do
   # (for the methods that access redis directly)
 
   it "shows a page listing all checks" do
-    @redis.should_receive(:keys).with('*:*:states').and_return(["#{entity_name}:#{check}:states"])
+    redis.should_receive(:keys).with('*:*:states').and_return(["#{entity_name}:#{check}:states"])
 
     expect_stats
 
+    redis.should_receive(:zrange).with("executive_instances", "0", "-1", :withscores => true)
+
     expect_entity_check_status(entity_check)
 
     Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => @redis).and_return(entity)
+      with(entity_name, :redis => redis).and_return(entity)
 
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+      with(entity, 'ping', :redis => redis).and_return(entity_check)
 
     get '/'
     last_response.should be_ok
   end
 
   it "shows a page listing failing checks" do
-    @redis.should_receive(:zrange).with("executive_instances", "0", "-1", :withscores => true)
-    @redis.should_receive(:zrange).with('failed_checks', 0, -1).and_return(["#{entity_name}:#{check}:states"])
+    redis.should_receive(:zrange).with("executive_instances", "0", "-1", :withscores => true)
+    redis.should_receive(:zrange).with('failed_checks', 0, -1).and_return(["#{entity_name}:#{check}:states"])
 
     expect_stats
 
     expect_entity_check_status(entity_check)
 
     Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => @redis).and_return(entity)
+      with(entity_name, :redis => redis).and_return(entity)
 
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+      with(entity, 'ping', :redis => redis).and_return(entity_check)
     get '/failing'
     last_response.should be_ok
   end
 
   it "shows a page listing flapjack statistics" do
     expect_stats
+    redis.should_receive(:zrange).with("executive_instances", "0", "-1", :withscores => true)
 
     get '/self_stats'
     last_response.should be_ok
@@ -108,10 +112,10 @@ describe Flapjack::Gateways::Web, :sinatra => true, :redis => true do
     entity_check.should_receive(:contacts).and_return([])
 
     Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => @redis).and_return(entity)
+      with(entity_name, :redis => redis).and_return(entity)
 
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+      with(entity, 'ping', :redis => redis).and_return(entity_check)
 
     get "/check?entity=#{entity_name_esc}&check=ping"
     last_response.should be_ok
@@ -119,25 +123,28 @@ describe Flapjack::Gateways::Web, :sinatra => true, :redis => true do
   end
 
   it "returns 404 if an unknown entity is requested" do
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name_esc, :redis => redis).and_return(nil)
+
     get "/check?entity=#{entity_name_esc}&check=ping"
     last_response.should be_not_found
   end
 
   # TODO shouldn't create actual entity record
   it "returns 404 if no entity check is passed" do
-    Flapjack::Data::Entity.add({'id'   => '5000',
-                                'name' => entity_name},
-                               :redis => @redis)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
     get "/check?entity=#{entity_name_esc}"
     last_response.should be_not_found
   end
 
   it "creates an acknowledgement for an entity check" do
     Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => @redis).and_return(entity)
+      with(entity_name, :redis => redis).and_return(entity)
 
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+      with(entity, 'ping', :redis => redis).and_return(entity_check)
 
     entity_check.should_receive(:create_acknowledgement).
       with(an_instance_of(Hash))
@@ -157,10 +164,10 @@ describe Flapjack::Gateways::Web, :sinatra => true, :redis => true do
     ChronicDuration.should_receive(:parse).with('30 minutes').and_return(duration)
 
     Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => @redis).and_return(entity)
+      with(entity_name, :redis => redis).and_return(entity)
 
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+      with(entity, 'ping', :redis => redis).and_return(entity_check)
 
     entity_check.should_receive(:create_scheduled_maintenance).
       with(:start_time => start_time.to_i, :duration => duration, :summary => summary)
@@ -176,10 +183,10 @@ describe Flapjack::Gateways::Web, :sinatra => true, :redis => true do
     start_time = t - (24 * 60 * 60)
 
     Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => @redis).and_return(entity)
+      with(entity_name, :redis => redis).and_return(entity)
 
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+      with(entity, 'ping', :redis => redis).and_return(entity_check)
 
     Chronic.should_receive(:parse).with('now').and_return(t)
 
@@ -197,10 +204,10 @@ describe Flapjack::Gateways::Web, :sinatra => true, :redis => true do
     start_time = t - (24 * 60 * 60)
 
     Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => @redis).and_return(entity)
+      with(entity_name, :redis => redis).and_return(entity)
 
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+      with(entity, 'ping', :redis => redis).and_return(entity_check)
 
     entity_check.should_receive(:delete_scheduled_maintenance).
       with(:start_time => start_time)
@@ -223,7 +230,7 @@ describe Flapjack::Gateways::Web, :sinatra => true, :redis => true do
     contact.should_receive(:entities_and_checks).and_return([])
 
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with('0362', :redis => @redis).and_return(contact)
+      with('0362', :redis => redis).and_return(contact)
 
     get "/contacts/0362"
     last_response.should be_ok

data/spec/lib/flapjack/logger_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'flapjack/pikelet'
+
+describe Flapjack::Logger do
+
+  # let(:logger)     { mock(Log4r::Logger) }
+  # let(:stdout_out) { mock('stdout_out') }
+  # let(:syslog_out) { mock('syslog_out') }
+
+  it "creates a log4r logger"
+
+  it "changes the logging level via config hash"
+
+  it "passes a log command to its log4r logger"
+
+  # def setup_logger(type)
+  #   formatter = mock('Formatter')
+  #   Log4r::PatternFormatter.should_receive(:new).with(
+  #     :pattern => "[%l] %d :: #{type} :: %m",
+  #     :date_pattern => "%Y-%m-%dT%H:%M:%S%z").and_return(formatter)
+
+  #   stdout_out.should_receive(:formatter=).with(formatter)
+  #   syslog_out.should_receive(:formatter=).with(formatter)
+
+  #   Log4r::StdoutOutputter.should_receive(:new).and_return(stdout_out)
+  #   Log4r::SyslogOutputter.should_receive(:new).and_return(syslog_out)
+  #   logger.should_receive(:add).with(stdout_out)
+  #   logger.should_receive(:add).with(syslog_out)
+  #   Log4r::Logger.should_receive(:new).and_return(logger)
+  # end
+
+end

data/spec/lib/flapjack/pikelet_spec.rb

@@ -3,26 +3,135 @@ require 'flapjack/pikelet'
 
 describe Flapjack::Pikelet do
 
-  let(:stdout) { mock('StdoutOutputter') }
-  let(:syslogout) { mock('SyslogOutputter') }
-  let(:logger) { mock('Logger') }
+  let(:config)       { mock('config') }
+  let(:redis_config) { mock('redis_config') }
 
-  class Breakfast
-    include Flapjack::Pikelet
+  let(:logger)     { mock(Flapjack::Logger) }
+
+  let(:fiber) { mock(Fiber) }
+
+  it "creates and starts an executive pikelet" do
+    Flapjack::Logger.should_receive(:new).and_return(logger)
+
+    config.should_receive(:[]).with('logger').and_return(nil)
+
+    executive = mock('executive')
+    executive.should_receive(:start)
+    Flapjack::Executive.should_receive(:new).with(:config => config,
+      :redis_config => redis_config, :logger => logger).and_return(executive)
+
+    fiber.should_receive(:resume)
+    Fiber.should_receive(:new).and_yield.and_return(fiber)
+
+    pik = Flapjack::Pikelet.create('executive', :config => config,
+      :redis_config => redis_config)
+    pik.should be_a(Flapjack::Pikelet::Generic)
+    pik.start
   end
 
-  it "should bootstrap an including class" do
-    Log4r::StdoutOutputter.should_receive(:new).and_return(stdout)
-    Log4r::SyslogOutputter.should_receive(:new).and_return(syslogout)
-    logger.should_receive(:add).with(stdout)
-    logger.should_receive(:add).with(syslogout)
-    Log4r::Logger.should_receive(:new).and_return(logger)
+  it "handles an exception raised by a jabber pikelet" do
+    Flapjack::Logger.should_receive(:new).and_return(logger)
+    logger.should_receive(:fatal)
+
+    config.should_receive(:[]).with('logger').and_return(nil)
+
+    jabber = mock('jabber')
+    jabber.should_receive(:start).and_raise(RuntimeError)
+    jabber.should_receive(:stop)
+    Flapjack::Gateways::Jabber.should_receive(:new).with(:config => config,
+      :redis_config => redis_config, :logger => logger).and_return(jabber)
+
+    fiber.should_receive(:resume)
+    Fiber.should_receive(:new).and_yield.and_return(fiber)
+
+    pik = Flapjack::Pikelet.create('jabber', :config => config,
+      :redis_config => redis_config)
+    pik.should be_a(Flapjack::Pikelet::Generic)
+    pik.start
+  end
+
+  it "creates and starts a resque worker gateway" do
+    Flapjack::Logger.should_receive(:new).and_return(logger)
+
+    config.should_receive(:[]).with('logger').and_return(nil)
+    config.should_receive(:[]).with('queue').and_return('email_notif')
+
+    Flapjack::Gateways::Email.should_receive(:instance_variable_set).
+      with('@config', config)
+    Flapjack::Gateways::Email.should_receive(:instance_variable_set).
+      with('@redis_config', redis_config)
+    Flapjack::Gateways::Email.should_receive(:instance_variable_set).
+      with('@logger', logger)
+
+    worker = mock('worker')
+    worker.should_receive(:work).with(0.1)
+    Flapjack::Gateways::Email.should_receive(:start)
+    EM::Resque::Worker.should_receive(:new).with('email_notif').and_return(worker)
+
+    fiber.should_receive(:resume)
+    Fiber.should_receive(:new).and_yield.and_return(fiber)
+
+    pik = Flapjack::Pikelet.create('email', :config => config,
+      :redis_config => redis_config)
+    pik.should be_a(Flapjack::Pikelet::Resque)
+    pik.start
+  end
+
+  it "handles an exception raised by a resque worker gateway" do
+    Flapjack::Logger.should_receive(:new).and_return(logger)
+    logger.should_receive(:fatal)
+
+    config.should_receive(:[]).with('logger').and_return(nil)
+    config.should_receive(:[]).with('queue').and_return('email_notif')
+
+    Flapjack::Gateways::Email.should_receive(:instance_variable_set).
+      with('@config', config)
+    Flapjack::Gateways::Email.should_receive(:instance_variable_set).
+      with('@redis_config', redis_config)
+    Flapjack::Gateways::Email.should_receive(:instance_variable_set).
+      with('@logger', logger)
+
+    worker = mock('worker')
+    worker.should_receive(:work).with(0.1).and_raise(RuntimeError)
+    Flapjack::Gateways::Email.should_receive(:start)
+    Flapjack::Gateways::Email.should_receive(:stop)
+    EM::Resque::Worker.should_receive(:new).with('email_notif').and_return(worker)
+
+    fiber.should_receive(:resume)
+    Fiber.should_receive(:new).and_yield.and_return(fiber)
+
+    pik = Flapjack::Pikelet.create('email', :config => config,
+      :redis_config => redis_config)
+    pik.should be_a(Flapjack::Pikelet::Resque)
+    pik.start
+  end
+
+  it "creates a thin server gateway" do
+    Flapjack::Logger.should_receive(:new).and_return(logger)
+
+    config.should_receive(:[]).with('logger').and_return(nil)
+    config.should_receive(:[]).with('port').and_return(7654)
+
+    server = mock('server')
+    server.should_receive(:start)
+    Thin::Server.should_receive(:new).
+      with(/^(?:\d{1,3}\.){3}\d{1,3}$/, 7654,
+        Flapjack::Gateways::Web, :signals => false).
+      and_return(server)
+
+    Flapjack::Gateways::Web.should_receive(:instance_variable_set).
+      with('@config', config)
+    Flapjack::Gateways::Web.should_receive(:instance_variable_set).
+      with('@redis_config', redis_config)
+    Flapjack::Gateways::Web.should_receive(:instance_variable_set).
+      with('@logger', logger)
 
-    b = Breakfast.new
-    b.bootstrap
+    Flapjack::Gateways::Web.should_receive(:start)
 
-    b.should respond_to(:logger)
-    b.logger.should equal(logger)
+    pik = Flapjack::Pikelet.create('web', :config => config,
+      :redis_config => redis_config)
+    pik.should be_a(Flapjack::Pikelet::Thin)
+    pik.start
   end
 
 end

data/spec/lib/flapjack/redis_pool_spec.rb

@@ -3,19 +3,17 @@ require 'flapjack/redis_pool'
 
 describe Flapjack::RedisPool do
 
-  it "is initialized, and emptied" do
+  it "is initialized" do
     EM.synchrony do
       redis_count = 3
 
       redis_conns = redis_count.times.collect {
         redis = mock('redis')
-        redis.should_receive(:quit)
         redis
       }
       ::Redis.should_receive(:new).exactly(redis_count).times.and_return(*redis_conns)
 
       frp = Flapjack::RedisPool.new(:size => redis_count)
-      frp.empty!
 
       EM.stop
     end

data/spec/spec_helper.rb

@@ -21,6 +21,22 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 # in ./support/ and its subdirectories.
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
+class MockLogger
+  attr_accessor :messages
+
+  def initialize
+    @messages = []
+  end
+
+  %w(debug info warn error fatal).each do |level|
+    class_eval <<-RUBY
+      def #{level}(msg)
+        @messages << msg
+      end
+    RUBY
+  end
+end
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # Require this file using `require "spec_helper"` to ensure that it is only
@@ -38,6 +54,18 @@ RSpec.configure do |config|
   #     --seed 1234
   config.order = 'random'
 
+  config.before(:each, :logger => true) do
+    def test_logger(class_name)
+      logger = Log4r::Logger.new(class_name)
+      outp = Log4r::FileOutputter.new(class_name,
+        :filename => File.join(File.dirname(__FILE__), '..', 'log', 'test.log'))
+      outp.formatter = Log4r::PatternFormatter.new(:pattern => "[%l] %d :: #{class_name} :: %m",
+        :date_pattern => "%Y-%m-%dT%H:%M:%S%z")
+      logger.add(outp)
+      logger
+    end
+  end
+
   config.around(:each, :redis => true) do |example|
     @redis = ::Redis.new(:db => 14, :driver => :ruby)
     @redis.flushdb
@@ -45,11 +73,16 @@ RSpec.configure do |config|
     @redis.quit
   end
 
+  config.around(:each, :logger => true) do |example|
+    @logger = MockLogger.new
+    example.run
+    @logger.messages.clear
+  end
+
   config.after(:each, :time => true) do
     Delorean.back_to_the_present
   end
 
   config.include HamlViewHelper, :haml_view => true
-
   config.include Rack::Test::Methods, :sinatra => true
 end