flapjack 0.7.35 → 0.8.0

data/spec/lib/flapjack/data/entity_spec.rb

@@ -9,9 +9,9 @@ describe Flapjack::Data::Entity, :redis => true do
   it "creates an entity if allowed when it can't find it" do
     entity = Flapjack::Data::Entity.find_by_name(name, :redis => @redis, :create => true)
 
-    entity.should_not be_nil
-    entity.name.should == name
-    @redis.get("entity_id:#{name}").should == ''
+    expect(entity).not_to be_nil
+    expect(entity.name).to eq(name)
+    expect(@redis.get("entity_id:#{name}")).to eq('')
   end
 
   it "adds a registered contact with an entity" do
@@ -27,12 +27,12 @@ describe Flapjack::Data::Entity, :redis => true do
                                 :redis => @redis)
 
     entity = Flapjack::Data::Entity.find_by_id('5000', :redis => @redis)
-    entity.should_not be_nil
+    expect(entity).not_to be_nil
     contacts = entity.contacts
-    contacts.should_not be_nil
-    contacts.should be_an(Array)
-    contacts.should have(1).contact
-    contacts.first.name.should == 'John Johnson'
+    expect(contacts).not_to be_nil
+    expect(contacts).to be_an(Array)
+    expect(contacts.size).to eq(1)
+    expect(contacts.first.name).to eq('John Johnson')
   end
 
   it "does not add a registered contact with an entity if the contact is unknown" do
@@ -42,11 +42,11 @@ describe Flapjack::Data::Entity, :redis => true do
                                 :redis => @redis)
 
     entity = Flapjack::Data::Entity.find_by_id('5000', :redis => @redis)
-    entity.should_not be_nil
+    expect(entity).not_to be_nil
     contacts = entity.contacts
-    contacts.should_not be_nil
-    contacts.should be_an(Array)
-    contacts.should be_empty
+    expect(contacts).not_to be_nil
+    expect(contacts).to be_an(Array)
+    expect(contacts).to be_empty
   end
 
   it "finds an entity by id" do
@@ -55,8 +55,8 @@ describe Flapjack::Data::Entity, :redis => true do
                                 :redis => @redis)
 
     entity = Flapjack::Data::Entity.find_by_id('5000', :redis => @redis)
-    entity.should_not be_nil
-    entity.name.should == name
+    expect(entity).not_to be_nil
+    expect(entity.name).to eq(name)
   end
 
   it "finds an entity by name" do
@@ -65,8 +65,8 @@ describe Flapjack::Data::Entity, :redis => true do
                                 :redis => @redis)
 
     entity = Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
-    entity.should_not be_nil
-    entity.id.should == '5000'
+    expect(entity).not_to be_nil
+    expect(entity.id).to eq('5000')
   end
 
   it "returns a list of all entities" do
@@ -78,11 +78,11 @@ describe Flapjack::Data::Entity, :redis => true do
                                 :redis => @redis)
 
     entities = Flapjack::Data::Entity.all(:redis => @redis)
-    entities.should_not be_nil
-    entities.should be_an(Array)
-    entities.should have(2).entities
-    entities[0].id.should == '5000'
-    entities[1].id.should == '5001'
+    expect(entities).not_to be_nil
+    expect(entities).to be_an(Array)
+    expect(entities.size).to eq(2)
+    expect(entities[0].id).to eq('5000')
+    expect(entities[1].id).to eq('5001')
   end
 
   it "returns a list of checks for an entity" do
@@ -95,11 +95,11 @@ describe Flapjack::Data::Entity, :redis => true do
 
     entity = Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
     check_list = entity.check_list
-    check_list.should_not be_nil
-    check_list.should have(2).checks
+    expect(check_list).not_to be_nil
+    expect(check_list.size).to eq(2)
     sorted_list = check_list.sort
-    sorted_list[0].should == 'ping'
-    sorted_list[1].should == 'ssh'
+    expect(sorted_list[0]).to eq('ping')
+    expect(sorted_list[1]).to eq('ssh')
   end
 
   it "returns a count of checks for an entity" do
@@ -113,8 +113,8 @@ describe Flapjack::Data::Entity, :redis => true do
 
     entity = Flapjack::Data::Entity.find_by_id(5000, :redis => @redis)
     check_count = entity.check_count
-    check_count.should_not be_nil
-    check_count.should == 2
+    expect(check_count).not_to be_nil
+    expect(check_count).to eq(2)
   end
 
   it "finds entity names matching a pattern" do
@@ -129,10 +129,10 @@ describe Flapjack::Data::Entity, :redis => true do
                                :redis => @redis)
 
     entities = Flapjack::Data::Entity.find_all_name_matching('abc', :redis => @redis)
-    entities.should_not be_nil
-    entities.should be_an(Array)
-    entities.should have(1).entity
-    entities.first.should == 'abc-123'
+    expect(entities).not_to be_nil
+    expect(entities).to be_an(Array)
+    expect(entities.size).to eq(1)
+    expect(entities.first).to eq('abc-123')
   end
 
   it "adds tags to entities" do
@@ -143,16 +143,16 @@ describe Flapjack::Data::Entity, :redis => true do
 
     entity.add_tags('source:foobar', 'foo')
 
-    entity.should_not be_nil
-    entity.should be_an(Flapjack::Data::Entity)
-    entity.name.should == 'abc-123'
-    entity.tags.should include("source:foobar")
-    entity.tags.should include("foo")
+    expect(entity).not_to be_nil
+    expect(entity).to be_an(Flapjack::Data::Entity)
+    expect(entity.name).to eq('abc-123')
+    expect(entity.tags).to include("source:foobar")
+    expect(entity.tags).to include("foo")
 
     # and test the tags as read back from redis
     entity = Flapjack::Data::Entity.find_by_id('5000', :redis => @redis)
-    entity.tags.should include("source:foobar")
-    entity.tags.should include("foo")
+    expect(entity.tags).to include("source:foobar")
+    expect(entity.tags).to include("foo")
 
   end
 
@@ -164,14 +164,14 @@ describe Flapjack::Data::Entity, :redis => true do
 
     entity.add_tags('source:foobar', 'foo')
 
-    entity.should_not be_nil
-    entity.tags.should include("source:foobar")
-    entity.tags.should include("foo")
+    expect(entity).not_to be_nil
+    expect(entity.tags).to include("source:foobar")
+    expect(entity.tags).to include("foo")
 
     entity.delete_tags('source:foobar')
 
-    entity.tags.should_not include("source:foobar")
-    entity.tags.should include("foo")
+    expect(entity.tags).not_to include("source:foobar")
+    expect(entity.tags).to include("foo")
 
   end
 
@@ -189,25 +189,25 @@ describe Flapjack::Data::Entity, :redis => true do
     entity0.add_tags('source:foobar', 'abc')
     entity1.add_tags('source:foobar', 'def')
 
-    entity0.should_not be_nil
-    entity0.should be_an(Flapjack::Data::Entity)
-    entity0.tags.should include("source:foobar")
-    entity0.tags.should include("abc")
-    entity0.tags.should_not include("def")
-    entity1.should_not be_nil
-    entity1.should be_an(Flapjack::Data::Entity)
-    entity1.tags.should include("source:foobar")
-    entity1.tags.should include("def")
-    entity1.tags.should_not include("abc")
+    expect(entity0).not_to be_nil
+    expect(entity0).to be_an(Flapjack::Data::Entity)
+    expect(entity0.tags).to include("source:foobar")
+    expect(entity0.tags).to include("abc")
+    expect(entity0.tags).not_to include("def")
+    expect(entity1).not_to be_nil
+    expect(entity1).to be_an(Flapjack::Data::Entity)
+    expect(entity1.tags).to include("source:foobar")
+    expect(entity1.tags).to include("def")
+    expect(entity1.tags).not_to include("abc")
 
     entities = Flapjack::Data::Entity.find_all_with_tags(['abc'], :redis => @redis)
-    entities.should be_an(Array)
-    entities.should have(1).entity
-    entities.first.should == 'abc-123'
+    expect(entities).to be_an(Array)
+    expect(entities.size).to eq(1)
+    expect(entities.first).to eq('abc-123')
 
     entities = Flapjack::Data::Entity.find_all_with_tags(['donkey'], :redis => @redis)
-    entities.should be_an(Array)
-    entities.should have(0).entities
+    expect(entities).to be_an(Array)
+    expect(entities).to be_empty
   end
 
   it "finds entities with several tags" do
@@ -224,23 +224,23 @@ describe Flapjack::Data::Entity, :redis => true do
     entity0.add_tags('source:foobar', 'abc')
     entity1.add_tags('source:foobar', 'def')
 
-    entity0.should_not be_nil
-    entity0.should be_an(Flapjack::Data::Entity)
-    entity0.tags.should include("source:foobar")
-    entity0.tags.should include("abc")
-    entity1.should_not be_nil
-    entity1.should be_an(Flapjack::Data::Entity)
-    entity1.tags.should include("source:foobar")
-    entity1.tags.should include("def")
+    expect(entity0).not_to be_nil
+    expect(entity0).to be_an(Flapjack::Data::Entity)
+    expect(entity0.tags).to include("source:foobar")
+    expect(entity0.tags).to include("abc")
+    expect(entity1).not_to be_nil
+    expect(entity1).to be_an(Flapjack::Data::Entity)
+    expect(entity1.tags).to include("source:foobar")
+    expect(entity1.tags).to include("def")
 
     entities = Flapjack::Data::Entity.find_all_with_tags(['source:foobar'], :redis => @redis)
-    entities.should be_an(Array)
-    entities.should have(2).entity
+    expect(entities).to be_an(Array)
+    expect(entities.size).to eq(2)
 
     entities = Flapjack::Data::Entity.find_all_with_tags(['source:foobar', 'def'], :redis => @redis)
-    entities.should be_an(Array)
-    entities.should have(1).entity
-    entities.first.should == 'def-456'
+    expect(entities).to be_an(Array)
+    expect(entities.size).to eq(1)
+    expect(entities.first).to eq('def-456')
   end
 
 end

data/spec/lib/flapjack/data/event_spec.rb

@@ -23,56 +23,56 @@ describe Flapjack::Data::Event do
   context 'class' do
 
     it "returns the next event (blocking, archiving)" do
-      mock_redis.should_receive(:brpoplpush).with('events', /^events_archive:/, 0).and_return(event_data.to_json)
-      mock_redis.should_receive(:expire)
+      expect(mock_redis).to receive(:brpoplpush).with('events', /^events_archive:/, 0).and_return(event_data.to_json)
+      expect(mock_redis).to receive(:expire)
 
       result = Flapjack::Data::Event.next('events', :block => true, :archive_events => true, :redis => mock_redis)
-      result.should be_an_instance_of(Flapjack::Data::Event)
+      expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (blocking, not archiving)" do
-      mock_redis.should_receive(:brpop).with('events', 0).and_return(['events', event_data.to_json])
+      expect(mock_redis).to receive(:brpop).with('events', 0).and_return(['events', event_data.to_json])
 
       result = Flapjack::Data::Event.next('events', :block => true, :archive_events => false, :redis => mock_redis)
-      result.should be_an_instance_of(Flapjack::Data::Event)
+      expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (non-blocking, archiving)" do
-      mock_redis.should_receive(:rpoplpush).with('events', /^events_archive:/).and_return(event_data.to_json)
-      mock_redis.should_receive(:expire)
+      expect(mock_redis).to receive(:rpoplpush).with('events', /^events_archive:/).and_return(event_data.to_json)
+      expect(mock_redis).to receive(:expire)
 
       result = Flapjack::Data::Event.next('events', :block => false, :archive_events => true, :redis => mock_redis)
-      result.should be_an_instance_of(Flapjack::Data::Event)
+      expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "returns the next event (non-blocking, not archiving)" do
-      mock_redis.should_receive(:rpop).with('events').and_return(event_data.to_json)
+      expect(mock_redis).to receive(:rpop).with('events').and_return(event_data.to_json)
 
       result = Flapjack::Data::Event.next('events', :block => false, :archive_events => false, :redis => mock_redis)
-      result.should be_an_instance_of(Flapjack::Data::Event)
+      expect(result).to be_an_instance_of(Flapjack::Data::Event)
     end
 
     it "handles invalid event JSON"
 
     it "returns a count of pending events" do
       events_len = 23
-      mock_redis.should_receive(:llen).with('events').and_return(events_len)
+      expect(mock_redis).to receive(:llen).with('events').and_return(events_len)
 
       pc = Flapjack::Data::Event.pending_count('events', :redis => mock_redis)
-      pc.should == events_len
+      expect(pc).to eq(events_len)
     end
 
     it "creates a notification testing event" do
-      Time.should_receive(:now).and_return(time)
-      mock_redis.should_receive(:lpush).with('events', /"testing"/ )
+      expect(Time).to receive(:now).and_return(time)
+      expect(mock_redis).to receive(:lpush).with('events', /"testing"/ )
 
       Flapjack::Data::Event.test_notifications(entity_name, check,
         :summary => 'test', :details => 'testing', :redis => mock_redis)
     end
 
     it "creates an acknowledgement event" do
-      Time.should_receive(:now).and_return(time)
-      mock_redis.should_receive(:lpush).with('events', /"acking"/ )
+      expect(Time).to receive(:now).and_return(time)
+      expect(mock_redis).to receive(:lpush).with('events', /"acking"/ )
 
       Flapjack::Data::Event.create_acknowledgement(entity_name, check,
         :summary => 'acking', :time => time.to_i, :redis => mock_redis)
@@ -81,20 +81,24 @@ describe Flapjack::Data::Event do
   end
 
   context 'instance' do
-    subject { Flapjack::Data::Event.new(event_data) }
-
-    its(:entity)   { should == event_data['entity'] }
-    its(:state)    { should == event_data['state'] }
-    its(:duration) { should == event_data['duration'] }
-    its(:time)     { should == event_data['time'] }
-    its(:id)       { should == 'xyz-example.com:ping' }
-    its(:type)     { should == 'service' }
-
-    it { should be_a_service }
-    it { should_not be_a_acknowledgement }
-    it { should_not be_a_test_notifications }
-    it { should_not be_ok }
-    it { should be_a_failure }
+    let(:event) { Flapjack::Data::Event.new(event_data) }
+
+    it "matches the data it is initialised with" do
+      expect(event.entity).to eq(event_data['entity'])
+      expect(event.state).to eq(event_data['state'])
+      expect(event.duration).to eq(event_data['duration'])
+      expect(event.time).to eq(event_data['time'])
+      expect(event.id).to eq('xyz-example.com:ping')
+      expect(event.type).to eq('service')
+
+      expect(event).to be_a_service
+      expect(event).to be_a_service
+      expect(event).not_to be_an_acknowledgement
+      expect(event).not_to be_a_test_notifications
+      expect(event).not_to be_ok
+      expect(event).to be_a_failure
+    end
+
   end
 
 end

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

@@ -8,19 +8,19 @@ describe Flapjack::Data::Message do
   it "assigns itself an ID" do
     message = Flapjack::Data::Message.for_contact(contact)
     mid = message.id
-    mid.should_not be_nil
-    mid.should be_a(String)
+    expect(mid).not_to be_nil
+    expect(mid).to be_a(String)
   end
 
   it "returns its contained data" do
     message = Flapjack::Data::Message.for_contact(contact, :medium => 'email',
                 :address => 'jja@example.com')
 
-    contact.should_receive(:id).and_return('23')
-    contact.should_receive(:first_name).and_return('James')
-    contact.should_receive(:last_name).and_return('Jameson')
+    expect(contact).to receive(:id).and_return('23')
+    expect(contact).to receive(:first_name).and_return('James')
+    expect(contact).to receive(:last_name).and_return('Jameson')
 
-    message.contents.should include('contact_id' => '23',
+    expect(message.contents).to include('contact_id' => '23',
                                     'contact_first_name' => 'James',
                                     'contact_last_name' => 'Jameson',
                                     'media' => 'email',

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

@@ -35,18 +35,18 @@ describe Flapjack::Data::NotificationRule, :redis => true do
   }
 
   it "checks that a notification rule exists" do
-    Flapjack::Data::NotificationRule.exists_with_id?(existing_rule.id, :redis => @redis).should be_true
-    Flapjack::Data::NotificationRule.exists_with_id?('not_there', :redis => @redis).should be_false
+    expect(Flapjack::Data::NotificationRule.exists_with_id?(existing_rule.id, :redis => @redis)).to be true
+    expect(Flapjack::Data::NotificationRule.exists_with_id?('not_there', :redis => @redis)).to be false
   end
 
   it "returns a notification rule if it exists" do
     rule = Flapjack::Data::NotificationRule.find_by_id(existing_rule.id, :redis => @redis)
-    rule.should_not be_nil
+    expect(rule).not_to be_nil
   end
 
   it "does not return a notification rule if it does not exist" do
     rule = Flapjack::Data::NotificationRule.find_by_id('not_there', :redis => @redis)
-    rule.should be_nil
+    expect(rule).to be_nil
   end
 
   it "updates a notification rule" do
@@ -55,50 +55,50 @@ describe Flapjack::Data::NotificationRule, :redis => true do
     expect {
       rule_data[:warning_blackhole] = true
       errors = rule.update(rule_data)
-      errors.should be_nil
+      expect(errors).to be_nil
     }.to change { rule.warning_blackhole }.from(false).to(true)
   end
 
   it "converts time restriction data to an IceCube schedule" do
     sched = Flapjack::Data::NotificationRule.
               time_restriction_to_icecube_schedule(weekdays_8_18, timezone)
-    sched.should_not be_nil
+    expect(sched).not_to be_nil
   end
 
   it "generates a JSON string representing its data" do
     rule = existing_rule
     # bit of extra hackery for the inserted ID values
-    rule.to_json.should == {:id => rule.id}.merge(rule_data).to_json
+    expect(rule.to_json).to eq({:id => rule.id}.merge(rule_data).to_json)
   end
 
   it "checks whether entity names match" do
     rule = existing_rule
 
-    rule.match_entity?('foo-app-01.example.com').should be_true
-    rule.match_entity?('foo-app-02.example.com').should be_false
+    expect(rule.match_entity?('foo-app-01.example.com')).to be true
+    expect(rule.match_entity?('foo-app-02.example.com')).to be false
   end
 
   it "checks whether entity tags match" do
     rule = existing_rule
 
-    rule.match_tags?(['database', 'physical'].to_set).should be_true
-    rule.match_tags?(['database', 'physical', 'beetroot'].to_set).should be_true
-    rule.match_tags?(['database'].to_set).should be_false
-    rule.match_tags?(['virtual'].to_set).should be_false
+    expect(rule.match_tags?(['database', 'physical'].to_set)).to be true
+    expect(rule.match_tags?(['database', 'physical', 'beetroot'].to_set)).to be true
+    expect(rule.match_tags?(['database'].to_set)).to be false
+    expect(rule.match_tags?(['virtual'].to_set)).to be false
   end
 
   it "checks if blackhole settings for a rule match a severity level" do
     rule_data[:warning_blackhole] = true
     rule = Flapjack::Data::NotificationRule.add(rule_data, :redis => @redis)
 
-    rule.blackhole?('warning').should be_true
-    rule.blackhole?('critical').should be_false
+    expect(rule.blackhole?('warning')).to be true
+    expect(rule.blackhole?('critical')).to be false
   end
 
   it "returns the media settings for a rule's severity level" do
     rule = existing_rule
-    rule.media_for_severity('warning').should == ['email']
-    rule.media_for_severity('critical').should =~ ['email', 'sms']
+    expect(rule.media_for_severity('warning')).to eq(['email'])
+    expect(rule.media_for_severity('critical')).to match_array(['email', 'sms'])
   end
 
   context 'validation' do
@@ -106,10 +106,10 @@ describe Flapjack::Data::NotificationRule, :redis => true do
     it "fails to add a notification rule with invalid data" do
       rule_data[:entities] = [1, {}]
       rule_or_errors = Flapjack::Data::NotificationRule.add(rule_data, :redis => @redis)
-      rule_or_errors.should_not be_nil
-      rule_or_errors.should be_an(Array)
-      rule_or_errors.should have(1).error
-      rule_or_errors.should == ["Rule entities must be a list of strings"]
+      expect(rule_or_errors).not_to be_nil
+      expect(rule_or_errors).to be_an(Array)
+      expect(rule_or_errors.size).to eq(1)
+      expect(rule_or_errors).to eq(["Rule entities must be a list of strings"])
     end
 
     it "fails to update a notification rule with invalid data" do
@@ -117,9 +117,9 @@ describe Flapjack::Data::NotificationRule, :redis => true do
       expect {
         rule_data[:entities] = [57]
         errors = rule.update(rule_data)
-        errors.should_not be_nil
-        errors.should have(1).error
-        errors.should == ["Rule entities must be a list of strings"]
+        expect(errors).not_to be_nil
+        expect(errors.size).to eq(1)
+        expect(errors).to eq(["Rule entities must be a list of strings"])
       }.not_to change { rule.entities }
     end