bullet 4.7.1 → 4.8.0

data/Rakefile

@@ -3,7 +3,6 @@ require "bundler"
 Bundler.setup
 
 require "rake"
-require "rdoc/task"
 require "rspec"
 require "rspec/core/rake_task"
 
@@ -35,11 +34,19 @@ RSpec::Core::RakeTask.new('spec:progress') do |spec|
   spec.pattern = "spec/**/*_spec.rb"
 end
 
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
-  rdoc.title = "bullet #{Bullet::VERSION}"
-  rdoc.rdoc_files.include("README*")
-  rdoc.rdoc_files.include("lib/**/*.rb")
+
+begin
+  require 'rdoc/task'
+
+  desc "Generate documentation for the plugin."
+  Rake::RDocTask.new do |rdoc|
+    rdoc.rdoc_dir = "rdoc"
+    rdoc.title = "bullet #{Bullet::VERSION}"
+    rdoc.rdoc_files.include("README*")
+    rdoc.rdoc_files.include("lib/**/*.rb")
+  end
+rescue LoadError
+  puts 'RDocTask is not supported for this platform'
 end
 
 task :default => :spec

data/lib/bullet.rb

@@ -66,7 +66,7 @@ module Bullet
 
     def add_whitelist(options)
       @whitelist[options[:type]][options[:class_name].classify] ||= []
-      @whitelist[options[:type]][options[:class_name].classify] << options[:association].to_s.tableize.to_sym
+      @whitelist[options[:type]][options[:class_name].classify] << options[:association]
     end
 
     def get_whitelist_associations(type, class_name)

data/lib/bullet/active_record41.rb

@@ -0,0 +1,97 @@
+module Bullet
+  module ActiveRecord
+    def self.enable
+      require 'active_record'
+      ::ActiveRecord::Relation.class_eval do
+        alias_method :origin_to_a, :to_a
+        # if select a collection of objects, then these objects have possible to cause N+1 query.
+        # if select only one object, then the only one object has impossible to cause N+1 query.
+        def to_a
+          records = origin_to_a
+          if records.first.class.name !~ /^HABTM_/
+            if records.size > 1
+              Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+              Bullet::Detector::CounterCache.add_possible_objects(records)
+            elsif records.size == 1
+              Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+              Bullet::Detector::CounterCache.add_impossible_object(records.first)
+            end
+          end
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::Preloader.class_eval do
+        alias_method :origin_preloaders_on, :preloaders_on
+
+        def preloaders_on(association, records, scope)
+          if records.first.class.name !~ /^HABTM_/
+            records.each do |record|
+              Bullet::Detector::Association.add_object_associations(record, association)
+            end
+            Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, association)
+          end
+          origin_preloaders_on(association, records, scope)
+        end
+      end
+
+      ::ActiveRecord::FinderMethods.class_eval do
+        # add includes in scope
+        alias_method :origin_find_with_associations, :find_with_associations
+        def find_with_associations
+          records = origin_find_with_associations
+          associations = (eager_load_values + includes_values).uniq
+          records.each do |record|
+            Bullet::Detector::Association.add_object_associations(record, associations)
+            Bullet::Detector::NPlusOneQuery.call_association(record, associations)
+          end
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, associations)
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::JoinDependency.class_eval do
+        alias_method :origin_construct_model, :construct_model
+        # call join associations
+        def construct_model(record, node, row, model_cache, id, aliases)
+          associations = node.reflection.name
+          Bullet::Detector::Association.add_object_associations(record, associations)
+          Bullet::Detector::NPlusOneQuery.call_association(record, associations)
+          origin_construct_model(record, node, row, model_cache, id, aliases)
+        end
+      end
+
+      ::ActiveRecord::Associations::CollectionAssociation.class_eval do
+        # call one to many associations
+        alias_method :origin_load_target, :load_target
+        def load_target
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless @inversed
+          origin_load_target
+        end
+      end
+
+      ::ActiveRecord::Associations::SingularAssociation.class_eval do
+        # call has_one and belongs_to associations
+        alias_method :origin_reader, :reader
+        def reader(force_reload = false)
+          result = origin_reader(force_reload)
+          if @owner.class.name !~ /^HABTM_/
+            Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless @inversed
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+          end
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::HasManyAssociation.class_eval do
+        alias_method :origin_has_cached_counter?, :has_cached_counter?
+
+        def has_cached_counter?(reflection = reflection)
+          result = origin_has_cached_counter?(reflection)
+          Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name) unless result
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/dependency.rb

@@ -18,8 +18,10 @@ module Bullet
                                      'active_record3'
                                    elsif active_record31? || active_record32?
                                      'active_record3x'
-                                   elsif active_record4?
+                                   elsif active_record40?
                                      'active_record4'
+                                   elsif active_record41?
+                                     'active_record41'
                                    end
                                  end
     end
@@ -56,6 +58,14 @@ module Bullet
       active_record3? && ::ActiveRecord::VERSION::MINOR == 2
     end
 
+    def active_record40?
+      active_record4? && ::ActiveRecord::VERSION::MINOR == 0
+    end
+
+    def active_record41?
+      active_record4? && ::ActiveRecord::VERSION::MINOR == 1
+    end
+
     def mongoid2x?
       mongoid? && ::Mongoid::VERSION =~ /\A2\.[4-8]/
     end

data/lib/bullet/mongoid4x.rb

@@ -44,7 +44,7 @@ module Bullet
         alias_method :origin_set_relation, :set_relation
 
         def set_relation(name, relation)
-          if relation && relation.metadata.macro !~ /embed/
+          if relation && relation.relation_metadata.macro !~ /embed/
             Bullet::Detector::NPlusOneQuery.call_association(self, name)
           end
           origin_set_relation(name, relation)

data/lib/bullet/registry/base.rb

@@ -33,7 +33,7 @@ module Bullet
       end
 
       def include?(key, value)
-        @registry[key] && @registry[key].include?(value)
+        !@registry[key].nil? && @registry[key].include?(value)
       end
     end
   end

data/lib/bullet/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Bullet
-  VERSION = "4.7.1"
+  VERSION = "4.8.0"
 end

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