flapjack 0.7.18 → 0.7.19

data/spec/lib/flapjack/data/contact_spec.rb

@@ -209,6 +209,7 @@ describe Flapjack::Data::Contact, :redis => true do
     ec = Flapjack::Data::EntityCheck.for_entity_name(entity_name, 'PING', :redis => @redis)
     t = Time.now.to_i
     ec.update_state('ok', :timestamp => t, :summary => 'a')
+    ec.last_update = t
 
     contact = Flapjack::Data::Contact.find_by_id('362', :redis => @redis)
     eandcs = contact.entities(:checks => true)

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

@@ -1,7 +1,5 @@
 require 'spec_helper'
 
-require 'yajl/json_gem'
-
 require 'flapjack/data/entity'
 require 'flapjack/data/entity_check'
 
@@ -104,14 +102,24 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       ec.should_not be_in_scheduled_maintenance
     end
 
+    it "returns its current maintenance period" do
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+      ec.current_maintenance(:scheduled => true).should be_nil
+
+      t = Time.now.to_i
+
+      ec.create_unscheduled_maintenance(t, half_an_hour, :summary => 'oops')
+      ec.current_maintenance.should == {:start_time => t,
+                                        :duration => half_an_hour,
+                                        :summary => 'oops'}
+    end
+
     it "creates an unscheduled maintenance period" do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_unscheduled_maintenance(:start_time => t, :duration => half_an_hour, :summary => 'oops')
+      ec.create_unscheduled_maintenance(t, half_an_hour, :summary => 'oops')
 
-      timestamp = @redis.get("#{name}:#{check}:unscheduled_maintenance")
-      timestamp.should_not be_nil
-      timestamp.should == t.to_s
+      ec.should be_in_unscheduled_maintenance
 
       umps = ec.maintenances(nil, nil, :scheduled => false)
       umps.should_not be_nil
@@ -134,11 +142,78 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       summary.should == 'oops'
     end
 
+    it "creates an unscheduled maintenance period and ends the current one early", :time => true do
+      t = Time.now.to_i
+      later_t = t + (15 * 60)
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+      ec.create_unscheduled_maintenance(t, half_an_hour, :summary => 'oops')
+      Delorean.time_travel_to( Time.at(later_t) )
+      ec.create_unscheduled_maintenance(later_t, half_an_hour, :summary => 'spoo')
+
+      ec.should be_in_unscheduled_maintenance
+
+      umps = ec.maintenances(nil, nil, :scheduled => false)
+      umps.should_not be_nil
+      umps.should be_an(Array)
+      umps.should have(2).unscheduled_maintenance_periods
+      umps[0].should be_a(Hash)
+
+      start_time = umps[0][:start_time]
+      start_time.should_not be_nil
+      start_time.should be_an(Integer)
+      start_time.should == t
+
+      duration = umps[0][:duration]
+      duration.should_not be_nil
+      duration.should be_a(Float)
+      duration.should == (15 * 60)
+
+      start_time_curr = umps[1][:start_time]
+      start_time_curr.should_not be_nil
+      start_time_curr.should be_an(Integer)
+      start_time_curr.should == later_t
+
+      duration_curr = umps[1][:duration]
+      duration_curr.should_not be_nil
+      duration_curr.should be_a(Float)
+      duration_curr.should == half_an_hour
+    end
+
+    it "ends an unscheduled maintenance period" do
+      t = Time.now.to_i
+      later_t = t + (15 * 60)
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+
+      ec.create_unscheduled_maintenance(t, half_an_hour, :summary => 'oops')
+      ec.should be_in_unscheduled_maintenance
+
+      Delorean.time_travel_to( Time.at(later_t) )
+      ec.should be_in_unscheduled_maintenance
+      ec.end_unscheduled_maintenance(later_t)
+      ec.should_not be_in_unscheduled_maintenance
+
+      umps = ec.maintenances(nil, nil, :scheduled => false)
+      umps.should_not be_nil
+      umps.should be_an(Array)
+      umps.should have(1).unscheduled_maintenance_period
+      umps[0].should be_a(Hash)
+
+      start_time = umps[0][:start_time]
+      start_time.should_not be_nil
+      start_time.should be_an(Integer)
+      start_time.should == t
+
+      duration = umps[0][:duration]
+      duration.should_not be_nil
+      duration.should be_a(Float)
+      duration.should == (15 * 60)
+    end
+
     it "creates a scheduled maintenance period for a future time" do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_scheduled_maintenance(:start_time => t + (60 * 60),
-        :duration => half_an_hour, :summary => "30 minutes")
+      ec.create_scheduled_maintenance(t + (60 * 60),
+        half_an_hour, :summary => "30 minutes")
 
       smps = ec.maintenances(nil, nil, :scheduled => true)
       smps.should_not be_nil
@@ -161,8 +236,8 @@ describe Flapjack::Data::EntityCheck, :redis => true do
     it "creates a scheduled maintenance period covering the current time" do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_scheduled_maintenance(:start_time => t - (60 * 60),
-        :duration => 2 * (60 * 60), :summary => "2 hours")
+      ec.create_scheduled_maintenance(t - (60 * 60),
+        2 * (60 * 60), :summary => "2 hours")
 
       smps = ec.maintenances(nil, nil, :scheduled => true)
       smps.should_not be_nil
@@ -184,8 +259,8 @@ describe Flapjack::Data::EntityCheck, :redis => true do
     it "removes a scheduled maintenance period for a future time" do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_scheduled_maintenance(:start_time => t + (60 * 60),
-        :duration => 2 * (60 * 60), :summary => "2 hours")
+      ec.create_scheduled_maintenance(t + (60 * 60),
+        2 * (60 * 60), :summary => "2 hours")
 
       ec.end_scheduled_maintenance(t + (60 * 60))
 
@@ -200,8 +275,8 @@ describe Flapjack::Data::EntityCheck, :redis => true do
     it "shortens a scheduled maintenance period covering a current time", :time => true do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_scheduled_maintenance(:start_time => t + (60 * 60),
-        :duration => 2 * (60 * 60), :summary => "2 hours")
+      ec.create_scheduled_maintenance(t + (60 * 60),
+        2 * (60 * 60), :summary => "2 hours")
 
       Delorean.time_travel_to( Time.at(t + (90 * 60)) )
 
@@ -218,8 +293,8 @@ describe Flapjack::Data::EntityCheck, :redis => true do
     it "does not alter or remove a scheduled maintenance period covering a past time", :time => true do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_scheduled_maintenance(:start_time => t + (60 * 60),
-        :duration => 2 * (60 * 60), :summary => "2 hours")
+      ec.create_scheduled_maintenance(t + (60 * 60),
+        2 * (60 * 60), :summary => "2 hours")
 
       Delorean.time_travel_to( Time.at(t + (6 * (60 * 60)) ))
 
@@ -239,10 +314,10 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       three_hours_ago = t - (60 * 60 * 3)
 
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_scheduled_maintenance(:start_time => five_hours_ago,
-        :duration => half_an_hour, :summary => "first")
-      ec.create_scheduled_maintenance(:start_time => three_hours_ago,
-        :duration => half_an_hour, :summary => "second")
+      ec.create_scheduled_maintenance(five_hours_ago, half_an_hour,
+        :summary => "first")
+      ec.create_scheduled_maintenance(three_hours_ago, half_an_hour,
+        :summary => "second")
 
       smp = ec.maintenances(nil, nil, :scheduled => true)
       smp.should_not be_nil
@@ -264,10 +339,10 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       three_hours_ago = t - (60 * 60 * 3)
 
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_unscheduled_maintenance(:start_time => five_hours_ago,
-        :duration => half_an_hour, :summary => "first")
-      ec.create_unscheduled_maintenance(:start_time => three_hours_ago,
-        :duration => half_an_hour, :summary => "second")
+      ec.create_unscheduled_maintenance(five_hours_ago,
+        half_an_hour, :summary => "first")
+      ec.create_unscheduled_maintenance(three_hours_ago,
+        half_an_hour, :summary => "second")
 
       ump =  ec.maintenances(nil, nil, :scheduled => false)
       ump.should_not be_nil
@@ -305,6 +380,47 @@ describe Flapjack::Data::EntityCheck, :redis => true do
     state.should == 'critical'
   end
 
+  it "updates enabled checks" do
+    ts = Time.now.to_i
+    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+    ec.last_update = ts
+
+    saved_check_ts = @redis.zscore("current_checks:#{name}", check)
+    saved_check_ts.should_not be_nil
+    saved_check_ts.should == ts
+    saved_entity_ts = @redis.zscore("current_entities", name)
+    saved_entity_ts.should_not be_nil
+    saved_entity_ts.should == ts
+  end
+
+  it "exposes that it is enabled" do
+    @redis.zadd("current_checks:#{name}", Time.now.to_i, check)
+    @redis.zadd("current_entities", Time.now.to_i, name)
+    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+
+    e = ec.enabled?
+    e.should be_true
+  end
+
+  it "exposes that it is disabled" do
+    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+
+    e = ec.enabled?
+    e.should be_false
+  end
+
+  it "disables checks" do
+    @redis.zadd("current_checks:#{name}", Time.now.to_i, check)
+    @redis.zadd("current_entities", Time.now.to_i, name)
+    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+    ec.disable!
+
+    saved_check_ts = @redis.zscore("current_checks:#{name}", check)
+    saved_entity_ts = @redis.zscore("current_entities", name)
+    saved_check_ts.should be_nil
+    saved_entity_ts.should be_nil
+  end
+
   it "does not update state with invalid value" do
     @redis.hset("check:#{name}:#{check}", 'state', 'ok')
 
@@ -386,12 +502,12 @@ describe Flapjack::Data::EntityCheck, :redis => true do
 
     t = Time.now.to_i
 
-    ec.create_scheduled_maintenance(:start_time => time_before(t, 180),
-      :duration => half_an_hour, :summary => "a")
-    ec.create_scheduled_maintenance(:start_time => time_before(t, 120),
-      :duration => half_an_hour, :summary => "b")
-    ec.create_scheduled_maintenance(:start_time => time_before(t, 60),
-      :duration => half_an_hour, :summary => "c")
+    ec.create_scheduled_maintenance(time_before(t, 180),
+      half_an_hour, :summary => "a")
+    ec.create_scheduled_maintenance(time_before(t, 120),
+      half_an_hour, :summary => "b")
+    ec.create_scheduled_maintenance(time_before(t, 60),
+      half_an_hour, :summary => "c")
 
     sched_maint_periods = ec.maintenances(time_before(t, 150), t,
       :scheduled => true)

data/spec/lib/flapjack/data/entity_spec.rb

@@ -90,8 +90,8 @@ describe Flapjack::Data::Entity, :redis => true do
                                 'name'     => name},
                                 :redis => @redis)
 
-    @redis.hset("check:#{name}:ping", 'state', 'OK')
-    @redis.hset("check:#{name}:ssh",  'state', 'OK')
+    @redis.zadd("current_checks:#{name}", Time.now.to_i, "ping")
+    @redis.zadd("current_checks:#{name}", Time.now.to_i, "ssh")
 
     entity = Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
     check_list = entity.check_list
@@ -108,8 +108,8 @@ describe Flapjack::Data::Entity, :redis => true do
                                 'contacts' => []},
                                :redis => @redis)
 
-    @redis.hset("check:#{name}:ping", 'state', 'OK')
-    @redis.hset("check:#{name}:ssh",  'state', 'OK')
+    @redis.zadd("current_checks:#{name}", Time.now.to_i, "ping")
+    @redis.zadd("current_checks:#{name}", Time.now.to_i, "ssh")
 
     entity = Flapjack::Data::Entity.find_by_id(5000, :redis => @redis)
     check_count = entity.check_count

data/spec/lib/flapjack/data/event_spec.rb

@@ -26,14 +26,14 @@ describe Flapjack::Data::Event do
       mock_redis.should_receive(:brpoplpush).with('events', /^events_archive:/, 0).and_return(event_data.to_json)
       mock_redis.should_receive(:expire)
 
-      result = Flapjack::Data::Event.next(:block => true, :archive_events => true, :redis => mock_redis)
+      result = Flapjack::Data::Event.next('events', :block => true, :archive_events => true, :redis => mock_redis)
       result.should be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (blocking, not archiving)" do
       mock_redis.should_receive(:brpop).with('events', 0).and_return(['events', event_data.to_json])
 
-      result = Flapjack::Data::Event.next(:block => true, :archive_events => false, :redis => mock_redis)
+      result = Flapjack::Data::Event.next('events', :block => true, :archive_events => false, :redis => mock_redis)
       result.should be_an_instance_of(Flapjack::Data::Event)
     end
 
@@ -41,14 +41,14 @@ describe Flapjack::Data::Event do
       mock_redis.should_receive(:rpoplpush).with('events', /^events_archive:/).and_return(event_data.to_json)
       mock_redis.should_receive(:expire)
 
-      result = Flapjack::Data::Event.next(:block => false, :archive_events => true, :redis => mock_redis)
+      result = Flapjack::Data::Event.next('events', :block => false, :archive_events => true, :redis => mock_redis)
       result.should be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (non-blocking, not archiving)" do
       mock_redis.should_receive(:rpop).with('events').and_return(event_data.to_json)
 
-      result = Flapjack::Data::Event.next(:block => false, :archive_events => false, :redis => mock_redis)
+      result = Flapjack::Data::Event.next('events', :block => false, :archive_events => false, :redis => mock_redis)
       result.should be_an_instance_of(Flapjack::Data::Event)
     end
 

data/spec/lib/flapjack/data/message_spec.rb

@@ -14,14 +14,13 @@ describe Flapjack::Data::Message do
 
   it "returns its contained data" do
     message = Flapjack::Data::Message.for_contact(contact, :medium => 'email',
-                :address => 'jja@example.com', :notification_contents => {'notification' => 'contents'})
+                :address => 'jja@example.com')
 
     contact.should_receive(:id).and_return('23')
     contact.should_receive(:first_name).and_return('James')
     contact.should_receive(:last_name).and_return('Jameson')
 
-    message.contents.should include('notification' => 'contents',
-                                    'contact_id' => '23',
+    message.contents.should include('contact_id' => '23',
                                     'contact_first_name' => 'James',
                                     'contact_last_name' => 'Jameson',
                                     'media' => 'email',

data/spec/lib/flapjack/data/notification_spec.rb

@@ -9,33 +9,27 @@ describe Flapjack::Data::Notification, :redis => true, :logger => true do
 
   let(:timezone) { mock('timezone') }
 
-  it "generates a notification for an event" do
-    notification = Flapjack::Data::Notification.for_event(event, :type => 'problem',
-      :max_notified_severity => nil, :contacts => [contact],
-      :default_timezone => timezone, :logger => @logger)
-    notification.should_not be_nil
-    notification.event.should == event
-    notification.type.should == 'problem'
-  end
+  it "generates a notification for an event" # do
+  #   notification = Flapjack::Data::Notification.for_event(event, :type => 'problem',
+  #     :max_notified_severity => nil, :contacts => [contact],
+  #     :default_timezone => timezone, :logger => @logger)
+  #   notification.should_not be_nil
+  #   notification.event.should == event
+  #   notification.type.should == 'problem'
+  # end
 
   it "generates messages for contacts" do
-    notification = Flapjack::Data::Notification.for_event(event, :type => 'problem',
-      :max_notified_severity => nil, :contacts => [contact],
-      :default_timezone => timezone, :logger => @logger)
+    # TODO sensible default values for notification, check that they're passed
+    # in message.notification_contents
+    notification = Flapjack::Data::Notification.new
 
     contact.should_receive(:id).and_return('23')
     contact.should_receive(:notification_rules).and_return([])
     contact.should_receive(:media).and_return('email' => 'example@example.com',
                                               'sms'   => '0123456789')
 
-    event.should_receive(:id).and_return('abc-123.com:ping')
-    event.should_receive(:state).and_return('critical')
-    event.should_receive(:summary).and_return('Shiny & happy')
-    event.should_receive(:details).and_return('Really Shiny & happy')
-    event.should_receive(:time).and_return(Time.now.to_i)
-    event.should_receive(:duration).and_return(nil)
-
-    messages = notification.messages
+    messages = notification.messages([contact], :default_timezone => timezone,
+      :logger => @logger)
     messages.should_not be_nil
     messages.should have(2).items
 

data/spec/lib/flapjack/gateways/api/entity_methods_spec.rb

@@ -376,7 +376,7 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
 
     it "deletes an unscheduled maintenance period for an entity check" do
       end_time = Time.now + (60 * 60) # an hour from now
-      entity_check.should_receive(:end_unscheduled_maintenance).with(:end_time => end_time.to_i)
+      entity_check.should_receive(:end_unscheduled_maintenance).with(end_time.to_i)
 
       Flapjack::Data::EntityCheck.should_receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
@@ -396,7 +396,7 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
       Flapjack::Data::EntityCheck.should_receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
       entity_check.should_receive(:create_scheduled_maintenance).
-        with(:summary => 'test', :duration => duration, :start_time => start.getutc.to_i)
+        with(start.getutc.to_i, duration, :summary => 'test')
 
       post "/scheduled_maintenances/#{entity_name_esc}/#{check}?" +
          "start_time=#{CGI.escape(start.iso8601)}&summary=test&duration=#{duration}"

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

@@ -83,6 +83,40 @@ describe Flapjack::Gateways::Jabber, :logger => true do
     fj.on_groupchat(stanza)
   end
 
+  it "strips XML tags from the received message" do
+    stanza.should_receive(:body).
+      and_return('flapjack: tell me about <span style="text-decoration: underline;">' +
+                 '<a href="http://example.org/">example.org</a></span>')
+
+    from = mock('from')
+    from.should_receive(:stripped).and_return('sender')
+    stanza.should_receive(:from).and_return(from)
+
+    redis = mock('redis')
+    entity = mock(Flapjack::Data::Entity)
+    entity.should_receive(:check_list).and_return(['ping'])
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).with('example.org',
+      :redis => redis).and_return(entity)
+
+    entity_check = mock(Flapjack::Data::EntityCheck)
+    entity_check.should_receive(:current_maintenance).with(:scheduled => true).and_return(nil)
+    entity_check.should_receive(:current_maintenance).with(:unscheduled => true).and_return(nil)
+    entity_check.should_receive(:check).and_return('ping')
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).with(entity, 'ping',
+      :redis => redis).and_return(entity_check)
+
+    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))
+
+    fj.on_groupchat(stanza)
+  end
+
   it "receives a message it doesn't understand" do
     stanza.should_receive(:body).once.and_return('flapjack: hello!')
     from = mock('from')

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

@@ -1,7 +1,5 @@
 require 'spec_helper'
 
-require 'yajl/json_gem'
-
 require 'flapjack/gateways/pagerduty'
 
 describe Flapjack::Gateways::Pagerduty, :logger => true do