flapjack 0.7.35 → 0.8.0

data/spec/lib/flapjack/gateways/jsonapi/entity_presenter_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'flapjack/gateways/jsonapi/entity_presenter'
+
+describe 'Flapjack::Gateways::JSONAPI::EntityPresenter' do
+
+  let(:entity) { double(Flapjack::Data::Entity) }
+
+  let(:check_a) { double(Flapjack::Data::EntityCheck) }
+  let(:check_b) { double(Flapjack::Data::EntityCheck) }
+
+  let(:checkpres_a) { double(Flapjack::Gateways::JSONAPI::EntityCheckPresenter) }
+  let(:checkpres_b) { double(Flapjack::Gateways::JSONAPI::EntityCheckPresenter) }
+
+  let(:time) { Time.now.to_i }
+
+  let(:start_time) { time - (6 * 60 * 60) }
+  let(:end_time)   { time - (2 * 60 * 60) }
+
+  def expect_check_presenters
+    expect(entity).to receive(:name).exactly(4).times.and_return('foo')
+    expect(entity).to receive(:check_list).and_return(['ping', 'ssh'])
+    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
+      with(entity, 'ssh', anything).and_return(check_a)
+    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
+      with(entity, 'ping', anything).and_return(check_b)
+
+    expect(Flapjack::Gateways::JSONAPI::EntityCheckPresenter).to receive(:new).
+      with(check_a).and_return(checkpres_a)
+    expect(Flapjack::Gateways::JSONAPI::EntityCheckPresenter).to receive(:new).
+      with(check_b).and_return(checkpres_b)
+  end
+
+  it 'returns a list of status hashes for each check on an entity' do
+    expect_check_presenters
+
+    status_a = double('status_a')
+    status_b = double('status_b')
+    expect(checkpres_a).to receive(:status).and_return(status_a)
+    expect(checkpres_b).to receive(:status).and_return(status_b)
+
+    ep = Flapjack::Gateways::JSONAPI::EntityPresenter.new(entity)
+    status = ep.status
+    expect(status).to eq([{:entity => entity.name, :check => 'ping', :status => status_b},
+                      {:entity => entity.name, :check => 'ssh',  :status => status_a}])
+
+  end
+
+  it "returns a list of outage hashes for each check on an entity" do
+    expect_check_presenters
+    outages_a = double('outages_a')
+    outages_b = double('outages_b')
+    expect(checkpres_a).to receive(:outages).with(start_time, end_time).
+      and_return(outages_a)
+    expect(checkpres_b).to receive(:outages).with(start_time, end_time).
+      and_return(outages_b)
+
+    ep = Flapjack::Gateways::JSONAPI::EntityPresenter.new(entity)
+    outages = ep.outages(start_time, end_time)
+    expect(outages).to eq([{:entity => entity.name, :check => 'ping', :outages => outages_b},
+                       {:entity => entity.name, :check => 'ssh',  :outages => outages_a}])
+  end
+
+  it "returns a list of unscheduled maintenance periods for each check on an entity" do
+    expect_check_presenters
+    unsched_maint_a = double('unsched_maint_a')
+    unsched_maint_b = double('unsched_maint_b')
+    expect(checkpres_a).to receive(:unscheduled_maintenances).with(start_time, end_time).
+      and_return(unsched_maint_a)
+    expect(checkpres_b).to receive(:unscheduled_maintenances).with(start_time, end_time).
+      and_return(unsched_maint_b)
+
+    ep = Flapjack::Gateways::JSONAPI::EntityPresenter.new(entity)
+    unsched_maint = ep.unscheduled_maintenances(start_time, end_time)
+    expect(unsched_maint).to eq([{:entity => entity.name, :check => 'ping', :unscheduled_maintenances => unsched_maint_b},
+                             {:entity => entity.name, :check => 'ssh',  :unscheduled_maintenances => unsched_maint_a}])
+  end
+
+  it "returns a list of scheduled maintenance periods for each check on an entity" do
+    expect_check_presenters
+    sched_maint_a = double('sched_maint_a')
+    sched_maint_b = double('sched_maint_b')
+    expect(checkpres_a).to receive(:scheduled_maintenances).with(start_time, end_time).
+      and_return(sched_maint_a)
+    expect(checkpres_b).to receive(:scheduled_maintenances).with(start_time, end_time).
+      and_return(sched_maint_b)
+
+    ep = Flapjack::Gateways::JSONAPI::EntityPresenter.new(entity)
+    sched_maint = ep.scheduled_maintenances(start_time, end_time)
+    expect(sched_maint).to eq([{:entity => entity.name, :check => 'ping', :scheduled_maintenances => sched_maint_b},
+                           {:entity => entity.name, :check => 'ssh',  :scheduled_maintenances => sched_maint_a}])
+  end
+
+  it "returns a list of downtime for each check on an entity" do
+    expect_check_presenters
+    downtime_a = double('downtime_a')
+    downtime_b = double('downtime_b')
+    expect(checkpres_a).to receive(:downtime).with(start_time, end_time).
+      and_return(downtime_a)
+    expect(checkpres_b).to receive(:downtime).with(start_time, end_time).
+      and_return(downtime_b)
+
+    ep = Flapjack::Gateways::JSONAPI::EntityPresenter.new(entity)
+    downtime = ep.downtime(start_time, end_time)
+    expect(downtime).to eq([{:entity => entity.name, :check => 'ping', :downtime => downtime_b},
+                        {:entity => entity.name, :check => 'ssh',  :downtime => downtime_a}])
+  end
+
+end

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

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'flapjack/gateways/jsonapi'
+
+describe 'Flapjack::Gateways::JSONAPI', :sinatra => true, :logger => true do
+
+  it "handles a route matching failure"
+
+end

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

@@ -17,28 +17,28 @@ describe Flapjack::Gateways::Oobetet, :logger => true do
   let(:stanza) { double('stanza') }
 
   it "raises an error if a required config setting is not set" do
-    Socket.should_receive(:gethostname).and_return('thismachine')
+    expect(Socket).to receive(:gethostname).and_return('thismachine')
 
     fo = Flapjack::Gateways::Oobetet.new(:config => config.delete('watched_check'), :logger => @logger)
 
-    lambda {
+    expect {
       fo.setup
-    }.should raise_error
+    }.to raise_error
   end
 
   it "hooks up event handlers to the appropriate methods" do
     fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
 
-    EventMachine::Synchrony.should_receive(:next_tick).exactly(3).times.and_yield
+    expect(EventMachine::Synchrony).to receive(:next_tick).exactly(3).times.and_yield
 
-    fo.should_receive(:register_handler).with(:ready).and_yield(stanza)
-    fo.should_receive(:on_ready).with(stanza)
+    expect(fo).to receive(:register_handler).with(:ready).and_yield(stanza)
+    expect(fo).to receive(:on_ready).with(stanza)
 
-    fo.should_receive(:register_handler).with(:message, :groupchat?).and_yield(stanza)
-    fo.should_receive(:on_groupchat).with(stanza)
+    expect(fo).to receive(:register_handler).with(:message, :groupchat?).and_yield(stanza)
+    expect(fo).to receive(:on_groupchat).with(stanza)
 
-    fo.should_receive(:register_handler).with(:disconnected).and_yield(stanza)
-    fo.should_receive(:on_disconnect).with(stanza).and_return(true)
+    expect(fo).to receive(:register_handler).with(:disconnected).and_yield(stanza)
+    expect(fo).to receive(:on_disconnect).with(stanza).and_return(true)
 
     fo.register_handlers
   end
@@ -46,8 +46,8 @@ describe Flapjack::Gateways::Oobetet, :logger => true do
   it "joins a chat room after connecting" do
     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))
+    expect(fo).to receive(:write).with(an_instance_of(Blather::Stanza::Presence))
+    expect(fo).to receive(:write).with(an_instance_of(Blather::Stanza::Message))
 
     fo.on_ready(stanza)
   end
@@ -55,11 +55,11 @@ describe Flapjack::Gateways::Oobetet, :logger => true do
   it "reconnects when disconnected (if not quitting)" do
     fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
 
-    EventMachine::Timer.should_receive(:new).with(1).and_yield
-    fo.should_receive(:connect)
+    expect(EventMachine::Timer).to receive(:new).with(1).and_yield
+    expect(fo).to receive(:connect)
 
     ret = fo.on_disconnect(stanza)
-    ret.should be_true
+    expect(ret).to be true
   end
 
   it "records times of a problem status messages" do
@@ -68,14 +68,14 @@ describe Flapjack::Gateways::Oobetet, :logger => true do
 
     t = Time.now
 
-    stanza.should_receive(:body).and_return( %q{PROBLEM: "PING" on foo.bar.net} )
-    Time.should_receive(:now).and_return(t)
+    expect(stanza).to receive(:body).and_return( %q{PROBLEM: "PING" on foo.bar.net} )
+    expect(Time).to receive(:now).and_return(t)
 
     fo.on_groupchat(stanza)
     fo_times = fo.instance_variable_get('@times')
-    fo_times.should_not be_nil
-    fo_times.should have_key(:last_problem)
-    fo_times[:last_problem].should == t.to_i
+    expect(fo_times).not_to be_nil
+    expect(fo_times).to have_key(:last_problem)
+    expect(fo_times[:last_problem]).to eq(t.to_i)
   end
 
   it "records times of a recovery status messages" do
@@ -84,14 +84,14 @@ describe Flapjack::Gateways::Oobetet, :logger => true do
 
     t = Time.now
 
-    stanza.should_receive(:body).and_return( %q{RECOVERY: "PING" on foo.bar.net} )
-    Time.should_receive(:now).and_return(t)
+    expect(stanza).to receive(:body).and_return( %q{RECOVERY: "PING" on foo.bar.net} )
+    expect(Time).to receive(:now).and_return(t)
 
     fo.on_groupchat(stanza)
     fo_times = fo.instance_variable_get('@times')
-    fo_times.should_not be_nil
-    fo_times.should have_key(:last_recovery)
-    fo_times[:last_recovery].should == t.to_i
+    expect(fo_times).not_to be_nil
+    expect(fo_times).to have_key(:last_recovery)
+    expect(fo_times[:last_recovery]).to eq(t.to_i)
   end
 
   it "records times of an acknowledgement status messages" do
@@ -100,26 +100,26 @@ describe Flapjack::Gateways::Oobetet, :logger => true do
 
     t = Time.now
 
-    stanza.should_receive(:body).and_return( %q{ACKNOWLEDGEMENT: "PING" on foo.bar.net} )
-    Time.should_receive(:now).and_return(t)
+    expect(stanza).to receive(:body).and_return( %q{ACKNOWLEDGEMENT: "PING" on foo.bar.net} )
+    expect(Time).to receive(:now).and_return(t)
 
     fo.on_groupchat(stanza)
     fo_times = fo.instance_variable_get('@times')
-    fo_times.should_not be_nil
-    fo_times.should have_key(:last_ack)
-    fo_times[:last_ack].should == t.to_i
+    expect(fo_times).not_to be_nil
+    expect(fo_times).to have_key(:last_ack)
+    expect(fo_times[:last_ack]).to eq(t.to_i)
   end
 
   it "runs a loop checking for recorded problems" do
     timer = double('timer')
-    timer.should_receive(:cancel)
-    EM::Synchrony.should_receive(:add_periodic_timer).with(60).and_return(timer)
+    expect(timer).to receive(:cancel)
+    expect(EM::Synchrony).to receive(:add_periodic_timer).with(60).and_return(timer)
 
     fo = Flapjack::Gateways::Oobetet.new(:config => config, :logger => @logger)
-    fo.should_receive(:register_handler).exactly(3).times
-    fo.should_receive(:connect)
+    expect(fo).to receive(:register_handler).exactly(3).times
+    expect(fo).to receive(:connect)
 
-    EM::Synchrony.should_receive(:sleep).with(10) {
+    expect(EM::Synchrony).to receive(:sleep).with(10) {
       fo.instance_variable_set('@should_quit', true)
       nil
     }

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

@@ -12,34 +12,34 @@ describe Flapjack::Gateways::Pagerduty, :logger => true do
 
   it "prompts the blocking redis connection to quit" do
     shutdown_redis = double('shutdown_redis')
-    shutdown_redis.should_receive(:rpush).with(config['queue'], %q{{"notification_type":"shutdown"}})
-    EM::Hiredis.should_receive(:connect).and_return(shutdown_redis)
+    expect(shutdown_redis).to receive(:rpush).with(config['queue'], %q{{"notification_type":"shutdown"}})
+    expect(EM::Hiredis).to receive(:connect).and_return(shutdown_redis)
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to 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.should_receive(:get).with('sem_pagerduty_acks_running').and_return('true')
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(redis).to receive(:get).with('sem_pagerduty_acks_running').and_return('true')
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
-    fp.should_not_receive(:find_pagerduty_acknowledgements)
+    expect(fp).not_to receive(:find_pagerduty_acknowledgements)
     fp.find_pagerduty_acknowledgements_if_safe
   end
 
   it "looks for acknowledgements if the search is not already running" do
-    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)
+    expect(redis).to receive(:get).with('sem_pagerduty_acks_running').and_return(nil)
+    expect(redis).to receive(:set).with('sem_pagerduty_acks_running', 'true')
+    expect(redis).to receive(:expire).with('sem_pagerduty_acks_running', 300)
 
-    redis.should_receive(:del).with('sem_pagerduty_acks_running')
+    expect(redis).to receive(:del).with('sem_pagerduty_acks_running')
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
-    fp.should_receive(:find_pagerduty_acknowledgements)
+    expect(fp).to receive(:find_pagerduty_acknowledgements)
     fp.find_pagerduty_acknowledgements_if_safe
   end
 
@@ -50,7 +50,7 @@ describe Flapjack::Gateways::Pagerduty, :logger => true do
   # NB: needs to run in synchrony block to catch the evented HTTP requests
   it "looks for acknowledgements via the PagerDuty API" do
     check = 'PING'
-    Time.should_receive(:now).and_return(time)
+    expect(Time).to receive(:now).and_return(time)
     since = (time.utc - (60*60*24*7)).iso8601 # the last week
     unt   = (time.utc + (60*60*24)).iso8601   # 1 day in the future
 
@@ -72,7 +72,7 @@ describe Flapjack::Gateways::Pagerduty, :logger => true do
        with(:headers => {'Authorization'=>['flapjack', 'password123']}).
        to_return(:status => 200, :body => response.to_json, :headers => {})
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
 
@@ -80,22 +80,22 @@ describe Flapjack::Gateways::Pagerduty, :logger => true do
       result = fp.send(:pagerduty_acknowledged?, 'subdomain' => 'flpjck', 'username' => 'flapjack',
         'password' => 'password123', 'check' => check)
 
-      result.should be_a(Hash)
-      result.should have_key(:pg_acknowledged_by)
-      result[:pg_acknowledged_by].should be_a(Hash)
-      result[:pg_acknowledged_by].should have_key('id')
-      result[:pg_acknowledged_by]['id'].should == 'ABCDEFG'
+      expect(result).to be_a(Hash)
+      expect(result).to have_key(:pg_acknowledged_by)
+      expect(result[:pg_acknowledged_by]).to be_a(Hash)
+      expect(result[:pg_acknowledged_by]).to have_key('id')
+      expect(result[:pg_acknowledged_by]['id']).to eq('ABCDEFG')
       EM.stop
     end
 
   end
 
   it "creates acknowledgements when pagerduty acknowledgements are found" do
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
     contact = double('contact')
-    contact.should_receive(:pagerduty_credentials).and_return({
+    expect(contact).to receive(:pagerduty_credentials).and_return({
       'service_key' => '12345678',
       'subdomain"'  => 'flpjck',
       'username'    => 'flapjack',
@@ -103,32 +103,32 @@ describe Flapjack::Gateways::Pagerduty, :logger => true do
     })
 
     entity_check = double('entity_check')
-    entity_check.should_receive(:check).and_return('PING')
-    entity_check.should_receive(:contacts).and_return([contact])
-    entity_check.should_receive(:entity_name).exactly(2).times.and_return('foo-app-01.bar.net')
-    Flapjack::Data::Event.should_receive(:create_acknowledgement).with('foo-app-01.bar.net', 'PING',
+    expect(entity_check).to receive(:check).and_return('PING')
+    expect(entity_check).to receive(:contacts).and_return([contact])
+    expect(entity_check).to receive(:entity_name).exactly(2).times.and_return('foo-app-01.bar.net')
+    expect(Flapjack::Data::Event).to receive(:create_acknowledgement).with('foo-app-01.bar.net', 'PING',
       :summary => 'Acknowledged on PagerDuty', :duration => 14400, :redis => redis)
 
-    Flapjack::Data::Global.should_receive(:unacknowledged_failing_checks).and_return([entity_check])
+    expect(Flapjack::Data::Global).to receive(:unacknowledged_failing_checks).and_return([entity_check])
 
-    fp.should_receive(:pagerduty_acknowledged?).and_return({})
+    expect(fp).to receive(:pagerduty_acknowledged?).and_return({})
 
     fp.send(:find_pagerduty_acknowledgements)
   end
 
   it "runs a blocking loop listening for notifications" do
     timer = double('timer')
-    timer.should_receive(:cancel)
-    EM::Synchrony.should_receive(:add_periodic_timer).with(10).and_return(timer)
+    expect(timer).to receive(:cancel)
+    expect(EM::Synchrony).to receive(:add_periodic_timer).with(10).and_return(timer)
 
-    redis.should_receive(:del).with('sem_pagerduty_acks_running')
+    expect(redis).to receive(:del).with('sem_pagerduty_acks_running')
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fp = Flapjack::Gateways::Pagerduty.new(:config => config, :logger => @logger)
 
     blpop_count = 0
 
-    redis.should_receive(:blpop).twice {
+    expect(redis).to receive(:blpop).twice {
       blpop_count += 1
       if blpop_count == 1
         ["pagerduty_notifications", '{"notification_type":"problem","event_id":"main-example.com:ping",' +
@@ -139,12 +139,12 @@ describe Flapjack::Gateways::Pagerduty, :logger => true do
       end
     }
 
-    fp.should_receive(:test_pagerduty_connection).and_return(true)
-    fp.should_receive(:send_pagerduty_event)
+    expect(fp).to receive(:test_pagerduty_connection).and_return(true)
+    expect(fp).to receive(:send_pagerduty_event)
 
     fp.start
 
-    @logger.errors.should be_empty
+    expect(@logger.errors).to be_empty
   end
 
   it "tests the pagerduty connection" do
@@ -157,12 +157,12 @@ describe Flapjack::Gateways::Pagerduty, :logger => 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 => {})
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to 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
+      expect(ret).to be true
       EM.stop
     end
   end
@@ -177,13 +177,13 @@ describe Flapjack::Gateways::Pagerduty, :logger => 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 => {})
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to 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]
+      expect { ret }.not_to be_nil
+      expect(ret).to eq([200, nil])
       EM.stop
     end
   end

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

@@ -45,7 +45,7 @@ describe Flapjack::Gateways::SmsMessagenet, :logger => true do
       Flapjack::Gateways::SmsMessagenet.perform(message)
       EM.stop
     end
-    req.should have_been_requested
+    expect(req).to have_been_requested
   end
 
   it "truncates a long message a" do
@@ -70,7 +70,7 @@ describe Flapjack::Gateways::SmsMessagenet, :logger => true do
       Flapjack::Gateways::SmsMessagenet.perform(long_msg)
       EM.stop
     end
-    req.should have_been_requested
+    expect(req).to have_been_requested
   end
 
   it "does not send an SMS message with an invalid config" do
@@ -82,7 +82,7 @@ describe Flapjack::Gateways::SmsMessagenet, :logger => true do
       EM.stop
     end
 
-    WebMock.should_not have_requested(:get,
+    expect(WebMock).not_to have_requested(:get,
       "https://www.messagenet.com.au/dotnet/Lodge.asmx/LodgeSMSMessage")
   end