flapjack 1.6.0 → 2.0.0b1

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

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'flapjack/data/message'
-
-describe Flapjack::Data::Message do
-
-  let(:contact) { double(Flapjack::Data::Contact) }
-
-  it "assigns itself an ID" do
-    message = Flapjack::Data::Message.for_contact(contact)
-    mid = message.id
-    expect(mid).not_to be_nil
-    expect(mid).to be_a(String)
-  end
-
-  it "returns its contained data" do
-    message = Flapjack::Data::Message.for_contact(contact, :medium => 'email',
-                :address => 'jja@example.com')
-
-    expect(contact).to receive(:id).and_return('23')
-    expect(contact).to receive(:first_name).and_return('James')
-    expect(contact).to receive(:last_name).and_return('Jameson')
-
-    expect(message.contents).to include('contact_id' => '23',
-                                    'contact_first_name' => 'James',
-                                    'contact_last_name' => 'Jameson',
-                                    'media' => 'email',
-                                    'address' => 'jja@example.com')
-  end
-
-end

data/spec/lib/flapjack/data/migration_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-require 'flapjack/data/migration'
-require 'flapjack/data/notification_rule'
-
-describe Flapjack::Data::Migration, :redis => true do
-
-  it 'removes an orphaned entity id' do
-    @redis.hset('all_entity_ids_by_name', 'name_1', 'id_2')
-    @redis.hset('all_entity_names_by_id', 'id_1', 'name_1')
-    @redis.hset('all_entity_names_by_id', 'id_2', 'name_1')
-
-    Flapjack::Data::Migration.clear_orphaned_entity_ids(:redis => @redis)
-
-    expect(@redis.hgetall('all_entity_ids_by_name')).to eq('name_1' => 'id_2')
-    expect(@redis.hgetall('all_entity_names_by_id')).to eq('id_2' => 'name_1')
-  end
-
-  it "fixes a notification rule wih no contact association" do
-    contact = Flapjack::Data::Contact.add( {
-        'id'         => 'c362',
-        'first_name' => 'John',
-        'last_name'  => 'Johnson',
-        'email'      => 'johnj@example.com',
-        'media'      => {
-          'pagerduty' => {
-            'service_key' => '123456789012345678901234',
-            'subdomain'   => 'flpjck',
-            'username'    => 'flapjack',
-            'password'    => 'very_secure'
-          },
-        },
-      },
-      :redis => @redis)
-
-    rule = contact.add_notification_rule(
-     :tags               => ["database","physical"],
-     :entities           => ["foo-app-01.example.com"],
-     :time_restrictions  => [],
-     :unknown_media      => [],
-     :warning_media      => ["email"],
-     :critical_media     => ["sms", "email"],
-     :unknown_blackhole  => false,
-     :warning_blackhole  => false,
-     :critical_blackhole => false
-    )
-
-    rule_id = rule.id
-
-    # degrade as the bug had previously
-    @redis.hset("notification_rule:#{rule.id}", 'contact_id', '')
-
-    rule = Flapjack::Data::NotificationRule.find_by_id(rule_id, :redis => @redis)
-    expect(rule).not_to be_nil
-    expect(rule.contact_id).to be_empty
-
-    Flapjack::Data::Migration.correct_notification_rule_contact_linkages(:redis => @redis)
-
-    rule = Flapjack::Data::NotificationRule.find_by_id(rule_id, :redis => @redis)
-    expect(rule).not_to be_nil
-    expect(rule.contact_id).to eq(contact.id)
-  end
-
-  it "removes a disabled check from a medium's alerting checks" do
-    contact = Flapjack::Data::Contact.add( {
-        'id'         => 'c363_a-f@42%*',
-        'first_name' => 'Jane',
-        'last_name'  => 'Janeley',
-        'email'      => 'janej@example.com',
-        'media'      => {
-          'email' => {
-            'address'          => 'janej@example.com',
-            'interval'         => 60,
-            'rollup_threshold' => 5,
-          },
-        },
-      },
-      :redis => @redis)
-
-    entity = Flapjack::Data::Entity.add({ 'id'   => '5000',
-                                          'name' => 'abc-123',
-                                          'contacts' => ['c363_a-f@42%*'] },
-                                          :redis => @redis)
-
-    entity_check_ping = Flapjack::Data::EntityCheck.for_entity_name('abc-123', 'ping', :redis => @redis)
-    entity_check_ping.update_state('critical')
-
-    entity_check_ssh  = Flapjack::Data::EntityCheck.for_entity_name('abc-123', 'ssh', :redis => @redis)
-    entity_check_ssh.update_state('critical')
-
-    contact.add_alerting_check_for_media('email', 'abc-123:ping')
-    contact.add_alerting_check_for_media('email', 'abc-123:ssh')
-
-    expect(contact.alerting_checks_for_media('email')).to eq(['abc-123:ping', 'abc-123:ssh'])
-
-    entity_check_ssh.disable!
-
-    expect(contact.alerting_checks_for_media('email')).to eq(['abc-123:ping', 'abc-123:ssh'])
-
-    Flapjack::Data::Migration.correct_rollup_including_disabled_checks(:redis => @redis)
-
-    expect(contact.alerting_checks_for_media('email')).to eq(['abc-123:ping'])
-  end
-
-end

data/spec/lib/flapjack/data/notification_rule_spec.rb

@@ -1,232 +0,0 @@
-require 'spec_helper'
-require 'flapjack/data/notification_rule'
-
-describe Flapjack::Data::NotificationRule, :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 = wd.to_hash
-    wd[:start_time] = wd.delete(:start_date)
-    wd[:rrules].first[:rule_type] = wd[:rrules].first[:rule_type].sub(/\AIceCube::(\w+)Rule\z/, '\1')
-    wd
-  }
-
-  let(:rule_data) {
-    {:contact_id         => '23',
-     :tags               => ["database","physical"],
-     :regex_tags         => [],
-     :entities           => ["foo-app-01.example.com", "foo-app-10.example.com"],
-     :regex_entities     => [],
-     :time_restrictions  => [ weekdays_8_18 ],
-     :unknown_media      => [],
-     :warning_media      => ["email"],
-     :critical_media     => ["sms", "email"],
-     :unknown_blackhole  => false,
-     :warning_blackhole  => false,
-     :critical_blackhole => false
-    }
-  }
-
-  let(:empty_rule_data) {
-    {:contact_id         => '23',
-     :tags               => [],
-     :regex_tags         => [],
-     :entities           => [],
-     :regex_entities     => [],
-     :time_restrictions  => [ weekdays_8_18 ],
-     :unknown_media      => [],
-     :warning_media      => ["email"],
-     :critical_media     => ["sms", "email"],
-     :unknown_blackhole  => false,
-     :warning_blackhole  => false,
-     :critical_blackhole => false
-    }
-  }
-
-  let(:regex_rule_data) {
-    {:contact_id         => '23',
-     :tags               => [],
-     :regex_tags         => ["^data.*$","^(physical|bare_metal)$"],
-     :entities           => [],
-     :regex_entities     => ['^foo-\S{3}-\d{2}.example.com$','.*abc.*'],
-     :time_restrictions  => [ weekdays_8_18 ],
-     :unknown_media      => [],
-     :warning_media      => ["email"],
-     :critical_media     => ["sms", "email"],
-     :unknown_blackhole  => false,
-     :warning_blackhole  => false,
-     :critical_blackhole => false
-    }
-  }
-
-  let(:rule_id) { 'ABC123' }
-
-  let(:timezone) { ActiveSupport::TimeZone.new("Europe/Moscow") }
-
-  let(:existing_rule) {
-    Flapjack::Data::NotificationRule.add(rule_data, :redis => @redis)
-  }
-
-  let(:existing_empty_rule) {
-    Flapjack::Data::NotificationRule.add(empty_rule_data, :redis => @redis)
-  }
-
-  let(:existing_regex_rule) {
-    Flapjack::Data::NotificationRule.add(regex_rule_data, :redis => @redis)
-  }
-
-  it "checks that a notification rule exists" do
-    expect(Flapjack::Data::NotificationRule.exists_with_id?(existing_rule.id, :redis => @redis)).to be true
-    expect(Flapjack::Data::NotificationRule.exists_with_id?('not_there', :redis => @redis)).to be false
-  end
-
-  it "returns a notification rule if it exists" do
-    rule = Flapjack::Data::NotificationRule.find_by_id(existing_rule.id, :redis => @redis)
-    expect(rule).not_to be_nil
-  end
-
-  it "does not return a notification rule if it does not exist" do
-    rule = Flapjack::Data::NotificationRule.find_by_id('not_there', :redis => @redis)
-    expect(rule).to be_nil
-  end
-
-  it "updates a notification rule" do
-    rule = existing_rule
-
-    expect {
-      expect {
-        errors = rule.update(:warning_blackhole => true)
-        expect(errors).to be_nil
-      }.to change { rule.warning_blackhole }.from(false).to(true)
-    }.not_to change { rule.contact_id }
-  end
-
-  it "converts time restriction data to an IceCube schedule" do
-    sched = Flapjack::Data::NotificationRule.
-              time_restriction_to_icecube_schedule(weekdays_8_18, timezone)
-    expect(sched).not_to be_nil
-  end
-
-  it "generates a JSON string representing its data" do
-    rule = existing_rule
-    # bit of extra hackery for the ID values
-    munged = {:id => rule.id}.merge(rule_data)
-    munged[:links] = {:contacts => [munged.delete(:contact_id)]}
-    expect(rule.to_jsonapi).to eq(Flapjack.dump_json(munged))
-  end
-
-  it "checks whether entity names match" do
-    rule = existing_rule
-
-    expect(rule.match_entity?('foo-app-01.example.com')).to be true
-    expect(rule.match_entity?('foo-app-10.example.com')).to be true
-    expect(rule.match_entity?('foo-app-02.example.com')).to be false
-
-    expect(existing_empty_rule.match_entity?('anything.example.com')).to be true
-  end
-
-  it "checks whether entity names match a regex" do
-    rule = existing_regex_rule
-
-    expect(rule.match_regex_entities?('foo-abc-01.example.com')).to be true
-    expect(rule.match_regex_entities?('foo-abc-99.example.com')).to be true
-    expect(rule.match_regex_entities?('foo-app-01.example.com')).to be false # does not match second regexp_entities
-    expect(rule.match_regex_entities?('foo-abc.example.com')).to be false
-    expect(rule.match_regex_entities?('bar-abc-01.example.com')).to be false
-
-    expect(existing_empty_rule.match_regex_entities?('anything.example.com')).to be true
-  end
-
-  it "checks whether event tags match" do
-    rule = existing_rule
-
-    expect(rule.match_tags?(['database', 'physical'].to_set)).to be true
-    expect(rule.match_tags?(['database', 'physical', 'beetroot'].to_set)).to be true
-    expect(rule.match_tags?(['database'].to_set)).to be false
-    expect(rule.match_tags?(['virtual'].to_set)).to be false
-    expect(rule.match_tags?([].to_set)).to be false
-
-    expect(existing_empty_rule.match_regex_entities?(['virtual'].to_set)).to be true
-  end
-
-  it "checks whether event tags match a regex" do
-    rule = existing_regex_rule
-
-    expect(rule.match_regex_tags?(['database', 'physical'].to_set)).to be true
-    expect(rule.match_regex_tags?(['database', 'physical', 'beetroot'].to_set)).to be true
-    expect(rule.match_regex_tags?(['database'].to_set)).to be false
-    expect(rule.match_regex_tags?(['database.physical'].to_set)).to be false # does not match second regex_tags
-    expect(rule.match_regex_tags?(['data1', 'data2'].to_set)).to be false # does not match second regex_tags
-    expect(rule.match_regex_tags?(['virtual'].to_set)).to be false
-
-    expect(existing_empty_rule.match_regex_entities?(['virtual'].to_set)).to be true
-  end
-
-  it "checks if blackhole settings for a rule match a severity level" do
-    rule_data[:warning_blackhole] = true
-    rule = Flapjack::Data::NotificationRule.add(rule_data, :redis => @redis)
-
-    expect(rule.blackhole?('warning')).to be true
-    expect(rule.blackhole?('critical')).to be false
-  end
-
-  it "returns the media settings for a rule's severity level" do
-    rule = existing_rule
-    expect(rule.media_for_severity('warning')).to eq(['email'])
-    expect(rule.media_for_severity('critical')).to match_array(['email', 'sms'])
-  end
-
-  context 'validation' do
-
-    it "fails to add a notification rule with invalid data" do
-      rule_data[:entities] = [1, {}]
-      rule_or_errors = Flapjack::Data::NotificationRule.add(rule_data, :redis => @redis)
-      expect(rule_or_errors).not_to be_nil
-      expect(rule_or_errors).to be_an(Array)
-      expect(rule_or_errors.size).to eq(1)
-      expect(rule_or_errors).to eq(["Rule entities must be a list of strings"])
-    end
-
-    it "fails to update a notification rule with invalid data" do
-      rule = Flapjack::Data::NotificationRule.add(rule_data, :redis => @redis)
-      expect {
-        rule_data[:entities] = [57]
-        errors = rule.update(rule_data)
-        expect(errors).not_to be_nil
-        expect(errors.size).to eq(1)
-        expect(errors).to eq(["Rule entities must be a list of strings"])
-      }.not_to change { rule.entities }
-    end
-
-    # https://github.com/flapjack/flapjack/issues/549
-    it "fails to add a notification rule with invalid data" do
-      rule_data[:time_restrictions] = [
-        {
-          "start_time" => "2014-06-22 00:00:00",
-          "end_time" => "2015-01-01 00:00:00",
-          "rrules" => [
-            {
-              "validations" => {
-                "day" => [1,2,3,4,5,6,7]
-              },
-              "rule_type" => "Weekly",
-              "interval" => 1,
-              "week_start" => 0
-            }
-          ],
-          "exrules" => [],
-          "rtimes" => [],
-          "extimes" => []
-        }
-      ]
-      rule_or_errors = Flapjack::Data::NotificationRule.add(rule_data, :redis => @redis)
-      expect(rule_or_errors).not_to be_nil
-      expect(rule_or_errors).to be_an(Array)
-      expect(rule_or_errors.size).to eq(1)
-      expect(rule_or_errors).to eq(["Rule time restrictions are invalid"])
-    end
-
-  end
-
-end

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

@@ -1,53 +0,0 @@
-require 'spec_helper'
-require 'flapjack/data/notification'
-
-describe Flapjack::Data::Notification, :redis => true, :logger => true do
-
-  let(:event)   { double(Flapjack::Data::Event) }
-
-  let(:contact) { double(Flapjack::Data::Contact) }
-
-  let(:timezone) { double('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 messages for contacts" do
-    # TODO sensible default values for notification, check that they're passed
-    # in message.notification_contents
-    notification = Flapjack::Data::Notification.new
-
-    expect(contact).to receive(:id).and_return('23')
-    expect(contact).to receive(:notification_rules).and_return([])
-    expect(contact).to receive(:media).and_return('email' => 'example@example.com',
-                                              'sms'   => '0123456789')
-    expect(contact).to receive(:add_alerting_check_for_media).with("email", nil)
-    expect(contact).to receive(:add_alerting_check_for_media).with("sms", nil)
-    expect(contact).to receive(:clean_alerting_checks_for_media).with("email").and_return(0)
-    expect(contact).to receive(:clean_alerting_checks_for_media).with("sms").and_return(0)
-    expect(contact).to receive(:count_alerting_checks_for_media).with("email").and_return(0)
-    expect(contact).to receive(:count_alerting_checks_for_media).with("sms").and_return(0)
-    expect(contact).to receive(:rollup_threshold_for_media).with("email").and_return(nil)
-    expect(contact).to receive(:rollup_threshold_for_media).with("sms").and_return(nil)
-
-    messages = notification.messages([contact], :default_timezone => timezone,
-      :logger => @logger)
-    expect(messages).not_to be_nil
-    expect(messages.size).to eq(2)
-
-    expect(messages.first.contact).to eq(contact)
-    expect(messages.first.medium).to eq('email')
-    expect(messages.first.address).to eq('example@example.com')
-
-    expect(messages.last.contact).to eq(contact)
-    expect(messages.last.medium).to  eq('sms')
-    expect(messages.last.address).to eq('0123456789')
-  end
-
-end

data/spec/lib/flapjack/data/semaphore_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'flapjack/data/semaphore'
-
-describe 'Flapjack::Data::Semaphore', :redis => true do
-
-  it "obtains a lock that locks" do
-    options = {:redis => @redis, :expiry => 60}
-    lock_1 = Flapjack::Data::Semaphore.new('fooey', options)
-    expect(lock_1.class).to eq(Flapjack::Data::Semaphore)
-    expect{Flapjack::Data::Semaphore.new('fooey', options)}.to raise_error(Flapjack::Data::Semaphore::ResourceLocked)
-  end
-
-  it "releases a lock" do
-    options = {:redis => @redis, :expiry => 60}
-    lock_1 = Flapjack::Data::Semaphore.new('fooey', options)
-    expect(lock_1.class).to eq(Flapjack::Data::Semaphore)
-    lock_1.release
-
-    lock_2 = Flapjack::Data::Semaphore.new('fooey', options)
-    expect(lock_2.class).to eq(Flapjack::Data::Semaphore)
-  end
-
-end
-

data/spec/lib/flapjack/filters/acknowledgement_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'flapjack/filters/acknowledgement'
-
-describe Flapjack::Filters::Acknowledgement do
-
-end