flapjack 0.7.35 → 0.8.0

data/lib/flapjack/pikelet.rb

@@ -20,6 +20,7 @@ require 'thin'
 require 'flapjack/notifier'
 require 'flapjack/processor'
 require 'flapjack/gateways/api'
+require 'flapjack/gateways/jsonapi'
 require 'flapjack/gateways/jabber'
 require 'flapjack/gateways/oobetet'
 require 'flapjack/gateways/pagerduty'
@@ -216,8 +217,9 @@ module Flapjack
 
     class Thin < Flapjack::Pikelet::Base
 
-      PIKELET_TYPES = {'web'  => Flapjack::Gateways::Web,
-                       'api'  => Flapjack::Gateways::API}
+      PIKELET_TYPES = {'web'     => Flapjack::Gateways::Web,
+                       'api'     => Flapjack::Gateways::API,
+                       'jsonapi' => Flapjack::Gateways::JSONAPI}
 
       def self.create(type, opts = {})
         ::Thin::Logging.silent = true

data/lib/flapjack/version.rb

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

data/spec/lib/flapjack/coordinator_spec.rb

@@ -12,30 +12,30 @@ describe Flapjack::Coordinator do
   let!(:time)  { Time.now }
 
   it "starts and stops a pikelet" do
-    Flapjack::Logger.should_receive(:new).and_return(logger)
+    expect(Flapjack::Logger).to receive(:new).and_return(logger)
 
     cfg = {'processor' => {'enabled' => true}}
-    EM.should_receive(:synchrony).and_yield
-    config.should_receive(:for_redis).and_return({})
-    config.should_receive(:all).twice.and_return(cfg)
+    expect(EM).to receive(:synchrony).and_yield
+    expect(config).to receive(:for_redis).and_return({})
+    expect(config).to receive(:all).twice.and_return(cfg)
 
     processor = double('processor')
-    processor.should_receive(:start)
-    processor.should_receive(:stop)
-    processor.should_receive(:update_status)
-    processor.should_receive(:status).exactly(3).times.and_return('stopped')
+    expect(processor).to receive(:start)
+    expect(processor).to receive(:stop)
+    expect(processor).to receive(:update_status)
+    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
 
-    Time.should_receive(:now).and_return(time)
+    expect(Time).to receive(:now).and_return(time)
 
     fc = Flapjack::Coordinator.new(config)
-    Flapjack::Pikelet.should_receive(:create).with('processor',
+    expect(Flapjack::Pikelet).to receive(:create).with('processor',
         :config => cfg['processor'], :redis_config => {}, :boot_time => time, :coordinator => fc).
       and_return(processor)
 
-    fiber.should_receive(:resume)
-    Fiber.should_receive(:new).and_yield.and_return(fiber)
+    expect(fiber).to receive(:resume)
+    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
 
-    EM.should_receive(:stop)
+    expect(EM).to receive(:stop)
 
     # Syslog.should_receive(:opened?).and_return(true)
     # Syslog.should_receive(:close)
@@ -45,31 +45,31 @@ describe Flapjack::Coordinator do
   end
 
   it "handles an exception raised by a pikelet and shuts down" do
-    Flapjack::Logger.should_receive(:new).and_return(logger)
-    logger.should_receive(:fatal)
+    expect(Flapjack::Logger).to receive(:new).and_return(logger)
+    expect(logger).to receive(:fatal)
 
     cfg = {'processor' => {'enabled' => true}}
-    EM.should_receive(:synchrony).and_yield
-    config.should_receive(:for_redis).and_return({})
-    config.should_receive(:all).twice.and_return(cfg)
+    expect(EM).to receive(:synchrony).and_yield
+    expect(config).to receive(:for_redis).and_return({})
+    expect(config).to receive(:all).twice.and_return(cfg)
 
     processor = double('processor')
-    processor.should_receive(:start).and_raise(RuntimeError)
-    processor.should_receive(:stop)
-    processor.should_receive(:update_status)
-    processor.should_receive(:status).exactly(3).times.and_return('stopped')
+    expect(processor).to receive(:start).and_raise(RuntimeError)
+    expect(processor).to receive(:stop)
+    expect(processor).to receive(:update_status)
+    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
 
-    Time.should_receive(:now).and_return(time)
+    expect(Time).to receive(:now).and_return(time)
 
     fc = Flapjack::Coordinator.new(config)
-    Flapjack::Pikelet.should_receive(:create).with('processor',
+    expect(Flapjack::Pikelet).to receive(:create).with('processor',
         :config => cfg['processor'], :redis_config => {}, :boot_time => time, :coordinator => fc)
       .and_return(processor)
 
-    fiber.should_receive(:resume)
-    Fiber.should_receive(:new).and_yield.and_return(fiber)
+    expect(fiber).to receive(:resume)
+    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
 
-    EM.should_receive(:stop)
+    expect(EM).to receive(:stop)
 
     # Syslog.should_receive(:opened?).and_return(true)
     # Syslog.should_receive(:close)
@@ -80,36 +80,36 @@ describe Flapjack::Coordinator do
 
   it "loads an old executive pikelet config block with no new data" do
     cfg = {'executive' => {'enabled' => true}}
-    EM.should_receive(:synchrony).and_yield
-    config.should_receive(:for_redis).and_return({})
-    config.should_receive(:all).twice.and_return(cfg)
+    expect(EM).to receive(:synchrony).and_yield
+    expect(config).to receive(:for_redis).and_return({})
+    expect(config).to receive(:all).twice.and_return(cfg)
 
     processor = double('processor')
-    processor.should_receive(:start)
-    processor.should_receive(:stop)
-    processor.should_receive(:update_status)
-    processor.should_receive(:status).exactly(3).times.and_return('stopped')
+    expect(processor).to receive(:start)
+    expect(processor).to receive(:stop)
+    expect(processor).to receive(:update_status)
+    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
 
     notifier = double('processor')
-    notifier.should_receive(:start)
-    notifier.should_receive(:stop)
-    notifier.should_receive(:update_status)
-    notifier.should_receive(:status).exactly(3).times.and_return('stopped')
+    expect(notifier).to receive(:start)
+    expect(notifier).to receive(:stop)
+    expect(notifier).to receive(:update_status)
+    expect(notifier).to receive(:status).exactly(3).times.and_return('stopped')
 
-    Time.should_receive(:now).and_return(time)
+    expect(Time).to receive(:now).and_return(time)
 
     fc = Flapjack::Coordinator.new(config)
-    Flapjack::Pikelet.should_receive(:create).with('processor',
+    expect(Flapjack::Pikelet).to receive(:create).with('processor',
         :config => cfg['executive'], :redis_config => {}, :boot_time => time, :coordinator => fc).
       and_return(processor)
-    Flapjack::Pikelet.should_receive(:create).with('notifier',
+    expect(Flapjack::Pikelet).to receive(:create).with('notifier',
         :config => cfg['executive'], :redis_config => {}, :boot_time => time, :coordinator => fc).
       and_return(notifier)
 
-    fiber.should_receive(:resume)
-    Fiber.should_receive(:new).and_yield.and_return(fiber)
+    expect(fiber).to receive(:resume)
+    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
 
-    EM.should_receive(:stop)
+    expect(EM).to receive(:stop)
 
     # Syslog.should_receive(:opened?).and_return(true)
     # Syslog.should_receive(:close)
@@ -123,28 +123,28 @@ describe Flapjack::Coordinator do
            'processor' => {'foo' => 'bar'},
            'notifier'  => {'enabled' => false}
           }
-    EM.should_receive(:synchrony).and_yield
-    config.should_receive(:for_redis).and_return({})
-    config.should_receive(:all).twice.and_return(cfg)
+    expect(EM).to receive(:synchrony).and_yield
+    expect(config).to receive(:for_redis).and_return({})
+    expect(config).to receive(:all).twice.and_return(cfg)
 
     processor = double('processor')
-    processor.should_receive(:start)
-    processor.should_receive(:stop)
-    processor.should_receive(:update_status)
-    processor.should_receive(:status).exactly(3).times.and_return('stopped')
+    expect(processor).to receive(:start)
+    expect(processor).to receive(:stop)
+    expect(processor).to receive(:update_status)
+    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
 
-    Time.should_receive(:now).and_return(time)
+    expect(Time).to receive(:now).and_return(time)
 
     fc = Flapjack::Coordinator.new(config)
-    Flapjack::Pikelet.should_receive(:create).with('processor',
+    expect(Flapjack::Pikelet).to receive(:create).with('processor',
         :config => cfg['executive'].merge(cfg['processor']),
         :redis_config => {}, :boot_time => time, :coordinator => fc).
       and_return(processor)
 
-    fiber.should_receive(:resume)
-    Fiber.should_receive(:new).and_yield.and_return(fiber)
+    expect(fiber).to receive(:resume)
+    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
 
-    EM.should_receive(:stop)
+    expect(EM).to receive(:stop)
 
     # Syslog.should_receive(:opened?).and_return(true)
     # Syslog.should_receive(:close)
@@ -154,44 +154,44 @@ describe Flapjack::Coordinator do
   end
 
   it "traps system signals and shuts down" do
-    Flapjack::Logger.should_receive(:new).and_return(logger)
+    expect(Flapjack::Logger).to receive(:new).and_return(logger)
 
-    RbConfig::CONFIG.should_receive(:[]).with('host_os').and_return('darwin12.0.0')
+    expect(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return('darwin12.0.0')
 
-    Kernel.should_receive(:trap).with('INT').and_yield
-    Kernel.should_receive(:trap).with('TERM').and_yield
-    Kernel.should_receive(:trap).with('QUIT').and_yield
-    Kernel.should_receive(:trap).with('HUP').and_yield
+    expect(Kernel).to receive(:trap).with('INT').and_yield
+    expect(Kernel).to receive(:trap).with('TERM').and_yield
+    expect(Kernel).to receive(:trap).with('QUIT').and_yield
+    expect(Kernel).to receive(:trap).with('HUP').and_yield
 
-    config.should_receive(:all).and_return({})
-    config.should_receive(:for_redis).and_return({})
+    expect(config).to receive(:all).and_return({})
+    expect(config).to receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
-    fc.should_receive(:stop).exactly(3).times
-    fc.should_receive(:reload)
+    expect(fc).to receive(:stop).exactly(3).times
+    expect(fc).to receive(:reload)
 
     fc.send(:setup_signals)
   end
 
   it "only traps two system signals on Windows" do
-    Flapjack::Logger.should_receive(:new).and_return(logger)
+    expect(Flapjack::Logger).to receive(:new).and_return(logger)
 
-    RbConfig::CONFIG.should_receive(:[]).with('host_os').and_return('mswin')
+    expect(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return('mswin')
 
-    Kernel.should_receive(:trap).with('INT').and_yield
-    Kernel.should_receive(:trap).with('TERM').and_yield
-    Kernel.should_not_receive(:trap).with('QUIT')
-    Kernel.should_not_receive(:trap).with('HUP')
+    expect(Kernel).to receive(:trap).with('INT').and_yield
+    expect(Kernel).to receive(:trap).with('TERM').and_yield
+    expect(Kernel).not_to receive(:trap).with('QUIT')
+    expect(Kernel).not_to receive(:trap).with('HUP')
 
-    config.should_receive(:all).and_return({})
-    config.should_receive(:for_redis).and_return({})
+    expect(config).to receive(:all).and_return({})
+    expect(config).to receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
-    fc.should_receive(:stop).twice
+    expect(fc).to receive(:stop).twice
 
     fc.send(:setup_signals)
   end
 
   it "stops one pikelet and starts another on reload" do
-    Flapjack::Logger.should_receive(:new).and_return(logger)
+    expect(Flapjack::Logger).to receive(:new).and_return(logger)
 
     old_cfg = {'processor' => {'enabled' => true}}
     new_cfg = {'gateways' => {'jabber' => {'enabled' => true}}}
@@ -199,42 +199,42 @@ describe Flapjack::Coordinator do
     new_config = double('new_config')
     filename = double('filename')
 
-    config.should_receive(:all).twice.and_return(old_cfg)
-    config.should_receive(:filename).and_return(filename)
+    expect(config).to receive(:all).twice.and_return(old_cfg)
+    expect(config).to receive(:filename).and_return(filename)
 
-    Flapjack::Configuration.should_receive(:new).and_return(new_config)
-    new_config.should_receive(:load).with(filename)
-    new_config.should_receive(:all).and_return(new_cfg)
+    expect(Flapjack::Configuration).to receive(:new).and_return(new_config)
+    expect(new_config).to receive(:load).with(filename)
+    expect(new_config).to receive(:all).and_return(new_cfg)
 
     processor = double('processor')
-    processor.should_receive(:type).twice.and_return('processor')
-    processor.should_receive(:stop)
-    processor.should_receive(:update_status)
-    processor.should_receive(:status).exactly(3).times.and_return('stopped')
+    expect(processor).to receive(:type).twice.and_return('processor')
+    expect(processor).to receive(:stop)
+    expect(processor).to receive(:update_status)
+    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
 
-    config.should_receive(:for_redis).and_return({})
+    expect(config).to receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
 
     jabber = double('jabber')
-    Flapjack::Pikelet.should_receive(:create).
+    expect(Flapjack::Pikelet).to receive(:create).
       with('jabber', :config => {"enabled" => true}, :redis_config => {},
         :boot_time => time, :coordinator => fc).
       and_return(jabber)
-    jabber.should_receive(:start)
+    expect(jabber).to receive(:start)
 
-    fiber.should_receive(:resume)
-    Fiber.should_receive(:new).and_yield.and_return(fiber)
+    expect(fiber).to receive(:resume)
+    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
 
     fc.instance_variable_set('@boot_time', time)
     fc.instance_variable_set('@pikelets', [processor])
     fc.reload
-    fc.instance_variable_get('@pikelets').should == [jabber]
+    expect(fc.instance_variable_get('@pikelets')).to eq([jabber])
 
 
   end
 
   it "reloads a pikelet config without restarting it" do
-    Flapjack::Logger.should_receive(:new).and_return(logger)
+    expect(Flapjack::Logger).to receive(:new).and_return(logger)
 
     old_cfg = {'processor' => {'enabled' => true, 'foo' => 'bar'}}
     new_cfg = {'processor' => {'enabled' => true, 'foo' => 'baz'}}
@@ -242,29 +242,29 @@ describe Flapjack::Coordinator do
     new_config = double('new_config')
     filename = double('filename')
 
-    config.should_receive(:all).twice.and_return(old_cfg)
-    config.should_receive(:filename).and_return(filename)
+    expect(config).to receive(:all).twice.and_return(old_cfg)
+    expect(config).to receive(:filename).and_return(filename)
 
-    Flapjack::Configuration.should_receive(:new).and_return(new_config)
-    new_config.should_receive(:load).with(filename)
-    new_config.should_receive(:all).and_return(new_cfg)
+    expect(Flapjack::Configuration).to receive(:new).and_return(new_config)
+    expect(new_config).to receive(:load).with(filename)
+    expect(new_config).to receive(:all).and_return(new_cfg)
 
     processor = double('processor')
-    processor.should_not_receive(:start)
-    processor.should_receive(:type).exactly(3).times.and_return('processor')
-    processor.should_receive(:reload).with(new_cfg['processor']).and_return(true)
-    processor.should_not_receive(:stop)
+    expect(processor).not_to receive(:start)
+    expect(processor).to receive(:type).exactly(3).times.and_return('processor')
+    expect(processor).to receive(:reload).with(new_cfg['processor']).and_return(true)
+    expect(processor).not_to receive(:stop)
 
-    config.should_receive(:for_redis).and_return({})
+    expect(config).to receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
     fc.instance_variable_set('@boot_time', time)
     fc.instance_variable_set('@pikelets', [processor])
     fc.reload
-    fc.instance_variable_get('@pikelets').should == [processor]
+    expect(fc.instance_variable_get('@pikelets')).to eq([processor])
   end
 
   it "reloads a pikelet config while restarting it" do
-    Flapjack::Logger.should_receive(:new).and_return(logger)
+    expect(Flapjack::Logger).to receive(:new).and_return(logger)
 
     old_cfg = {'processor' => {'enabled' => true, 'foo' => 'bar'}}
     new_cfg = {'processor' => {'enabled' => true, 'baz' => 'qux'}}
@@ -272,30 +272,30 @@ describe Flapjack::Coordinator do
     new_config = double('new_config')
     filename = double('filename')
 
-    config.should_receive(:all).twice.and_return(old_cfg)
-    config.should_receive(:filename).and_return(filename)
+    expect(config).to receive(:all).twice.and_return(old_cfg)
+    expect(config).to receive(:filename).and_return(filename)
 
-    Flapjack::Configuration.should_receive(:new).and_return(new_config)
-    new_config.should_receive(:load).with(filename)
-    new_config.should_receive(:all).and_return(new_cfg)
+    expect(Flapjack::Configuration).to receive(:new).and_return(new_config)
+    expect(new_config).to receive(:load).with(filename)
+    expect(new_config).to receive(:all).and_return(new_cfg)
 
     processor = double('processor')
-    processor.should_receive(:type).exactly(5).times.and_return('processor')
-    processor.should_receive(:reload).with(new_cfg['processor']).and_return(false)
-    processor.should_receive(:stop)
-    processor.should_receive(:update_status)
-    processor.should_receive(:status).exactly(3).times.and_return('stopped')
+    expect(processor).to receive(:type).exactly(5).times.and_return('processor')
+    expect(processor).to receive(:reload).with(new_cfg['processor']).and_return(false)
+    expect(processor).to receive(:stop)
+    expect(processor).to receive(:update_status)
+    expect(processor).to receive(:status).exactly(3).times.and_return('stopped')
 
-    fiber.should_receive(:resume)
-    Fiber.should_receive(:new).and_yield.and_return(fiber)
+    expect(fiber).to receive(:resume)
+    expect(Fiber).to receive(:new).and_yield.and_return(fiber)
 
     new_exec = double('new_executive')
-    new_exec.should_receive(:start)
+    expect(new_exec).to receive(:start)
 
-    config.should_receive(:for_redis).and_return({})
+    expect(config).to receive(:for_redis).and_return({})
     fc = Flapjack::Coordinator.new(config)
 
-    Flapjack::Pikelet.should_receive(:create).
+    expect(Flapjack::Pikelet).to receive(:create).
       with('processor', :config => new_cfg['processor'], :redis_config => {},
         :boot_time => time, :coordinator => fc).
       and_return(new_exec)
@@ -303,7 +303,7 @@ describe Flapjack::Coordinator do
     fc.instance_variable_set('@boot_time', time)
     fc.instance_variable_set('@pikelets', [processor])
     fc.reload
-    fc.instance_variable_get('@pikelets').should == [new_exec]
+    expect(fc.instance_variable_get('@pikelets')).to eq([new_exec])
   end
 
 end

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

@@ -70,28 +70,36 @@ describe Flapjack::Data::Contact, :redis => true do
 
   it "returns a list of all contacts" do
     contacts = Flapjack::Data::Contact.all(:redis => @redis)
-    contacts.should_not be_nil
-    contacts.should be_an(Array)
-    contacts.should have(2).contacts
-    contacts[0].name.should == 'Jane Janeley'
-    contacts[1].name.should == 'John Johnson'
+    expect(contacts).not_to be_nil
+    expect(contacts).to be_an(Array)
+    expect(contacts.size).to eq(2)
+    expect(contacts[0].name).to eq('Jane Janeley')
+    expect(contacts[1].name).to eq('John Johnson')
   end
 
   it "finds a contact by id" do
     contact = Flapjack::Data::Contact.find_by_id('c362', :redis => @redis)
-    contact.should_not be_nil
-    contact.name.should == "John Johnson"
+    expect(contact).not_to be_nil
+    expect(contact.name).to eq("John Johnson")
+  end
+
+  it "finds contacts by ids" do
+    contacts = Flapjack::Data::Contact.find_by_ids(['c362','c363_a-f@42%*'], :redis => @redis)
+    expect(contacts).not_to be_nil
+    expect(contacts.length).to eq(2)
+    contact = contacts.first
+    expect(contact.name).to eq("John Johnson")
   end
 
   it "adds a contact with the same id as an existing one, clears notification rules" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
-    contact.should_not be_nil
+    expect(contact).not_to be_nil
 
     contact.add_notification_rule(notification_rule_data)
 
     nr = contact.notification_rules
-    nr.should_not be_nil
-    nr.should have(2).notification_rules
+    expect(nr).not_to be_nil
+    expect(nr.size).to eq(2)
 
     Flapjack::Data::Contact.add({'id'         => 'c363_a-f@42%*',
                                  'first_name' => 'Smithy',
@@ -100,44 +108,44 @@ describe Flapjack::Data::Contact, :redis => true do
                                  :redis       => @redis)
 
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
-    contact.should_not be_nil
-    contact.name.should == 'Smithy Smith'
+    expect(contact).not_to be_nil
+    expect(contact.name).to eq('Smithy Smith')
     rules = contact.notification_rules
-    rules.should have(1).notification_rule
-    nr.map(&:id).should_not include(rules.first.id)
+    expect(rules.size).to eq(1)
+    expect(nr.map(&:id)).not_to include(rules.first.id)
   end
 
   it "updates a contact and clears their media settings" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
 
     contact.update('media' => {})
-    contact.media.should be_empty
+    expect(contact.media).to be_empty
   end
 
   it "updates a contact, does not clear notification rules" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
-    contact.should_not be_nil
+    expect(contact).not_to be_nil
 
     contact.add_notification_rule(notification_rule_data)
 
     nr1 = contact.notification_rules
-    nr1.should_not be_nil
-    nr1.should have(2).notification_rules
+    expect(nr1).not_to be_nil
+    expect(nr1.size).to eq(2)
 
     contact.update('first_name' => 'John',
                    'last_name'  => 'Smith',
                    'email'      => 'johns@example.com')
-    contact.name.should == 'John Smith'
+    expect(contact.name).to eq('John Smith')
 
     nr2 = contact.notification_rules
-    nr2.should_not be_nil
-    nr2.should have(2).notification_rules
-    nr1.map(&:id).should == nr2.map(&:id)
+    expect(nr2).not_to be_nil
+    expect(nr2.size).to eq(2)
+    expect(nr1.map(&:id)).to eq(nr2.map(&:id))
   end
 
   it "adds a notification rule for a contact" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
-    contact.should_not be_nil
+    expect(contact).not_to be_nil
 
     expect {
       contact.add_notification_rule(notification_rule_data)
@@ -146,7 +154,7 @@ describe Flapjack::Data::Contact, :redis => true do
 
   it "removes a notification rule from a contact" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
-    contact.should_not be_nil
+    expect(contact).not_to be_nil
 
     rule = contact.add_notification_rule(notification_rule_data)
 
@@ -161,29 +169,29 @@ describe Flapjack::Data::Contact, :redis => true do
     @redis.smembers("contact_notification_rules:c363_a-f@42%*").each do |rule_id|
       @redis.srem("contact_notification_rules:c363_a-f@42%*", rule_id)
     end
-    @redis.smembers("contact_notification_rules:c363_a-f@42%*").should be_empty
+    expect(@redis.smembers("contact_notification_rules:c363_a-f@42%*")).to be_empty
 
     rules = contact.notification_rules
-    rules.should have(1).rule
+    expect(rules.size).to eq(1)
     rule = rules.first
     [:entities, :tags, :time_restrictions,
      :warning_media, :critical_media,
      :warning_blackhole, :critical_blackhole].each do |k|
-      rule.send(k).should == general_notification_rule_data[k]
+      expect(rule.send(k)).to eq(general_notification_rule_data[k])
     end
   end
 
   it "creates a general notification rule for a pre-existing contact if the existing general one was changed" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
     rules = contact.notification_rules
-    rules.should have(1).notification_rule
+    expect(rules.size).to eq(1)
     rule = rules.first
 
     rule.update(notification_rule_data)
 
     rules = contact.notification_rules
-    rules.should have(2).notification_rules
-    rules.select {|r| r.is_specific? }.should have(1).rule
+    expect(rules.size).to eq(2)
+    expect(rules.select {|r| r.is_specific? }.size).to eq(1)
   end
 
   it "deletes a contact by id, including linked entities, checks, tags and notification rules" do
@@ -223,30 +231,30 @@ describe Flapjack::Data::Contact, :redis => true do
 
     contact = Flapjack::Data::Contact.find_by_id('c362', :redis => @redis)
     eandcs = contact.entities(:checks => true)
-    eandcs.should_not be_nil
-    eandcs.should be_an(Array)
-    eandcs.should have(1).entity_and_checks
+    expect(eandcs).not_to be_nil
+    expect(eandcs).to be_an(Array)
+    expect(eandcs.size).to eq(1)
 
     eandc = eandcs.first
-    eandc.should be_a(Hash)
+    expect(eandc).to be_a(Hash)
 
     entity = eandc[:entity]
-    entity.name.should == entity_name
+    expect(entity.name).to eq(entity_name)
     checks = eandc[:checks]
-    checks.should be_a(Set)
-    checks.should have(1).check
-    checks.should include('PING')
+    expect(checks).to be_a(Set)
+    expect(checks.size).to eq(1)
+    expect(checks).to include('PING')
   end
 
   it "returns pagerduty credentials for a contact" do
     contact = Flapjack::Data::Contact.find_by_id('c362', :redis => @redis)
     credentials = contact.pagerduty_credentials
-    credentials.should_not be_nil
-    credentials.should be_a(Hash)
-    credentials.should == {'service_key' => '123456789012345678901234',
+    expect(credentials).not_to be_nil
+    expect(credentials).to be_a(Hash)
+    expect(credentials).to eq({'service_key' => '123456789012345678901234',
                            'subdomain'   => 'flpjck',
                            'username'    => 'flapjack',
-                           'password'    => 'very_secure'}
+                           'password'    => 'very_secure'})
   end
 
   it "sets pagerduty credentials for a contact" do
@@ -256,78 +264,78 @@ describe Flapjack::Data::Contact, :redis => true do
                                       'username'    => 'flapjack',
                                       'password'    => 'tomato')
 
-    @redis.hget('contact_media:c362', 'pagerduty').should == '567890123456789012345678'
-    @redis.hgetall('contact_pagerduty:c362').should == {
+    expect(@redis.hget('contact_media:c362', 'pagerduty')).to eq('567890123456789012345678')
+    expect(@redis.hgetall('contact_pagerduty:c362')).to eq({
       'subdomain'   => 'eggs',
       'username'    => 'flapjack',
       'password'    => 'tomato'
-    }
+    })
   end
 
   it "sets the interval for a contact's media" do
     contact = Flapjack::Data::Contact.find_by_id('c362', :redis => @redis)
     contact.set_interval_for_media('email', 42)
     email_interval_raw = @redis.hget("contact_media_intervals:#{contact.id}", 'email')
-    email_interval_raw.should == '42'
+    expect(email_interval_raw).to eq('42')
   end
 
   it "returns the interval for a contact's media" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
     email_interval = contact.interval_for_media('email')
-    email_interval.should == 60
+    expect(email_interval).to eq(60)
   end
 
   it "returns default 15 mins for interval for a contact's media that has no set interval" do
     contact = Flapjack::Data::Contact.find_by_id('c362', :redis => @redis)
     email_interval = contact.interval_for_media('email')
-    email_interval.should == 900
+    expect(email_interval).to eq(900)
   end
 
   it "removes the interval for a contact's media" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
     contact.set_interval_for_media('email', nil)
     email_interval_raw = @redis.hget("contact_media_intervals:#{contact.id}", 'email')
-    email_interval_raw.should be_nil
+    expect(email_interval_raw).to be_nil
   end
 
   it "sets the rollup threshold for a contact's media" do
     contact = Flapjack::Data::Contact.find_by_id('c362', :redis => @redis)
     email_rollup_threshold = contact.set_rollup_threshold_for_media('email', 3)
     email_rollup_threshold_raw = @redis.hget("contact_media_rollup_thresholds:#{contact.id}", 'email')
-    email_rollup_threshold_raw.should == '3'
+    expect(email_rollup_threshold_raw).to eq('3')
   end
 
   it "returns the rollup threshold for a contact's media" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
     email_rollup_threshold = contact.rollup_threshold_for_media('email')
-    email_rollup_threshold.should_not be_nil
-    email_rollup_threshold.should be_a(Integer)
-    email_rollup_threshold.should == 5
+    expect(email_rollup_threshold).not_to be_nil
+    expect(email_rollup_threshold).to be_a(Integer)
+    expect(email_rollup_threshold).to eq(5)
   end
 
   it "removes the rollup threshold for a contact's media" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
     email_rollup_threshold = contact.set_rollup_threshold_for_media('email', nil)
     email_rollup_threshold_raw = @redis.hget("contact_media_rollup_thresholds:#{contact.id}", 'email')
-    email_rollup_threshold_raw.should be_nil
+    expect(email_rollup_threshold_raw).to be_nil
   end
 
   it "sets the address for a contact's media" do
     contact = Flapjack::Data::Contact.find_by_id('c362', :redis => @redis)
     contact.set_address_for_media('email', 'spongebob@example.com')
     email_address_raw = @redis.hget("contact_media:#{contact.id}", 'email')
-    email_address_raw.should == 'spongebob@example.com'
+    expect(email_address_raw).to eq('spongebob@example.com')
   end
 
   it "removes a contact's media" do
     contact = Flapjack::Data::Contact.find_by_id('c363_a-f@42%*', :redis => @redis)
     contact.remove_media('email')
     email_address_raw = @redis.hget("contac_media:#{contact.id}", 'email')
-    email_address_raw.should be_nil
+    expect(email_address_raw).to be_nil
     email_rollup_threshold_raw = @redis.hget("contact_media_rollup_thresholds:#{contact.id}", 'email')
-    email_rollup_threshold_raw.should be_nil
+    expect(email_rollup_threshold_raw).to be_nil
     email_interval_raw = @redis.hget("contact_media_intervals:#{contact.id}", 'email')
-    email_interval_raw.should be_nil
+    expect(email_interval_raw).to be_nil
   end
 
 end