bullet 4.7.0 → 4.8.0

data/spec/bullet/detector/association_spec.rb

@@ -12,32 +12,32 @@ module Bullet
       context ".start_request" do
         it "should set @@checked to false" do
           Association.start_request
-          Association.class_variable_get(:@@checked).should be_false
+          expect(Association.class_variable_get(:@@checked)).to eq false
         end
       end
 
       context ".clear" do
         it "should clear all class variables" do
           Association.clear
-          Association.class_variable_get(:@@object_associations).should be_nil
-          Association.class_variable_get(:@@possible_objects).should be_nil
-          Association.class_variable_get(:@@impossible_objects).should be_nil
-          Association.class_variable_get(:@@call_object_associations).should be_nil
-          Association.class_variable_get(:@@eager_loadings).should be_nil
+          expect(Association.class_variable_get(:@@object_associations)).to be_nil
+          expect(Association.class_variable_get(:@@possible_objects)).to be_nil
+          expect(Association.class_variable_get(:@@impossible_objects)).to be_nil
+          expect(Association.class_variable_get(:@@call_object_associations)).to be_nil
+          expect(Association.class_variable_get(:@@eager_loadings)).to be_nil
         end
       end
 
       context ".add_object_association" do
         it "should add object, associations pair" do
           Association.add_object_associations(@post1, :associations)
-          Association.send(:object_associations).should be_include(@post1.bullet_ar_key, :associations)
+          expect(Association.send(:object_associations)).to be_include(@post1.bullet_ar_key, :associations)
         end
       end
 
       context ".add_call_object_associations" do
         it "should add call object, associations pair" do
           Association.add_call_object_associations(@post1, :associations)
-          Association.send(:call_object_associations).should be_include(@post1.bullet_ar_key, :associations)
+          expect(Association.send(:call_object_associations)).to be_include(@post1.bullet_ar_key, :associations)
         end
       end
     end

data/spec/bullet/detector/base_spec.rb

@@ -5,7 +5,7 @@ module Bullet
     describe Base do
       context ".end_request" do
         it "should call clear" do
-          Base.should_receive(:clear)
+          expect(Base).to receive(:clear)
           Base.end_request
         end
       end

data/spec/bullet/detector/counter_cache_spec.rb

@@ -11,21 +11,21 @@ module Bullet
 
       context ".clear" do
         it "should clear all class variables" do
-          CounterCache.class_variable_get(:@@possible_objects).should be_nil
-          CounterCache.class_variable_get(:@@impossible_objects).should be_nil
+          expect(CounterCache.class_variable_get(:@@possible_objects)).to be_nil
+          expect(CounterCache.class_variable_get(:@@impossible_objects)).to be_nil
         end
       end
 
       context ".add_counter_cache" do
         it "should create notification if conditions met" do
-          CounterCache.should_receive(:conditions_met?).with(@post1.bullet_ar_key, [:comments]).and_return(true)
-          CounterCache.should_receive(:create_notification).with("Post", [:comments])
+          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_ar_key, [:comments]).and_return(true)
+          expect(CounterCache).to receive(:create_notification).with("Post", [:comments])
           CounterCache.add_counter_cache(@post1, [:comments])
         end
 
         it "should not create notification if conditions not met" do
-          CounterCache.should_receive(:conditions_met?).with(@post1.bullet_ar_key, [:comments]).and_return(false)
-          CounterCache.should_receive(:create_notification).never
+          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_ar_key, [:comments]).and_return(false)
+          expect(CounterCache).to receive(:create_notification).never
           CounterCache.add_counter_cache(@post1, [:comments])
         end
       end
@@ -33,30 +33,30 @@ module Bullet
       context ".add_possible_objects" do
         it "should add possible objects" do
           CounterCache.add_possible_objects([@post1, @post2])
-          CounterCache.send(:possible_objects).should be_include(@post1.bullet_ar_key)
-          CounterCache.send(:possible_objects).should be_include(@post2.bullet_ar_key)
+          expect(CounterCache.send(:possible_objects)).to be_include(@post1.bullet_ar_key)
+          expect(CounterCache.send(:possible_objects)).to be_include(@post2.bullet_ar_key)
         end
 
         it "should add impossible object" do
           CounterCache.add_impossible_object(@post1)
-          CounterCache.send(:impossible_objects).should be_include(@post1.bullet_ar_key)
+          expect(CounterCache.send(:impossible_objects)).to be_include(@post1.bullet_ar_key)
         end
       end
 
       context ".conditions_met?" do
         it "should be true when object is possible, not impossible" do
           CounterCache.add_possible_objects(@post1)
-          CounterCache.send(:conditions_met?, @post1.bullet_ar_key, :associations).should be_true
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_ar_key, :associations)).to eq true
         end
 
         it "should be false when object is not possible" do
-          CounterCache.send(:conditions_met?, @post1.bullet_ar_key, :associations).should be_false
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_ar_key, :associations)).to eq false
         end
 
         it "should be true when object is possible, and impossible" do
           CounterCache.add_possible_objects(@post1)
           CounterCache.add_impossible_object(@post1)
-          CounterCache.send(:conditions_met?, @post1.bullet_ar_key, :associations).should be_false
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_ar_key, :associations)).to eq false
         end
       end
     end

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -12,11 +12,11 @@ module Bullet
       context ".call_association" do
         it "should set @@checked to true" do
           NPlusOneQuery.call_association(@post, :associations)
-          NPlusOneQuery.class_variable_get(:@@checked).should be_true
+          expect(NPlusOneQuery.class_variable_get(:@@checked)).to eq true
         end
 
         it "should add call_object_associations" do
-          NPlusOneQuery.should_receive(:add_call_object_associations).with(@post, :associations)
+          expect(NPlusOneQuery).to receive(:add_call_object_associations).with(@post, :associations)
           NPlusOneQuery.call_association(@post, :associations)
         end
       end
@@ -24,71 +24,71 @@ module Bullet
       context ".possible?" do
         it "should be true if possible_objects contain" do
           NPlusOneQuery.add_possible_objects(@post)
-          NPlusOneQuery.send(:possible?, @post.bullet_ar_key).should be_true
+          expect(NPlusOneQuery.send(:possible?, @post.bullet_ar_key)).to eq true
         end
       end
 
       context ".impossible?" do
         it "should be true if impossible_objects contain" do
           NPlusOneQuery.add_impossible_object(@post)
-          NPlusOneQuery.send(:impossible?, @post.bullet_ar_key).should be_true
+          expect(NPlusOneQuery.send(:impossible?, @post.bullet_ar_key)).to eq true
         end
       end
 
       context ".association?" do
         it "should be true if object, associations pair is already existed" do
           NPlusOneQuery.add_object_associations(@post, :association)
-          NPlusOneQuery.send(:association?, @post.bullet_ar_key, :association).should be_true
+          expect(NPlusOneQuery.send(:association?, @post.bullet_ar_key, :association)).to eq true
         end
 
         it "should be false if object, association pair is not existed" do
           NPlusOneQuery.add_object_associations(@post, :association1)
-          NPlusOneQuery.send(:association?, @post.bullet_ar_key, :associatio2).should be_false
+          expect(NPlusOneQuery.send(:association?, @post.bullet_ar_key, :associatio2)).to eq false
         end
       end
 
       context ".conditions_met?" do
         it "should be true if object is possible, not impossible and object, associations pair is not already existed" do
-          NPlusOneQuery.stub(:possible?).with(@post.bullet_ar_key).and_return(true)
-          NPlusOneQuery.stub(:impossible?).with(@post.bullet_ar_key).and_return(false)
-          NPlusOneQuery.stub(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
-          NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations).should be_true
+          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_ar_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_ar_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations)).to eq true
         end
 
         it "should be false if object is not possible, not impossible and object, associations pair is not already existed" do
-          NPlusOneQuery.stub(:possible?).with(@post.bullet_ar_key).and_return(false)
-          NPlusOneQuery.stub(:impossible?).with(@post.bullet_ar_key).and_return(false)
-          NPlusOneQuery.stub(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
-          NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations).should be_false
+          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_ar_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_ar_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations)).to eq false
         end
 
         it "should be false if object is possible, but impossible and object, associations pair is not already existed" do
-          NPlusOneQuery.stub(:possible?).with(@post.bullet_ar_key).and_return(true)
-          NPlusOneQuery.stub(:impossible?).with(@post.bullet_ar_key).and_return(true)
-          NPlusOneQuery.stub(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
-          NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations).should be_false
+          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_ar_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_ar_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations)).to eq false
         end
 
         it "should be false if object is possible, not impossible and object, associations pair is already existed" do
-          NPlusOneQuery.stub(:possible?).with(@post.bullet_ar_key).and_return(true)
-          NPlusOneQuery.stub(:impossible?).with(@post.bullet_ar_key).and_return(false)
-          NPlusOneQuery.stub(:association?).with(@post.bullet_ar_key, :associations).and_return(true)
-          NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations).should be_false
+          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_ar_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_ar_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_ar_key, :associations).and_return(true)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations)).to eq false
         end
       end
 
       context ".call_association" do
         it "should create notification if conditions met" do
-          NPlusOneQuery.should_receive(:conditions_met?).with(@post.bullet_ar_key, :association).and_return(true)
-          NPlusOneQuery.should_receive(:caller_in_project).and_return(["caller"])
-          NPlusOneQuery.should_receive(:create_notification).with(["caller"], "Post", :association)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_ar_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:caller_in_project).and_return(["caller"])
+          expect(NPlusOneQuery).to receive(:create_notification).with(["caller"], "Post", :association)
           NPlusOneQuery.call_association(@post, :association)
         end
 
         it "should not create notification if conditions not met" do
-          NPlusOneQuery.should_receive(:conditions_met?).with(@post.bullet_ar_key, :association).and_return(false)
-          NPlusOneQuery.should_not_receive(:caller_in_project!)
-          NPlusOneQuery.should_not_receive(:create_notification).with("Post", :association)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_ar_key, :association).and_return(false)
+          expect(NPlusOneQuery).not_to receive(:caller_in_project!)
+          expect(NPlusOneQuery).not_to receive(:create_notification).with("Post", :association)
           NPlusOneQuery.call_association(@post, :association)
         end
       end
@@ -96,19 +96,19 @@ module Bullet
       context ".add_possible_objects" do
         it "should add possible objects" do
           NPlusOneQuery.add_possible_objects([@post, @post2])
-          NPlusOneQuery.send(:possible_objects).should be_include(@post.bullet_ar_key)
-          NPlusOneQuery.send(:possible_objects).should be_include(@post2.bullet_ar_key)
+          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post.bullet_ar_key)
+          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post2.bullet_ar_key)
         end
 
         it "should not raise error if object is nil" do
-          lambda { NPlusOneQuery.add_possible_objects(nil) }.should_not raise_error
+          expect { NPlusOneQuery.add_possible_objects(nil) }.not_to raise_error
         end
       end
 
       context ".add_impossible_object" do
         it "should add impossible object" do
           NPlusOneQuery.add_impossible_object(@post)
-          NPlusOneQuery.send(:impossible_objects).should be_include(@post.bullet_ar_key)
+          expect(NPlusOneQuery.send(:impossible_objects)).to be_include(@post.bullet_ar_key)
         end
       end
     end

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -11,42 +11,42 @@ module Bullet
 
       context ".call_associations" do
         it "should get empty array if eager_loadings" do
-          UnusedEagerLoading.send(:call_associations, @post.bullet_ar_key, Set.new([:association])).should be_empty
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_ar_key, Set.new([:association]))).to be_empty
         end
 
         it "should get call associations if object and association are both in eager_loadings and call_object_associations" do
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
-          UnusedEagerLoading.send(:call_associations, @post.bullet_ar_key, Set.new([:association])).should == [:association]
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_ar_key, Set.new([:association]))).to eq([:association])
         end
 
         it "should not get call associations if not exist in call_object_associations" do
           UnusedEagerLoading.add_eager_loadings([@post], :association)
-          UnusedEagerLoading.send(:call_associations, @post.bullet_ar_key, Set.new([:association])).should be_empty
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_ar_key, Set.new([:association]))).to be_empty
         end
       end
 
       context ".diff_object_associations" do
         it "should return associations not exist in call_association" do
-          UnusedEagerLoading.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association])).should == [:association]
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association]))).to eq([:association])
         end
 
         it "should return empty if associations exist in call_association" do
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
-          UnusedEagerLoading.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association])).should be_empty
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association]))).to be_empty
         end
       end
 
       context ".check_unused_preload_associations" do
         it "should set @@checked to true" do
           UnusedEagerLoading.check_unused_preload_associations
-          UnusedEagerLoading.class_variable_get(:@@checked).should be_true
+          expect(UnusedEagerLoading.class_variable_get(:@@checked)).to eq true
         end
 
         it "should create notification if object_association_diff is not empty" do
           UnusedEagerLoading.add_object_associations(@post, :association)
-          UnusedEagerLoading.should_receive(:create_notification).with("Post", [:association])
+          expect(UnusedEagerLoading).to receive(:create_notification).with("Post", [:association])
           UnusedEagerLoading.check_unused_preload_associations
         end
 
@@ -55,8 +55,8 @@ module Bullet
           UnusedEagerLoading.add_object_associations(@post, :association)
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
-          UnusedEagerLoading.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association])).should be_empty
-          UnusedEagerLoading.should_not_receive(:create_notification).with("Post", [:association])
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association]))).to be_empty
+          expect(UnusedEagerLoading).not_to receive(:create_notification).with("Post", [:association])
           UnusedEagerLoading.check_unused_preload_associations
         end
       end
@@ -64,30 +64,30 @@ module Bullet
       context ".add_eager_loadings" do
         it "should add objects, associations pair when eager_loadings are empty" do
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :associations)
-          UnusedEagerLoading.send(:eager_loadings).should be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :associations)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :associations)
         end
 
         it "should add objects, associations pair for existing eager_loadings" do
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :association2)
-          UnusedEagerLoading.send(:eager_loadings).should be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :association1)
-          UnusedEagerLoading.send(:eager_loadings).should be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :association2)
         end
 
         it "should merge objects, associations pair for existing eager_loadings" do
           UnusedEagerLoading.add_eager_loadings([@post], :association1)
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :association2)
-          UnusedEagerLoading.send(:eager_loadings).should be_include([@post.bullet_ar_key], :association1)
-          UnusedEagerLoading.send(:eager_loadings).should be_include([@post.bullet_ar_key], :association2)
-          UnusedEagerLoading.send(:eager_loadings).should be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :association2)
         end
 
         it "should delete objects, associations pair for existing eager_loadings" do
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
           UnusedEagerLoading.add_eager_loadings([@post], :association2)
-          UnusedEagerLoading.send(:eager_loadings).should be_include([@post.bullet_ar_key], :association1)
-          UnusedEagerLoading.send(:eager_loadings).should be_include([@post.bullet_ar_key], :association2)
-          UnusedEagerLoading.send(:eager_loadings).should be_include([@post2.bullet_ar_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post2.bullet_ar_key], :association1)
         end
       end
     end

data/spec/bullet/ext/object_spec.rb

@@ -4,13 +4,13 @@ describe Object do
   context "bullet_ar_key" do
     it "should return class and id composition" do
       post = Post.first
-      post.bullet_ar_key.should == "Post:#{post.id}"
+      expect(post.bullet_ar_key).to eq("Post:#{post.id}")
     end
 
     if mongoid?
       it "should return class with namesapce and id composition" do
         post = Mongoid::Post.first
-        post.bullet_ar_key.should == "Mongoid::Post:#{post.id}"
+        expect(post.bullet_ar_key).to eq("Mongoid::Post:#{post.id}")
       end
     end
   end

data/spec/bullet/ext/string_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe String do
   context "bullet_class_name" do
     it "should only return class name" do
-      "Post:1".bullet_class_name.should == "Post"
+      expect("Post:1".bullet_class_name).to eq("Post")
     end
 
     it "should return class name with namespace" do
-      "Mongoid::Post:1234567890".bullet_class_name.should == "Mongoid::Post"
+      expect("Mongoid::Post:1234567890".bullet_class_name).to eq("Mongoid::Post")
     end
   end
 end

data/spec/bullet/notification/base_spec.rb

@@ -7,49 +7,54 @@ module Bullet
 
       context "#title" do
         it "should raise NoMethodError" do
-          lambda { subject.title }.should raise_error(NoMethodError)
+          expect { subject.title }.to raise_error(NoMethodError)
         end
       end
 
       context "#body" do
         it "should raise NoMethodError" do
-          lambda { subject.body }.should raise_error(NoMethodError)
+          expect { subject.body }.to raise_error(NoMethodError)
         end
       end
 
       context "#whoami" do
         it "should display user name" do
           user = `whoami`.chomp
-          subject.whoami.should == "user: #{user}"
+          expect(subject.whoami).to eq("user: #{user}")
         end
       end
 
       context "#body_with_caller" do
         it "should return body" do
-          subject.stub(:body => "body")
-          subject.body_with_caller.should == "body"
+          allow(subject).to receive(:body).and_return("body")
+          expect(subject.body_with_caller).to eq("body")
         end
       end
 
       context "#standard_notice" do
         it "should return title + body" do
-          subject.stub(:title => "title", :body => "body")
-          subject.standard_notice.should == "title\nbody"
+          allow(subject).to receive(:title).and_return("title")
+          allow(subject).to receive(:body).and_return("body")
+          expect(subject.standard_notice).to eq("title\nbody")
         end
       end
 
       context "#full_notice" do
         it "should return whoami + url + title + body_with_caller" do
-          subject.stub(:whoami => "whoami", :url => "url", :title => "title", :body_with_caller => "body_with_caller")
-          subject.full_notice.should == "whoami\nurl\ntitle\nbody_with_caller"
+          allow(subject).to receive(:whoami).and_return("whoami")
+          allow(subject).to receive(:url).and_return("url")
+          allow(subject).to receive(:title).and_return("title")
+          allow(subject).to receive(:body_with_caller).and_return("body_with_caller")
+          expect(subject.full_notice).to eq("whoami\nurl\ntitle\nbody_with_caller")
         end
       end
 
       context "#notify_inline" do
         it "should send full_notice to notifier" do
           notifier = double
-          subject.stub(:notifier => notifier, :full_notice => "full_notice")
-          notifier.should_receive(:inline_notify).with("full_notice")
+          allow(subject).to receive(:notifier).and_return(notifier)
+          allow(subject).to receive(:full_notice).and_return("full_notice")
+          expect(notifier).to receive(:inline_notify).with("full_notice")
           subject.notify_inline
         end
       end
@@ -57,8 +62,9 @@ module Bullet
       context "#notify_out_of_channel" do
         it "should send full_out_of_channel to notifier" do
           notifier = double
-          subject.stub(:notifier => notifier, :full_notice => "full_notice")
-          notifier.should_receive(:out_of_channel_notify).with("full_notice")
+          allow(subject).to receive(:notifier).and_return(notifier)
+          allow(subject).to receive(:full_notice).and_return("full_notice")
+          expect(notifier).to receive(:out_of_channel_notify).with("full_notice")
           subject.notify_out_of_channel
         end
       end

data/spec/bullet/notification/counter_cache_spec.rb

@@ -5,8 +5,8 @@ module Bullet
     describe CounterCache do
       subject { CounterCache.new(Post, [:comments, :votes]) }
 
-      its(:body) { should == "  Post => [:comments, :votes]" }
-      its(:title) { should == "Need Counter Cache" }
+      it { expect(subject.body).to eq("  Post => [:comments, :votes]") }
+      it { expect(subject.title).to eq("Need Counter Cache") }
     end
   end
 end

data/spec/bullet/notification/n_plus_one_query_spec.rb

@@ -5,9 +5,9 @@ module Bullet
     describe NPlusOneQuery do
       subject { NPlusOneQuery.new([["caller1", "caller2"]], Post, [:comments, :votes], "path") }
 
-      its(:body_with_caller) { should == "  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]\nN+1 Query method call stack\n  caller1\n  caller2" }
-      its(:body) { should == "  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]" }
-      its(:title) { should == "N+1 Query in path" }
+      it { expect(subject.body_with_caller).to eq("  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]\nN+1 Query method call stack\n  caller1\n  caller2") }
+      it { expect(subject.body).to eq("  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]") }
+      it { expect(subject.title).to eq("N+1 Query in path") }
     end
   end
 end

data/spec/bullet/notification/unused_eager_loading_spec.rb

@@ -5,8 +5,8 @@ module Bullet
     describe UnusedEagerLoading do
       subject { UnusedEagerLoading.new(Post, [:comments, :votes], "path") }
 
-      its(:body) { should == "  Post => [:comments, :votes]\n  Remove from your finder: :include => [:comments, :votes]" }
-      its(:title) { should == "Unused Eager Loading in path" }
+      it { expect(subject.body).to eq("  Post => [:comments, :votes]\n  Remove from your finder: :include => [:comments, :votes]") }
+      it { expect(subject.title).to eq("Unused Eager Loading in path") }
     end
   end
 end

data/spec/bullet/notification_collector_spec.rb

@@ -7,25 +7,25 @@ module Bullet
     context "#add" do
       it "should add a value" do
         subject.add("value1")
-        subject.collection.should be_include("value1")
+        expect(subject.collection).to be_include("value1")
       end
     end
 
     context "#reset" do
       it "should reset collector" do
         subject.reset
-        subject.collection.should be_empty
+        expect(subject.collection).to be_empty
       end
     end
 
     context "#notifications_present?" do
       it "should be true if collection is not empty" do
-        subject.should be_notifications_present
+        expect(subject).to be_notifications_present
       end
 
       it "should be false if collection is empty" do
         subject.reset
-        subject.should_not be_notifications_present
+        expect(subject).not_to be_notifications_present
       end
     end
   end