flapjack 0.6.61 → 0.7.0

data/lib/flapjack/gateways/pagerduty.rb

@@ -37,7 +37,7 @@ module Flapjack
 
       def start
         @logger.info("starting")
-        while not test_pagerduty_connection do
+        while not test_pagerduty_connection and not @should_quit do
           @logger.error("Can't connect to the pagerduty API, retrying after 10 seconds")
           EM::Synchrony.sleep(10)
         end

data/lib/flapjack/gateways/web.rb

@@ -19,28 +19,21 @@ module Flapjack
 
     class Web < Sinatra::Base
 
-      if defined?(FLAPJACK_ENV) && 'test'.eql?(FLAPJACK_ENV)
-        # expose test errors properly
-        set :raise_errors, true
-        set :show_exceptions, false
-      else
-        rescue_exception = Proc.new do |env, e|
-          if settings.show_exceptions?
-            # ensure the sinatra error page shows properly
-            request = Sinatra::Request.new(env)
-            printer = Sinatra::ShowExceptions.new(proc{ raise e })
-            s, h, b = printer.call(env)
-            [s, h, b]
-          else
-            @logger.error e.message
-            @logger.error e.backtrace.join("\n")
-            [503, {}, ""]
-          end
+      rescue_exception = Proc.new do |env, e|
+        if settings.show_exceptions?
+          # ensure the sinatra error page shows properly
+          request = Sinatra::Request.new(env)
+          printer = Sinatra::ShowExceptions.new(proc{ raise e })
+          s, h, b = printer.call(env)
+          [s, h, b]
+        else
+          @logger.error e.message
+          @logger.error e.backtrace.join("\n")
+          [503, {}, ""]
         end
-
-        # doesn't work with Rack::Test unless we wrap tests in EM.synchrony blocks
-        use Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception
       end
+      use Rack::FiberPool, :size => 25, :rescue_exception => rescue_exception
+
       use Rack::MethodOverride
 
       class << self
@@ -49,7 +42,13 @@ module Flapjack
 
           @logger.info "starting web - class"
 
-          if @config && @config['access_log']
+          if accesslog = (@config && @config['access_log'])
+            if not File.directory?(File.dirname(accesslog))
+              puts "Parent directory for log file #{accesslog} doesn't exist"
+              puts "Exiting!"
+              exit
+            end
+
             access_logger = Flapjack::AsyncLogger.new(@config['access_log'])
             use Flapjack::CommonLogger, access_logger
           end
@@ -95,6 +94,35 @@ module Flapjack
         haml :self_stats
       end
 
+      get '/self_stats.json' do
+        self_stats
+
+        {
+          'events_queued'    => @events_queued,
+          'failing_services' => @count,
+          'processed_events' => {
+            'all_time' => {
+              'total'   => @event_counters['all'],
+              'ok'      => @event_counters['ok'],
+              'failure' => @event_counters['failure'],
+              'action'  => @event_counters['action'],
+            },
+            'instance' => {
+              'total'   => @event_counters_instance['all'],
+              'ok'      => @event_counters_instance['ok'],
+              'failure' => @event_counters_instance['failure'],
+              'action'  => @event_counters_instance['action'],
+              'average' => @event_rate_all,
+            }
+          },
+          'total_keys' => @keys.length,
+          'uptime'     => @uptime_string,
+          'boottime'   => @boot_time,
+          'current_time' => Time.now,
+          'executive_instances' => @executive_instances,
+        }.to_json
+      end
+
       get '/check' do
         @entity = params[:entity]
         @check  = params[:check]
@@ -217,7 +245,7 @@ module Flapjack
           @pagerduty_credentials = @contact.pagerduty_credentials
         end
 
-        @entities_and_checks = @contact.entities_and_checks.sort_by {|ec|
+        @entities_and_checks = @contact.entities(:checks => true).sort_by {|ec|
           ec[:entity].name
         }
 

data/lib/flapjack/gateways/web/views/self_stats.haml

@@ -23,3 +23,5 @@
       %p Boot time: #{@boot_time}
       %p Current time: #{Time.now}
       %p Executive Instances: #{@executive_instances.inspect}
+      %p
+        %a{:href => 'self_stats.json'} Instrument as JSON

data/lib/flapjack/utility.rb

@@ -42,5 +42,15 @@ module Flapjack
       "#{tzname} (UTC#{tzoffset})"
     end
 
+    def remove_utc_offset(time)
+      Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec)
+    end
+
+    def symbolize(obj)
+      return obj.inject({}){|memo,(k,v)| memo[k.to_sym] =  symbolize(v); memo} if obj.is_a? Hash
+      return obj.inject([]){|memo,v    | memo           << symbolize(v); memo} if obj.is_a? Array
+      return obj
+    end
+
   end
 end

data/lib/flapjack/version.rb

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

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

@@ -1,10 +1,28 @@
 require 'spec_helper'
 
+require 'active_support/time_with_zone'
+require 'ice_cube'
+
 require 'flapjack/data/contact'
 require 'flapjack/data/entity_check'
+require 'flapjack/data/notification_rule'
 
 describe Flapjack::Data::Contact, :redis => true do
 
+  weekdays_8_18 = IceCube::Schedule.new(Time.local(2013,2,1,8,0,0), :duration => 60 * 60 * 10)
+  weekdays_8_18.add_recurrence_rule(IceCube::Rule.weekly.day(:monday, :tuesday, :wednesday, :thursday, :friday))
+
+  let(:notification_rule_data) {
+    {:entity_tags        => ["database","physical"],
+     :entities           => ["foo-app-01.example.com"],
+     :time_restrictions  => [ weekdays_8_18.to_hash ],
+     :warning_media      => ["email"],
+     :critical_media     => ["sms", "email"],
+     :warning_blackhole  => false,
+     :critical_blackhole => false
+    }
+  }
+
   before(:each) do
     Flapjack::Data::Contact.add({'id'         => '362',
                                  'first_name' => 'John',
@@ -42,14 +60,93 @@ describe Flapjack::Data::Contact, :redis => true do
     contact.name.should == "John Johnson"
   end
 
-  it "deletes all contacts" do
-    Flapjack::Data::Contact.delete_all(:redis => @redis)
-    contact = Flapjack::Data::Contact.find_by_id('362', :redis => @redis)
-    contact.should be_nil
+  it "adds a contact with the same id as an existing one, clears notification rules" do
     contact = Flapjack::Data::Contact.find_by_id('363', :redis => @redis)
-    contact.should be_nil
+    contact.should_not be_nil
+
+    contact.add_notification_rule(notification_rule_data)
+
+    nr = contact.notification_rules
+    nr.should_not be_nil
+    nr.should have(1).notification_rule
+
+    Flapjack::Data::Contact.add({'id'         => '363',
+                                 'first_name' => 'Smithy',
+                                 'last_name'  => 'Smith',
+                                 'email'      => 'smithys@example.com'},
+                                 :redis       => @redis)
+
+    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
   end
 
+  it "updates a contact, does not clear notification rules" do
+    contact = Flapjack::Data::Contact.find_by_id('363', :redis => @redis)
+    contact.should_not be_nil
+
+    contact.add_notification_rule(notification_rule_data)
+
+    nr = contact.notification_rules
+    nr.should_not be_nil
+    nr.should have(1).notification_rule
+
+    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
+  end
+
+  it "adds a notification rule for a contact" do
+    contact = Flapjack::Data::Contact.find_by_id('363', :redis => @redis)
+    contact.should_not be_nil
+
+    expect {
+      contact.add_notification_rule(notification_rule_data)
+    }.to change { contact.notification_rules.size }.from(0).to(1)
+  end
+
+  it "removes a notification rule from a contact" do
+    contact = Flapjack::Data::Contact.find_by_id('363', :redis => @redis)
+    contact.should_not be_nil
+
+    rule = contact.add_notification_rule(notification_rule_data)
+
+    expect {
+      contact.delete_notification_rule(rule)
+    }.to change { contact.notification_rules.size }.from(1).to(0)
+  end
+
+  it "deletes a contact by id, including linked entities, checks, tags and notification rules" do
+    contact = Flapjack::Data::Contact.find_by_id('362', :redis => @redis)
+    contact.add_tags('admin')
+
+    entity_name = 'abc-123'
+
+    entity = Flapjack::Data::Entity.add({'id'   => '5000',
+                                         'name' => entity_name,
+                                         'contacts' => ['362']},
+                                         :redis => @redis)
+
+    expect {
+      expect {
+        expect {
+          contact.delete!
+        }.to change { Flapjack::Data::Contact.all(:redis => @redis).size }.by(-1)
+      }.to change { @redis.smembers('contact_tag:admin').size }.by(-1)
+    }.to change { entity.contacts.size }.by(-1)
+  end
+
+  it "deletes all contacts"
+
   it "returns a list of entities and their checks for a contact" do
     entity_name = 'abc-123'
 
@@ -63,7 +160,7 @@ describe Flapjack::Data::Contact, :redis => true do
     ec.update_state('ok', :timestamp => t, :summary => 'a')
 
     contact = Flapjack::Data::Contact.find_by_id('362', :redis => @redis)
-    eandcs = contact.entities_and_checks
+    eandcs = contact.entities(:checks => true)
     eandcs.should_not be_nil
     eandcs.should be_an(Array)
     eandcs.should have(1).entity_and_checks

data/spec/lib/flapjack/data/global_spec.rb

@@ -3,4 +3,6 @@ require 'flapjack/data/global'
 
 describe Flapjack::Data::Global do
 
+  it "returns unacknowledged failing checks"
+
 end

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

@@ -3,4 +3,10 @@ require 'flapjack/data/message'
 
 describe Flapjack::Data::Message do
 
+  it "is generated for a contact"
+
+  it "assigns itself an ID"
+
+  it "returns its contained data"
+
 end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'flapjack/data/notification_rule'
+
+describe Flapjack::Data::NotificationRule do
+
+  it "checks that a notification rule exists"
+
+  it "returns a notification rule if it exists"
+
+  it "does not return a notification rule if it does not exist"
+
+  it "updates a notification rule"
+
+  it "checks whether tag or entity names match"
+
+  it "checks whether times match"
+
+  it "checks if blackhole settings for a rule match a severity level"
+
+  it "returns the media settings for a rule's severity level"
+
+end

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

@@ -3,4 +3,10 @@ require 'flapjack/data/notification'
 
 describe Flapjack::Data::Notification do
 
+  it "generates a notification for an event"
+
+  it "generates messages for contacts"
+
+  it "returns its contained data"
+
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'flapjack/gateways/api'
 
-describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true do
+describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true, :json => true do
 
   def app
     Flapjack::Gateways::API
@@ -14,11 +14,58 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true do
   let(:entity_name_esc) { URI.escape(entity_name) }
   let(:check)           { 'ping' }
 
+  let(:contact)         { mock(Flapjack::Data::Contact, :id => '21') }
+  let(:contact_core)    {
+    {'id'         => contact.id,
+     'first_name' => "Ada",
+     'last_name'  => "Lovelace",
+     'email'      => "ada@example.com",
+     'tags'       => ["legend", "first computer programmer"]
+    }
+  }
+
+  let(:media) {
+    {'email' => 'ada@example.com',
+     'sms'   => '04123456789'
+    }
+  }
+
+  let(:media_intervals) {
+    {'email' => 500,
+     'sms'   => 300
+    }
+  }
+
   let(:entity_presenter)       { mock(Flapjack::Gateways::API::EntityPresenter) }
   let(:entity_check_presenter) { mock(Flapjack::Gateways::API::EntityCheckPresenter) }
 
   let(:redis)           { mock(::Redis) }
 
+  let(:notification_rule) {
+    mock(Flapjack::Data::NotificationRule, :id => '1', :contact_id => '21')
+  }
+
+  let(:notification_rule_data) {
+    {"contact_id"         => "21",
+     "entity_tags"        => ["database","physical"],
+     "entities"           => ["foo-app-01.example.com"],
+     "time_restrictions"  => nil,
+     "warning_media"      => ["email"],
+     "critical_media"     => ["sms", "email"],
+     "warning_blackhole"  => false,
+     "critical_blackhole" => false
+    }
+  }
+
+  before(:all) do
+    Flapjack::Gateways::API.class_eval {
+      set :raise_errors, true
+    }
+    Flapjack::Gateways::API.instance_variable_get('@middleware').delete_if {|m|
+      m[0] == Rack::FiberPool
+    }
+  end
+
   before(:each) do
     Flapjack::RedisPool.should_receive(:new).and_return(redis)
     Flapjack::Gateways::API.instance_variable_set('@config', {})
@@ -290,7 +337,7 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true do
       ]
     }
 
-    Flapjack::Data::Contact.should_receive(:delete_all)
+    Flapjack::Data::Contact.should_receive(:all).with(:redis => redis).and_return([])
     Flapjack::Data::Contact.should_receive(:add).twice
 
     post "/contacts", contacts.to_json, {'CONTENT_TYPE' => 'application/json'}
@@ -298,7 +345,6 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true do
   end
 
   it "does not create contacts if the data is improperly formatted" do
-    Flapjack::Data::Contact.should_not_receive(:delete_all)
     Flapjack::Data::Contact.should_not_receive(:add)
 
     post "/contacts", {'contacts' => ["Hello", "again"]}.to_json,
@@ -321,11 +367,688 @@ describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true do
       ]
     }
 
-    Flapjack::Data::Contact.should_receive(:delete_all)
+    Flapjack::Data::Contact.should_receive(:all).with(:redis => redis).and_return([])
     Flapjack::Data::Contact.should_receive(:add)
 
     post "/contacts", contacts.to_json, {'CONTENT_TYPE' => 'application/json'}
     last_response.status.should == 200
   end
 
+  it "updates a contact if it is already present" do
+    contacts = {'contacts' =>
+      [{"id" => "0362",
+        "first_name" => "John",
+        "last_name" => "Smith",
+        "email" => "johns@example.dom",
+        "media" => {"email"  => "johns@example.dom",
+                    "jabber" => "johns@conference.localhost"}},
+       {"id" => "0363",
+        "first_name" => "Jane",
+        "last_name" => "Jones",
+        "email" => "jane@example.dom",
+        "media" => {"email" => "jane@example.dom"}}
+      ]
+    }
+
+    existing = mock(Flapjack::Data::Contact)
+    existing.should_receive(:id).and_return("0363")
+    existing.should_receive(:update).with(contacts['contacts'][1])
+
+    Flapjack::Data::Contact.should_receive(:all).with(:redis => redis).and_return([existing])
+    Flapjack::Data::Contact.should_receive(:add).with(contacts['contacts'][0], :redis => redis)
+
+    post "/contacts", contacts.to_json, {'CONTENT_TYPE' => 'application/json'}
+    last_response.status.should == 200
+  end
+
+  it "deletes a contact not found in a bulk update list" do
+    contacts = {'contacts' =>
+      [{"id" => "0363",
+        "first_name" => "Jane",
+        "last_name" => "Jones",
+        "email" => "jane@example.dom",
+        "media" => {"email" => "jane@example.dom"}}
+      ]
+    }
+
+    existing = mock(Flapjack::Data::Contact)
+    existing.should_receive(:id).twice.and_return("0362")
+    existing.should_receive(:delete!)
+
+    Flapjack::Data::Contact.should_receive(:all).with(:redis => redis).and_return([existing])
+    Flapjack::Data::Contact.should_receive(:add).with(contacts['contacts'][0], :redis => redis)
+
+    post "/contacts", contacts.to_json, {'CONTENT_TYPE' => 'application/json'}
+    last_response.status.should == 200
+  end
+
+  it "returns all the contacts" do
+    contact.should_receive(:to_json).and_return(contact_core.to_json)
+    Flapjack::Data::Contact.should_receive(:all).with(:redis => redis).
+      and_return([contact])
+
+    get '/contacts'
+    last_response.should be_ok
+    last_response.body.should be_json_eql([contact_core].to_json)
+  end
+
+  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)
+
+    get "/contacts/#{contact.id}"
+    last_response.should be_ok
+    last_response.body.should be_json_eql(contact_core.to_json)
+  end
+
+  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)
+
+    get "/contacts/#{contact.id}"
+    last_response.should be_not_found
+  end
+
+  it "lists a contact's notification rules" do
+    notification_rule_2 = mock(Flapjack::Data::NotificationRule, :id => '2', :contact_id => '21')
+    notification_rule.should_receive(:to_json).and_return('"rule_1"')
+    notification_rule_2.should_receive(:to_json).and_return('"rule_2"')
+    notification_rules = [ notification_rule, notification_rule_2 ]
+
+    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)
+
+    get "/contacts/#{contact.id}/notification_rules"
+    last_response.should be_ok
+    last_response.body.should be_json_eql( '["rule_1", "rule_2"]' )
+  end
+
+  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)
+
+    get "/contacts/#{contact.id}/notification_rules"
+    last_response.should be_not_found
+  end
+
+  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)
+
+    get "/notification_rules/#{notification_rule.id}"
+    last_response.should be_ok
+    last_response.body.should be_json_eql('"rule_1"')
+  end
+
+  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)
+
+    get "/notification_rules/#{notification_rule.id}"
+    last_response.should be_not_found
+  end
+
+  # 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)
+    notification_rule.should_receive(:to_json).and_return('"rule_1"')
+
+    # symbolize the keys
+    notification_rule_data_sym = notification_rule_data.inject({}){|memo,(k,v)|
+      memo[k.to_sym] = v; memo
+    }
+    notification_rule_data_sym.delete(:contact_id)
+
+    contact.should_receive(:add_notification_rule).
+      with(notification_rule_data_sym).and_return(notification_rule)
+
+    post "/notification_rules", notification_rule_data.to_json,
+      {'CONTENT_TYPE' => 'application/json'}
+    last_response.should be_ok
+    last_response.body.should be_json_eql('"rule_1"')
+  end
+
+  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)
+
+    post "/notification_rules", notification_rule_data.to_json,
+      {'CONTENT_TYPE' => 'application/json'}
+    last_response.should be_not_found
+  end
+
+  it "does not create a notification_rule if a rule id is provided" do
+    contact.should_not_receive(:add_notification_rule)
+    Flapjack::Data::Contact.should_receive(:find_by_id).
+      with(contact.id, :redis => redis).and_return(contact)
+
+    post "/notification_rules", notification_rule_data.merge(:id => 1).to_json,
+      {'CONTENT_TYPE' => 'application/json'}
+    last_response.status.should == 403
+  end
+
+  # 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)
+    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)
+
+    # symbolize the keys
+    notification_rule_data_sym = notification_rule_data.inject({}){|memo,(k,v)|
+      memo[k.to_sym] = v; memo
+    }
+    notification_rule_data_sym.delete(:contact_id)
+
+    notification_rule.should_receive(:update).with(notification_rule_data_sym)
+
+    put "/notification_rules/#{notification_rule.id}", notification_rule_data.to_json,
+      {'CONTENT_TYPE' => 'application/json'}
+    last_response.should be_ok
+    last_response.body.should be_json_eql('"rule_1"')
+  end
+
+  it "does not update a notification rule that's not present" do
+    Flapjack::Data::Contact.should_receive(:find_by_id).
+      with(contact.id, :redis => redis).and_return(contact)
+    Flapjack::Data::NotificationRule.should_receive(:find_by_id).
+      with(notification_rule.id, :redis => redis).and_return(nil)
+
+    put "/notification_rules/#{notification_rule.id}", notification_rule_data
+    last_response.should be_not_found
+  end
+
+  it "does not update 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)
+
+    put "/notification_rules/#{notification_rule.id}", notification_rule_data.to_json,
+      {'CONTENT_TYPE' => 'application/json'}
+    last_response.should be_not_found
+  end
+
+  # DELETE /notification_rules/RULE_ID
+  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)
+    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)
+
+    delete "/notification_rules/#{notification_rule.id}"
+    last_response.status.should == 204
+  end
+
+  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)
+
+    delete "/notification_rules/#{notification_rule.id}"
+    last_response.should be_not_found
+  end
+
+  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)
+    Flapjack::Data::Contact.should_receive(:find_by_id).
+      with(contact.id, :redis => redis).and_return(nil)
+
+    delete "/notification_rules/#{notification_rule.id}"
+    last_response.should be_not_found
+  end
+
+  # GET /contacts/CONTACT_ID/media
+  it "returns the media of a contact" do
+    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)
+    result = Hash[ *(media.keys.collect {|m|
+      [m, {'address'  => media[m],
+           'interval' => media_intervals[m] }]
+      }).flatten(1)].to_json
+
+    get "/contacts/#{contact.id}/media"
+    last_response.should be_ok
+    last_response.body.should be_json_eql(result)
+  end
+
+  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)
+
+    get "/contacts/#{contact.id}/media"
+    last_response.should be_not_found
+  end
+
+  # GET /contacts/CONTACT_ID/media/MEDIA
+  it "returns the specified media of a contact" do
+    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)
+
+    result = {'address' => media['sms'], 'interval' => media_intervals['sms']}
+
+    get "/contacts/#{contact.id}/media/sms"
+    last_response.should be_ok
+    last_response.body.should be_json_eql(result.to_json)
+  end
+
+  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)
+
+    get "/contacts/#{contact.id}/media/sms"
+    last_response.should be_not_found
+  end
+
+  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)
+
+    get "/contacts/#{contact.id}/media/telepathy"
+    last_response.should be_not_found
+  end
+
+  # PUT, DELETE /contacts/CONTACT_ID/media/MEDIA
+  it "creates/updates a media of a contact" do
+    # as far as API is concerned these are the same -- contact.rb spec test
+    # may distinguish between them
+    alt_media = media.merge('sms' => '04987654321')
+    alt_media_intervals = media_intervals.merge('sms' => '200')
+
+    contact.should_receive(:set_address_for_media).with('sms', '04987654321')
+    contact.should_receive(:set_interval_for_media).with('sms', '200')
+    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)
+
+    result = {'address' => alt_media['sms'], 'interval' => alt_media_intervals['sms']}
+
+    put "/contacts/#{contact.id}/media/sms", {:address => '04987654321', :interval => '200'}
+    last_response.should be_ok
+    last_response.body.should be_json_eql(result.to_json)
+  end
+
+  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)
+
+    put "/contacts/#{contact.id}/media/sms", {:address => '04987654321', :interval => '200'}
+    last_response.should be_not_found
+  end
+
+  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)
+
+    put "/contacts/#{contact.id}/media/sms", {:interval => '200'}
+    last_response.should be_forbidden
+  end
+
+  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)
+
+    put "/contacts/#{contact.id}/media/sms", {:address => '04987654321'}
+    last_response.should be_forbidden
+  end
+
+  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)
+
+    delete "/contacts/#{contact.id}/media/sms"
+    last_response.status.should == 204
+  end
+
+  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)
+
+    delete "/contacts/#{contact.id}/media/sms"
+    last_response.should be_not_found
+  end
+
+  # GET /contacts/CONTACT_ID/timezone
+  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)
+
+    get "/contacts/#{contact.id}/timezone"
+    last_response.should be_ok
+    last_response.body.should be_json_eql('"Australia/Sydney"')
+  end
+
+  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)
+
+    get "/contacts/#{contact.id}/timezone"
+    last_response.should be_not_found
+  end
+
+  # PUT /contacts/CONTACT_ID/timezone
+  it "sets the timezone of a contact" do
+    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)
+
+    put "/contacts/#{contact.id}/timezone", {:timezone => 'Australia/Perth'}
+    last_response.should be_ok
+  end
+
+  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)
+
+    put "/contacts/#{contact.id}/timezone", {:timezone => 'Australia/Perth'}
+    last_response.should be_not_found
+  end
+
+  # DELETE /contacts/CONTACT_ID/timezone
+  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)
+
+    delete "/contacts/#{contact.id}/timezone"
+    last_response.status.should == 204
+  end
+
+  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)
+
+    delete "/contacts/#{contact.id}/timezone"
+    last_response.should be_not_found
+  end
+
+
+
+  it "sets a single tag on an entity and returns current tags" do
+    entity.should_receive(:add_tags).with('web')
+    entity.should_receive(:tags).and_return(['web'])
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    post "entities/#{entity_name}/tags", :tag => 'web'
+    last_response.should be_ok
+    last_response.body.should be_json_eql( ['web'].to_json )
+  end
+
+  it "does not set a single tag on an entity that's not found" do
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(nil)
+
+    post "entities/#{entity_name}/tags", :tag => 'web'
+    last_response.should be_not_found
+  end
+
+  it "sets multiple tags on an entity and returns current tags" do
+    entity.should_receive(:add_tags).with('web', 'app')
+    entity.should_receive(:tags).and_return(['web', 'app'])
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    # NB submitted at a lower level as tag[]=web&tag[]=app
+    post "entities/#{entity_name}/tags", :tag => ['web', 'app']
+    last_response.should be_ok
+    last_response.body.should be_json_eql( ['web', 'app'].to_json )
+  end
+
+  it "does not set multiple tags on an entity that's not found" do
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(nil)
+
+    post "entities/#{entity_name}/tags", :tag => ['web', 'app']
+    last_response.should be_not_found
+  end
+
+  it "removes a single tag from an entity" do
+    entity.should_receive(:delete_tags).with('web')
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    delete "entities/#{entity_name}/tags", :tag => 'web'
+    last_response.status.should == 204
+  end
+
+  it "does not remove a single tag from an entity that's not found" do
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(nil)
+
+    delete "entities/#{entity_name}/tags", :tag => 'web'
+    last_response.should be_not_found
+  end
+
+  it "removes multiple tags from an entity" do
+    entity.should_receive(:delete_tags).with('web', 'app')
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    delete "entities/#{entity_name}/tags", :tag => ['web', 'app']
+    last_response.status.should == 204
+  end
+
+  it "does not remove multiple tags from an entity that's not found" do
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(nil)
+
+    delete "entities/#{entity_name}/tags", :tag => ['web', 'app']
+    last_response.should be_not_found
+  end
+
+  it "gets all tags on an entity" do
+    entity.should_receive(:tags).and_return(['web', 'app'])
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "entities/#{entity_name}/tags"
+    last_response.should be_ok
+    last_response.body.should be_json_eql( ['web', 'app'].to_json )
+  end
+
+  it "does not get all tags on an entity that's not found" do
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(nil)
+
+    get "entities/#{entity_name}/tags"
+    last_response.should be_not_found
+  end
+
+
+  it "sets a single tag on a contact and returns current tags" do
+    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)
+
+    post "contacts/#{contact.id}/tags", :tag => 'web'
+    last_response.should be_ok
+    last_response.body.should be_json_eql( ['web'].to_json )
+  end
+
+  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)
+
+    post "contacts/#{contact.id}/tags", :tag => 'web'
+    last_response.should be_not_found
+  end
+
+  it "sets multiple tags on a contact and returns current tags" do
+    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)
+
+    post "contacts/#{contact.id}/tags", :tag => ['web', 'app']
+    last_response.should be_ok
+    last_response.body.should be_json_eql( ['web', 'app'].to_json )
+  end
+
+  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)
+
+    post "contacts/#{contact.id}/tags", :tag => ['web', 'app']
+    last_response.should be_not_found
+  end
+
+  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)
+
+    delete "contacts/#{contact.id}/tags", :tag => 'web'
+    last_response.status.should == 204
+  end
+
+  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)
+
+    delete "contacts/#{contact.id}/tags", :tag => 'web'
+    last_response.should be_not_found
+  end
+
+  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)
+
+    delete "contacts/#{contact.id}/tags", :tag => ['web', 'app']
+    last_response.status.should == 204
+  end
+
+  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)
+
+    delete "contacts/#{contact.id}/tags", :tag => ['web', 'app']
+    last_response.should be_not_found
+  end
+
+  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)
+
+    get "contacts/#{contact.id}/tags"
+    last_response.should be_ok
+    last_response.body.should be_json_eql( ['web', 'app'].to_json )
+  end
+
+  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)
+
+    get "contacts/#{contact.id}/tags"
+    last_response.should be_not_found
+  end
+
+  it "gets all entity tags for a contact" do
+    entity_1 = mock(Flapjack::Data::Entity)
+    entity_1.should_receive(:name).and_return('entity_1')
+    entity_2 = mock(Flapjack::Data::Entity)
+    entity_2.should_receive(:name).and_return('entity_2')
+    tag_data = [{:entity => entity_1, :tags => ['web']},
+                {:entity => entity_2, :tags => ['app']}]
+    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)
+
+    get "contacts/#{contact.id}/entity_tags"
+    last_response.should be_ok
+    tag_response = {'entity_1' => ['web'],
+                    'entity_2' => ['app']}
+    last_response.body.should be_json_eql( tag_response.to_json )
+  end
+
+  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)
+
+    get "contacts/#{contact.id}/entity_tags"
+    last_response.should be_not_found
+  end
+
+  it "adds tags to multiple entities for a contact" do
+    entity_1 = mock(Flapjack::Data::Entity)
+    entity_1.should_receive(:name).twice.and_return('entity_1')
+    entity_1.should_receive(:add_tags).with('web')
+    entity_2 = mock(Flapjack::Data::Entity)
+    entity_2.should_receive(:name).twice.and_return('entity_2')
+    entity_2.should_receive(:add_tags).with('app')
+
+    entities = [{:entity => entity_1}, {:entity => entity_2}]
+    contact.should_receive(:entities).and_return(entities)
+    tag_data = [{:entity => entity_1, :tags => ['web']},
+                {:entity => entity_2, :tags => ['app']}]
+    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)
+
+    post "contacts/#{contact.id}/entity_tags",
+      :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
+    last_response.should be_ok
+    tag_response = {'entity_1' => ['web'],
+                    'entity_2' => ['app']}
+    last_response.body.should be_json_eql( tag_response.to_json )
+  end
+
+  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)
+
+    post "contacts/#{contact.id}/entity_tags",
+      :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
+    last_response.should be_not_found
+  end
+
+  it "deletes tags from multiple entities for a contact" do
+    entity_1 = mock(Flapjack::Data::Entity)
+    entity_1.should_receive(:name).and_return('entity_1')
+    entity_1.should_receive(:delete_tags).with('web')
+    entity_2 = mock(Flapjack::Data::Entity)
+    entity_2.should_receive(:name).and_return('entity_2')
+    entity_2.should_receive(:delete_tags).with('app')
+
+    entities = [{:entity => entity_1}, {:entity => entity_2}]
+    contact.should_receive(:entities).and_return(entities)
+
+    Flapjack::Data::Contact.should_receive(:find_by_id).
+      with(contact.id, :redis => redis).and_return(contact)
+
+    delete "contacts/#{contact.id}/entity_tags",
+      :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
+    last_response.status.should == 204
+  end
+
+  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)
+
+    delete "contacts/#{contact.id}/entity_tags",
+      :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
+    last_response.should be_not_found
+  end
+
 end