flapjack 0.7.35 → 0.8.0

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

@@ -23,31 +23,31 @@ describe Flapjack::Data::Notification, :redis => true, :logger => true do
     # in message.notification_contents
     notification = Flapjack::Data::Notification.new
 
-    contact.should_receive(:id).and_return('23')
-    contact.should_receive(:notification_rules).and_return([])
-    contact.should_receive(:media).and_return('email' => 'example@example.com',
+    expect(contact).to receive(:id).and_return('23')
+    expect(contact).to receive(:notification_rules).and_return([])
+    expect(contact).to receive(:media).and_return('email' => 'example@example.com',
                                               'sms'   => '0123456789')
-    contact.should_receive(:add_alerting_check_for_media).with("email", nil)
-    contact.should_receive(:add_alerting_check_for_media).with("sms", nil)
-    contact.should_receive(:clean_alerting_checks_for_media).with("email").and_return(0)
-    contact.should_receive(:clean_alerting_checks_for_media).with("sms").and_return(0)
-    contact.should_receive(:count_alerting_checks_for_media).with("email").and_return(0)
-    contact.should_receive(:count_alerting_checks_for_media).with("sms").and_return(0)
-    contact.should_receive(:rollup_threshold_for_media).with("email").and_return(nil)
-    contact.should_receive(:rollup_threshold_for_media).with("sms").and_return(nil)
+    expect(contact).to receive(:add_alerting_check_for_media).with("email", nil)
+    expect(contact).to receive(:add_alerting_check_for_media).with("sms", nil)
+    expect(contact).to receive(:clean_alerting_checks_for_media).with("email").and_return(0)
+    expect(contact).to receive(:clean_alerting_checks_for_media).with("sms").and_return(0)
+    expect(contact).to receive(:count_alerting_checks_for_media).with("email").and_return(0)
+    expect(contact).to receive(:count_alerting_checks_for_media).with("sms").and_return(0)
+    expect(contact).to receive(:rollup_threshold_for_media).with("email").and_return(nil)
+    expect(contact).to receive(:rollup_threshold_for_media).with("sms").and_return(nil)
 
     messages = notification.messages([contact], :default_timezone => timezone,
       :logger => @logger)
-    messages.should_not be_nil
-    messages.should have(2).items
+    expect(messages).not_to be_nil
+    expect(messages.size).to eq(2)
 
-    messages.first.contact.should == contact
-    messages.first.medium.should == 'email'
-    messages.first.address.should == 'example@example.com'
+    expect(messages.first.contact).to eq(contact)
+    expect(messages.first.medium).to eq('email')
+    expect(messages.first.address).to eq('example@example.com')
 
-    messages.last.contact.should == contact
-    messages.last.medium.should  == 'sms'
-    messages.last.address.should == '0123456789'
+    expect(messages.last.contact).to eq(contact)
+    expect(messages.last.medium).to  eq('sms')
+    expect(messages.last.address).to eq('0123456789')
   end
 
 end

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

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

data/spec/lib/flapjack/data/tag_spec.rb

@@ -1,35 +1,36 @@
 require 'spec_helper'
+require 'flapjack/data/tag'
 
 describe Flapjack::Data::Tag, :redis => true do
 
   it "adds references to tags" do
     tags = Flapjack::Data::Tag.create('special', ['apple', 'button', 'carbon'], :redis => @redis)
 
-    tags.should include('carbon')
-    tags.should_not include('chocolate')
+    expect(tags).to include('carbon')
+    expect(tags).not_to include('chocolate')
 
     tags.add('chocolate')
-    tags.should include('chocolate')
+    expect(tags).to include('chocolate')
   end
 
   it "deletes references from tags" do
     tags = Flapjack::Data::Tag.create('special', ['apple', 'button', 'carbon'], :redis => @redis)
 
-    tags.should include('apple')
-    tags.should include('button')
+    expect(tags).to include('apple')
+    expect(tags).to include('button')
 
     tags.delete('button')
-    tags.should include('apple')
-    tags.should_not include('button')
+    expect(tags).to include('apple')
+    expect(tags).not_to include('button')
   end
 
   it "lists references contained in a tag" do
     t1 = Flapjack::Data::Tag.create('special', ['apple', 'button', 'carbon'], :redis => @redis)
 
     t2 = Flapjack::Data::Tag.find('special', :redis => @redis)
-    t2.should include('apple')
-    t2.should include('carbon')
-    t2.should_not include('chocolate')
+    expect(t2).to include('apple')
+    expect(t2).to include('carbon')
+    expect(t2).not_to include('chocolate')
   end
 
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'flapjack/gateways/api'
 
-describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger => true, :json => true do
+describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger => true do
 
   def app
     Flapjack::Gateways::API
@@ -60,7 +60,7 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
   end
 
   before(:each) do
-    Flapjack::RedisPool.should_receive(:new).and_return(redis)
+    expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
     Flapjack::Gateways::API.instance_variable_set('@config', {})
     Flapjack::Gateways::API.instance_variable_set('@logger', @logger)
     Flapjack::Gateways::API.start
@@ -82,19 +82,19 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
       ]
     }
 
-    Flapjack::Data::Contact.should_receive(:all).with(:redis => redis).and_return([])
-    Flapjack::Data::Contact.should_receive(:add).twice
+    expect(Flapjack::Data::Contact).to receive(:all).with(:redis => redis).and_return([])
+    expect(Flapjack::Data::Contact).to receive(:add).twice
 
     apost "/contacts", contacts.to_json, {'CONTENT_TYPE' => 'application/json'}
-    last_response.status.should == 204
+    expect(last_response.status).to eq(204)
   end
 
   it "does not create contacts if the data is improperly formatted" do
-    Flapjack::Data::Contact.should_not_receive(:add)
+    expect(Flapjack::Data::Contact).not_to receive(:add)
 
     apost "/contacts", {'contacts' => ["Hello", "again"]}.to_json,
       {'CONTENT_TYPE' => 'application/json'}
-    last_response.status.should == 403
+    expect(last_response.status).to eq(403)
   end
 
   it "does not create contacts if they don't contain an id" do
@@ -112,11 +112,11 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
       ]
     }
 
-    Flapjack::Data::Contact.should_receive(:all).with(:redis => redis).and_return([])
-    Flapjack::Data::Contact.should_receive(:add)
+    expect(Flapjack::Data::Contact).to receive(:all).with(:redis => redis).and_return([])
+    expect(Flapjack::Data::Contact).to receive(:add)
 
     apost "/contacts", contacts.to_json, {'CONTENT_TYPE' => 'application/json'}
-    last_response.status.should == 204
+    expect(last_response.status).to eq(204)
   end
 
   it "updates a contact if it is already present" do
@@ -136,14 +136,14 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
     }
 
     existing = double(Flapjack::Data::Contact)
-    existing.should_receive(:id).and_return("0363")
-    existing.should_receive(:update).with(contacts['contacts'][1])
+    expect(existing).to receive(:id).and_return("0363")
+    expect(existing).to 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)
+    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)
 
     apost "/contacts", contacts.to_json, {'CONTENT_TYPE' => 'application/json'}
-    last_response.status.should == 204
+    expect(last_response.status).to eq(204)
   end
 
   it "deletes a contact not found in a bulk update list" do
@@ -157,91 +157,91 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
     }
 
     existing = double(Flapjack::Data::Contact)
-    existing.should_receive(:id).twice.and_return("0362")
-    existing.should_receive(:delete!)
+    expect(existing).to receive(:id).twice.and_return("0362")
+    expect(existing).to 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)
+    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)
 
     apost "/contacts", contacts.to_json, {'CONTENT_TYPE' => 'application/json'}
-    last_response.status.should == 204
+    expect(last_response.status).to eq(204)
   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).
+    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'
-    last_response.should be_ok
-    last_response.body.should be_json_eql([contact_core].to_json)
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq([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).
+    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}"
-    last_response.should be_ok
-    last_response.body.should be_json_eql(contact_core.to_json)
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq(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).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     aget "/contacts/#{contact.id}"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   it "lists a contact's notification rules" do
     notification_rule_2 = double(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"')
+    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 ]
 
-    contact.should_receive(:notification_rules).and_return(notification_rules)
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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"
-    last_response.should be_ok
-    last_response.body.should be_json_eql( '["rule_1", "rule_2"]' )
+    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
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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}"
-    last_response.should be_ok
-    last_response.body.should be_json_eql('"rule_1"')
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq('"rule_1"')
   end
 
   it "does not return a notification rule that does not exist" do
-    Flapjack::Data::NotificationRule.should_receive(:find_by_id).
+    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}"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   # POST /notification_rules
   it "creates a new notification rule" do
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
-    notification_rule.should_receive(:respond_to?).with(:critical_media).and_return(true)
-    notification_rule.should_receive(:to_json).and_return('"rule_1"')
+    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)|
@@ -249,38 +249,38 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
     }
     notification_rule_data_sym.delete(:contact_id)
 
-    contact.should_receive(:add_notification_rule).
+    expect(contact).to receive(:add_notification_rule).
       with(notification_rule_data_sym, :logger => @logger).and_return(notification_rule)
 
     apost "/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"')
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq('"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).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     apost "/notification_rules", notification_rule_data.to_json,
       {'CONTENT_TYPE' => 'application/json'}
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   it "does not create a notification_rule if a rule id is provided" do
-    contact.should_not_receive(:add_notification_rule)
+    expect(contact).not_to receive(:add_notification_rule)
 
     apost "/notification_rules", notification_rule_data.merge(:id => 1).to_json,
       {'CONTENT_TYPE' => 'application/json'}
-    last_response.status.should == 403
+    expect(last_response.status).to eq(403)
   end
 
   # PUT /notification_rules/RULE_ID
   it "updates a notification rule" do
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(contact)
-    notification_rule.should_receive(:to_json).and_return('"rule_1"')
-    Flapjack::Data::NotificationRule.should_receive(:find_by_id).
+    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
@@ -289,71 +289,71 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
     }
     notification_rule_data_sym.delete(:contact_id)
 
-    notification_rule.should_receive(:update).with(notification_rule_data_sym, :logger => @logger).and_return(nil)
+    expect(notification_rule).to receive(:update).with(notification_rule_data_sym, :logger => @logger).and_return(nil)
 
     aput "/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"')
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq('"rule_1"')
   end
 
   it "does not update a notification rule that's not present" do
-    Flapjack::Data::NotificationRule.should_receive(:find_by_id).
+    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_rule_data
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   it "does not update a notification_rule for a contact that's not present" do
-    Flapjack::Data::NotificationRule.should_receive(:find_by_id).
+    expect(Flapjack::Data::NotificationRule).to receive(:find_by_id).
       with(notification_rule.id, {:redis => redis, :logger => @logger}).and_return(notification_rule)
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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_rule_data.to_json,
       {'CONTENT_TYPE' => 'application/json'}
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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)
-    contact.should_receive(:delete_notification_rule).with(notification_rule)
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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}"
-    last_response.status.should == 204
+    expect(last_response.status).to eq(204)
   end
 
   it "does not delete a notification rule that's not present" do
-    Flapjack::Data::NotificationRule.should_receive(:find_by_id).
+    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}"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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)
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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}"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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)
-    contact.should_receive(:media_rollup_thresholds).and_return(media_rollup_thresholds)
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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],
@@ -362,24 +362,24 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
       }).flatten(1)].to_json
 
     aget "/contacts/#{contact.id}/media"
-    last_response.should be_ok
-    last_response.body.should be_json_eql(result)
+    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
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     aget "/contacts/#{contact.id}/media"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   # GET /contacts/CONTACT_ID/media/MEDIA
   it "returns the specified media of a contact" do
-    contact.should_receive(:media).and_return(media)
-    contact.should_receive(:media_intervals).and_return(media_intervals)
-    contact.should_receive(:media_rollup_thresholds).and_return(media_rollup_thresholds)
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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 = {
@@ -389,25 +389,25 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
     }
 
     aget "/contacts/#{contact.id}/media/sms"
-    last_response.should be_ok
-    last_response.body.should be_json_eql(result.to_json)
+    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
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   # PUT, DELETE /contacts/CONTACT_ID/media/MEDIA
@@ -418,13 +418,13 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
     alt_media_intervals = media_intervals.merge('sms' => '200')
     alt_media_rollup_thresholds = media_rollup_thresholds.merge('sms' => '5')
 
-    contact.should_receive(:set_address_for_media).with('sms', '04987654321')
-    contact.should_receive(:set_interval_for_media).with('sms', '200')
-    contact.should_receive(:set_rollup_threshold_for_media).with('sms', '5')
-    contact.should_receive(:media).and_return(alt_media)
-    contact.should_receive(:media_intervals).and_return(alt_media_intervals)
-    contact.should_receive(:media_rollup_thresholds).and_return(alt_media_rollup_thresholds)
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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'],
@@ -433,8 +433,8 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
 
     aput "/contacts/#{contact.id}/media/sms", :address => '04987654321',
       :interval => '200', :rollup_threshold => '5'
-    last_response.should be_ok
-    last_response.body.should be_json_eql(result.to_json)
+    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
@@ -443,33 +443,33 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
               'username'    => "sausage@example.com",
               'password'    => "sausage"}
 
-    contact.should_receive(:set_pagerduty_credentials).with(result)
-    contact.should_receive(:pagerduty_credentials).and_return(result)
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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']
 
-    last_response.should be_ok
-    last_response.body.should be_json_eql(result.to_json)
+    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
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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'
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   it "does not create a media of a contact if no address is provided" do
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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'
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   it "creates a media of a contact even if no interval is provided" do
@@ -477,270 +477,270 @@ describe 'Flapjack::Gateways::API::ContactMethods', :sinatra => true, :logger =>
     alt_media_intervals = media_intervals.merge('sms' => nil)
     alt_media_rollup_thresholds = media_rollup_thresholds.merge('sms' => nil)
 
-    contact.should_receive(:set_address_for_media).with('sms', '04987654321')
-    contact.should_receive(:set_interval_for_media).with('sms', nil)
-    contact.should_receive(:set_rollup_threshold_for_media).with("sms", nil)
-    contact.should_receive(:media).and_return(alt_media)
-    contact.should_receive(:media_intervals).and_return(alt_media_intervals)
-    contact.should_receive(:media_rollup_thresholds).and_return(alt_media_rollup_thresholds)
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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'
-    last_response.should be_ok
+    expect(last_response).to be_ok
   end
 
   it "deletes a media of a contact" do
-    contact.should_receive(:remove_media).with('sms')
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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"
-    last_response.status.should == 204
+    expect(last_response.status).to eq(204)
   end
 
   it "does not delete a media of a contact that's not present" do
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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"
-    last_response.should be_ok
-    last_response.body.should be_json_eql('"Australia/Sydney"')
+    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
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     aget "/contacts/#{contact.id}/timezone"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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'}
-    last_response.should be_ok
+    expect(last_response).to 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).
+    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'}
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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"
-    last_response.status.should == 204
+    expect(last_response.status).to eq(204)
   end
 
   it "does not delete the timezone of a contact that's not present" do
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     adelete "/contacts/#{contact.id}/timezone"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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", :tag => 'web'
-    last_response.should be_ok
-    last_response.body.should be_json_eql( ['web'].to_json )
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq(['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).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     apost "contacts/#{contact.id}/tags", :tag => 'web'
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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", :tag => ['web', 'app']
-    last_response.should be_ok
-    last_response.body.should be_json_eql( ['web', 'app'].to_json )
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq(['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).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     apost "contacts/#{contact.id}/tags", :tag => ['web', 'app']
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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", :tag => 'web'
-    last_response.status.should == 204
+    expect(last_response.status).to eq(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).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     adelete "contacts/#{contact.id}/tags", :tag => 'web'
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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", :tag => ['web', 'app']
-    last_response.status.should == 204
+    expect(last_response.status).to eq(204)
   end
 
   it "does not remove multiple tags from a contact that's not found" do
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     adelete "contacts/#{contact.id}/tags", :tag => ['web', 'app']
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   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).
+    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"
-    last_response.should be_ok
-    last_response.body.should be_json_eql( ['web', 'app'].to_json )
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq(['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).
+    expect(Flapjack::Data::Contact).to receive(:find_by_id).
       with(contact.id, {:redis => redis, :logger => @logger}).and_return(nil)
 
     aget "contacts/#{contact.id}/tags"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   it "gets all entity tags for a contact" do
     entity_1 = double(Flapjack::Data::Entity)
-    entity_1.should_receive(:name).and_return('entity_1')
+    expect(entity_1).to receive(:name).and_return('entity_1')
     entity_2 = double(Flapjack::Data::Entity)
-    entity_2.should_receive(:name).and_return('entity_2')
+    expect(entity_2).to 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).
+    expect(contact).to receive(:entities).with(:tags => true).
       and_return(tag_data)
 
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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"
-    last_response.should be_ok
+    expect(last_response).to be_ok
     tag_response = {'entity_1' => ['web'],
                     'entity_2' => ['app']}
-    last_response.body.should be_json_eql( tag_response.to_json )
+    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
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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"
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   it "adds tags to multiple entities for a contact" do
     entity_1 = double(Flapjack::Data::Entity)
-    entity_1.should_receive(:name).twice.and_return('entity_1')
-    entity_1.should_receive(:add_tags).with('web')
+    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)
-    entity_2.should_receive(:name).twice.and_return('entity_2')
-    entity_2.should_receive(:add_tags).with('app')
+    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}]
-    contact.should_receive(:entities).and_return(entities)
+    expect(contact).to 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)
+    expect(contact).to receive(:entities).with(:tags => true).and_return(tag_data)
 
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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']}
-    last_response.should be_ok
+    expect(last_response).to be_ok
     tag_response = {'entity_1' => ['web'],
                     'entity_2' => ['app']}
-    last_response.body.should be_json_eql( tag_response.to_json )
+    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
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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']}
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end
 
   it "deletes tags from multiple entities for a contact" do
     entity_1 = double(Flapjack::Data::Entity)
-    entity_1.should_receive(:name).and_return('entity_1')
-    entity_1.should_receive(:delete_tags).with('web')
+    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)
-    entity_2.should_receive(:name).and_return('entity_2')
-    entity_2.should_receive(:delete_tags).with('app')
+    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}]
-    contact.should_receive(:entities).and_return(entities)
+    expect(contact).to receive(:entities).and_return(entities)
 
-    Flapjack::Data::Contact.should_receive(:find_by_id).
+    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']}
-    last_response.status.should == 204
+    expect(last_response.status).to eq(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).
+    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']}
-    last_response.should be_forbidden
+    expect(last_response).to be_forbidden
   end