flapjack 0.7.35 → 0.8.0

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

@@ -38,33 +38,33 @@ describe 'Flapjack::Gateways::API::EntityCheckPresenter' do
   }
 
   it "returns a list of outage hashes for an entity check" do
-    entity_check.should_receive(:historical_states).
+    expect(entity_check).to receive(:historical_states).
       with(time - (5 * 60 * 60), time - (2 * 60 * 60)).and_return(states)
 
-    entity_check.should_receive(:historical_state_before).
+    expect(entity_check).to receive(:historical_state_before).
       with(time - (4 * 60 * 60)).and_return(nil)
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
     outages = ecp.outages(time - (5 * 60 * 60), time - (2 * 60 * 60))
-    outages.should_not be_nil
-    outages.should be_an(Array)
-    outages.should have(4).time_ranges
+    expect(outages).not_to be_nil
+    expect(outages).to be_an(Array)
+    expect(outages.size).to eq(4)
 
     # TODO check the data in those hashes
   end
 
   it "returns a list of outage hashes with no start and end time set" do
-    entity_check.should_receive(:historical_states).
+    expect(entity_check).to receive(:historical_states).
       with(nil, nil).and_return(states)
 
-    entity_check.should_receive(:historical_state_before).
+    expect(entity_check).to receive(:historical_state_before).
       with(time - (4 * 60 * 60)).and_return(nil)
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
     outages = ecp.outages(nil, nil)
-    outages.should_not be_nil
-    outages.should be_an(Array)
-    outages.should have(4).time_ranges
+    expect(outages).not_to be_nil
+    expect(outages).to be_an(Array)
+    expect(outages.size).to eq(4)
 
     # TODO check the data in those hashes
   end
@@ -73,113 +73,113 @@ describe 'Flapjack::Gateways::API::EntityCheckPresenter' do
     states[1][:state] = 'critical'
     states[2][:state] = 'ok'
 
-    entity_check.should_receive(:historical_states).
+    expect(entity_check).to receive(:historical_states).
       with(nil, nil).and_return(states)
 
-    entity_check.should_receive(:historical_state_before).
+    expect(entity_check).to receive(:historical_state_before).
       with(time - (4 * 60 * 60)).and_return(nil)
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
     outages = ecp.outages(nil, nil)
-    outages.should_not be_nil
-    outages.should be_an(Array)
-    outages.should have(3).time_ranges
+    expect(outages).not_to be_nil
+    expect(outages).to be_an(Array)
+    expect(outages.size).to eq(3)
   end
 
   it "returns a (small) outage hash for a single state change" do
-    entity_check.should_receive(:historical_states).
+    expect(entity_check).to receive(:historical_states).
       with(nil, nil).and_return([{:state => 'critical', :timestamp => time - (4 * 60 * 60)}])
-    entity_check.should_receive(:historical_state_before).
+    expect(entity_check).to receive(:historical_state_before).
       with(time - (4 * 60 * 60)).and_return(nil)
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
     outages = ecp.outages(nil, nil)
-    outages.should_not be_nil
-    outages.should be_an(Array)
-    outages.should have(1).time_range
+    expect(outages).not_to be_nil
+    expect(outages).to be_an(Array)
+    expect(outages.size).to eq(1)
   end
 
   it "a list of unscheduled maintenances for an entity check" do
-    entity_check.should_receive(:maintenances).
+    expect(entity_check).to receive(:maintenances).
       with(time - (12 * 60 * 60), time, :scheduled => false).and_return(maintenances)
 
-    entity_check.should_receive(:maintenances).
+    expect(entity_check).to receive(:maintenances).
       with(nil, time - (12 * 60 * 60), :scheduled => false).and_return([])
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
     unsched_maint = ecp.unscheduled_maintenances(time - (12 * 60 * 60), time)
 
-    unsched_maint.should be_an(Array)
-    unsched_maint.should have(4).time_ranges
+    expect(unsched_maint).to be_an(Array)
+    expect(unsched_maint.size).to eq(4)
 
     # TODO check the data in those hashes
   end
 
   it "a list of scheduled maintenances for an entity check" do
-    entity_check.should_receive(:maintenances).
+    expect(entity_check).to receive(:maintenances).
       with(time - (12 * 60 * 60), time, :scheduled => true).and_return(maintenances)
 
-    entity_check.should_receive(:maintenances).
+    expect(entity_check).to receive(:maintenances).
       with(nil, time - (12 * 60 * 60), :scheduled => true).and_return([])
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
     sched_maint = ecp.scheduled_maintenances(time - (12 * 60 * 60), time)
 
-    sched_maint.should be_an(Array)
-    sched_maint.should have(4).time_ranges
+    expect(sched_maint).to be_an(Array)
+    expect(sched_maint.size).to eq(4)
 
     # TODO check the data in those hashes
   end
 
   it "returns downtime and percentage for a downtime check" do
-    entity_check.should_receive(:historical_states).
+    expect(entity_check).to receive(:historical_states).
       with(time - (12 * 60 * 60), time).and_return(states)
 
-    entity_check.should_receive(:historical_state_before).
+    expect(entity_check).to receive(:historical_state_before).
       with(time - (4 * 60 * 60)).and_return(nil)
 
-    entity_check.should_receive(:maintenances).
+    expect(entity_check).to receive(:maintenances).
       with(time - (12 * 60 * 60), time, :scheduled => true).and_return(maintenances)
 
-    entity_check.should_receive(:maintenances).
+    expect(entity_check).to receive(:maintenances).
       with(nil, time - (12 * 60 * 60), :scheduled => true).and_return([])
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
     downtimes = ecp.downtime(time - (12 * 60 * 60), time)
 
     # 22 minutes, 3 + 8 + 11
-    downtimes.should be_a(Hash)
-    downtimes[:total_seconds].should == {'critical' => (22 * 60),
-      'ok' => ((12 * 60 * 60) - (22 * 60))}
-    downtimes[:percentages].should == {'critical' => (((22 * 60) * 100.0) / (12 * 60 * 60)),
-      'ok' => ((((12 * 60 * 60) - (22 * 60)) * 100.0) / (12 * 60 *60))}
-    downtimes[:downtime].should be_an(Array)
+    expect(downtimes).to be_a(Hash)
+    expect(downtimes[:total_seconds]).to eq({'critical' => (22 * 60),
+      'ok' => ((12 * 60 * 60) - (22 * 60))})
+    expect(downtimes[:percentages]).to eq({'critical' => (((22 * 60) * 100.0) / (12 * 60 * 60)),
+      'ok' => ((((12 * 60 * 60) - (22 * 60)) * 100.0) / (12 * 60 *60))})
+    expect(downtimes[:downtime]).to be_an(Array)
     # the last outage gets split by the intervening maintenance period,
     # but the fully covered one gets removed.
-    downtimes[:downtime].should have(4).time_ranges
+    expect(downtimes[:downtime].size).to eq(4)
   end
 
   it "returns downtime (but no percentage) for an unbounded downtime check" do
-    entity_check.should_receive(:historical_states).
+    expect(entity_check).to receive(:historical_states).
       with(nil, nil).and_return(states)
 
-    entity_check.should_receive(:historical_state_before).
+    expect(entity_check).to receive(:historical_state_before).
       with(time - (4 * 60 * 60)).and_return(nil)
 
-    entity_check.should_receive(:maintenances).
+    expect(entity_check).to receive(:maintenances).
       with(nil, nil, :scheduled => true).and_return(maintenances)
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
     downtimes = ecp.downtime(nil, nil)
 
     # 22 minutes, 3 + 8 + 11
-    downtimes.should be_a(Hash)
-    downtimes[:total_seconds].should == {'critical' => (22 * 60)}
-    downtimes[:percentages].should == {'critical' => nil}
-    downtimes[:downtime].should be_an(Array)
+    expect(downtimes).to be_a(Hash)
+    expect(downtimes[:total_seconds]).to eq({'critical' => (22 * 60)})
+    expect(downtimes[:percentages]).to eq({'critical' => nil})
+    expect(downtimes[:downtime]).to be_an(Array)
     # the last outage gets split by the intervening maintenance period,
     # but the fully covered one gets removed.
-    downtimes[:downtime].should have(4).time_ranges
+    expect(downtimes[:downtime].size).to eq(4)
   end
 
   it "returns downtime and handles an unfinished problem state" do
@@ -187,25 +187,25 @@ describe 'Flapjack::Gateways::API::EntityCheckPresenter' do
                {:state => 'ok',       :timestamp => time - (4 * 60 * 60) + (5 * 60)},
                {:state => 'critical', :timestamp => time - (3 * 60 * 60)}]
 
-    entity_check.should_receive(:historical_states).
+    expect(entity_check).to receive(:historical_states).
       with(nil, nil).and_return(current)
 
-    entity_check.should_receive(:historical_state_before).
+    expect(entity_check).to receive(:historical_state_before).
       with(time - (4 * 60 * 60)).and_return(nil)
 
-    entity_check.should_receive(:maintenances).
+    expect(entity_check).to receive(:maintenances).
       with(nil, nil, :scheduled => true).and_return([])
 
     ecp = Flapjack::Gateways::API::EntityCheckPresenter.new(entity_check)
     downtimes = ecp.downtime(nil, nil)
 
-    downtimes.should be_a(Hash)
-    downtimes[:total_seconds].should == {'critical' => (5 * 60)}
-    downtimes[:percentages].should == {'critical' => nil}
-    downtimes[:downtime].should be_an(Array)
+    expect(downtimes).to be_a(Hash)
+    expect(downtimes[:total_seconds]).to eq({'critical' => (5 * 60)})
+    expect(downtimes[:percentages]).to eq({'critical' => nil})
+    expect(downtimes[:downtime]).to be_an(Array)
     # the last outage gets split by the intervening maintenance period,
     # but the fully covered one gets removed.
-    downtimes[:downtime].should have(2).time_ranges
+    expect(downtimes[:downtime].size).to eq(2)
   end
 
 end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'flapjack/gateways/api'
 
-describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger => true, :json => true do
+describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger => true do
 
   def app
     Flapjack::Gateways::API
@@ -26,20 +26,20 @@ describe 'Flapjack::Gateways::API::EntityMethods', :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
   end
 
   it "returns a list of checks for an entity" do
-    entity.should_receive(:check_list).and_return([check])
-    Flapjack::Data::Entity.should_receive(:find_by_name).
+    expect(entity).to receive(:check_list).and_return([check])
+    expect(Flapjack::Data::Entity).to receive(:find_by_name).
       with(entity_name, :redis => redis).and_return(entity)
 
     aget "/checks/#{entity_name_esc}"
-    last_response.should be_ok
-    last_response.body.should == [check].to_json
+    expect(last_response).to be_ok
+    expect(last_response.body).to eq([check].to_json)
   end
 
   context 'non-bulk API calls' do
@@ -47,76 +47,76 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
     it "returns the status for all checks on an entity" do
       status = double('status', :to_json => 'status!'.to_json)
       result = {:entity => entity_name, :check => check, :status => status}
-      entity_presenter.should_receive(:status).and_return(result)
+      expect(entity_presenter).to receive(:status).and_return(result)
 
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/status/#{entity_name_esc}"
-      last_response.should be_ok
-      last_response.body.should == ['status!'].to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(['status!'].to_json)
     end
 
     it "should not show the status for an entity that's not found" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(nil)
 
       aget "/status/#{entity_name_esc}"
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "returns the status for a check on an entity" do
       status = double('status', :to_json => 'status!'.to_json)
-      entity_check_presenter.should_receive(:status).and_return(status)
+      expect(entity_check_presenter).to receive(:status).and_return(status)
 
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/status/#{entity_name_esc}/#{check}"
-      last_response.should be_ok
-      last_response.body.should == 'status!'.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('status!'.to_json)
     end
 
     it "should not show the status for a check on an entity that's not found" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(nil)
 
       aget "/status/#{entity_name_esc}/#{check}"
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "should not show the status for a check that's not found on an entity" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(nil)
 
       aget "/status/#{entity_name_esc}/#{check}"
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "returns a list of scheduled maintenance periods for an entity" do
       sched = double('sched', :to_json => 'sched!'.to_json)
       result = {:entity => entity_name, :check => check, :scheduled_maintenances => sched}
-      entity_presenter.should_receive(:scheduled_maintenances).with(nil, nil).and_return(result)
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(entity_presenter).to receive(:scheduled_maintenances).with(nil, nil).and_return(result)
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/scheduled_maintenances/#{entity_name_esc}"
-      last_response.should be_ok
-      last_response.body.should == [{:check => check, :scheduled_maintenance => sched}].to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq([{:check => check, :scheduled_maintenance => sched}].to_json)
     end
 
     it "returns a list of scheduled maintenance periods within a time window for an entity" do
@@ -125,75 +125,75 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
 
       sched = double('sched', :to_json => 'sched!'.to_json)
       result = {:entity => entity_name, :check => check, :scheduled_maintenances => sched}
-      entity_presenter.should_receive(:scheduled_maintenances).with(start.to_i, finish.to_i).and_return(result)
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(entity_presenter).to receive(:scheduled_maintenances).with(start.to_i, finish.to_i).and_return(result)
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/scheduled_maintenances/#{entity_name_esc}?" +
         "start_time=#{CGI.escape(start.iso8601)}&end_time=#{CGI.escape(finish.iso8601)}"
-      last_response.should be_ok
-      last_response.body.should == [{:check => check, :scheduled_maintenance => sched}].to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq([{:check => check, :scheduled_maintenance => sched}].to_json)
     end
 
     it "returns a list of scheduled maintenance periods for a check on an entity" do
       sched = double('sched', :to_json => 'sched!'.to_json)
-      entity_check_presenter.should_receive(:scheduled_maintenances).with(nil, nil).and_return(sched)
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(entity_check_presenter).to receive(:scheduled_maintenances).with(nil, nil).and_return(sched)
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
       aget "/scheduled_maintenances/#{entity_name_esc}/#{check}"
-      last_response.should be_ok
-      last_response.body.should == 'sched!'.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('sched!'.to_json)
     end
 
     it "creates an acknowledgement for an entity check" do
-      entity_check.should_receive(:entity_name).and_return(entity_name)
-      entity_check.should_receive(:check).and_return(check)
+      expect(entity_check).to receive(:entity_name).and_return(entity_name)
+      expect(entity_check).to receive(:check).and_return(check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
-      Flapjack::Data::Event.should_receive(:create_acknowledgement).
+      expect(Flapjack::Data::Event).to receive(:create_acknowledgement).
         with(entity_name, check, :summary => nil, :duration => (4 * 60 * 60), :redis => redis)
 
       apost "/acknowledgements/#{entity_name_esc}/#{check}"
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "returns a list of unscheduled maintenance periods for an entity" do
       unsched = double('unsched', :to_json => 'unsched!'.to_json)
       result = {:entity => entity_name, :check => check, :unscheduled_maintenances => unsched}
-      entity_presenter.should_receive(:unscheduled_maintenances).with(nil, nil).and_return(result)
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(entity_presenter).to receive(:unscheduled_maintenances).with(nil, nil).and_return(result)
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/unscheduled_maintenances/#{entity_name_esc}"
-      last_response.should be_ok
-      last_response.body.should == [{:check => check, :unscheduled_maintenance => unsched}].to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq([{:check => check, :unscheduled_maintenance => unsched}].to_json)
     end
 
     it "returns a list of unscheduled maintenance periods for a check on an entity" do
       unsched = double('unsched', :to_json => 'unsched!'.to_json)
-      entity_check_presenter.should_receive(:unscheduled_maintenances).with(nil, nil).and_return(unsched)
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(entity_check_presenter).to receive(:unscheduled_maintenances).with(nil, nil).and_return(unsched)
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
       aget "/unscheduled_maintenances/#{entity_name_esc}/#{check}"
-      last_response.should be_ok
-      last_response.body.should == 'unsched!'.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('unsched!'.to_json)
     end
 
     it "returns a list of unscheduled maintenance periods within a time window for a check an entity" do
@@ -201,93 +201,93 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
       finish   = Time.parse('6 Jan 2012')
 
       unsched = double('unsched', :to_json => 'unsched!'.to_json)
-      entity_check_presenter.should_receive(:unscheduled_maintenances).with(start.to_i, finish.to_i).and_return(unsched)
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(entity_check_presenter).to receive(:unscheduled_maintenances).with(start.to_i, finish.to_i).and_return(unsched)
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
       aget "/unscheduled_maintenances/#{entity_name_esc}/#{check}" +
         "?start_time=#{CGI.escape(start.iso8601)}&end_time=#{CGI.escape(finish.iso8601)}"
-      last_response.should be_ok
-      last_response.body.should == 'unsched!'.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('unsched!'.to_json)
     end
 
     it "returns a list of outages for an entity" do
       out = double('out', :to_json => 'out!'.to_json)
       result = {:entity => entity_name, :check => check, :outages => out}
-      entity_presenter.should_receive(:outages).with(nil, nil).and_return(result)
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(entity_presenter).to receive(:outages).with(nil, nil).and_return(result)
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/outages/#{entity_name_esc}"
-      last_response.should be_ok
-      last_response.body.should == [{:check => check, :outages => out}].to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq([{:check => check, :outages => out}].to_json)
     end
 
     it "returns a list of outages for a check on an entity" do
       out = double('out', :to_json => 'out!'.to_json)
-      entity_check_presenter.should_receive(:outages).with(nil, nil).and_return(out)
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(entity_check_presenter).to receive(:outages).with(nil, nil).and_return(out)
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
       aget "/outages/#{entity_name_esc}/#{check}"
-      last_response.should be_ok
-      last_response.body.should == 'out!'.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('out!'.to_json)
     end
 
     it "returns a list of downtimes for an entity" do
       down = double('down', :to_json => 'down!'.to_json)
       result = {:entity => entity_name, :check => check, :downtime => down}
-      entity_presenter.should_receive(:downtime).with(nil, nil).and_return(result)
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(entity_presenter).to receive(:downtime).with(nil, nil).and_return(result)
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/downtime/#{entity_name_esc}"
-      last_response.should be_ok
-      last_response.body.should == [{:check => check, :downtime => down}].to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq([{:check => check, :downtime => down}].to_json)
     end
 
     it "returns a list of downtimes for a check on an entity" do
       down = double('down', :to_json => 'down!'.to_json)
-      entity_check_presenter.should_receive(:downtime).with(nil, nil).and_return(down)
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(entity_check_presenter).to receive(:downtime).with(nil, nil).and_return(down)
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
       aget "/downtime/#{entity_name_esc}/#{check}"
-      last_response.should be_ok
-      last_response.body.should == 'down!'.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq('down!'.to_json)
     end
 
     it "creates a test notification event for check on an entity" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      entity.should_receive(:name).and_return(entity_name)
-      entity_check.should_receive(:entity).and_return(entity)
-      entity_check.should_receive(:entity_name).and_return(entity_name)
-      entity_check.should_receive(:check).and_return('foo')
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(entity).to receive(:name).and_return(entity_name)
+      expect(entity_check).to receive(:entity).and_return(entity)
+      expect(entity_check).to receive(:entity_name).and_return(entity_name)
+      expect(entity_check).to receive(:check).and_return('foo')
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, 'foo', :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Event.should_receive(:test_notifications).
+      expect(Flapjack::Data::Event).to receive(:test_notifications).
         with(entity_name, 'foo', hash_including(:redis => redis))
 
       apost "/test_notifications/#{entity_name_esc}/foo"
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
   end
@@ -297,107 +297,107 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
     it "returns the status for all checks on an entity" do
       status = double('status')
       result = [{:entity => entity_name, :check => check, :status => status}]
-      entity_presenter.should_receive(:status).and_return(result)
+      expect(entity_presenter).to receive(:status).and_return(result)
 
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/status", :entity => entity_name
-      last_response.body.should == result.to_json
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "should not show the status for an entity that's not found" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(nil)
 
       aget "/status", :entity => entity_name
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "returns the status for a check on an entity" do
       status = double('status')
       result = [{:entity => entity_name, :check => check, :status => status}]
-      entity_check_presenter.should_receive(:status).and_return(status)
+      expect(entity_check_presenter).to receive(:status).and_return(status)
 
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/status", :check => {entity_name => check}
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "should not show the status for a check on an entity that's not found" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(nil)
 
       aget "/status", :check => {entity_name => check}
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "should not show the status for a check that's not found on an entity" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(nil)
 
       aget "/status", :check => {entity_name => check}
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "creates an acknowledgement for an entity check" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      entity_check.should_receive(:entity_name).and_return(entity_name)
-      entity_check.should_receive(:check).and_return(check)
+      expect(entity_check).to receive(:entity_name).and_return(entity_name)
+      expect(entity_check).to receive(:check).and_return(check)
 
-      Flapjack::Data::Event.should_receive(:create_acknowledgement).
+      expect(Flapjack::Data::Event).to receive(:create_acknowledgement).
         with(entity_name, check, :summary => nil, :duration => (4 * 60 * 60), :redis => redis)
 
       apost '/acknowledgements',:check => {entity_name => check}
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "deletes an unscheduled maintenance period for an entity check" do
       end_time = Time.now + (60 * 60) # an hour from now
-      entity_check.should_receive(:end_unscheduled_maintenance).with(end_time.to_i)
+      expect(entity_check).to receive(:end_unscheduled_maintenance).with(end_time.to_i)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       adelete "/unscheduled_maintenances", :check => {entity_name => check}, :end_time => end_time.iso8601
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "creates a scheduled maintenance period for an entity check" do
       start = Time.now + (60 * 60) # an hour from now
       duration = (2 * 60 * 60)     # two hours
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
-      entity_check.should_receive(:create_scheduled_maintenance).
+      expect(entity_check).to receive(:create_scheduled_maintenance).
         with(start.getutc.to_i, duration, :summary => 'test')
 
       apost "/scheduled_maintenances/#{entity_name_esc}/#{check}?" +
          "start_time=#{CGI.escape(start.iso8601)}&summary=test&duration=#{duration}"
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "doesn't create a scheduled maintenance period if the start time isn't passed" do
@@ -405,28 +405,28 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
 
       apost "/scheduled_maintenances/#{entity_name_esc}/#{check}?" +
          "summary=test&duration=#{duration}"
-      last_response.status.should == 403
+      expect(last_response.status).to eq(403)
     end
 
     it "deletes a scheduled maintenance period for an entity check" do
       start_time = Time.now + (60 * 60) # an hour from now
-      entity_check.should_receive(:end_scheduled_maintenance).with(start_time.to_i)
+      expect(entity_check).to receive(:end_scheduled_maintenance).with(start_time.to_i)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       adelete "/scheduled_maintenances", :check => {entity_name => check}, :start_time => start_time.iso8601
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "doesn't delete a scheduled maintenance period if the start time isn't passed" do
-      entity_check.should_not_receive(:end_scheduled_maintenance)
+      expect(entity_check).not_to receive(:end_scheduled_maintenance)
 
       adelete "/scheduled_maintenances", :check => {entity_name => check}
-      last_response.status.should == 403
+      expect(last_response.status).to eq(403)
     end
 
     it "deletes scheduled maintenance periods for multiple entity checks" do
@@ -434,36 +434,36 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
 
       entity_check_2 = double(Flapjack::Data::EntityCheck)
 
-      entity_check.should_receive(:end_scheduled_maintenance).with(start_time.to_i)
-      entity_check_2.should_receive(:end_scheduled_maintenance).with(start_time.to_i)
+      expect(entity_check).to receive(:end_scheduled_maintenance).with(start_time.to_i)
+      expect(entity_check_2).to receive(:end_scheduled_maintenance).with(start_time.to_i)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, 'foo', :redis => redis).and_return(entity_check_2)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       adelete "/scheduled_maintenances", :check => {entity_name => [check, 'foo']}, :start_time => start_time.iso8601
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "returns a list of scheduled maintenance periods for an entity" do
       sm = double('sched_maint')
       result = [{:entity => entity_name, :check => check, :scheduled_maintenances => sm}]
 
-      entity_presenter.should_receive(:scheduled_maintenances).with(nil, nil).and_return(result)
+      expect(entity_presenter).to receive(:scheduled_maintenances).with(nil, nil).and_return(result)
 
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/scheduled_maintenances", :entity => entity_name
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "returns a list of scheduled maintenance periods within a time window for an entity" do
@@ -473,75 +473,75 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
       sm = double('sched_maint')
       result = [{:entity => entity_name, :check => check, :scheduled_maintenances => sm}]
 
-      entity_presenter.should_receive(:scheduled_maintenances).with(start.to_i, finish.to_i).and_return(result)
+      expect(entity_presenter).to receive(:scheduled_maintenances).with(start.to_i, finish.to_i).and_return(result)
 
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/scheduled_maintenances", :entity => entity_name,
         :start_time => start.iso8601, :end_time => finish.iso8601
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "returns a list of scheduled maintenance periods for a check on an entity" do
       sm = double('sched_maint')
       result = [{:entity => entity_name, :check => check, :scheduled_maintenances => sm}]
 
-      entity_check_presenter.should_receive(:scheduled_maintenances).with(nil, nil).and_return(sm)
+      expect(entity_check_presenter).to receive(:scheduled_maintenances).with(nil, nil).and_return(sm)
 
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/scheduled_maintenances", :check => {entity_name => check}
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "returns a list of unscheduled maintenance periods for an entity" do
       um = double('unsched_maint')
       result = [{:entity => entity_name, :check => check, :unscheduled_maintenances => um}]
 
-      entity_presenter.should_receive(:unscheduled_maintenances).with(nil, nil).and_return(result)
+      expect(entity_presenter).to receive(:unscheduled_maintenances).with(nil, nil).and_return(result)
 
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/unscheduled_maintenances", :entity => entity_name
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "returns a list of unscheduled maintenance periods for a check on an entity" do
       um = double('unsched_maint')
       result = [{:entity => entity_name, :check => check, :unscheduled_maintenances => um}]
 
-      entity_check_presenter.should_receive(:unscheduled_maintenances).with(nil, nil).and_return(um)
+      expect(entity_check_presenter).to receive(:unscheduled_maintenances).with(nil, nil).and_return(um)
 
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/unscheduled_maintenances", :check => {entity_name => check}
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "returns a list of unscheduled maintenance periods within a time window for a check an entity" do
@@ -551,21 +551,21 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
       um = double('unsched_maint')
       result = [{:entity => entity_name, :check => check, :unscheduled_maintenances => um}]
 
-      entity_check_presenter.should_receive(:unscheduled_maintenances).with(start.to_i, finish.to_i).and_return(um)
+      expect(entity_check_presenter).to receive(:unscheduled_maintenances).with(start.to_i, finish.to_i).and_return(um)
 
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/unscheduled_maintenances", :check => {entity_name => check},
         :start_time => start.iso8601, :end_time => finish.iso8601
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "returns a list of outages, for one whole entity and two checks on another entity" do
@@ -586,136 +586,136 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
       foo_check_presenter = double(Flapjack::Gateways::API::EntityCheckPresenter)
       bar_check_presenter = double(Flapjack::Gateways::API::EntityCheckPresenter)
 
-      entity_presenter.should_receive(:outages).with(nil, nil).and_return(result[0])
-      foo_check_presenter.should_receive(:outages).with(nil, nil).and_return(outages_2)
-      bar_check_presenter.should_receive(:outages).with(nil, nil).and_return(outages_3)
+      expect(entity_presenter).to receive(:outages).with(nil, nil).and_return(result[0])
+      expect(foo_check_presenter).to receive(:outages).with(nil, nil).and_return(outages_2)
+      expect(bar_check_presenter).to receive(:outages).with(nil, nil).and_return(outages_3)
 
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
 
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(foo_check).and_return(foo_check_presenter)
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(bar_check).and_return(bar_check_presenter)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_2_name, :redis => redis).and_return(entity_2)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity_2, 'foo', :redis => redis).and_return(foo_check)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity_2, 'bar', :redis => redis).and_return(bar_check)
 
       aget "/outages", :entity => entity_name, :check => {entity_2_name => ['foo', 'bar']}
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "returns a list of outages for a check on an entity" do
       outages = double('outages')
       result = [{:entity => entity_name, :check => check, :outages => outages}]
 
-      entity_check_presenter.should_receive(:outages).with(nil, nil).and_return(outages)
+      expect(entity_check_presenter).to receive(:outages).with(nil, nil).and_return(outages)
 
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/outages", :check => {entity_name => check}
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "returns a list of downtimes for an entity" do
       downtime = double('downtime')
       result = [{:entity => entity_name, :check => check, :downtime => downtime}]
 
-      entity_presenter.should_receive(:downtime).with(nil, nil).and_return(result)
+      expect(entity_presenter).to receive(:downtime).with(nil, nil).and_return(result)
 
-      Flapjack::Gateways::API::EntityPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityPresenter).to receive(:new).
         with(entity, :redis => redis).and_return(entity_presenter)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/downtime", :entity => entity_name
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "returns a list of downtimes for a check on an entity" do
       downtime = double('downtime')
       result = [{:entity => entity_name, :check => check, :downtime => downtime}]
 
-      entity_check_presenter.should_receive(:downtime).with(nil, nil).and_return(downtime)
+      expect(entity_check_presenter).to receive(:downtime).with(nil, nil).and_return(downtime)
 
-      Flapjack::Gateways::API::EntityCheckPresenter.should_receive(:new).
+      expect(Flapjack::Gateways::API::EntityCheckPresenter).to receive(:new).
         with(entity_check).and_return(entity_check_presenter)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "/downtime", :check => {entity_name => check}
-      last_response.should be_ok
-      last_response.body.should == result.to_json
+      expect(last_response).to be_ok
+      expect(last_response.body).to eq(result.to_json)
     end
 
     it "creates test notification events for all checks on an entity" do
-      entity.should_receive(:check_list).and_return([check, 'foo'])
-      entity.should_receive(:name).twice.and_return(entity_name)
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(entity).to receive(:check_list).and_return([check, 'foo'])
+      expect(entity).to receive(:name).twice.and_return(entity_name)
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
-      entity_check.should_receive(:entity).and_return(entity)
-      entity_check.should_receive(:entity_name).and_return(entity_name)
-      entity_check.should_receive(:check).and_return(check)
+      expect(entity_check).to receive(:entity).and_return(entity)
+      expect(entity_check).to receive(:entity_name).and_return(entity_name)
+      expect(entity_check).to receive(:check).and_return(check)
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
       entity_check_2 = double(Flapjack::Data::EntityCheck)
-      entity_check_2.should_receive(:entity).and_return(entity)
-      entity_check_2.should_receive(:entity_name).and_return(entity_name)
-      entity_check_2.should_receive(:check).and_return('foo')
+      expect(entity_check_2).to receive(:entity).and_return(entity)
+      expect(entity_check_2).to receive(:entity_name).and_return(entity_name)
+      expect(entity_check_2).to receive(:check).and_return('foo')
 
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, 'foo', :redis => redis).and_return(entity_check_2)
 
-      Flapjack::Data::Event.should_receive(:test_notifications).
+      expect(Flapjack::Data::Event).to receive(:test_notifications).
         with(entity_name, check, hash_including(:redis => redis))
 
-      Flapjack::Data::Event.should_receive(:test_notifications).
+      expect(Flapjack::Data::Event).to receive(:test_notifications).
         with(entity_name, 'foo', hash_including(:redis => redis))
 
       apost '/test_notifications', :entity => entity_name
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "creates a test notification event for check on an entity" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
-      entity.should_receive(:name).and_return(entity_name)
-      entity_check.should_receive(:entity).and_return(entity)
-      entity_check.should_receive(:entity_name).and_return(entity_name)
-      entity_check.should_receive(:check).and_return(check)
-      Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      expect(entity).to receive(:name).and_return(entity_name)
+      expect(entity_check).to receive(:entity).and_return(entity)
+      expect(entity_check).to receive(:entity_name).and_return(entity_name)
+      expect(entity_check).to receive(:check).and_return(check)
+      expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
 
-      Flapjack::Data::Event.should_receive(:test_notifications).
+      expect(Flapjack::Data::Event).to receive(:test_notifications).
         with(entity_name, check, hash_including(:redis => redis))
 
       apost '/test_notifications', :check => {entity_name => check}
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "creates entities from a submitted list" do
@@ -731,18 +731,18 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
          }
         ]
       }
-      Flapjack::Data::Entity.should_receive(:add).twice
+      expect(Flapjack::Data::Entity).to receive(:add).twice
 
       apost "/entities", entities.to_json, {'CONTENT_TYPE' => 'application/json'}
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "does not create entities if the data is improperly formatted" do
-      Flapjack::Data::Entity.should_not_receive(:add)
+      expect(Flapjack::Data::Entity).not_to receive(:add)
 
       apost "/entities", {'entities' => ["Hello", "there"]}.to_json,
         {'CONTENT_TYPE' => 'application/json'}
-      last_response.status.should == 403
+      expect(last_response.status).to eq(403)
     end
 
     it "does not create entities if they don't contain an id" do
@@ -757,10 +757,10 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
          }
         ]
       }
-      Flapjack::Data::Entity.should_receive(:add)
+      expect(Flapjack::Data::Entity).to receive(:add)
 
       apost "/entities", entities.to_json, {'CONTENT_TYPE' => 'application/json'}
-      last_response.status.should == 403
+      expect(last_response.status).to eq(403)
     end
 
   end
@@ -768,94 +768,94 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
   context "tags" do
 
     it "sets a single tag on an entity and returns current tags" do
-      entity.should_receive(:add_tags).with('web')
-      entity.should_receive(:tags).and_return(['web'])
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(entity).to receive(:add_tags).with('web')
+      expect(entity).to receive(:tags).and_return(['web'])
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       apost "entities/#{entity_name}/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 an entity that's not found" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(nil)
 
       apost "entities/#{entity_name}/tags", :tag => 'web'
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "sets multiple tags on an entity and returns current tags" do
-      entity.should_receive(:add_tags).with('web', 'app')
-      entity.should_receive(:tags).and_return(['web', 'app'])
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(entity).to receive(:add_tags).with('web', 'app')
+      expect(entity).to receive(:tags).and_return(['web', 'app'])
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       # NB submitted at a lower level as tag[]=web&tag[]=app
       apost "entities/#{entity_name}/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 an entity that's not found" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(nil)
 
       apost "entities/#{entity_name}/tags", :tag => ['web', 'app']
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "removes a single tag from an entity" do
-      entity.should_receive(:delete_tags).with('web')
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(entity).to receive(:delete_tags).with('web')
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       adelete "entities/#{entity_name}/tags", :tag => 'web'
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "does not remove a single tag from an entity that's not found" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(nil)
 
       adelete "entities/#{entity_name}/tags", :tag => 'web'
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "removes multiple tags from an entity" do
-      entity.should_receive(:delete_tags).with('web', 'app')
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(entity).to receive(:delete_tags).with('web', 'app')
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       adelete "entities/#{entity_name}/tags", :tag => ['web', 'app']
-      last_response.status.should == 204
+      expect(last_response.status).to eq(204)
     end
 
     it "does not remove multiple tags from an entity that's not found" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(nil)
 
       adelete "entities/#{entity_name}/tags", :tag => ['web', 'app']
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
     it "gets all tags on an entity" do
-      entity.should_receive(:tags).and_return(['web', 'app'])
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(entity).to receive(:tags).and_return(['web', 'app'])
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
       aget "entities/#{entity_name}/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 an entity that's not found" do
-      Flapjack::Data::Entity.should_receive(:find_by_name).
+      expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(nil)
 
       aget "entities/#{entity_name}/tags"
-      last_response.should be_forbidden
+      expect(last_response).to be_forbidden
     end
 
   end