flapjack 0.7.6 → 0.7.7

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## Flapjack Changelog
 
+# 0.7.7 - 2012-05-22
+- Bug: relax notification rule validations somewhat gh-185 (@jessereynolds)
+- Chore: log notification rule validation errors from api gh-183 (@jessereynolds)
+
 # 0.7.6 - 2013-05-20
 - Bug: Problems with email notifications (no name, text part missing fields) gh-158 (@ali-graham)
 

data/lib/flapjack/data/contact.rb

@@ -171,9 +171,12 @@ module Flapjack
         }.compact
       end
 
-      def add_notification_rule(rule_data)
+      def add_notification_rule(rule_data, opts = {})
+        if logger = opts[:logger]
+          logger.debug("add_notification_rule: contact_id: #{self.id} (#{self.id.class})")
+        end
         Flapjack::Data::NotificationRule.add(rule_data.merge(:contact_id => self.id),
-          :redis => @redis)
+          :redis => @redis, :logger => opts[:logger])
       end
 
       def delete_notification_rule(rule)

data/lib/flapjack/data/message.rb

@@ -4,6 +4,9 @@
 # from which individual 'Message' objects are created, one for each
 # contact+media recipient.
 
+require 'flapjack/data/contact'
+require 'flapjack/data/notification'
+
 module Flapjack
   module Data
     class Message
@@ -17,9 +20,9 @@ module Flapjack
       def id
         return @id if @id
         t = Time.now
-        # FIXME: consider just using a UUID here
+        # FIXME: consider using a UUID here
         # this is planned to be used as part of alert history keys
-        @id = self.object_id.to_i.to_s + '-' + t.to_i.to_s + '.' + t.tv_usec.to_s
+        @id = "#{self.object_id.to_i}-#{t.to_i}.#{t.tv_usec}"
       end
 
       def contents
@@ -27,12 +30,12 @@ module Flapjack
              'address'            => address,
              'id'                 => id}
         if contact
-          c.merge('contact_id'         => contact.id,
-                  'contact_first_name' => contact.first_name,
-                  'contact_last_name'  => contact.last_name)
+          c.update('contact_id'         => contact.id,
+                   'contact_first_name' => contact.first_name,
+                   'contact_last_name'  => contact.last_name)
         end
         c['duration'] = duration if duration
-        c.merge(notification.contents) if notification
+        c.update(notification.contents) if notification
       end
 
     private

data/lib/flapjack/data/notification.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+require 'flapjack/data/contact'
+require 'flapjack/data/event'
 require 'flapjack/data/message'
 
 module Flapjack
@@ -19,15 +21,14 @@ module Flapjack
         return [] if contacts.nil?
         @messages ||= contacts.collect {|contact|
 
-           # TODO don't include messages here if the contact doesn't have
-           # the medium enabled or has blackholed at this level -- this
-           # will simplify the executive logic
+          # TODO move the message filtering logic from executive into this
+          # class and apply here, don't generate message if it won't be sent
 
-          contact.media.keys.inject([]) { |ret, mk|
+          contact.media.each_pair.inject([]) { |ret, (k, v)|
             m = Flapjack::Data::Message.for_contact(:contact => contact)
             m.notification = self
-            m.medium  = mk
-            m.address = contact.media[mk]
+            m.medium  = k
+            m.address = v
             ret << m
             ret
           }

data/lib/flapjack/data/notification_rule.rb

@@ -37,13 +37,13 @@ module Flapjack
         raise "Redis connection not set" unless redis = options[:redis]
 
         rule_id = SecureRandom.uuid
-        self.add_or_update(rule_data.merge(:id => rule_id), :redis => redis)
+        self.add_or_update(rule_data.merge(:id => rule_id), options)
         self.find_by_id(rule_id, :redis => redis)
       end
 
-      def update(rule_data)
-        return false unless self.class.add_or_update(rule_data.merge(:id => @id),
-          :redis => @redis)
+      def update(rule_data, opts = {})
+        return false unless self.class.add_or_update({:contact_id => @contact_id}.merge(rule_data.merge(:id => @id)),
+          :redis => @redis, :logger => opts[:logger])
         refresh
         true
       end
@@ -108,6 +108,11 @@ module Flapjack
       def self.add_or_update(rule_data, options = {})
         redis = options[:redis]
         raise "a redis connection must be supplied" unless redis
+        logger = options[:logger]
+
+        # make some assumptions about the incoming data
+        rule_data[:warning_blackhole]  = rule_data[:warning_blackhole] || false
+        rule_data[:critical_blackhole] = rule_data[:critical_blackhole] || false
 
         return unless self.validate_data(rule_data, options)
 
@@ -123,6 +128,7 @@ module Flapjack
           :warning_blackhole  => rule_data[:warning_blackhole],
           :critical_blackhole => rule_data[:critical_blackhole],
         }
+        logger.debug("NotificationRule#add_or_update json_rule_data: #{json_rule_data.inspect}") if logger
 
         redis.sadd("contact_notification_rules:#{json_rule_data[:contact_id]}",
                    json_rule_data[:id])
@@ -200,14 +206,16 @@ module Flapjack
         validations = {proc { d.has_key?(:id) } =>
                        "id not set",
 
-                       proc { d.has_key?(:entities) &&
-                              d[:entities].is_a?(Array) &&
-                              d[:entities].all? {|e| e.is_a?(String)} } =>
+                       proc { !d.has_key?(:entities) ||
+                              ( d[:entities].nil? ||
+                                d[:entities].is_a?(Array) &&
+                                d[:entities].all? {|e| e.is_a?(String)} ) } =>
                        "entities must be a list of strings",
 
-                       proc { d.has_key?(:entity_tags) &&
-                              d[:entity_tags].is_a?(Array) &&
-                              d[:entity_tags].all? {|et| et.is_a?(String)}} =>
+                       proc { !d.has_key?(:entity_tags) ||
+                              ( d[:entity_tags].nil? ||
+                                d[:entity_tags].is_a?(Array) &&
+                                d[:entity_tags].all? {|et| et.is_a?(String)} ) } =>
                        "entity_tags must be a list of strings",
 
                        proc { (d.has_key?(:entities) &&
@@ -218,29 +226,32 @@ module Flapjack
                                (d[:entity_tags].size > 0)) } =>
                        "entities or entity tags must have at least one value",
 
-                       proc { d.has_key?(:time_restrictions) &&
-                              d[:time_restrictions].all? {|tr|
-                                !!prepare_time_restriction(symbolize(tr))
-                              }
+                       proc { !d.has_key?(:time_restrictions) ||
+                              ( d[:time_restrictions].nil? ||
+                                d[:time_restrictions].all? {|tr|
+                                  !!prepare_time_restriction(symbolize(tr))
+                                } )
                             } =>
                        "time restrictions are invalid",
 
                        # TODO should the media types be checked against a whitelist?
-                       proc { d.has_key?(:warning_media) &&
-                              d[:warning_media].is_a?(Array) &&
-                              d[:warning_media].all? {|et| et.is_a?(String)}} =>
+                       proc { !d.has_key?(:warning_media) ||
+                              ( d[:warning_media].nil? ||
+                                d[:warning_media].is_a?(Array) &&
+                                d[:warning_media].all? {|et| et.is_a?(String)} ) } =>
                        "warning_media must be a list of strings",
 
-                       proc { d.has_key?(:critical_media) &&
-                              d[:critical_media].is_a?(Array) &&
-                              d[:critical_media].all? {|et| et.is_a?(String)}} =>
+                       proc { !d.has_key?(:critical_media) ||
+                              ( d[:critical_media].nil? ||
+                                d[:critical_media].is_a?(Array) &&
+                                d[:critical_media].all? {|et| et.is_a?(String)} ) } =>
                        "critical_media must be a list of strings",
 
-                       proc { d.has_key?(:warning_blackhole) &&
+                       proc { !d.has_key?(:warning_blackhole) ||
                               [TrueClass, FalseClass].include?(d[:warning_blackhole].class) } =>
                        "warning_blackhole must be true or false",
 
-                       proc { d.has_key?(:critical_blackhole) &&
+                       proc { !d.has_key?(:critical_blackhole) ||
                               [TrueClass, FalseClass].include?(d[:critical_blackhole].class) } =>
                        "critical_blackhole must be true or false",
                       }
@@ -255,6 +266,7 @@ module Flapjack
         if logger = options[:logger]
           error_str = errors.join(", ")
           logger.info "validation error: #{error_str}"
+          logger.debug "rule failing validations: #{d.inspect}"
         end
         false
       end

data/lib/flapjack/gateways/api.rb

@@ -339,13 +339,16 @@ module Flapjack
           return error(403, "post cannot be used for update, do a put instead")
         end
 
+        logger.debug("post /notification_rules data: ")
+        logger.debug(params.inspect)
+
         find_contact(params[:contact_id]) do |contact|
 
           rule_data = hashify(:entities, :entity_tags,
             :warning_media, :critical_media, :time_restrictions,
             :warning_blackhole, :critical_blackhole) {|k| [k, params[k]]}
 
-          unless rule = contact.add_notification_rule(rule_data)
+          unless rule = contact.add_notification_rule(rule_data, :logger => logger)
             return error(403, "invalid notification rule data")
           end
           rule.to_json
@@ -356,6 +359,9 @@ module Flapjack
       # https://github.com/flpjck/flapjack/wiki/API#wiki-put_notification_rules_id
       put('/notification_rules/:id') do
         content_type :json
+        logger.debug("put /notification_rules/#{params[:id]} data: ")
+        logger.debug(params.inspect)
+
         find_rule(params[:id]) do |rule|
           find_contact(rule.contact_id) do |contact|
 
@@ -363,7 +369,7 @@ module Flapjack
               :warning_media, :critical_media, :time_restrictions,
               :warning_blackhole, :critical_blackhole) {|k| [k, params[k]]}
 
-            unless rule.update(rule_data)
+            unless rule.update(rule_data, :logger => logger)
               return error(403, "invalid notification rule data")
             end
             rule.to_json
@@ -374,7 +380,9 @@ module Flapjack
       # Deletes a notification rule
       # https://github.com/flpjck/flapjack/wiki/API#wiki-put_notification_rules_id
       delete('/notification_rules/:id') do
+        logger.debug("delete /notification_rules/#{params[:id]}")
         find_rule(params[:id]) do |rule|
+          logger.debug("rule to delete: #{rule.inspect}, contact_id: #{rule.contact_id}")
           find_contact(rule.contact_id) do |contact|
             contact.delete_notification_rule(rule)
             status 204
@@ -560,6 +568,7 @@ module Flapjack
       end
 
       not_found do
+        logger.debug("in not_found :-(")
         error(404, "not routable")
       end
 
@@ -587,13 +596,13 @@ module Flapjack
 
       # following a callback-heavy pattern -- feels like nodejs :)
       def find_contact(contact_id, &block)
-        contact = Flapjack::Data::Contact.find_by_id(contact_id, :redis => redis)
+        contact = Flapjack::Data::Contact.find_by_id(contact_id.to_s, :redis => redis, :logger => logger)
         return(yield(contact)) if contact
         error(404, "could not find contact with id '#{contact_id}'")
       end
 
       def find_rule(rule_id, &block)
-        rule = Flapjack::Data::NotificationRule.find_by_id(rule_id, :redis => redis)
+        rule = Flapjack::Data::NotificationRule.find_by_id(rule_id, :redis => redis, :logger => logger)
         return(yield(rule)) if rule
         error(404, "could not find notification rule with id '#{rule_id}'")
       end

data/lib/flapjack/version.rb

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

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

@@ -3,10 +3,34 @@ require 'flapjack/data/message'
 
 describe Flapjack::Data::Message do
 
-  it "is generated for a contact"
+  let(:contact) { mock(Flapjack::Data::Contact) }
 
-  it "assigns itself an ID"
+  it "assigns itself an ID" do
+    message = Flapjack::Data::Message.for_contact(:contact => contact)
+    mid = message.id
+    mid.should_not be_nil
+    mid.should be_a(String)
+  end
 
-  it "returns its contained data"
+  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'
+
+    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',
+                                    'contact_first_name' => 'James',
+                                    'contact_last_name' => 'Jameson',
+                                    'media' => 'email',
+                                    'address' => 'jja@example.com')
+  end
 
 end

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

@@ -1,12 +1,61 @@
 require 'spec_helper'
 require 'flapjack/data/notification'
 
-describe Flapjack::Data::Notification do
+describe Flapjack::Data::Notification, :redis => true do
 
-  it "generates a notification for an event"
+  let(:event) { mock(Flapjack::Data::Event) }
 
-  it "generates messages for contacts"
+  let(:contact) { mock(Flapjack::Data::Contact) }
 
-  it "returns its contained data"
+  it "generates a notification for an event" do
+    notification = Flapjack::Data::Notification.for_event(event, :type => 'problem',
+      :max_notified_severity => nil)
+    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)
+    contact.should_receive(:media).and_return('email' => 'example@example.com',
+                                              'sms'   => '0123456789')
+
+    messages = notification.messages(:contacts => [contact])
+    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(:time).and_return(t)
+    event.should_receive(:duration).and_return(nil)
+
+    notification.contents.should == {'event_id'              => 'example.com:ping',
+                                     'state'                 => 'ok',
+                                     'summary'               => 'Shiny & happy',
+                                     'time'                  => t,
+                                     'duration'              => nil,
+                                     'notification_type'     => 'problem',
+                                     'max_notified_severity' => nil}
+
+  end
 
 end

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

@@ -536,7 +536,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "returns the core information of a specified contact" do
     contact.should_receive(:to_json).and_return(contact_core.to_json)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     get "/contacts/#{contact.id}"
     last_response.should be_ok
@@ -545,7 +545,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not return information for a contact that does not exist" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}"
     last_response.should be_not_found
@@ -559,7 +559,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
     contact.should_receive(:notification_rules).and_return(notification_rules)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     get "/contacts/#{contact.id}/notification_rules"
     last_response.should be_ok
@@ -568,7 +568,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not list notification rules for a contact that does not exist" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}/notification_rules"
     last_response.should be_not_found
@@ -577,7 +577,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "returns a specified notification rule" do
     notification_rule.should_receive(:to_json).and_return('"rule_1"')
     Flapjack::Data::NotificationRule.should_receive(:find_by_id).
-      with(notification_rule.id, :redis => redis).and_return(notification_rule)
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
 
     get "/notification_rules/#{notification_rule.id}"
     last_response.should be_ok
@@ -586,7 +586,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not return a notification rule that does not exist" do
     Flapjack::Data::NotificationRule.should_receive(:find_by_id).
-      with(notification_rule.id, :redis => redis).and_return(nil)
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/notification_rules/#{notification_rule.id}"
     last_response.should be_not_found
@@ -595,7 +595,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   # POST /notification_rules
   it "creates a new notification rule" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
     notification_rule.should_receive(:to_json).and_return('"rule_1"')
 
     # symbolize the keys
@@ -605,7 +605,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     notification_rule_data_sym.delete(:contact_id)
 
     contact.should_receive(:add_notification_rule).
-      with(notification_rule_data_sym).and_return(notification_rule)
+      with(notification_rule_data_sym, :logger => @logger).and_return(notification_rule)
 
     post "/notification_rules", notification_rule_data.to_json,
       {'CONTENT_TYPE' => 'application/json'}
@@ -615,7 +615,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not create a notification_rule for a contact that's not present" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     post "/notification_rules", notification_rule_data.to_json,
       {'CONTENT_TYPE' => 'application/json'}
@@ -633,10 +633,10 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   # PUT /notification_rules/RULE_ID
   it "updates a notification rule" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
     notification_rule.should_receive(:to_json).and_return('"rule_1"')
     Flapjack::Data::NotificationRule.should_receive(:find_by_id).
-      with(notification_rule.id, :redis => redis).and_return(notification_rule)
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
 
     # symbolize the keys
     notification_rule_data_sym = notification_rule_data.inject({}){|memo,(k,v)|
@@ -644,7 +644,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     }
     notification_rule_data_sym.delete(:contact_id)
 
-    notification_rule.should_receive(:update).with(notification_rule_data_sym).and_return(true)
+    notification_rule.should_receive(:update).with(notification_rule_data_sym, :logger => @logger).and_return(true)
 
     put "/notification_rules/#{notification_rule.id}", notification_rule_data.to_json,
       {'CONTENT_TYPE' => 'application/json'}
@@ -654,7 +654,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not update a notification rule that's not present" do
     Flapjack::Data::NotificationRule.should_receive(:find_by_id).
-      with(notification_rule.id, :redis => redis).and_return(nil)
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     put "/notification_rules/#{notification_rule.id}", notification_rule_data
     last_response.should be_not_found
@@ -662,9 +662,9 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not update a notification_rule for a contact that's not present" do
     Flapjack::Data::NotificationRule.should_receive(:find_by_id).
-      with(notification_rule.id, :redis => redis).and_return(notification_rule)
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     put "/notification_rules/#{notification_rule.id}", notification_rule_data.to_json,
       {'CONTENT_TYPE' => 'application/json'}
@@ -675,10 +675,10 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "deletes a notification rule" do
     notification_rule.should_receive(:contact_id).and_return(contact.id)
     Flapjack::Data::NotificationRule.should_receive(:find_by_id).
-      with(notification_rule.id, :redis => redis).and_return(notification_rule)
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
     contact.should_receive(:delete_notification_rule).with(notification_rule)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     delete "/notification_rules/#{notification_rule.id}"
     last_response.status.should == 204
@@ -686,7 +686,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not delete a notification rule that's not present" do
     Flapjack::Data::NotificationRule.should_receive(:find_by_id).
-      with(notification_rule.id, :redis => redis).and_return(nil)
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "/notification_rules/#{notification_rule.id}"
     last_response.should be_not_found
@@ -695,9 +695,9 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "does not delete a notification rule if the contact is not present" do
     notification_rule.should_receive(:contact_id).and_return(contact.id)
     Flapjack::Data::NotificationRule.should_receive(:find_by_id).
-      with(notification_rule.id, :redis => redis).and_return(notification_rule)
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "/notification_rules/#{notification_rule.id}"
     last_response.should be_not_found
@@ -708,7 +708,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     contact.should_receive(:media).and_return(media)
     contact.should_receive(:media_intervals).and_return(media_intervals)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
     result = Hash[ *(media.keys.collect {|m|
       [m, {'address'  => media[m],
            'interval' => media_intervals[m] }]
@@ -721,7 +721,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not return the media of a contact if the contact is not present" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}/media"
     last_response.should be_not_found
@@ -732,7 +732,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     contact.should_receive(:media).twice.and_return(media)
     contact.should_receive(:media_intervals).and_return(media_intervals)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     result = {'address' => media['sms'], 'interval' => media_intervals['sms']}
 
@@ -743,7 +743,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not return the media of a contact if the contact is not present" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}/media/sms"
     last_response.should be_not_found
@@ -752,7 +752,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "does not return the media of a contact if the media is not present" do
     contact.should_receive(:media).and_return(media)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     get "/contacts/#{contact.id}/media/telepathy"
     last_response.should be_not_found
@@ -770,7 +770,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     contact.should_receive(:media).and_return(alt_media)
     contact.should_receive(:media_intervals).and_return(alt_media_intervals)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     result = {'address' => alt_media['sms'], 'interval' => alt_media_intervals['sms']}
 
@@ -781,7 +781,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not create a media of a contact that's not present" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     put "/contacts/#{contact.id}/media/sms", {:address => '04987654321', :interval => '200'}
     last_response.should be_not_found
@@ -789,7 +789,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not create a media of a contact if no address is provided" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     put "/contacts/#{contact.id}/media/sms", {:interval => '200'}
     last_response.should be_forbidden
@@ -797,7 +797,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not create a media of a contact if no interval is provided" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     put "/contacts/#{contact.id}/media/sms", {:address => '04987654321'}
     last_response.should be_forbidden
@@ -806,7 +806,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "deletes a media of a contact" do
     contact.should_receive(:remove_media).with('sms')
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     delete "/contacts/#{contact.id}/media/sms"
     last_response.status.should == 204
@@ -814,7 +814,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not delete a media of a contact that's not present" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "/contacts/#{contact.id}/media/sms"
     last_response.should be_not_found
@@ -824,7 +824,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "returns the timezone of a contact" do
     contact.should_receive(:timezone).and_return(::ActiveSupport::TimeZone.new('Australia/Sydney'))
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     get "/contacts/#{contact.id}/timezone"
     last_response.should be_ok
@@ -833,7 +833,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "doesn't get the timezone of a contact that doesn't exist" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "/contacts/#{contact.id}/timezone"
     last_response.should be_not_found
@@ -844,7 +844,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     contact.should_receive(:timezone=).with('Australia/Perth')
     contact.should_receive(:timezone).and_return(ActiveSupport::TimeZone.new('Australia/Perth'))
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     put "/contacts/#{contact.id}/timezone", {:timezone => 'Australia/Perth'}
     last_response.should be_ok
@@ -852,7 +852,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "doesn't set the timezone of a contact who can't be found" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     put "/contacts/#{contact.id}/timezone", {:timezone => 'Australia/Perth'}
     last_response.should be_not_found
@@ -862,7 +862,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "deletes the timezone of a contact" do
     contact.should_receive(:timezone=).with(nil)
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     delete "/contacts/#{contact.id}/timezone"
     last_response.status.should == 204
@@ -870,7 +870,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not delete the timezone of a contact that's not present" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "/contacts/#{contact.id}/timezone"
     last_response.should be_not_found
@@ -974,7 +974,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     contact.should_receive(:add_tags).with('web')
     contact.should_receive(:tags).and_return(['web'])
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     post "contacts/#{contact.id}/tags", :tag => 'web'
     last_response.should be_ok
@@ -983,7 +983,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not set a single tag on a contact that's not found" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     post "contacts/#{contact.id}/tags", :tag => 'web'
     last_response.should be_not_found
@@ -993,7 +993,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     contact.should_receive(:add_tags).with('web', 'app')
     contact.should_receive(:tags).and_return(['web', 'app'])
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     post "contacts/#{contact.id}/tags", :tag => ['web', 'app']
     last_response.should be_ok
@@ -1002,7 +1002,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not set multiple tags on a contact that's not found" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     post "contacts/#{contact.id}/tags", :tag => ['web', 'app']
     last_response.should be_not_found
@@ -1011,7 +1011,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "removes a single tag from a contact" do
     contact.should_receive(:delete_tags).with('web')
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     delete "contacts/#{contact.id}/tags", :tag => 'web'
     last_response.status.should == 204
@@ -1019,7 +1019,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not remove a single tag from a contact that's not found" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "contacts/#{contact.id}/tags", :tag => 'web'
     last_response.should be_not_found
@@ -1028,7 +1028,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "removes multiple tags from a contact" do
     contact.should_receive(:delete_tags).with('web', 'app')
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     delete "contacts/#{contact.id}/tags", :tag => ['web', 'app']
     last_response.status.should == 204
@@ -1036,7 +1036,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not remove multiple tags from a contact that's not found" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "contacts/#{contact.id}/tags", :tag => ['web', 'app']
     last_response.should be_not_found
@@ -1045,7 +1045,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
   it "gets all tags on a contact" do
     contact.should_receive(:tags).and_return(['web', 'app'])
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     get "contacts/#{contact.id}/tags"
     last_response.should be_ok
@@ -1054,7 +1054,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not get all tags on a contact that's not found" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "contacts/#{contact.id}/tags"
     last_response.should be_not_found
@@ -1071,7 +1071,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
       and_return(tag_data)
 
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     get "contacts/#{contact.id}/entity_tags"
     last_response.should be_ok
@@ -1082,7 +1082,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not get all entity tags for a contact that's not found" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     get "contacts/#{contact.id}/entity_tags"
     last_response.should be_not_found
@@ -1103,7 +1103,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     contact.should_receive(:entities).with(:tags => true).and_return(tag_data)
 
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     post "contacts/#{contact.id}/entity_tags",
       :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
@@ -1115,7 +1115,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not add tags to multiple entities for a contact that's not found" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     post "contacts/#{contact.id}/entity_tags",
       :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
@@ -1134,7 +1134,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
     contact.should_receive(:entities).and_return(entities)
 
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(contact)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
 
     delete "contacts/#{contact.id}/entity_tags",
       :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
@@ -1143,7 +1143,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json =>
 
   it "does not delete tags from multiple entities for a contact that's not found" do
     Flapjack::Data::Contact.should_receive(:find_by_id).
-      with(contact.id, :redis => redis).and_return(nil)
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     delete "contacts/#{contact.id}/entity_tags",
       :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flapjack
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.7.7
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-20 00:00:00.000000000 Z
+date: 2013-05-22 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: -549406373323108870
+      hash: 4574905656823869764
 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: -549406373323108870
+      hash: 4574905656823869764
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23