flapjack 0.7.35 → 0.8.0

data/spec/lib/flapjack/gateways/api/entity_presenter_spec.rb

@@ -17,16 +17,16 @@ describe 'Flapjack::Gateways::API::EntityPresenter' do
   let(:end_time)   { time - (2 * 60 * 60) }
 
   def expect_check_presenters
-    entity.should_receive(:name).exactly(4).times.and_return('foo')
-    entity.should_receive(:check_list).and_return(['ping', 'ssh'])
-    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+    expect(entity).to receive(:name).exactly(4).times.and_return('foo')
+    expect(entity).to receive(:check_list).and_return(['ping', 'ssh'])
+    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
       with(entity, 'ssh', anything).and_return(check_a)
-    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
       with(entity, 'ping', anything).and_return(check_b)
 
-    Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+    expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
       with(check_a).and_return(checkpres_a)
-    Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+    expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
       with(check_b).and_return(checkpres_b)
   end
 
@@ -35,13 +35,13 @@ describe 'Flapjack::Gateways::API::EntityPresenter' do
 
     status_a = double('status_a')
     status_b = double('status_b')
-    checkpres_a.should_receive(:status).and_return(status_a)
-    checkpres_b.should_receive(:status).and_return(status_b)
+    expect(checkpres_a).to receive(:status).and_return(status_a)
+    expect(checkpres_b).to receive(:status).and_return(status_b)
 
     ep = Flapjack::Gateways::API::EntityPresenter.new(entity)
     status = ep.status
-    status.should == [{:entity => entity.name, :check => 'ping', :status => status_b},
-                      {:entity => entity.name, :check => 'ssh',  :status => status_a}]
+    expect(status).to eq([{:entity => entity.name, :check => 'ping', :status => status_b},
+                      {:entity => entity.name, :check => 'ssh',  :status => status_a}])
 
   end
 
@@ -49,60 +49,60 @@ describe 'Flapjack::Gateways::API::EntityPresenter' do
     expect_check_presenters
     outages_a = double('outages_a')
     outages_b = double('outages_b')
-    checkpres_a.should_receive(:outages).with(start_time, end_time).
+    expect(checkpres_a).to receive(:outages).with(start_time, end_time).
       and_return(outages_a)
-    checkpres_b.should_receive(:outages).with(start_time, end_time).
+    expect(checkpres_b).to receive(:outages).with(start_time, end_time).
       and_return(outages_b)
 
     ep = Flapjack::Gateways::API::EntityPresenter.new(entity)
     outages = ep.outages(start_time, end_time)
-    outages.should == [{:entity => entity.name, :check => 'ping', :outages => outages_b},
-                       {:entity => entity.name, :check => 'ssh',  :outages => outages_a}]
+    expect(outages).to eq([{:entity => entity.name, :check => 'ping', :outages => outages_b},
+                       {:entity => entity.name, :check => 'ssh',  :outages => outages_a}])
   end
 
   it "returns a list of unscheduled maintenance periods for each check on an entity" do
     expect_check_presenters
     unsched_maint_a = double('unsched_maint_a')
     unsched_maint_b = double('unsched_maint_b')
-    checkpres_a.should_receive(:unscheduled_maintenances).with(start_time, end_time).
+    expect(checkpres_a).to receive(:unscheduled_maintenances).with(start_time, end_time).
       and_return(unsched_maint_a)
-    checkpres_b.should_receive(:unscheduled_maintenances).with(start_time, end_time).
+    expect(checkpres_b).to receive(:unscheduled_maintenances).with(start_time, end_time).
       and_return(unsched_maint_b)
 
     ep = Flapjack::Gateways::API::EntityPresenter.new(entity)
     unsched_maint = ep.unscheduled_maintenances(start_time, end_time)
-    unsched_maint.should == [{:entity => entity.name, :check => 'ping', :unscheduled_maintenances => unsched_maint_b},
-                             {:entity => entity.name, :check => 'ssh',  :unscheduled_maintenances => unsched_maint_a}]
+    expect(unsched_maint).to eq([{:entity => entity.name, :check => 'ping', :unscheduled_maintenances => unsched_maint_b},
+                             {:entity => entity.name, :check => 'ssh',  :unscheduled_maintenances => unsched_maint_a}])
   end
 
   it "returns a list of scheduled maintenance periods for each check on an entity" do
     expect_check_presenters
     sched_maint_a = double('sched_maint_a')
     sched_maint_b = double('sched_maint_b')
-    checkpres_a.should_receive(:scheduled_maintenances).with(start_time, end_time).
+    expect(checkpres_a).to receive(:scheduled_maintenances).with(start_time, end_time).
       and_return(sched_maint_a)
-    checkpres_b.should_receive(:scheduled_maintenances).with(start_time, end_time).
+    expect(checkpres_b).to receive(:scheduled_maintenances).with(start_time, end_time).
       and_return(sched_maint_b)
 
     ep = Flapjack::Gateways::API::EntityPresenter.new(entity)
     sched_maint = ep.scheduled_maintenances(start_time, end_time)
-    sched_maint.should == [{:entity => entity.name, :check => 'ping', :scheduled_maintenances => sched_maint_b},
-                           {:entity => entity.name, :check => 'ssh',  :scheduled_maintenances => sched_maint_a}]
+    expect(sched_maint).to eq([{:entity => entity.name, :check => 'ping', :scheduled_maintenances => sched_maint_b},
+                           {:entity => entity.name, :check => 'ssh',  :scheduled_maintenances => sched_maint_a}])
   end
 
   it "returns a list of downtime for each check on an entity" do
     expect_check_presenters
     downtime_a = double('downtime_a')
     downtime_b = double('downtime_b')
-    checkpres_a.should_receive(:downtime).with(start_time, end_time).
+    expect(checkpres_a).to receive(:downtime).with(start_time, end_time).
       and_return(downtime_a)
-    checkpres_b.should_receive(:downtime).with(start_time, end_time).
+    expect(checkpres_b).to receive(:downtime).with(start_time, end_time).
       and_return(downtime_b)
 
     ep = Flapjack::Gateways::API::EntityPresenter.new(entity)
     downtime = ep.downtime(start_time, end_time)
-    downtime.should == [{:entity => entity.name, :check => 'ping', :downtime => downtime_b},
-                        {:entity => entity.name, :check => 'ssh',  :downtime => downtime_a}]
+    expect(downtime).to eq([{:entity => entity.name, :check => 'ping', :downtime => downtime_b},
+                        {:entity => entity.name, :check => 'ssh',  :downtime => downtime_a}])
   end
 
 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, :json => true do
+describe 'Flapjack::Gateways::API', :sinatra => true, :logger => true do
 
   it "handles a route matching failure"
 

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

@@ -10,15 +10,15 @@ describe Flapjack::Gateways::Email, :logger => true do
     redis = double('redis')
 
     # TODO better checking of what gets passed here
-    EM::P::SmtpClient.should_receive(:send).with(
+    expect(EM::P::SmtpClient).to receive(:send).with(
       hash_including(:host    => 'localhost',
                      :port    => 25)).and_return(email)
 
     response = double(response)
-    response.should_receive(:"respond_to?").with(:code).and_return(true)
-    response.should_receive(:code).and_return(250)
+    expect(response).to receive(:"respond_to?").with(:code).and_return(true)
+    expect(response).to receive(:code).and_return(250)
 
-    EM::Synchrony.should_receive(:sync).with(email).and_return(response)
+    expect(EM::Synchrony).to receive(:sync).with(email).and_return(response)
 
     notification = {'notification_type'   => 'recovery',
                     'contact_first_name'  => 'John',

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

@@ -16,178 +16,178 @@ describe Flapjack::Gateways::Jabber, :logger => true do
   let(:stanza) { double('stanza') }
 
   it "hooks up event handlers to the appropriate methods" do
-    Socket.should_receive(:gethostname).and_return('thismachine')
+    expect(Socket).to receive(:gethostname).and_return('thismachine')
 
-    Flapjack::RedisPool.should_receive(:new)
+    expect(Flapjack::RedisPool).to receive(:new)
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
-    EventMachine::Synchrony.should_receive(:next_tick).exactly(4).times.and_yield
+    expect(EventMachine::Synchrony).to receive(:next_tick).exactly(4).times.and_yield
 
-    fj.should_receive(:register_handler).with(:ready).and_yield(stanza)
-    fj.should_receive(:on_ready).with(stanza)
+    expect(fj).to receive(:register_handler).with(:ready).and_yield(stanza)
+    expect(fj).to receive(:on_ready).with(stanza)
 
-    fj.should_receive(:register_handler).with(:message, :groupchat?, :body => /^flapjack:\s+/).and_yield(stanza)
-    fj.should_receive(:on_groupchat).with(stanza)
+    expect(fj).to receive(:register_handler).with(:message, :groupchat?, :body => /^flapjack:\s+/).and_yield(stanza)
+    expect(fj).to receive(:on_groupchat).with(stanza)
 
-    fj.should_receive(:register_handler).with(:message, :chat?).and_yield(stanza)
-    fj.should_receive(:on_chat).with(stanza)
+    expect(fj).to receive(:register_handler).with(:message, :chat?).and_yield(stanza)
+    expect(fj).to receive(:on_chat).with(stanza)
 
-    fj.should_receive(:register_handler).with(:disconnected).and_yield(stanza)
-    fj.should_receive(:on_disconnect).with(stanza).and_return(true)
+    expect(fj).to receive(:register_handler).with(:disconnected).and_yield(stanza)
+    expect(fj).to receive(:on_disconnect).with(stanza).and_return(true)
 
     fj.setup
   end
 
   it "joins a chat room after connecting" do
-    Flapjack::RedisPool.should_receive(:new)
+    expect(Flapjack::RedisPool).to receive(:new)
 
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
-    fj.should_receive(:connected?).and_return(true)
+    expect(fj).to receive(:connected?).and_return(true)
 
-    EventMachine::Synchrony.should_receive(:next_tick).and_yield
-    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Presence))
-    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+    expect(EventMachine::Synchrony).to receive(:next_tick).and_yield
+    expect(fj).to receive(:write).with(an_instance_of(Blather::Stanza::Presence))
+    expect(fj).to receive(:write).with(an_instance_of(Blather::Stanza::Message))
 
     fj.on_ready(stanza)
   end
 
   it "receives an acknowledgement message" do
-    stanza.should_receive(:body).and_return('flapjack: ACKID 876 fixing now duration: 90m')
+    expect(stanza).to receive(:body).and_return('flapjack: ACKID 876 fixing now duration: 90m')
     from = double('from')
-    from.should_receive(:stripped).and_return('sender')
-    stanza.should_receive(:from).and_return(from)
+    expect(from).to receive(:stripped).and_return('sender')
+    expect(stanza).to receive(:from).and_return(from)
 
     redis = double('redis')
-    redis.should_receive(:hget).with('unacknowledged_failures', '876').
+    expect(redis).to receive(:hget).with('unacknowledged_failures', '876').
       and_return('main-example.com:ping')
 
     entity_check = double(Flapjack::Data::EntityCheck)
-    entity_check.should_receive(:in_unscheduled_maintenance?)
+    expect(entity_check).to receive(:in_unscheduled_maintenance?)
 
-    Flapjack::Data::Event.should_receive(:create_acknowledgement).
+    expect(Flapjack::Data::Event).to receive(:create_acknowledgement).
       with('main-example.com', 'ping', :summary => 'fixing now',
            :acknowledgement_id => '876',
            :duration => (90 * 60), :redis => redis)
 
-    Flapjack::Data::EntityCheck.should_receive(:for_event_id).
+    expect(Flapjack::Data::EntityCheck).to receive(:for_event_id).
       with('main-example.com:ping', :redis => redis).
       and_return(entity_check)
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
-    EventMachine::Synchrony.should_receive(:next_tick).and_yield
-    fj.should_receive(:connected?).and_return(true)
-    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+    expect(EventMachine::Synchrony).to receive(:next_tick).and_yield
+    expect(fj).to receive(:connected?).and_return(true)
+    expect(fj).to receive(:write).with(an_instance_of(Blather::Stanza::Message))
 
     fj.on_groupchat(stanza)
   end
 
   it "strips XML tags from the received message" do
-    stanza.should_receive(:body).
+    expect(stanza).to receive(:body).
       and_return('flapjack: tell me about <span style="text-decoration: underline;">' +
                  '<a href="http://example.org/">example.org</a></span>')
 
     from = double('from')
-    from.should_receive(:stripped).and_return('sender')
-    stanza.should_receive(:from).and_return(from)
+    expect(from).to receive(:stripped).and_return('sender')
+    expect(stanza).to receive(:from).and_return(from)
 
     redis = double('redis')
     entity = double(Flapjack::Data::Entity)
-    entity.should_receive(:check_list).and_return(['ping'])
+    expect(entity).to receive(:check_list).and_return(['ping'])
 
-    Flapjack::Data::Entity.should_receive(:find_by_name).with('example.org',
+    expect(Flapjack::Data::Entity).to receive(:find_by_name).with('example.org',
       :redis => redis).and_return(entity)
 
     entity_check = double(Flapjack::Data::EntityCheck)
-    entity_check.should_receive(:current_maintenance).with(:scheduled => true).and_return(nil)
-    entity_check.should_receive(:current_maintenance).with(:unscheduled => true).and_return(nil)
+    expect(entity_check).to receive(:current_maintenance).with(:scheduled => true).and_return(nil)
+    expect(entity_check).to receive(:current_maintenance).with(:unscheduled => true).and_return(nil)
 
-    Flapjack::Data::EntityCheck.should_receive(:for_entity).with(entity, 'ping',
+    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).with(entity, 'ping',
       :redis => redis).and_return(entity_check)
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
-    EventMachine::Synchrony.should_receive(:next_tick).and_yield
-    fj.should_receive(:connected?).and_return(true)
-    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+    expect(EventMachine::Synchrony).to receive(:next_tick).and_yield
+    expect(fj).to receive(:connected?).and_return(true)
+    expect(fj).to receive(:write).with(an_instance_of(Blather::Stanza::Message))
 
     fj.on_groupchat(stanza)
   end
 
   it "handles a message with a newline in it" do
-    stanza.should_receive(:body).
+    expect(stanza).to receive(:body).
       and_return("flapjack: tell me about \nexample.com")
 
     from = double('from')
-    from.should_receive(:stripped).and_return('sender')
-    stanza.should_receive(:from).and_return(from)
+    expect(from).to receive(:stripped).and_return('sender')
+    expect(stanza).to receive(:from).and_return(from)
 
     redis = double('redis')
     entity = double(Flapjack::Data::Entity)
-    entity.should_receive(:check_list).and_return(['ping'])
+    expect(entity).to receive(:check_list).and_return(['ping'])
 
-    Flapjack::Data::Entity.should_receive(:find_by_name).with('example.com',
+    expect(Flapjack::Data::Entity).to receive(:find_by_name).with('example.com',
       :redis => redis).and_return(entity)
 
     entity_check = double(Flapjack::Data::EntityCheck)
-    entity_check.should_receive(:current_maintenance).with(:scheduled => true).and_return(nil)
-    entity_check.should_receive(:current_maintenance).with(:unscheduled => true).and_return(nil)
+    expect(entity_check).to receive(:current_maintenance).with(:scheduled => true).and_return(nil)
+    expect(entity_check).to receive(:current_maintenance).with(:unscheduled => true).and_return(nil)
 
-    Flapjack::Data::EntityCheck.should_receive(:for_entity).with(entity, 'ping',
+    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).with(entity, 'ping',
       :redis => redis).and_return(entity_check)
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
-    EventMachine::Synchrony.should_receive(:next_tick).and_yield
-    fj.should_receive(:connected?).and_return(true)
-    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+    expect(EventMachine::Synchrony).to receive(:next_tick).and_yield
+    expect(fj).to receive(:connected?).and_return(true)
+    expect(fj).to receive(:write).with(an_instance_of(Blather::Stanza::Message))
 
     fj.on_groupchat(stanza)
   end
 
   it "receives a message it doesn't understand" do
-    stanza.should_receive(:body).once.and_return('flapjack: hello!')
+    expect(stanza).to receive(:body).once.and_return('flapjack: hello!')
     from = double('from')
-    from.should_receive(:stripped).and_return('sender')
-    stanza.should_receive(:from).and_return(from)
+    expect(from).to receive(:stripped).and_return('sender')
+    expect(stanza).to receive(:from).and_return(from)
 
-    Flapjack::RedisPool.should_receive(:new)
+    expect(Flapjack::RedisPool).to receive(:new)
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
-    EventMachine::Synchrony.should_receive(:next_tick).and_yield
-    fj.should_receive(:connected?).and_return(true)
-    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+    expect(EventMachine::Synchrony).to receive(:next_tick).and_yield
+    expect(fj).to receive(:connected?).and_return(true)
+    expect(fj).to receive(:write).with(an_instance_of(Blather::Stanza::Message))
 
     fj.on_groupchat(stanza)
   end
 
   it "reconnects when disconnected (if not quitting)" do
-    Flapjack::RedisPool.should_receive(:new)
+    expect(Flapjack::RedisPool).to receive(:new)
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
     attempts = 0
 
-    EventMachine::Synchrony.should_receive(:sleep).with(5).exactly(1).times
-    EventMachine::Synchrony.should_receive(:sleep).with(2).exactly(3).times
-    fj.should_receive(:connect).exactly(4).times.and_return {
+    expect(EventMachine::Synchrony).to receive(:sleep).with(5).exactly(1).times
+    expect(EventMachine::Synchrony).to receive(:sleep).with(2).exactly(3).times
+    expect(fj).to receive(:connect).exactly(4).times.and_return {
       attempts +=1
       raise StandardError.new unless attempts > 3
     }
 
     ret = fj.on_disconnect(stanza)
-    ret.should be_true
+    expect(ret).to be true
   end
 
   it "prompts the blocking redis connection to quit" do
     shutdown_redis = double('shutdown_redis')
-    shutdown_redis.should_receive(:rpush).with('jabber_notifications', %q{{"notification_type":"shutdown"}})
-    EM::Hiredis.should_receive(:connect).and_return(shutdown_redis)
+    expect(shutdown_redis).to receive(:rpush).with('jabber_notifications', %q{{"notification_type":"shutdown"}})
+    expect(EM::Hiredis).to receive(:connect).and_return(shutdown_redis)
 
     redis = double('redis')
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
 
     fj.stop
@@ -195,23 +195,23 @@ describe Flapjack::Gateways::Jabber, :logger => true do
 
   it "runs a blocking loop listening for notifications" do
     timer = double('timer')
-    timer.should_receive(:cancel)
-    EM::Synchrony.should_receive(:add_periodic_timer).with(1).and_return(timer)
+    expect(timer).to receive(:cancel)
+    expect(EM::Synchrony).to receive(:add_periodic_timer).with(1).and_return(timer)
 
     redis = double('redis')
 
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     fj = Flapjack::Gateways::Jabber.new(:config => config, :logger => @logger)
-    fj.should_receive(:register_handler).exactly(4).times
+    expect(fj).to receive(:register_handler).exactly(4).times
 
-    fj.should_receive(:connect)
-    fj.should_receive(:connected?).exactly(3).times.and_return(true)
+    expect(fj).to receive(:connect)
+    expect(fj).to receive(:connected?).exactly(3).times.and_return(true)
 
     blpop_count = 0
 
     event_json = '{"notification_type":"problem","event_id":"main-example.com:ping",' +
       '"state":"critical","summary":"!!!","duration":43,"state_duration":76}'
-    redis.should_receive(:blpop).twice {
+    expect(redis).to receive(:blpop).twice {
       blpop_count += 1
       if blpop_count == 1
         ["jabber_notifications", event_json]
@@ -221,13 +221,13 @@ describe Flapjack::Gateways::Jabber, :logger => true do
       end
     }
 
-    EventMachine::Synchrony.should_receive(:next_tick).twice.and_yield
-    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
-    fj.should_receive(:close)
+    expect(EventMachine::Synchrony).to receive(:next_tick).twice.and_yield
+    expect(fj).to receive(:write).with(an_instance_of(Blather::Stanza::Message))
+    expect(fj).to receive(:close)
 
     fj.start
 
-    @logger.errors.should be_empty
+    expect(@logger.errors).to be_empty
   end
 
 end

data/spec/lib/flapjack/gateways/jsonapi/contact_methods_spec.rb

@@ -0,0 +1,830 @@
+require 'spec_helper'
+require 'flapjack/gateways/jsonapi'
+
+describe 'Flapjack::Gateways::JSONAPI::ContactMethods', :sinatra => true, :logger => true do
+
+  def app
+    Flapjack::Gateways::JSONAPI
+  end
+
+  JSON_REQUEST_MIME = 'application/vnd.api+json'
+
+  let(:contact)      { double(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(:media_rollup_thresholds) {
+    {'email' => 5}
+  }
+
+  let(:redis)           { double(::Redis) }
+
+  let(:notification_rule) {
+    double(Flapjack::Data::NotificationRule, :id => '1', :contact_id => '21')
+  }
+
+  let(:notification_rule_data) {
+    {"contact_id"         => "21",
+     "tags"               => ["database","physical"],
+     "entities"           => ["foo-app-01.example.com"],
+     "time_restrictions"  => nil,
+     "unknown_media"      => ["jabber"],
+     "warning_media"      => ["email"],
+     "critical_media"     => ["sms", "email"],
+     "unknown_blackhole"  => false,
+     "warning_blackhole"  => false,
+     "critical_blackhole" => false
+    }
+  }
+
+  let(:semaphore) {
+    double(Flapjack::Data::Semaphore, :resource => 'folly',
+           :key => 'semaphores:folly', :expiry => 30, :token => 'spatulas-R-us')
+  }
+
+  before(:all) do
+    Flapjack::Gateways::JSONAPI.class_eval {
+      set :raise_errors, true
+    }
+  end
+
+  before(:each) do
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    Flapjack::Gateways::JSONAPI.instance_variable_set('@config', {})
+    Flapjack::Gateways::JSONAPI.instance_variable_set('@logger', @logger)
+    Flapjack::Gateways::JSONAPI.start
+  end
+
+  it "returns all the contacts" do
+    expect(Flapjack::Data::Contact).to receive(:entities_jsonapi).
+      with([contact.id], :redis => redis).and_return([[], {}])
+    expect(contact).to receive(:linked_entity_ids=).with(nil)
+    expect(contact).to receive(:to_json).and_return(contact_core.to_json)
+    expect(Flapjack::Data::Contact).to receive(:all).with(:redis => redis).
+      and_return([contact])
+
+    aget '/contacts'
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq({:contacts => [contact_core]}.to_json)
+  end
+
+  it "returns the core information of a specified contact" do
+    expect(contact).to receive(:entities).and_return([])
+    expect(contact).to receive(:to_json).and_return(contact_core.to_json)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aget "/contacts/#{contact.id}"
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq({:contacts => [contact_core]}.to_json)
+  end
+
+  it "does not return information for a contact that does not exist" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aget "/contacts/#{contact.id}"
+    expect(last_response.status).to eq(404)
+  end
+
+  it "creates a contact with supplied ID" do
+    contact_data = {
+      "id"         => "0362",
+      "first_name" => "John",
+      "last_name"  => "Smith",
+      "email"      => "johns@example.dom",
+      "media"      => {
+        "email"  => "johns@example.dom",
+        "jabber" => "johns@conference.localhost"
+      }
+    }
+
+    expect(Flapjack::Data::Semaphore).to receive(:new).
+      with("contact_mass_update", {:redis => redis, :expiry => 30}).and_return(semaphore)
+    expect(Flapjack::Data::Contact).to receive(:exists_with_id?).
+      with("0362", {:redis => redis}).and_return(false)
+    expect(Flapjack::Data::Contact).to receive(:add).
+      with(contact_data, {:redis => redis}).and_return(contact)
+    expect(semaphore).to receive(:release).and_return(true)
+
+    apost "/contacts", { :contacts => [contact_data]}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq(["0362"].to_json)
+  end
+
+  it "updates a contact" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+    expect(contact).to receive(:update)
+    expect(contact).to receive(:to_json).and_return('{"sausage": "good"}')
+
+    aput "/contacts/21", {:contacts => [{'sausage' => 'good'}]}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(200)
+  end
+
+  it "deletes a contact" do
+  end
+
+  it "does not create a contact if the data is improperly formatted" do
+    expect(Flapjack::Data::Contact).not_to receive(:add)
+
+    apost "/contacts", {'sausage' => 'good'}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(422)
+  end
+
+  it "does not update a contact if id exists in sent entity" do
+    contact_data = {'id' => '21'}
+    expect(Flapjack::Data::Contact).not_to receive(:find_by_id)
+    expect(Flapjack::Data::Contact).not_to receive(:update)
+
+    aput "/contacts/21", contact_data.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(422)
+  end
+
+  it "replaces contacts with a submitted list" 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"}}
+      ]
+    }
+
+    expect(Flapjack::Data::Semaphore).to receive(:new).
+      with("contact_mass_update", {:redis => redis, :expiry => 30}).and_return(semaphore)
+    expect(Flapjack::Data::Contact).to receive(:all).with(:redis => redis).and_return([])
+    expect(Flapjack::Data::Contact).to receive(:add).twice
+    expect(semaphore).to receive(:release).and_return(true)
+
+    apost "/contacts_atomic", contacts.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(204)
+  end
+
+  it "does not replace contacts if the data is improperly formatted" do
+    expect(Flapjack::Data::Contact).not_to receive(:add)
+
+    apost "/contacts_atomic", {'contacts' => ["Hello", "again"]}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(422)
+  end
+
+  it "does not replace contacts if they don't contain an id in the source" do
+    contacts = {'contacts' =>
+      [{"id" => "0362",
+        "first_name" => "John",
+        "last_name" => "Smith",
+        "email" => "johns@example.dom",
+        "media" => {"email"  => "johns@example.dom",
+                    "jabber" => "johns@conference.localhost"}},
+       {"first_name" => "Jane",
+        "last_name" => "Jones",
+        "email" => "jane@example.dom",
+        "media" => {"email" => "jane@example.dom"}}
+      ]
+    }
+
+    expect(Flapjack::Data::Semaphore).to receive(:new).
+      with("contact_mass_update", {:redis => redis, :expiry => 30}).and_return(semaphore)
+    expect(Flapjack::Data::Contact).to receive(:all).with(:redis => redis).and_return([])
+    expect(Flapjack::Data::Contact).to receive(:add)
+    expect(semaphore).to receive(:release).and_return(true)
+
+    apost "/contacts_atomic", contacts.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(204)
+  end
+
+  it "updates a contact in a bulk replacement list 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"}}
+      ]
+    }
+
+    expect(Flapjack::Data::Semaphore).to receive(:new).
+      with("contact_mass_update", {:redis => redis, :expiry => 30}).and_return(semaphore)
+    existing = double(Flapjack::Data::Contact)
+    expect(existing).to receive(:id).and_return("0363")
+    expect(existing).to receive(:update).with(contacts['contacts'][1])
+
+    expect(Flapjack::Data::Contact).to receive(:all).with(:redis => redis).and_return([existing])
+    expect(Flapjack::Data::Contact).to receive(:add).with(contacts['contacts'][0], :redis => redis)
+    expect(semaphore).to receive(:release).and_return(true)
+
+    apost "/contacts_atomic", contacts.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(204)
+  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"}}
+      ]
+    }
+
+    expect(Flapjack::Data::Semaphore).to receive(:new).
+      with("contact_mass_update", {:redis => redis, :expiry => 30}).and_return(semaphore)
+    existing = double(Flapjack::Data::Contact)
+    expect(existing).to receive(:id).twice.and_return("0362")
+    expect(existing).to receive(:delete!)
+
+    expect(Flapjack::Data::Contact).to receive(:all).with(:redis => redis).and_return([existing])
+    expect(Flapjack::Data::Contact).to receive(:add).with(contacts['contacts'][0], :redis => redis)
+    expect(semaphore).to receive(:release).and_return(true)
+
+    apost "/contacts_atomic", contacts.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(204)
+  end
+
+  it "lists a contact's notification rules" do
+    notification_rule_2 = double(Flapjack::Data::NotificationRule, :id => '2', :contact_id => '21')
+    expect(notification_rule).to receive(:to_json).and_return('"rule_1"')
+    expect(notification_rule_2).to receive(:to_json).and_return('"rule_2"')
+    notification_rules = [ notification_rule, notification_rule_2 ]
+
+    expect(contact).to receive(:notification_rules).and_return(notification_rules)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aget "/contacts/#{contact.id}/notification_rules"
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq('["rule_1","rule_2"]')
+  end
+
+  it "does not list notification rules for a contact that does not exist" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aget "/contacts/#{contact.id}/notification_rules"
+    expect(last_response.status).to eq(404)
+  end
+
+  it "returns a specified notification rule" do
+    expect(notification_rule).to receive(:to_json).and_return('"rule_1"')
+    expect(Flapjack::Data::NotificationRule).to receive(:find_by_id).
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
+
+    aget "/notification_rules/#{notification_rule.id}"
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq('{"notification_rules":["rule_1"]}')
+  end
+
+  it "does not return a notification rule that does not exist" do
+    expect(Flapjack::Data::NotificationRule).to receive(:find_by_id).
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aget "/notification_rules/#{notification_rule.id}"
+    expect(last_response.status).to eq(404)
+  end
+
+  # POST /notification_rules
+  it "creates a new notification rule" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+    expect(notification_rule).to receive(:respond_to?).with(:critical_media).and_return(true)
+    expect(notification_rule).to 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)
+
+    expect(contact).to receive(:add_notification_rule).
+      with(notification_rule_data_sym, :logger => @logger).and_return(notification_rule)
+
+    apost "/notification_rules", {"notification_rules" => [notification_rule_data]}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(201)
+    expect(last_response.body).to eq('{"notification_rules":["rule_1"]}')
+  end
+
+  it "does not create a notification_rule for a contact that's not present" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    apost "/notification_rules", {"notification_rules" => [notification_rule_data]}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(404)
+  end
+
+  it "does not create a notification_rule if a rule id is provided" do
+    expect(contact).not_to receive(:add_notification_rule)
+
+    apost "/notification_rules", {"notification_rules" => [notification_rule_data.merge(:id => 1)]}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(422)
+  end
+
+  # PUT /notification_rules/RULE_ID
+  it "updates a notification rule" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+    expect(notification_rule).to receive(:to_json).and_return('"rule_1"')
+    expect(Flapjack::Data::NotificationRule).to receive(:find_by_id).
+      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)|
+      memo[k.to_sym] = v; memo
+    }
+    notification_rule_data_sym.delete(:contact_id)
+
+    expect(notification_rule).to receive(:update).with(notification_rule_data_sym, :logger => @logger).and_return(nil)
+
+    aput "/notification_rules/#{notification_rule.id}", {"notification_rules" => [notification_rule_data]}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq('{"notification_rules":["rule_1"]}')
+  end
+
+  it "does not update a notification rule that's not present" do
+    expect(Flapjack::Data::NotificationRule).to receive(:find_by_id).
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aput "/notification_rules/#{notification_rule.id}", {"notification_rules" => [notification_rule_data]}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(404)
+  end
+
+  it "does not update a notification_rule for a contact that's not present" do
+    expect(Flapjack::Data::NotificationRule).to receive(:find_by_id).
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aput "/notification_rules/#{notification_rule.id}", {"notification_rules" => [notification_rule_data]}.to_json,
+      {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(404)
+  end
+
+  # DELETE /notification_rules/RULE_ID
+  it "deletes a notification rule" do
+    expect(notification_rule).to receive(:contact_id).and_return(contact.id)
+    expect(Flapjack::Data::NotificationRule).to receive(:find_by_id).
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
+    expect(contact).to receive(:delete_notification_rule).with(notification_rule)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    adelete "/notification_rules/#{notification_rule.id}"
+    expect(last_response.status).to eq(204)
+  end
+
+  it "does not delete a notification rule that's not present" do
+    expect(Flapjack::Data::NotificationRule).to receive(:find_by_id).
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    adelete "/notification_rules/#{notification_rule.id}"
+    expect(last_response.status).to eq(404)
+  end
+
+  it "does not delete a notification rule if the contact is not present" do
+    expect(notification_rule).to receive(:contact_id).and_return(contact.id)
+    expect(Flapjack::Data::NotificationRule).to receive(:find_by_id).
+      with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    adelete "/notification_rules/#{notification_rule.id}"
+    expect(last_response.status).to eq(404)
+  end
+
+  # GET /contacts/CONTACT_ID/media
+  it "returns the media of a contact" do
+    expect(contact).to receive(:media).and_return(media)
+    expect(contact).to receive(:media_intervals).and_return(media_intervals)
+    expect(contact).to receive(:media_rollup_thresholds).and_return(media_rollup_thresholds)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+    result = Hash[ *(media.keys.collect {|m|
+      [m, {'address'          => media[m],
+           'interval'         => media_intervals[m],
+           'rollup_threshold' => media_rollup_thresholds[m] }]
+      }).flatten(1)].to_json
+
+    aget "/contacts/#{contact.id}/media"
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq(result)
+  end
+
+  it "does not return the media of a contact if the contact is not present" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aget "/contacts/#{contact.id}/media"
+    expect(last_response.status).to eq(404)
+  end
+
+  # GET /contacts/CONTACT_ID/media/MEDIA
+  it "returns the specified media of a contact" do
+    expect(contact).to receive(:media).and_return(media)
+    expect(contact).to receive(:media_intervals).and_return(media_intervals)
+    expect(contact).to receive(:media_rollup_thresholds).and_return(media_rollup_thresholds)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    result = {
+      'address'          => media['sms'],
+      'interval'         => media_intervals['sms'],
+      'rollup_threshold' => media_rollup_thresholds['sms'],
+    }
+
+    aget "/contacts/#{contact.id}/media/sms"
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq(result.to_json)
+  end
+
+  it "does not return the media of a contact if the contact is not present" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aget "/contacts/#{contact.id}/media/sms"
+    expect(last_response.status).to eq(404)
+  end
+
+  it "does not return the media of a contact if the media is not present" do
+    expect(contact).to receive(:media).and_return(media)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aget "/contacts/#{contact.id}/media/telepathy"
+    expect(last_response.status).to eq(404)
+  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')
+    alt_media_rollup_thresholds = media_rollup_thresholds.merge('sms' => '5')
+
+    expect(contact).to receive(:set_address_for_media).with('sms', '04987654321')
+    expect(contact).to receive(:set_interval_for_media).with('sms', '200')
+    expect(contact).to receive(:set_rollup_threshold_for_media).with('sms', '5')
+    expect(contact).to receive(:media).and_return(alt_media)
+    expect(contact).to receive(:media_intervals).and_return(alt_media_intervals)
+    expect(contact).to receive(:media_rollup_thresholds).and_return(alt_media_rollup_thresholds)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    result = {'address'          => alt_media['sms'],
+              'interval'         => alt_media_intervals['sms'],
+              'rollup_threshold' => alt_media_rollup_thresholds['sms']}
+
+    aput "/contacts/#{contact.id}/media/sms", :address => '04987654321',
+      :interval => '200', :rollup_threshold => '5'
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq(result.to_json)
+  end
+
+  it "updates a contact's pagerduty media credentials" do
+    result = {'service_key' => "flapjacktest@conference.jabber.sausage.net",
+              'subdomain'   => "sausage.pagerduty.com",
+              'username'    => "sausage@example.com",
+              'password'    => "sausage"}
+
+    expect(contact).to receive(:set_pagerduty_credentials).with(result)
+    expect(contact).to receive(:pagerduty_credentials).and_return(result)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aput "/contacts/#{contact.id}/media/pagerduty", :service_key => result['service_key'],
+      :subdomain => result['subdomain'], :username => result['username'],
+      :password => result['password']
+
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq(result.to_json)
+  end
+
+  it "does not create a media of a contact that's not present" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aput "/contacts/#{contact.id}/media/sms", :address => '04987654321', :interval => '200'
+    expect(last_response.status).to eq(404)
+  end
+
+  it "does not create a media of a contact if no address is provided" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aput "/contacts/#{contact.id}/media/sms", :interval => '200'
+    expect(last_response.status).to eq(422)
+  end
+
+  it "creates a media of a contact even if no interval is provided" do
+    alt_media = media.merge('sms' => '04987654321')
+    alt_media_intervals = media_intervals.merge('sms' => nil)
+    alt_media_rollup_thresholds = media_rollup_thresholds.merge('sms' => nil)
+
+    expect(contact).to receive(:set_address_for_media).with('sms', '04987654321')
+    expect(contact).to receive(:set_interval_for_media).with('sms', nil)
+    expect(contact).to receive(:set_rollup_threshold_for_media).with("sms", nil)
+    expect(contact).to receive(:media).and_return(alt_media)
+    expect(contact).to receive(:media_intervals).and_return(alt_media_intervals)
+    expect(contact).to receive(:media_rollup_thresholds).and_return(alt_media_rollup_thresholds)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aput "/contacts/#{contact.id}/media/sms", :address => '04987654321'
+    expect(last_response).to be_ok
+  end
+
+  it "deletes a media of a contact" do
+    expect(contact).to receive(:remove_media).with('sms')
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    adelete "/contacts/#{contact.id}/media/sms"
+    expect(last_response.status).to eq(204)
+  end
+
+  it "does not delete a media of a contact that's not present" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    adelete "/contacts/#{contact.id}/media/sms"
+    expect(last_response.status).to eq(404)
+  end
+
+  # GET /contacts/CONTACT_ID/timezone
+  it "returns the timezone of a contact" do
+    expect(contact).to receive(:timezone).and_return(::ActiveSupport::TimeZone.new('Australia/Sydney'))
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aget "/contacts/#{contact.id}/timezone"
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq('"Australia/Sydney"')
+  end
+
+  it "doesn't get the timezone of a contact that doesn't exist" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aget "/contacts/#{contact.id}/timezone"
+    expect(last_response.status).to eq(404)
+  end
+
+  # PUT /contacts/CONTACT_ID/timezone
+  it "sets the timezone of a contact" do
+    expect(contact).to receive(:timezone=).with('Australia/Perth')
+    expect(contact).to receive(:timezone).and_return(ActiveSupport::TimeZone.new('Australia/Perth'))
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aput "/contacts/#{contact.id}/timezone", {:timezone => 'Australia/Perth'}
+    expect(last_response).to be_ok
+  end
+
+  it "doesn't set the timezone of a contact who can't be found" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aput "/contacts/#{contact.id}/timezone", {:timezone => 'Australia/Perth'}
+    expect(last_response.status).to eq(404)
+  end
+
+  # DELETE /contacts/CONTACT_ID/timezone
+  it "deletes the timezone of a contact" do
+    expect(contact).to receive(:timezone=).with(nil)
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    adelete "/contacts/#{contact.id}/timezone"
+    expect(last_response.status).to eq(204)
+  end
+
+  it "does not delete the timezone of a contact that's not present" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    adelete "/contacts/#{contact.id}/timezone"
+    expect(last_response.status).to eq(404)
+  end
+
+  it "sets a single tag on a contact and returns current tags" do
+    expect(contact).to receive(:add_tags).with('web')
+    expect(contact).to receive(:tags).and_return(['web'])
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    apost "contacts/#{contact.id}/tags", {:tags => ['web']}.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq({:tags => ['web']}.to_json)
+  end
+
+  it "does not set a single tag on a contact that's not found" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    apost "contacts/#{contact.id}/tags", {:tags => ['web']}.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(404)
+  end
+
+  it "sets multiple tags on a contact and returns current tags" do
+    expect(contact).to receive(:add_tags).with('web', 'app')
+    expect(contact).to receive(:tags).and_return(['web', 'app'])
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    apost "contacts/#{contact.id}/tags", {:tags => ['web', 'app']}.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq({:tags => ['web', 'app']}.to_json)
+  end
+
+  it "does not set multiple tags on a contact that's not found" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    apost "contacts/#{contact.id}/tags", {:tags => ['web', 'app']}.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(404)
+  end
+
+  it "removes a single tag from a contact" do
+    expect(contact).to receive(:delete_tags).with('web')
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    adelete "contacts/#{contact.id}/tags", {:tags => ['web']}.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(204)
+  end
+
+  it "does not remove a single tag from a contact that's not found" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    adelete "contacts/#{contact.id}/tags", {:tags => ['web']}.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(404)
+  end
+
+  it "removes multiple tags from a contact" do
+    expect(contact).to receive(:delete_tags).with('web', 'app')
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    adelete "contacts/#{contact.id}/tags", {:tags => ['web', 'app']}.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(204)
+  end
+
+  it "does not remove multiple tags from a contact that's not found" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    adelete "contacts/#{contact.id}/tags", {:tags => ['web', 'app']}.to_json, {'CONTENT_TYPE' => JSON_REQUEST_MIME}
+    expect(last_response.status).to eq(404)
+  end
+
+  it "gets all tags on a contact" do
+    expect(contact).to receive(:tags).and_return(['web', 'app'])
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aget "contacts/#{contact.id}/tags"
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq({"tags"=>['web', 'app']}.to_json)
+  end
+
+  it "does not get all tags on a contact that's not found" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aget "contacts/#{contact.id}/tags"
+    expect(last_response.status).to eq(404)
+  end
+
+  it "gets all entity tags for a contact" do
+    entity_1 = double(Flapjack::Data::Entity)
+    expect(entity_1).to receive(:name).and_return('entity_1')
+    entity_2 = double(Flapjack::Data::Entity)
+    expect(entity_2).to receive(:name).and_return('entity_2')
+    tag_data = [{:entity => entity_1, :tags => ['web']},
+                {:entity => entity_2, :tags => ['app']}]
+    expect(contact).to receive(:entities).with(:tags => true).
+      and_return(tag_data)
+
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    aget "contacts/#{contact.id}/entity_tags"
+    expect(last_response).to be_ok
+    tag_response = {'entity_1' => ['web'],
+                    'entity_2' => ['app']}
+    expect(last_response.body).to eq(tag_response.to_json)
+  end
+
+  it "does not get all entity tags for a contact that's not found" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    aget "contacts/#{contact.id}/entity_tags"
+    expect(last_response.status).to eq(404)
+  end
+
+  it "adds tags to multiple entities for a contact" do
+    entity_1 = double(Flapjack::Data::Entity)
+    expect(entity_1).to receive(:name).twice.and_return('entity_1')
+    expect(entity_1).to receive(:add_tags).with('web')
+    entity_2 = double(Flapjack::Data::Entity)
+    expect(entity_2).to receive(:name).twice.and_return('entity_2')
+    expect(entity_2).to receive(:add_tags).with('app')
+
+    entities = [{:entity => entity_1}, {:entity => entity_2}]
+    expect(contact).to receive(:entities).and_return(entities)
+    tag_data = [{:entity => entity_1, :tags => ['web']},
+                {:entity => entity_2, :tags => ['app']}]
+    expect(contact).to receive(:entities).with(:tags => true).and_return(tag_data)
+
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    apost "contacts/#{contact.id}/entity_tags",
+      :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
+    expect(last_response).to be_ok
+    tag_response = {'entity_1' => ['web'],
+                    'entity_2' => ['app']}
+    expect(last_response.body).to  eq(tag_response.to_json)
+  end
+
+  it "does not add tags to multiple entities for a contact that's not found" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    apost "contacts/#{contact.id}/entity_tags",
+      :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
+    expect(last_response.status).to eq(404)
+  end
+
+  it "deletes tags from multiple entities for a contact" do
+    entity_1 = double(Flapjack::Data::Entity)
+    expect(entity_1).to receive(:name).and_return('entity_1')
+    expect(entity_1).to receive(:delete_tags).with('web')
+    entity_2 = double(Flapjack::Data::Entity)
+    expect(entity_2).to receive(:name).and_return('entity_2')
+    expect(entity_2).to receive(:delete_tags).with('app')
+
+    entities = [{:entity => entity_1}, {:entity => entity_2}]
+    expect(contact).to receive(:entities).and_return(entities)
+
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
+
+    adelete "contacts/#{contact.id}/entity_tags",
+      :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
+    expect(last_response.status).to eq(204)
+  end
+
+  it "does not delete tags from multiple entities for a contact that's not found" do
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
+      with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
+
+    adelete "contacts/#{contact.id}/entity_tags",
+      :entity => {'entity_1' => ['web'], 'entity_2' => ['app']}
+    expect(last_response.status).to eq(404)
+  end
+
+
+end