flapjack 0.6.53 → 0.6.54

data/spec/lib/flapjack/data/entity_check_spec.rb

@@ -485,6 +485,9 @@ describe Flapjack::Data::EntityCheck, :redis => true do
 
     @redis.hset("check:#{name}:#{check}", 'state', 'critical')
     ec.should be_failed
+
+    @redis.hset("check:#{name}:#{check}", 'state', 'unknown')
+    ec.should be_failed
   end
 
   it "returns that it has not failed" do
@@ -495,9 +498,6 @@ describe Flapjack::Data::EntityCheck, :redis => true do
 
     @redis.hset("check:#{name}:#{check}", 'state', 'acknowledgement')
     ec.should_not be_failed
-
-    @redis.hset("check:#{name}:#{check}", 'state', 'unknown')
-    ec.should_not be_failed
   end
 
   it "returns a status summary" do

data/spec/lib/flapjack/executive_spec.rb

@@ -1,21 +1,13 @@
 require 'spec_helper'
 require 'flapjack/executive'
 
-describe Flapjack::Executive, :redis => true do
+describe Flapjack::Executive, :logger => true do
 
   # NB: this is only testing the public API of the Executive class, which is pretty limited.
   # (initialize, main, stop). Most test coverage for this class comes from the cucumber features.
 
-  it "prompts the blocking redis connection to quit" do
-    redis = mock('redis')
-    redis.should_receive(:rpush).with('events', %q{{"type":"shutdown","host":"","service":"","state":""}})
-
-    executive = Flapjack::Executive.new
-    executive.add_shutdown_event(:redis => redis)
-  end
-
-  # TODO split out the setup stuff to a separate test
-  it "shuts down when provided with a shutdown event" do
+  # TODO this does too much -- split it up
+  it "starts up, runs and shuts down" do
     t = Time.now.to_i
 
     Flapjack::Filters::Ok.should_receive(:new)
@@ -25,35 +17,42 @@ describe Flapjack::Executive, :redis => true do
     Flapjack::Filters::Delays.should_receive(:new)
     Flapjack::Filters::Acknowledgement.should_receive(:new)
 
+    redis = mock('redis')
+
+    redis.should_receive(:set).with('boot_time', a_kind_of(Integer))
+    redis.should_receive(:hget).with('event_counters', 'all').and_return(nil)
+    redis.should_receive(:hset).with('event_counters', 'all', 0)
+    redis.should_receive(:hset).with('event_counters', 'ok', 0)
+    redis.should_receive(:hset).with('event_counters', 'failure', 0)
+    redis.should_receive(:hset).with('event_counters', 'action', 0)
+
+    redis.should_receive(:zadd).with('executive_instances', a_kind_of(Integer), a_kind_of(String))
+    redis.should_receive(:hset).with(/^event_counters:/, 'all', 0)
+    redis.should_receive(:hset).with(/^event_counters:/, 'ok', 0)
+    redis.should_receive(:hset).with(/^event_counters:/, 'failure', 0)
+    redis.should_receive(:hset).with(/^event_counters:/, 'action', 0)
+
+    redis.should_receive(:hincrby).with('event_counters', 'all', 1)
+    redis.should_receive(:hincrby).with(/^event_counters:/, 'all', 1)
+
+    Flapjack::Data::Event.should_receive(:pending_count).with(:redis => redis).and_return(0)
+
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    executive = Flapjack::Executive.new(:config => {}, :logger => @logger)
+
     shutdown_evt = mock(Flapjack::Data::Event)
+    shutdown_evt.should_receive(:inspect)
     shutdown_evt.should_receive(:id).and_return('-:-')
     shutdown_evt.should_receive(:type).exactly(3).times.and_return('shutdown')
     shutdown_evt.should_receive(:state).and_return(nil)
     shutdown_evt.should_receive(:summary).and_return(nil)
     shutdown_evt.should_receive(:time).and_return(Time.now)
-    Flapjack::Data::Event.should_receive(:next).and_return(shutdown_evt)
-
-    executive = Flapjack::Executive.new
-    Flapjack::RedisPool.should_receive(:new).and_return(@redis)
-    executive.bootstrap(:config => {})
-    @redis.should_receive(:empty!)
-
-    # hacky, but the behaviour it's mimicking (shutdown from another thread) isn't
-    # conducive to nice tests
-    executive.stub(:should_quit?).and_return(false, true)
-    executive.main
-    executive.cleanup
-
-    # TODO these will need to be made relative to the running instance,
-    # and a list of the running instances maintained somewhere
-    boot_time = @redis.get('boot_time')
-    boot_time.should_not be_nil
-    boot_time.to_i.should >= t
-
-    @redis.hget('event_counters', 'all').should == 1.to_s
-    @redis.hget('event_counters', 'ok').should == 0.to_s
-    @redis.hget('event_counters', 'failure').should == 0.to_s
-    @redis.hget('event_counters', 'action').should == 0.to_s
+    Flapjack::Data::Event.should_receive(:next) {
+      executive.instance_variable_set('@should_quit', true)
+      shutdown_evt
+    }
+
+    executive.start
   end
 
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'flapjack/gateways/api'
 
-describe 'Flapjack::Gateways::API', :sinatra => true do
+describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true do
 
   def app
     Flapjack::Gateways::API
@@ -21,7 +21,9 @@ describe 'Flapjack::Gateways::API', :sinatra => true do
 
   before(:each) do
     Flapjack::RedisPool.should_receive(:new).and_return(redis)
-    Flapjack::Gateways::API.bootstrap(:config => {})
+    Flapjack::Gateways::API.instance_variable_set('@config', {})
+    Flapjack::Gateways::API.instance_variable_set('@logger', @logger)
+    Flapjack::Gateways::API.start
   end
 
   it "returns a list of checks for an entity" do

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'flapjack/gateways/jabber'
 
-describe Flapjack::Gateways::Jabber do
+describe Flapjack::Gateways::Jabber, :logger => true do
 
   let(:config) { {'queue'    => 'jabber_notifications',
                   'server'   => 'example.com',
@@ -18,9 +18,8 @@ describe Flapjack::Gateways::Jabber do
   it "hooks up event handlers to the appropriate methods" do
     Socket.should_receive(:gethostname).and_return('thismachine')
 
-    fj = Flapjack::Gateways::Jabber.new
     Flapjack::RedisPool.should_receive(:new)
-    fj.bootstrap(:config => config)
+    fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
     EventMachine::Synchrony.should_receive(:next_tick).exactly(4).times.and_yield
 
@@ -40,11 +39,12 @@ describe Flapjack::Gateways::Jabber do
   end
 
   it "joins a chat room after connecting" do
-    fj = Flapjack::Gateways::Jabber.new
-    Flapjack::RedisPool.should_receive(:new).twice
-    fj.bootstrap(:config => config)
+    Flapjack::RedisPool.should_receive(:new)
 
+    fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
     fj.should_receive(:connected?).and_return(true)
+
+    EventMachine::Synchrony.should_receive(:next_tick).and_yield
     fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Presence))
     fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
 
@@ -72,11 +72,10 @@ describe Flapjack::Gateways::Jabber do
       with('main-example.com:ping', :redis => redis).
       and_return(entity_check)
 
-    fj = Flapjack::Gateways::Jabber.new
-    Flapjack::RedisPool.should_receive(:new)
-    fj.bootstrap(:config => config)
-    fj.instance_variable_set('@redis_handler', redis)
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
+    EventMachine::Synchrony.should_receive(:next_tick).and_yield
     fj.should_receive(:connected?).and_return(true)
     fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
 
@@ -89,10 +88,10 @@ describe Flapjack::Gateways::Jabber do
     from.should_receive(:stripped).and_return('sender')
     stanza.should_receive(:from).and_return(from)
 
-    fj = Flapjack::Gateways::Jabber.new
     Flapjack::RedisPool.should_receive(:new)
-    fj.bootstrap(:config => config)
+    fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
+    EventMachine::Synchrony.should_receive(:next_tick).and_yield
     fj.should_receive(:connected?).and_return(true)
     fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
 
@@ -100,12 +99,16 @@ describe Flapjack::Gateways::Jabber do
   end
 
   it "reconnects when disconnected (if not quitting)" do
-    fj = Flapjack::Gateways::Jabber.new
     Flapjack::RedisPool.should_receive(:new)
-    fj.bootstrap(:config => config)
+    fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
-    EventMachine::Timer.should_receive(:new).with(1).and_yield
-    fj.should_receive(:connect)
+    attempts = 0
+
+    EventMachine::Synchrony.should_receive(:sleep).with(2).exactly(3).times
+    fj.should_receive(:connect).exactly(4).times.and_return {
+      attempts +=1
+      raise StandardError.new unless attempts > 3
+    }
 
     ret = fj.on_disconnect(stanza)
     ret.should be_true
@@ -115,43 +118,43 @@ describe Flapjack::Gateways::Jabber do
     redis = mock('redis')
     redis.should_receive(:rpush).with('jabber_notifications', %q{{"notification_type":"shutdown"}})
 
-    fj = Flapjack::Gateways::Jabber.new
-    Flapjack::RedisPool.should_receive(:new)
-    fj.bootstrap(:config => config)
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
-    fj.add_shutdown_event(:redis => redis)
+    fj.stop
   end
 
   it "runs a blocking loop listening for notifications" do
-    timer_1 = mock('timer_1')
-    timer_2 = mock('timer_2')
-    timer_1.should_receive(:cancel)
-    timer_2.should_receive(:cancel)
-    EM::Synchrony.should_receive(:add_periodic_timer).with(30).and_return(timer_1)
-    EM::Synchrony.should_receive(:add_periodic_timer).with(60).and_return(timer_2)
+    timer = mock('timer')
+    timer.should_receive(:cancel)
+    EM::Synchrony.should_receive(:add_periodic_timer).with(60).and_return(timer)
 
     redis = mock('redis')
-    redis.should_receive(:empty!)
 
-    fj = Flapjack::Gateways::Jabber.new
     Flapjack::RedisPool.should_receive(:new).and_return(redis)
-    fj.bootstrap(:config => config)
+    fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
     fj.should_receive(:register_handler).exactly(4).times
 
     fj.should_receive(:connect)
     fj.should_receive(:connected?).exactly(3).times.and_return(true)
-    fj.should_receive(:should_quit?).exactly(4).times.and_return(false, false, true)
-    redis.should_receive(:blpop).twice.and_return(
-      ["jabber_notifications", %q{{"notification_type":"problem","event_id":"main-example.com:ping","state":"critical","summary":"!!!"}}],
-      ["jabber_notifications", %q{{"notification_type":"shutdown"}}]
-    )
+
+    blpop_count = 0
+
+    redis.should_receive(:blpop).twice {
+      blpop_count += 1
+      if blpop_count == 1
+        ["jabber_notifications", %q{{"notification_type":"problem","event_id":"main-example.com:ping","state":"critical","summary":"!!!"}}]
+      else
+        fj.instance_variable_set('@should_quit', true)
+        ["jabber_notifications", %q{{"notification_type":"shutdown"}}]
+      end
+    }
 
     EventMachine::Synchrony.should_receive(:next_tick).twice.and_yield
     fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
     fj.should_receive(:close)
 
-    fj.main
-    fj.cleanup
+    fj.start
   end
 
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'flapjack/gateways/oobetet'
 
-describe Flapjack::Gateways::Oobetet do
+describe Flapjack::Gateways::Oobetet, :logger => true do
 
   let(:config) { {'server'   => 'example.com',
                   'port'     => '5222',
@@ -19,8 +19,7 @@ describe Flapjack::Gateways::Oobetet do
   it "raises an error if a required config setting is not set" do
     Socket.should_receive(:gethostname).and_return('thismachine')
 
-    fo = Flapjack::Gateways::Oobetet.new
-    fo.bootstrap(:config => config.delete('watched_check'))
+    fo = Flapjack::Gateways::Oobetet.new(:config => config.delete('watched_check'), :logger => @logger)
 
     lambda {
       fo.setup
@@ -28,8 +27,7 @@ describe Flapjack::Gateways::Oobetet do
   end
 
   it "hooks up event handlers to the appropriate methods" do
-    fo = Flapjack::Gateways::Oobetet.new
-    fo.bootstrap(:config => config)
+    fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
 
     EventMachine::Synchrony.should_receive(:next_tick).exactly(3).times.and_yield
 
@@ -46,8 +44,7 @@ describe Flapjack::Gateways::Oobetet do
   end
 
   it "joins a chat room after connecting" do
-    fo = Flapjack::Gateways::Oobetet.new
-    fo.bootstrap(:config => config)
+    fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
 
     fo.should_receive(:write).with(an_instance_of(Blather::Stanza::Presence))
     fo.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
@@ -56,8 +53,7 @@ describe Flapjack::Gateways::Oobetet do
   end
 
   it "reconnects when disconnected (if not quitting)" do
-    fo = Flapjack::Gateways::Oobetet.new
-    fo.bootstrap(:config => config)
+    fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
 
     EventMachine::Timer.should_receive(:new).with(1).and_yield
     fo.should_receive(:connect)
@@ -67,9 +63,7 @@ describe Flapjack::Gateways::Oobetet do
   end
 
   it "records times of a problem status messages" do
-    fo = Flapjack::Gateways::Oobetet.new
-    fo.bootstrap(:config => config)
-
+    fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
     fo.setup
 
     t = Time.now
@@ -85,9 +79,7 @@ describe Flapjack::Gateways::Oobetet do
   end
 
   it "records times of a recovery status messages" do
-    fo = Flapjack::Gateways::Oobetet.new
-    fo.bootstrap(:config => config)
-
+    fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
     fo.setup
 
     t = Time.now
@@ -103,9 +95,7 @@ describe Flapjack::Gateways::Oobetet do
   end
 
   it "records times of an acknowledgement status messages" do
-    fo = Flapjack::Gateways::Oobetet.new
-    fo.bootstrap(:config => config)
-
+    fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
     fo.setup
 
     t = Time.now
@@ -125,16 +115,16 @@ describe Flapjack::Gateways::Oobetet do
     timer.should_receive(:cancel)
     EM::Synchrony.should_receive(:add_periodic_timer).with(60).and_return(timer)
 
-    fo = Flapjack::Gateways::Oobetet.new
-    fo.bootstrap(:config => config)
+    fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
     fo.should_receive(:register_handler).exactly(3).times
-
     fo.should_receive(:connect)
-    fo.should_receive(:should_quit?).twice.and_return(false, true)
 
-    EM::Synchrony.should_receive(:sleep).with(10)
+    EM::Synchrony.should_receive(:sleep).with(10) {
+      fo.instance_variable_set('@should_quit', true)
+      nil
+    }
 
-    fo.main
+    fo.start
   end
 
 end

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

@@ -4,39 +4,40 @@ require 'yajl/json_gem'
 
 require 'flapjack/gateways/pagerduty'
 
-describe Flapjack::Gateways::Pagerduty, :redis => true do
+describe Flapjack::Gateways::Pagerduty, :logger => true do
 
   let(:config) { {'queue'    => 'pagerduty_notifications'} }
 
   let(:time)   { Time.new }
 
+  let(:redis) {  mock('redis') }
+
   it "prompts the blocking redis connection to quit" do
-    redis = mock('redis')
     redis.should_receive(:rpush).with(config['queue'], %q{{"notification_type":"shutdown"}})
 
-    fp = Flapjack::Gateways::Pagerduty.new
-    Flapjack::RedisPool.should_receive(:new)
-    fp.bootstrap(:config => config)
-    fp.add_shutdown_event(:redis => redis)
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
+    fp.stop
   end
 
   it "doesn't look for acknowledgements if this search is already running" do
-    @redis.set(Flapjack::Gateways::Pagerduty::SEM_PAGERDUTY_ACKS_RUNNING, 'true')
-
-    fp = Flapjack::Gateways::Pagerduty.new
-    Flapjack::RedisPool.should_receive(:new)
-    fp.bootstrap(:config => config)
-    fp.instance_variable_set("@redis_timer", @redis)
+    redis.should_receive(:get).with('sem_pagerduty_acks_running').and_return('true')
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
     fp.should_not_receive(:find_pagerduty_acknowledgements)
     fp.find_pagerduty_acknowledgements_if_safe
   end
 
   it "looks for acknowledgements if the search is not already running" do
-    fp = Flapjack::Gateways::Pagerduty.new
-    Flapjack::RedisPool.should_receive(:new)
-    fp.bootstrap(:config => config)
-    fp.instance_variable_set("@redis_timer", @redis)
+    redis.should_receive(:get).with('sem_pagerduty_acks_running').and_return(nil)
+    redis.should_receive(:set).with('sem_pagerduty_acks_running', 'true')
+    redis.should_receive(:expire).with('sem_pagerduty_acks_running', 300)
+
+    redis.should_receive(:del).with('sem_pagerduty_acks_running')
+
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
     fp.should_receive(:find_pagerduty_acknowledgements)
     fp.find_pagerduty_acknowledgements_if_safe
@@ -71,11 +72,11 @@ describe Flapjack::Gateways::Pagerduty, :redis => true do
        with(:headers => {'Authorization'=>['flapjack', 'password123']}).
        to_return(:status => 200, :body => response.to_json, :headers => {})
 
-    EM.synchrony do
-      fp = Flapjack::Gateways::Pagerduty.new
-      Flapjack::RedisPool.should_receive(:new)
-      fp.bootstrap(:config => config)
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
+
 
+    EM.synchrony do
       result = fp.send(:pagerduty_acknowledged?, 'subdomain' => 'flpjck', 'username' => 'flapjack',
         'password' => 'password123', 'check' => check)
 
@@ -86,12 +87,12 @@ describe Flapjack::Gateways::Pagerduty, :redis => true do
       result[:pg_acknowledged_by]['id'].should == 'ABCDEFG'
       EM.stop
     end
+
   end
 
   it "creates acknowledgements when pagerduty acknowledgements are found" do
-    fp = Flapjack::Gateways::Pagerduty.new
-    Flapjack::RedisPool.should_receive(:new)
-    fp.bootstrap(:config => config)
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
     contact = mock('contact')
     contact.should_receive(:pagerduty_credentials).and_return({
@@ -119,25 +120,27 @@ describe Flapjack::Gateways::Pagerduty, :redis => true do
     timer.should_receive(:cancel)
     EM::Synchrony.should_receive(:add_periodic_timer).with(10).and_return(timer)
 
-    redis = mock('redis')
     redis.should_receive(:del).with('sem_pagerduty_acks_running')
-    redis.should_receive(:empty!)
 
-    fp = Flapjack::Gateways::Pagerduty.new
     Flapjack::RedisPool.should_receive(:new).and_return(redis)
-    fp.bootstrap(:config => config)
+    fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
+
+    blpop_count = 0
 
-    fp.should_receive(:should_quit?).exactly(3).times.and_return(false, false, true)
-    redis.should_receive(:blpop).twice.and_return(
-      ["pagerduty_notifications", %q{{"notification_type":"problem","event_id":"main-example.com:ping","state":"critical","summary":"!!!"}}],
-      ["pagerduty_notifications", %q{{"notification_type":"shutdown"}}]
-    )
+    redis.should_receive(:blpop).twice {
+      blpop_count += 1
+      if blpop_count == 1
+        ["pagerduty_notifications", %q{{"notification_type":"problem","event_id":"main-example.com:ping","state":"critical","summary":"!!!"}}]
+      else
+        fp.instance_variable_set('@should_quit', true)
+        ["pagerduty_notifications", %q{{"notification_type":"shutdown"}}]
+      end
+    }
 
     fp.should_receive(:test_pagerduty_connection).and_return(true)
     fp.should_receive(:send_pagerduty_event)
 
-    fp.main
-    fp.cleanup
+    fp.start
   end
 
   it "tests the pagerduty connection" do
@@ -150,14 +153,12 @@ describe Flapjack::Gateways::Pagerduty, :redis => true do
     stub_request(:post, "https://events.pagerduty.com/generic/2010-04-15/create_event.json").
       with(:body => body).to_return(:status => 200, :body => '{"status":"success"}', :headers => {})
 
-    EM.synchrony do
-      fp = Flapjack::Gateways::Pagerduty.new
-      Flapjack::RedisPool.should_receive(:new)
-      fp.bootstrap(:config => config)
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
+    EM.synchrony do
       ret = fp.send(:test_pagerduty_connection)
       ret.should be_true
-
       EM.stop
     end
   end
@@ -172,16 +173,13 @@ describe Flapjack::Gateways::Pagerduty, :redis => true do
     stub_request(:post, "https://events.pagerduty.com/generic/2010-04-15/create_event.json").
       with(:body => body).to_return(:status => 200, :body => "", :headers => {})
 
-    EM.synchrony do
-
-      fp = Flapjack::Gateways::Pagerduty.new
-      Flapjack::RedisPool.should_receive(:new)
-      fp.bootstrap(:config => config)
+    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
+    EM.synchrony do
       ret = fp.send(:send_pagerduty_event, evt)
       ret.should_not be_nil
       ret.should == [200, nil]
-
       EM.stop
     end
   end