flapjack 0.7.11 → 0.7.12

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## Flapjack Changelog
 
+# 0.7.12 - 2013-06-12
+- Feature: auto-generate a general notification rule for contacts that don't have any gh-199 (@ali-graham)
+- Bug: no recovery for unknown for contact with notification rules gh-203 (@jessereynolds)
+- Bug: UNKNOWN -> OK (brief) -> [any problem state] alert is masked by notification interval gh-204 (@jessereynolds)
+
 # 0.7.11 - 2013-06-11
 - Bug: unknown events not fully treated as problems - no notification delay blocking (second swing) gh-154 (@jessereynolds)
 - Bug: correct jabber alias in example acknowledgement strings (second swing) gh-189 (@jessereynolds)

data/features/notification_rules.feature

@@ -29,6 +29,7 @@ Feature: Notification rules on a per contact basis
 
     And user 1 has the following notification rules:
       | entities | entity_tags | warning_media | critical_media   | warning_blackhole | critical_blackhole | time_restrictions |
+      |          |             | email         | sms,email        | true              | true               |                   |
       | foo      |             | email         | sms,email        |                   |                    | 8-18 weekdays     |
       | bar      |             |               | sms,email        | true              |                    |                   |
       | baz      |             | email         | sms,email        |                   |                    |                   |
@@ -41,10 +42,10 @@ Feature: Notification rules on a per contact basis
 
     And user 3 has the following notification rules:
       | entities | entity_tags | warning_media | critical_media   | warning_blackhole | critical_blackhole | time_restrictions |
-      | buf      |             | email         | email            |                   |                    |                   |
-      | buf      |             | sms           | sms              |                   |                    |                   |
       |          |             | email         | email            |                   |                    |                   |
       | baz      |             | sms           | sms              |                   |                    |                   |
+      | buf      |             | email         | email            |                   |                    |                   |
+      | buf      |             | sms           | sms              |                   |                    |                   |
 
   @time_restrictions @time
   Scenario: Alerts only during specified time restrictions
@@ -157,6 +158,22 @@ Feature: Notification rules on a per contact basis
     And   a critical event is received
     Then  2 email alerts should be queued for malak@example.com
 
+  @intervals @time
+  Scenario: Alerts according to custom interval with unknown
+    Given the check is check 'ping' on entity 'bar'
+    And   the check is in an ok state
+    When  an unknown event is received
+    Then  no email alerts should be queued for malak@example.com
+    When  1 minute passes
+    And   an unknown event is received
+    Then  1 email alert should be queued for malak@example.com
+    When  10 minutes passes
+    And   an unknown event is received
+    Then  1 email alert should be queued for malak@example.com
+    When  5 minutes passes
+    And   an unknown event is received
+    Then  2 email alerts should be queued for malak@example.com
+
   @intervals @time
   Scenario: Problem directly after Recovery should alert despite notification intervals
     Given the check is check 'ping' on entity 'baz'
@@ -176,6 +193,25 @@ Feature: Notification rules on a per contact basis
     Then  3 email alerts should be queued for malak@example.com
     And   3 sms alerts should be queued for +61400000001
 
+  @intervals @time
+  Scenario: Problem directly after Recovery should alert despite notification intervals with unknown
+    Given the check is check 'ping' on entity 'baz'
+    And   the check is in an ok state
+    When  an unknown event is received
+    And   1 minute passes
+    And   an unknown event is received
+    Then  1 email alert should be queued for malak@example.com
+    And   1 sms alert should be queued for +61400000001
+    When  an ok event is received
+    Then  2 email alert should be queued for malak@example.com
+    And   2 sms alerts should be queued for +61400000001
+    When  1 minute passes
+    And   an unknown event is received
+    And   1 minute passes
+    And   an unknown event is received
+    Then  3 email alerts should be queued for malak@example.com
+    And   3 sms alerts should be queued for +61400000001
+
   @time
   Scenario: Contact with only entity specific rules should not be notified for other entities they are a contact for
     Given the check is check 'ping' on entity 'buf'

data/features/steps/events_steps.rb

@@ -285,6 +285,13 @@ Given /^user (\d+) has the following notification intervals:$/ do |contact_id, i
 end
 
 Given /^user (\d+) has the following notification rules:$/ do |contact_id, rules|
+  contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => @redis)
+  # delete any autogenerated rules, and do it using redis directly so no new
+  # ones will be created
+  contact.notification_rules.each do |nr|
+    @redis.srem("contact_notification_rules:#{contact_id}", nr.id)
+    @redis.del("notification_rule:#{nr.id}")
+  end
   rules.hashes.each do |rule|
     entities           = rule['entities'].split(',').map { |x| x.strip }
     entity_tags        = rule['entity_tags'].split(',').map { |x| x.strip }

data/lib/flapjack/data/contact.rb

@@ -55,7 +55,10 @@ module Flapjack
         end
 
         self.add_or_update(contact_id, contact_data, :redis => redis)
-        self.find_by_id(contact_id, :redis => redis)
+        if contact = self.find_by_id(contact_id, :redis => redis)
+          contact.notification_rules # invoke to create general rule
+        end
+        contact
       end
 
       def self.delete_all(options = {})
@@ -161,11 +164,26 @@ module Flapjack
       end
 
       # return an array of the notification rules of this contact
-      def notification_rules
-        @redis.smembers("contact_notification_rules:#{self.id}").collect { |rule_id|
-          next if (rule_id.nil? || rule_id == '')
-          Flapjack::Data::NotificationRule.find_by_id(rule_id, {:redis => @redis })
-        }.compact
+      def notification_rules(opts = {})
+        rules = @redis.smembers("contact_notification_rules:#{self.id}").inject([]) do |ret, rule_id|
+          unless (rule_id.nil? || rule_id == '')
+            ret << Flapjack::Data::NotificationRule.find_by_id(rule_id, :redis => @redis)
+          end
+          ret
+        end
+        if rules.all? {|r| r.is_specific? } # also true if empty
+          rule = self.add_notification_rule({
+              :entities           => [],
+              :entity_tags        => [],
+              :time_restrictions  => [],
+              :warning_media      => ['email', 'sms', 'jabber', 'pagerduty'],
+              :critical_media     => ['email', 'sms', 'jabber', 'pagerduty'],
+              :warning_blackhole  => false,
+              :critical_blackhole => false,
+            }, :logger => opts[:logger])
+          rules.unshift(rule)
+        end
+        rules
       end
 
       def add_notification_rule(rule_data, opts = {})

data/lib/flapjack/data/entity_check.rb

@@ -322,6 +322,9 @@ module Flapjack
         last_warning = last_warning_notification
         return STATE_WARNING if last_warning && (last_warning > last_recovery)
 
+        last_unknown = last_unknown_notification
+        return STATE_UNKNOWN if last_unknown && (last_unknown > last_recovery)
+
         nil
       end
 

data/lib/flapjack/data/message.rb

@@ -11,10 +11,13 @@ module Flapjack
   module Data
     class Message
 
-      attr_accessor :medium, :address, :id, :duration, :contact, :notification
+      attr_reader :medium, :address, :duration, :contact
 
-      def self.for_contact(opts = {})
-        self.new(:contact => opts[:contact])
+      def self.for_contact(contact, opts = {})
+        self.new(:contact => contact,
+                 :notification_contents => opts[:notification_contents],
+                 :medium => opts[:medium], :address => opts[:address],
+                 :duration => opts[:duration])
       end
 
       def id
@@ -28,20 +31,23 @@ module Flapjack
       def contents
         c = {'media'              => medium,
              'address'            => address,
-             'id'                 => id}
-        if contact
-          c.update('contact_id'         => contact.id,
-                   'contact_first_name' => contact.first_name,
-                   'contact_last_name'  => contact.last_name)
-        end
+             'id'                 => id,
+             'contact_id'         => contact.id,
+             'contact_first_name' => contact.first_name,
+             'contact_last_name'  => contact.last_name}
         c['duration'] = duration if duration
-        c.update(notification.contents) if notification
+        return c if @notification_contents.nil?
+        c.merge(@notification_contents)
       end
 
     private
 
       def initialize(opts = {})
         @contact = opts[:contact]
+        @notification_contents = opts[:notification_contents]
+        @medium = opts[:medium]
+        @address = opts[:address]
+        @duration = opts[:duration]
       end
 
     end

data/lib/flapjack/data/notification.rb

@@ -8,42 +8,109 @@ module Flapjack
   module Data
     class Notification
 
-      attr_accessor :event, :type, :max_notified_severity
+      attr_reader :event, :type, :max_notified_severity, :contacts,
+        :default_timezone
 
       def self.for_event(event, opts = {})
         self.new(:event => event,
                  :type => opts[:type],
-                 :max_notified_severity => opts[:max_notified_severity])
+                 :max_notified_severity => opts[:max_notified_severity],
+                 :contacts => opts[:contacts],
+                 :default_timezone => opts[:default_timezone],
+                 :logger => opts[:logger])
       end
 
-      def messages(opts = {})
-        contacts = opts[:contacts]
-        return [] if contacts.nil?
+      def messages
+        return [] if contacts.nil? || contacts.empty?
+
+        event_id = event.id
+        event_state = event.state
+
+        severity = if ([event_state, max_notified_severity] & ['critical', 'unknown']).any?
+          'critical'
+        elsif [event_state, max_notified_severity].include?('warning')
+          'warning'
+        else
+          'ok'
+        end
+
+        contents = {'event_id'              => event_id,
+                    'state'                 => event_state,
+                    'summary'               => event.summary,
+                    'details'               => event.details,
+                    'time'                  => event.time,
+                    'duration'              => event.duration || nil,
+                    'notification_type'     => type,
+                    'max_notified_severity' => max_notified_severity }
+
         @messages ||= contacts.collect {|contact|
+          contact_id = contact.id
+          rules = contact.notification_rules
+          media = contact.media
+
+          @logger.debug "considering messages for contact id #{contact_id} #{event_id} #{event_state} (media) #{media.inspect}"
+          rlen = rules.length
+          @logger.debug "found #{rlen} rule#{(rlen == 1) ? '' : 's'} for contact"
+
+          media_to_use = if rules.empty?
+            media
+          else
+            # matchers are rules of the contact that have matched the current event
+            # for time and entity
+            matchers = rules.select do |rule|
+              rule.match_entity?(event_id) &&
+                rule_occurring_now?(rule, :contact => contact, :default_timezone => default_timezone)
+            end
+
+            @logger.debug "#{matchers.length} matchers remain for this contact:"
+            matchers.each do |matcher|
+              @logger.debug "matcher: #{matcher.to_json}"
+            end
+
+            # delete any matchers for all entities if there are more specific matchers
+            if matchers.any? {|matcher| matcher.is_specific? }
+
+              @logger.debug("general removal: found #{matchers.length} entity specific matchers")
+              num_matchers = matchers.length
+
+              matchers.reject! {|matcher| !matcher.is_specific? }
+
+              if num_matchers != matchers.length
+                @logger.debug("notification: removal of general matchers when entity specific matchers are present: number of matchers changed from #{num_matchers} to #{matchers.length} for contact id: #{contact_id}")
+              end
+            end
+
+            # delete media based on blackholes
+            next if matchers.any? {|matcher| matcher.blackhole?(event_state) }
 
-          # TODO move the message filtering logic from executive into this
-          # class and apply here, don't generate message if it won't be sent
+            @logger.debug "notification: num matchers after removing blackhole matchers: #{matchers.size}"
 
-          contact.media.each_pair.inject([]) { |ret, (k, v)|
-            m = Flapjack::Data::Message.for_contact(:contact => contact)
-            m.notification = self
-            m.medium  = k
-            m.address = v
+            rule_media = matchers.collect{|matcher|
+              matcher.media_for_severity(severity)
+            }.flatten.uniq
+
+            @logger.debug "notification: collected media_for_severity(#{severity}): #{rule_media}"
+            rule_media = rule_media.flatten.uniq.reject {|medium|
+              contact.drop_notifications?(:media => medium,
+                                          :check => event_id,
+                                          :state => event_state)
+            }
+
+            @logger.debug "notification: media after contact_drop?: #{rule_media}"
+
+            media.select {|medium, address| rule_media.include?(medium) }
+          end
+
+          @logger.debug "notification: media_to_use: #{media_to_use}"
+
+          media_to_use.each_pair.inject([]) { |ret, (k, v)|
+            m = Flapjack::Data::Message.for_contact(contact,
+              :notification_contents => contents,
+              :medium => k, :address => v)
             ret << m
             ret
           }
-        }.flatten
-      end
-
-      def contents
-        @contents ||= {'event_id'              => event.id,
-                       'state'                 => event.state,
-                       'summary'               => event.summary,
-                       'details'               => event.details,
-                       'time'                  => event.time,
-                       'duration'              => event.duration || nil,
-                       'notification_type'     => type,
-                       'max_notified_severity' => max_notified_severity }
+        }.compact.flatten
       end
 
     private
@@ -53,6 +120,30 @@ module Flapjack
         @event = event
         @type  = opts[:type]
         @max_notified_severity = opts[:max_notified_severity]
+        @contacts = opts[:contacts]
+        @default_timezone = opts[:default_timezone]
+        @logger = opts[:logger]
+      end
+
+      # # time restrictions match?
+      # nil rule.time_restrictions matches
+      # times (start, end) within time restrictions will have any UTC offset removed and will be
+      # considered to be in the timezone of the contact
+      def rule_occurring_now?(rule, options = {})
+        contact = options[:contact]
+        default_timezone = options[:default_timezone]
+
+        return true if rule.time_restrictions.nil? or rule.time_restrictions.empty?
+
+        timezone = contact.timezone(:default => default_timezone)
+        usertime = timezone.now
+
+        rule.time_restrictions.any? do |tr|
+          # add contact's timezone to the time restriction schedule
+          schedule = Flapjack::Data::NotificationRule.
+                       time_restriction_to_icecube_schedule(tr, timezone)
+          schedule && schedule.occurring_at?(usertime)
+        end
       end
 
     end

data/lib/flapjack/data/notification_rule.rb

@@ -95,6 +95,11 @@ module Flapjack
         end
       end
 
+      def is_specific?
+        (!@entities.nil? && !@entities.empty?) ||
+          (!@entity_tags.nil? && !@entity_tags.empty?)
+      end
+
     private
 
       def initialize(rule_data, opts = {})

data/lib/flapjack/executive.rb

@@ -279,171 +279,49 @@ module Flapjack
       end
 
       notification = Flapjack::Data::Notification.for_event(
-        event, :type => notification_type, :max_notified_severity => max_notified_severity)
+        event, :type => notification_type,
+               :max_notified_severity => max_notified_severity,
+               :contacts => contacts,
+               :default_timezone => @default_contact_timezone,
+               :logger => @logger)
 
-      messages = notification.messages(:contacts => contacts)
-      messages = apply_notification_rules(messages, event.state)
-      enqueue_messages(messages)
-    end
-
-    # time restrictions match?
-    # nil rule.time_restrictions matches
-    # times (start, end) within time restrictions will have any UTC offset removed and will be
-    # considered to be in the timezone of the contact
-    def rule_occurring_now?(rule, opts)
-      contact = opts[:contact]
-      return true if rule.time_restrictions.nil? or rule.time_restrictions.empty?
-
-      timezone = contact.timezone(:default => @default_contact_timezone)
-      usertime = timezone.now
-
-      match = rule.time_restrictions.any? do |tr|
-        # add contact's timezone to the time restriction schedule
-        schedule = Flapjack::Data::NotificationRule.
-                     time_restriction_to_icecube_schedule(tr, timezone)
-        schedule && schedule.occurring_at?(usertime)
-      end
-      !!match
-    end
-
-    # delete messages based on entity name(s), tags, severity, time of day
-    def apply_notification_rules(messages, severity)
-      # first get all rules matching entity and time
-      @logger.debug "apply_notification_rules: got messages with size #{messages.size}"
-
-      # don't consider notification rules if the contact has none
-
-      tuple = messages.map do |message|
-        rules    = message.contact.notification_rules
-        event_id = message.notification.event.id
-
-        @logger.debug "considering message for contact: #{message.contact.id} #{message.medium} #{event_id} #{message.notification.event.state}"
-        @logger.debug "found #{rules.length} rules for this message's contact"
-
-        options  = {}
-        options[:no_rules_for_contact] = true if rules.empty?
-
-        # filter based on entity, tags, severity, time of day
-        matchers = rules.find_all do |rule|
-          rule.match_entity?(event_id) && rule_occurring_now?(rule, :contact => message.contact)
-        end
-        @logger.debug "#{matchers.length} matchers remain for this message:"
-        matchers.each {|matcher|
-          @logger.debug "matcher: #{matcher.to_json}"
-        }
-        [message, matchers, options]
-      end
-
-      # matchers are rules of the contact that have matched the current event
-      # for time and entity
-
-      @logger.debug "apply_notification_rules: num messages after entity and time matching: #{tuple.size}"
-
-      # delete any matchers for all entities if there are more specific matchers
-      tuple = tuple.map do |message, matchers, options|
-        num_matchers = matchers.length
-        if matchers.length > 1
-          @logger.debug("general removal when entity specific: #{matchers.length} matchers")
-          have_specific = matchers.detect do |matcher|
-            ( matcher.entities && !matcher.entities.empty? ) or
-              ( matcher.entity_tags && !matcher.entity_tags.empty? )
-          end
-          if have_specific
-            # delete any rules for all entities
-            matchers.reject! do |matcher|
-              ( matcher.entities.nil? || matcher.entities.empty? ) &&
-                ( matcher.entity_tags.nil? || matcher.entity_tags.empty? )
-            end
-          end
-        end
-        if num_matchers != matchers.length
-          @logger.debug("apply_notification_rules: removal of general matchers when entity specific matchers are present: number of matchers changed from #{num_matchers} to #{matchers.length} for message id: #{message.contact.id}, medium: #{message.medium}")
-        end
-        [message, matchers, options]
-      end
-
-      # delete media based on blackholes
-      tuple = tuple.find_all do |message, matchers, options|
-        # or use message.notification.contents['state']
-        matchers.none? {|matcher| matcher.blackhole?(severity) }
-      end
-
-      @logger.debug "apply_notification_rules: num messages after removing blackhole matches: #{tuple.size}"
-
-      # delete any media that doesn't meet severity<->media constraints
-      tuple = tuple.find_all do |message, matchers, options|
-        state = message.notification.event.state
-        max_notified_severity = message.notification.max_notified_severity
-
-        @logger.debug "apply_notification_rules severity-media constraints: considering message: #{message.contact.id} #{message.medium} #{state}"
-        # use EntityCheck#max_notified_severity_of_current_failure
-        # as calculated prior to updating the last_notification* keys
-        # if it's a higher severity than the current state
-        severity = 'ok'
-        case
-        when ([state, max_notified_severity] & ['critical', 'unknown']).any?
-          severity = 'critical'
-        when [state, max_notified_severity].include?('warning')
-          severity = 'warning'
-        end
-
-        no_rules_for_contact = !!options[:no_rules_for_contact]
-        sev_media_matchers = matchers.any? {|matcher|
-            (matcher.media_for_severity(severity) || []).include?(message.medium)
-          }
-        @logger.debug "apply_notification_rules severity-media constraints: no_rules_for_contact: #{no_rules_for_contact}, sev_media_matchers: #{sev_media_matchers}"
-        no_rules_for_contact || sev_media_matchers
-      end
-
-      @logger.debug "apply_notification_rules: num messages after pruning for severity-media constraints: #{tuple.size}"
-
-      # delete media based on notification interval
-      tuple = tuple.find_all do |message, matchers, options|
-        not message.contact.drop_notifications?(:media => message.medium,
-                                                :check => message.notification.event.id,
-                                                :state => message.notification.event.state)
-      end
-
-      @logger.debug "apply_notification_rules: num messages after pruning for notification intervals: #{tuple.size}"
-
-      tuple.map do |message, matchers, options|
-        message
-      end
-    end
-
-    def enqueue_messages(messages)
-
-      messages.each do |message|
+      notification.messages.each do |message|
         media_type = message.medium
         contents   = message.contents
-        event_id   = message.notification.event.id
+        address    = message.address
+        event_id   = event.id
 
         @notifylog.info("#{Time.now.to_s} | #{event_id} | " +
-          "#{message.notification.type} | #{message.contact.id} | #{media_type} | #{message.address}")
+          "#{notification_type} | #{message.contact.id} | #{media_type} | #{address}")
 
         unless @queues[media_type.to_sym]
           @logger.error("no queue for media type: #{media_type}")
           return
         end
 
-        @logger.info("Enqueueing #{media_type} alert for #{event_id} to #{message.address}")
+        @logger.info("Enqueueing #{media_type} alert for #{event_id} to #{address}")
 
-        if message.notification.event.state == 'ok'
+        if event.ok?
           message.contact.update_sent_alert_keys(
-            :media => message.medium,
-            :check => message.notification.event.id,
+            :media => media_type,
+            :check => event_id,
             :state => 'warning',
             :delete => true)
           message.contact.update_sent_alert_keys(
-            :media => message.medium,
-            :check => message.notification.event.id,
+            :media => media_type,
+            :check => event_id,
             :state => 'critical',
             :delete => true)
+          message.contact.update_sent_alert_keys(
+            :media => media_type,
+            :check => event_id,
+            :state => 'unknown',
+            :delete => true)
         else
           message.contact.update_sent_alert_keys(
-            :media => message.medium,
-            :check => message.notification.event.id,
-            :state => message.notification.event.state)
+            :media => media_type,
+            :check => event_id,
+            :state => event.state)
         end
 
         # TODO consider changing Resque jobs to use raw blpop like the others
@@ -460,8 +338,7 @@ module Flapjack
           @redis.rpush(@queues[:pagerduty], Yajl::Encoder.encode(contents))
         end
       end
-
-   end
+    end
 
   end
 end

data/lib/flapjack/version.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
 module Flapjack
-  VERSION = "0.7.11"
+  VERSION = "0.7.12"
 end

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

@@ -20,6 +20,16 @@ describe Flapjack::Data::Contact, :redis => true do
     }
   }
 
+  let(:general_notification_rule_data) {
+    {:entities           => [],
+     :entity_tags        => [],
+     :time_restrictions  => [],
+     :warning_media      => ['email', 'sms', 'jabber', 'pagerduty'],
+     :critical_media     => ['email', 'sms', 'jabber', 'pagerduty'],
+     :warning_blackhole  => false,
+     :critical_blackhole => false}
+  }
+
   before(:each) do
     Flapjack::Data::Contact.add({'id'         => '362',
                                  'first_name' => 'John',
@@ -71,7 +81,7 @@ describe Flapjack::Data::Contact, :redis => true do
 
     nr = contact.notification_rules
     nr.should_not be_nil
-    nr.should have(1).notification_rule
+    nr.should have(2).notification_rules
 
     Flapjack::Data::Contact.add({'id'         => '363',
                                  'first_name' => 'Smithy',
@@ -82,10 +92,9 @@ describe Flapjack::Data::Contact, :redis => true do
     contact = Flapjack::Data::Contact.find_by_id('363', :redis => @redis)
     contact.should_not be_nil
     contact.name.should == 'Smithy Smith'
-
-    nr = contact.notification_rules
-    nr.should_not be_nil
-    nr.should be_empty
+    rules = contact.notification_rules
+    rules.should have(1).notification_rule
+    nr.map(&:id).should_not include(rules.first.id)
   end
 
   it "updates a contact and clears their media settings" do
@@ -101,18 +110,19 @@ describe Flapjack::Data::Contact, :redis => true do
 
     contact.add_notification_rule(notification_rule_data)
 
-    nr = contact.notification_rules
-    nr.should_not be_nil
-    nr.should have(1).notification_rule
+    nr1 = contact.notification_rules
+    nr1.should_not be_nil
+    nr1.should have(2).notification_rules
 
     contact.update('first_name' => 'John',
                    'last_name'  => 'Smith',
                    'email'      => 'johns@example.com')
     contact.name.should == 'John Smith'
 
-    nr = contact.notification_rules
-    nr.should_not be_nil
-    nr.should have(1).notification_rule
+    nr2 = contact.notification_rules
+    nr2.should_not be_nil
+    nr2.should have(2).notification_rules
+    nr1.map(&:id).should == nr2.map(&:id)
   end
 
   it "adds a notification rule for a contact" do
@@ -121,7 +131,7 @@ describe Flapjack::Data::Contact, :redis => true do
 
     expect {
       contact.add_notification_rule(notification_rule_data)
-    }.to change { contact.notification_rules.size }.from(0).to(1)
+    }.to change { contact.notification_rules.size }.from(1).to(2)
   end
 
   it "removes a notification rule from a contact" do
@@ -132,7 +142,38 @@ describe Flapjack::Data::Contact, :redis => true do
 
     expect {
       contact.delete_notification_rule(rule)
-    }.to change { contact.notification_rules.size }.from(1).to(0)
+    }.to change { contact.notification_rules.size }.from(2).to(1)
+  end
+
+  it "creates a general notification rule for a pre-existing contact if none exists" do
+    contact = Flapjack::Data::Contact.find_by_id('363', :redis => @redis)
+
+    @redis.smembers("contact_notification_rules:363").each do |rule_id|
+      @redis.srem("contact_notification_rules:363", rule_id)
+    end
+    @redis.smembers("contact_notification_rules:363").should be_empty
+
+    rules = contact.notification_rules
+    rules.should have(1).rule
+    rule = rules.first
+    [:entities, :entity_tags, :time_restrictions,
+     :warning_media, :critical_media,
+     :warning_blackhole, :critical_blackhole].each do |k|
+      rule.send(k).should == general_notification_rule_data[k]
+    end
+  end
+
+  it "creates a general notification rule for a pre-existing contact if the existing general one was changed" do
+    contact = Flapjack::Data::Contact.find_by_id('363', :redis => @redis)
+    rules = contact.notification_rules
+    rules.should have(1).notification_rule
+    rule = rules.first
+
+    rule.update(notification_rule_data)
+
+    rules = contact.notification_rules
+    rules.should have(2).notification_rules
+    rules.select {|r| r.is_specific? }.should have(1).rule
   end
 
   it "deletes a contact by id, including linked entities, checks, tags and notification rules" do

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

@@ -6,20 +6,15 @@ describe Flapjack::Data::Message do
   let(:contact) { mock(Flapjack::Data::Contact) }
 
   it "assigns itself an ID" do
-    message = Flapjack::Data::Message.for_contact(:contact => contact)
+    message = Flapjack::Data::Message.for_contact(contact)
     mid = message.id
     mid.should_not be_nil
     mid.should be_a(String)
   end
 
   it "returns its contained data" do
-    notification = mock(Flapjack::Data::Notification)
-    notification.should_receive(:contents).and_return('notification' => 'contents')
-
-    message = Flapjack::Data::Message.for_contact(:contact => contact)
-    message.notification = notification
-    message.medium = 'email'
-    message.address = 'jja@example.com'
+    message = Flapjack::Data::Message.for_contact(contact, :medium => 'email',
+                :address => 'jja@example.com', :notification_contents => {'notification' => 'contents'})
 
     contact.should_receive(:id).and_return('23')
     contact.should_receive(:first_name).and_return('James')

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

@@ -1,15 +1,18 @@
 require 'spec_helper'
 require 'flapjack/data/notification'
 
-describe Flapjack::Data::Notification, :redis => true do
+describe Flapjack::Data::Notification, :redis => true, :logger => true do
 
-  let(:event) { mock(Flapjack::Data::Event) }
+  let(:event)   { mock(Flapjack::Data::Event) }
 
   let(:contact) { mock(Flapjack::Data::Contact) }
 
+  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)
+      :max_notified_severity => nil, :contacts => [contact],
+      :default_timezone => timezone, :logger => @logger)
     notification.should_not be_nil
     notification.event.should == event
     notification.type.should == 'problem'
@@ -17,47 +20,32 @@ describe Flapjack::Data::Notification, :redis => true do
 
   it "generates messages for contacts" do
     notification = Flapjack::Data::Notification.for_event(event, :type => 'problem',
-      :max_notified_severity => nil)
+      :max_notified_severity => nil, :contacts => [contact],
+      :default_timezone => timezone, :logger => @logger)
+
+    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')
 
-    messages = notification.messages(:contacts => [contact])
+    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.should_not be_nil
     messages.should have(2).items
 
-    messages.first.notification.should == notification
     messages.first.contact.should == contact
     messages.first.medium.should == 'email'
     messages.first.address.should == 'example@example.com'
 
-    messages.last.notification.should == notification
     messages.last.contact.should == contact
     messages.last.medium.should  == 'sms'
     messages.last.address.should == '0123456789'
   end
 
-  it "returns its contained data" do
-    notification = Flapjack::Data::Notification.for_event(event, :type => 'problem',
-      :max_notified_severity => nil)
-
-    t = Time.now.to_i
-
-    event.should_receive(:id).and_return('example.com:ping')
-    event.should_receive(:state).and_return('ok')
-    event.should_receive(:summary).and_return('Shiny & happy')
-    event.should_receive(:details).and_return('Really Shiny & happy')
-    event.should_receive(:time).and_return(t)
-    event.should_receive(:duration).and_return(nil)
-
-    notification.contents.should == {'event_id'              => 'example.com:ping',
-                                     'state'                 => 'ok',
-                                     'summary'               => 'Shiny & happy',
-                                     'details'               => 'Really Shiny & happy',
-                                     'time'                  => t,
-                                     'duration'              => nil,
-                                     'notification_type'     => 'problem',
-                                     'max_notified_severity' => nil}
-
-  end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flapjack
 version: !ruby/object:Gem::Version
-  version: 0.7.11
+  version: 0.7.12
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-11 00:00:00.000000000 Z
+date: 2013-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dante
@@ -553,7 +553,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3678389315543447731
+      hash: -3589199594353387110
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -562,7 +562,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3678389315543447731
+      hash: -3589199594353387110
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23