flapjack 1.6.0 → 2.0.0b1

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

@@ -4,317 +4,60 @@ require 'flapjack/data/event'
 describe Flapjack::Data::Event do
 
   let(:entity_name) { 'xyz-example.com' }
-  let(:check)       { 'ping' }
-  let(:redis)       { double(::Redis) }
-  let(:multi)       { double('multi') }
+  let(:check_name)  { 'ping' }
+  let(:redis)  { double(Redis) }
 
   let!(:time) { Time.now}
 
-  let(:event_data) { {'type'     => 'service',
-                      'state'    => 'critical',
+  let(:event_data) { {'state'    => 'critical',
                       'entity'   => entity_name,
-                      'check'    => check,
+                      'check'    => check_name,
                       'time'     => time.to_i,
                       'summary'  => 'timeout',
                       'details'  => "couldn't access",
                       'perfdata' => "/=5504MB;5554;6348;0;7935",
                       'acknowledgement_id' => '1234',
-                      'duration' => (60 * 60),
-                      'tags'     => ['dev'] }
-  }
-
-  before(:each) do
-    Flapjack::Data::Event.instance_variable_set('@previous_base_time_str', nil)
-  end
+                      'duration' => (60 * 60) }
+                   }
 
   context 'class' do
 
-    it "returns the next event (blocking, archiving)" do
-      expect(redis).to receive(:brpoplpush).
-        with('events', /^events_archive:/, 0).and_return(event_data.to_json)
-      expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
-      expect(redis).to receive(:sadd).
-        with('known_events_archive_keys', /^events_archive:/)
-      expect(redis).to receive(:expire)
-
-      result = Flapjack::Data::Event.next('events', :block => true,
-        :archive_events => true, :redis => redis)
-      expect(result).to be_an_instance_of(Flapjack::Data::Event)
-    end
-
-    it "returns the next event (blocking, not archiving)" do
-      expect(redis).to receive(:brpop).with('events', 0).
-        and_return(['events', event_data.to_json])
-
-      result = Flapjack::Data::Event.next('events',:block => true,
-        :archive_events => false, :redis => redis)
-      expect(result).to be_an_instance_of(Flapjack::Data::Event)
-    end
-
-    it "returns the next event (non-blocking, archiving)" do
-      expect(redis).to receive(:rpoplpush).
-        with('events', /^events_archive:/).and_return(event_data.to_json)
-      expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
-      expect(redis).to receive(:sadd).
-        with('known_events_archive_keys', /^events_archive:/)
-      expect(redis).to receive(:expire)
-
-      result = Flapjack::Data::Event.next('events', :block => false,
-        :archive_events => true, :redis => redis)
-      expect(result).to be_an_instance_of(Flapjack::Data::Event)
-    end
-
-    it "returns the next event (non-blocking, not archiving)" do
-      expect(redis).to receive(:rpop).with('events').
-        and_return(event_data.to_json)
-
-      result = Flapjack::Data::Event.next('events', :block => false,
-        :archive_events => false, :redis => redis)
-      expect(result).to be_an_instance_of(Flapjack::Data::Event)
-    end
-
-    it "rejects invalid event JSON (archiving)" do
-      bad_event_json = '{{{'
-      expect(redis).to receive(:brpoplpush).
-        with('events', /^events_archive:/, 0).and_return(bad_event_json)
-      expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
-      expect(redis).to receive(:sadd).
-        with('known_events_archive_keys', /^events_archive:/)
-      expect(redis).to receive(:multi).and_yield(multi)
-      expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-      expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-      expect(redis).to receive(:expire)
-
-      result = Flapjack::Data::Event.next('events', :block => true,
-        :archive_events => true, :redis => redis)
-      expect(result).to be_nil
-    end
-
-    it "rejects invalid event JSON (not archiving)" do
-      bad_event_json = '{{{'
-      expect(redis).to receive(:brpop).with('events', 0).
-        and_return(['events', bad_event_json])
-      expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-
-      result = Flapjack::Data::Event.next('events', :block => true,
-        :archive_events => false, :redis => redis)
-      expect(result).to be_nil
-    end
-
-    ['type', 'state', 'entity', 'check'].each do |required_key|
-
-      it "rejects an event with missing '#{required_key}' key (archiving)" do
-        bad_event_data = event_data.clone
-        bad_event_data.delete(required_key)
-        bad_event_json = bad_event_data.to_json
-        expect(redis).to receive(:brpoplpush).
-          with('events', /^events_archive:/, 0).and_return(bad_event_json)
-        expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
-        expect(redis).to receive(:sadd).
-          with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:multi).and_yield(multi)
-        expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(redis).to receive(:expire)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => redis)
-        expect(result).to be_nil
-      end
-
-      it "rejects an event with missing '#{required_key}' key (not archiving)" do
-        bad_event_data = event_data.clone
-        bad_event_data.delete(required_key)
-        bad_event_json = bad_event_data.to_json
-        expect(redis).to receive(:brpop).with('events', 0).
-          and_return(['events', bad_event_json])
-        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => false, :redis => redis)
-        expect(result).to be_nil
-      end
-
-      it "rejects an event with invalid '#{required_key}' key (archiving)" do
-        bad_event_data = event_data.clone
-        bad_event_data[required_key] = {'hello' => 'there'}
-        bad_event_json = bad_event_data.to_json
-        expect(redis).to receive(:brpoplpush).
-          with('events', /^events_archive:/, 0).and_return(bad_event_json)
-        expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
-        expect(redis).to receive(:sadd).
-          with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:multi).and_yield(multi)
-        expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(redis).to receive(:expire)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => redis)
-        expect(result).to be_nil
-      end
-
-      it "rejects an event with invalid '#{required_key}' key (not archiving)" do
-        bad_event_data = event_data.clone
-        bad_event_data[required_key] = {'hello' => 'there'}
-        bad_event_json = bad_event_data.to_json
-        expect(redis).to receive(:brpop).with('events', 0).
-          and_return(['events', bad_event_json])
-        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => false, :redis => redis)
-        expect(result).to be_nil
-      end
-    end
-
-    ['time', 'summary', 'details', 'perfdata', 'acknowledgement_id', 'duration', 'tags'].each do |optional_key|
-      it "rejects an event with invalid '#{optional_key}' key (archiving)" do
-        bad_event_data = event_data.clone
-        bad_event_data[optional_key] = {'hello' => 'there'}
-        bad_event_json = bad_event_data.to_json
-        expect(redis).to receive(:brpoplpush).
-          with('events', /^events_archive:/, 0).and_return(bad_event_json)
-        expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
-        expect(redis).to receive(:sadd).
-          with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:multi).and_yield(multi)
-        expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(redis).to receive(:expire)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => redis)
-        expect(result).to be_nil
-      end
-
-      it "rejects an event with invalid '#{optional_key}' key (not archiving)" do
-        bad_event_data = event_data.clone
-        bad_event_data[optional_key] = {'hello' => 'there'}
-        bad_event_json = bad_event_data.to_json
-        expect(redis).to receive(:brpop).with('events', 0).
-          and_return(['events', bad_event_json])
-        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => false, :redis => redis)
-        expect(result).to be_nil
-      end
-    end
-
-    ['type', 'state'].each do |key|
-
-      it "it matches case-insensitively for #{key} (archiving)" do
-        case_event_data = event_data.clone
-        case_event_data[key] = event_data[key].upcase
-        expect(redis).to receive(:brpoplpush).
-          with('events', /^events_archive:/, 0).and_return(case_event_data.to_json)
-        expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
-        expect(redis).to receive(:sadd).
-          with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:expire)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => redis)
-        expect(result).to be_an_instance_of(Flapjack::Data::Event)
-      end
-
-      it "it matches case-insensitively for #{key} (not archiving)" do
-        case_event_data = event_data.clone
-        case_event_data[key] = event_data[key].upcase
-        expect(redis).to receive(:brpop).with('events', 0).
-          and_return(['events', case_event_data.to_json])
-
-        result = Flapjack::Data::Event.next('events',:block => true,
-          :archive_events => false, :redis => redis)
-        expect(result).to be_an_instance_of(Flapjack::Data::Event)
-      end
-    end
-
-    ['time', 'duration'].each do |key|
-
-      it "it accepts an event with a numeric #{key} key (archiving)" do
-        num_event_data = event_data.clone
-        num_event_data[key] = event_data[key].to_i.to_s
-        expect(redis).to receive(:brpoplpush).
-          with('events', /^events_archive:/, 0).and_return(num_event_data.to_json)
-        expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
-        expect(redis).to receive(:sadd).
-          with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:expire)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => redis)
-        expect(result).to be_an_instance_of(Flapjack::Data::Event)
-      end
-
-      it "it accepts an event with a numeric #{key} key (not archiving)" do
-        num_event_data = event_data.clone
-        num_event_data[key] = event_data[key].to_i.to_s
-        expect(redis).to receive(:brpop).with('events', 0).
-          and_return(['events', num_event_data.to_json])
-
-        result = Flapjack::Data::Event.next('events',:block => true,
-          :archive_events => false, :redis => redis)
-        expect(result).to be_an_instance_of(Flapjack::Data::Event)
-      end
-
-      it "rejects an event with a non-numeric string #{key} key (archiving)" do
-        bad_event_data = event_data.clone
-        bad_event_data[key] = 'NaN'
-        bad_event_json = bad_event_data.to_json
-        expect(redis).to receive(:brpoplpush).
-          with('events', /^events_archive:/, 0).and_return(bad_event_json)
-        expect(Flapjack::Data::Migration).to receive(:purge_expired_archive_index).with(:redis => redis)
-        expect(redis).to receive(:sadd).
-          with('known_events_archive_keys', /^events_archive:/)
-        expect(redis).to receive(:multi).and_yield(multi)
-        expect(multi).to receive(:lrem).with(/^events_archive:/, 1, bad_event_json)
-        expect(multi).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-        expect(redis).to receive(:expire)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => true, :redis => redis)
-        expect(result).to be_nil
-      end
-
-      it "rejects an event with a non-numeric string #{key} key (not archiving)" do
-        bad_event_data = event_data.clone
-        bad_event_data[key] = 'NaN'
-        bad_event_json = bad_event_data.to_json
-        expect(redis).to receive(:brpop).with('events', 0).
-          and_return(['events', bad_event_json])
-        expect(redis).to receive(:lpush).with(/^events_rejected:/, bad_event_json)
-
-        result = Flapjack::Data::Event.next('events', :block => true,
-          :archive_events => false, :redis => redis)
-        expect(result).to be_nil
-      end
+    let(:check) { double(Flapjack::Data::Check) }
 
+    before(:each) do
+      allow(Flapjack).to receive(:redis).and_return(redis)
     end
 
     it "returns a count of pending events" do
       events_len = 23
       expect(redis).to receive(:llen).with('events').and_return(events_len)
 
-      pc = Flapjack::Data::Event.pending_count('events', :redis => redis)
+      pc = Flapjack::Data::Event.pending_count('events')
       expect(pc).to eq(events_len)
     end
 
     it "creates a notification testing event" do
+      expect(check).to receive(:name).and_return(check_name)
+
       expect(Time).to receive(:now).and_return(time)
+      expect(redis).to receive(:multi).and_yield
       expect(redis).to receive(:lpush).with('events', /"testing"/ )
+      expect(redis).to receive(:lpush).with('events_actions', anything)
 
-      Flapjack::Data::Event.test_notifications(entity_name, check,
-        :summary => 'test', :details => 'testing', :redis => redis)
+      Flapjack::Data::Event.test_notifications('events', [check],
+        :summary => 'test', :details => 'testing')
     end
 
     it "creates an acknowledgement event" do
+      expect(check).to receive(:name).and_return(check_name)
+
       expect(Time).to receive(:now).and_return(time)
+      expect(redis).to receive(:multi).and_yield
       expect(redis).to receive(:lpush).with('events', /"acking"/ )
+      expect(redis).to receive(:lpush).with('events_actions', anything)
 
-      Flapjack::Data::Event.create_acknowledgement(entity_name, check,
-        :summary => 'acking', :time => time.to_i, :redis => redis)
+      Flapjack::Data::Event.create_acknowledgements('events', [check],
+        :summary => 'acking', :time => time.to_i)
     end
 
   end
@@ -323,22 +66,64 @@ describe Flapjack::Data::Event do
     let(:event) { Flapjack::Data::Event.new(event_data) }
 
     it "matches the data it is initialised with" do
-      expect(event.entity).to eq(event_data['entity'])
       expect(event.state).to eq(event_data['state'])
       expect(event.duration).to eq(event_data['duration'])
       expect(event.time).to eq(event_data['time'])
       expect(event.id).to eq('xyz-example.com:ping')
-      expect(event.type).to eq('service')
-      expect(event.tags).to be_an_instance_of(Set)
-      expect(event.tags).to include('dev')
-      expect(event.tags).to_not include('prod')
-
-      expect(event).to be_a_service
-      expect(event).to be_a_service
-      expect(event).not_to be_an_acknowledgement
-      expect(event).not_to be_a_test_notifications
-      expect(event).not_to be_ok
-      expect(event).to be_a_failure
+    end
+  end
+
+  [:state, :check].each do |required_key|
+    it "rejects an event with missing '#{required_key}' key" do
+      bad_event_data = event_data.clone
+      bad_event_data.delete(required_key.to_s)
+      bad_event_json = Flapjack.dump_json(bad_event_data)
+
+      _, errors = Flapjack::Data::Event.parse_and_validate(bad_event_json)
+      expect(errors).not_to be_empty
+    end
+
+    it "rejects an event with invalid '#{required_key}' key" do
+      bad_event_data = event_data.clone
+      bad_event_data[required_key] = {'hello' => 'there'}
+      bad_event_json = Flapjack.dump_json(bad_event_data)
+
+      _, errors = Flapjack::Data::Event.parse_and_validate(bad_event_json)
+      expect(errors).not_to be_empty
+    end
+  end
+
+  [:entity, :time, :initial_failure_delay, :repeat_failure_delay, :summary,
+   :details, :perfdata, :acknowledgement_id, :duration].each do |optional_key|
+
+    it "rejects an event with invalid '#{optional_key}' key" do
+      bad_event_data = event_data.clone
+      bad_event_data[optional_key.to_s] = {'hello' => 'there'}
+      bad_event_json = Flapjack.dump_json(bad_event_data)
+
+      _, errors = Flapjack::Data::Event.parse_and_validate(bad_event_json)
+      expect(errors).not_to be_empty
+    end
+
+  end
+
+  [:time, :initial_failure_delay, :repeat_failure_delay, :duration].each do |key|
+    it "accepts an event with a numeric string #{key} key" do
+      numstr_event_data = event_data.clone
+      numstr_event_data[key.to_s] = '352'
+      numstr_event_json = Flapjack.dump_json(numstr_event_data)
+
+      _, errors = Flapjack::Data::Event.parse_and_validate(numstr_event_json)
+      expect(errors).to be_empty
+    end
+
+    it "rejects an event with a non-numeric or numeric string #{key} key" do
+      bad_event_data = event_data.clone
+      bad_event_data[key] = 'NaN'
+      bad_event_json = Flapjack.dump_json(bad_event_data)
+
+      _, errors = Flapjack::Data::Event.parse_and_validate(bad_event_json)
+      expect(errors).not_to be_empty
     end
 
   end

data/spec/lib/flapjack/data/medium_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+require 'flapjack/data/medium'
+
+describe Flapjack::Data::Medium, :redis => true do
+
+  it "requires the interval be set for email" do
+    medium = Flapjack::Data::Medium.new(:transport => 'email')
+    expect(medium.valid?).to be false
+    expect(medium.errors[:interval]).to match_array(["can't be blank", "is not a number"])
+  end
+
+  it "requires the interval be nil for pagerduty" do
+    medium = Flapjack::Data::Medium.new(:transport => 'pagerduty', :interval => 5)
+    expect(medium.valid?).to be false
+    expect(medium.errors[:interval]).to match_array(["must be nil"])
+  end
+
+end

data/spec/lib/flapjack/data/rule_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'flapjack/data/rule'
+
+describe Flapjack::Data::Rule, :redis => true do
+
+  let(:weekdays_8_18) {
+    wd = IceCube::Schedule.new(Time.local(2013,2,1,8,0,0), :duration => 60 * 60 * 10)
+    wd.add_recurrence_rule(IceCube::Rule.weekly.day(:monday, :tuesday, :wednesday, :thursday, :friday))
+    wd
+  }
+
+  let(:seven_fifty_nine)     { Time.local(2013,2,1,7,59,0)  }
+  let(:eight_zero_one)       { Time.local(2013,2,1,8,1,0)   }
+  let(:seventeen_fifty_nine) { Time.local(2013,2,1,17,59,0) }
+  let(:eighteen_zero_one)    { Time.local(2013,2,1,18,1,0)  }
+
+  it 'accepts a valid ical string as a time restriction value' do
+    rule_opts = {:enabled => true, :blackhole => false, :strategy => 'global'}
+
+    rule = Flapjack::Data::Rule.new(rule_opts.merge(:time_restriction_ical => weekdays_8_18.to_ical))
+    expect(rule.is_occurring_at?(seven_fifty_nine)).to be false
+    expect(rule.is_occurring_at?(eight_zero_one)).to be true
+    expect(rule.is_occurring_at?(seventeen_fifty_nine)).to be true
+    expect(rule.is_occurring_at?(eighteen_zero_one)).to be false
+    expect(rule).to be_valid
+
+    rule_2 = Flapjack::Data::Rule.new(rule_opts)
+    rule_2.time_restriction = weekdays_8_18
+    expect(rule_2.is_occurring_at?(seven_fifty_nine)).to be false
+    expect(rule_2.is_occurring_at?(eight_zero_one)).to be true
+    expect(rule_2.is_occurring_at?(seventeen_fifty_nine)).to be true
+    expect(rule_2.is_occurring_at?(eighteen_zero_one)).to be false
+    expect(rule_2).to be_valid
+  end
+
+  it 'rejects an invalid ical string as a time restriction value' do
+    rule_opts = {:enabled => true, :blackhole => false, :strategy => 'global'}
+
+    rule = Flapjack::Data::Rule.new(rule_opts.merge(:time_restriction_ical => 'HAHAHA'))
+    expect(rule.time_restriction).to be_nil
+    expect(rule).not_to be_valid
+  end
+end