bullet 4.0.0 → 4.13.1

data/lib/bullet.rb

@@ -1,20 +1,16 @@
+require "active_support/core_ext/module/delegation"
 require 'set'
 require 'uniform_notifier'
 require 'bullet/ext/object'
 require 'bullet/ext/string'
+require 'bullet/dependency'
 
 module Bullet
-  if Rails.version =~ /\A3\.0/
-    autoload :ActiveRecord, 'bullet/active_record3'
-  elsif Rails.version =~ /\A3\.[12]/
-    autoload :ActiveRecord, 'bullet/active_record31'
-  else
-    autoload :ActiveRecord, 'bullet/active_record2'
-    autoload :ActionController, 'bullet/action_controller2'
-  end
-  autoload :Mongoid, 'bullet/mongoid'
+  extend Dependency
+
+  autoload :ActiveRecord, "bullet/#{active_record_version}" if active_record?
+  autoload :Mongoid, "bullet/#{mongoid_version}" if mongoid?
   autoload :Rack, 'bullet/rack'
-  autoload :BulletLogger, 'bullet/logger'
   autoload :Notification, 'bullet/notification'
   autoload :Detector, 'bullet/detector'
   autoload :Registry, 'bullet/registry'
@@ -28,66 +24,122 @@ module Bullet
     end
   end
 
-  class <<self
-    attr_accessor :enable, :disable_browser_cache
-    attr_reader :notification_collector
+  class << self
+    attr_writer :enable, :n_plus_one_query_enable, :unused_eager_loading_enable, :counter_cache_enable, :stacktrace_includes
+    attr_reader :notification_collector, :whitelist
+    attr_accessor :add_footer, :orm_pathches_applied
 
-    delegate :alert=, :console=, :growl=, :rails_logger=, :xmpp=, :to => UniformNotifier
+    delegate :alert=, :console=, :growl=, :rails_logger=, :xmpp=, :airbrake=, :bugsnag=, :to => UniformNotifier
+
+    def raise=(should_raise)
+      UniformNotifier.raise=(should_raise ? Notification::UnoptimizedQueryError : false)
+    end
 
     DETECTORS = [ Bullet::Detector::NPlusOneQuery,
-                  Bullet::Detector::UnusedEagerAssociation,
-                  Bullet::Detector::Counter ]
+                  Bullet::Detector::UnusedEagerLoading,
+                  Bullet::Detector::CounterCache ]
 
     def enable=(enable)
-      @enable = enable
+      @enable = @n_plus_one_query_enable = @unused_eager_loading_enable = @counter_cache_enable = enable
       if enable?
-        begin
-          require 'mongoid'
-          Bullet::Mongoid.enable
-        rescue LoadError
-        end
-        begin
-          require 'active_record'
-          Bullet::ActiveRecord.enable
-          if Rails.version =~ /\A2./
-            Bullet::ActionController.enable
-          end
-        rescue LoadError
+        reset_whitelist
+        unless orm_pathches_applied
+          self.orm_pathches_applied = true
+          Bullet::Mongoid.enable if mongoid?
+          Bullet::ActiveRecord.enable if active_record?
         end
       end
     end
 
     def enable?
-      @enable == true
+      !!@enable
+    end
+
+    def n_plus_one_query_enable?
+      self.enable? && !!@n_plus_one_query_enable
+    end
+
+    def unused_eager_loading_enable?
+      self.enable? && !!@unused_eager_loading_enable
+    end
+
+    def counter_cache_enable?
+      self.enable? && !!@counter_cache_enable
+    end
+
+    def stacktrace_includes
+      @stacktrace_includes || []
+    end
+
+    def add_whitelist(options)
+      @whitelist[options[:type]][options[:class_name].classify] ||= []
+      @whitelist[options[:type]][options[:class_name].classify] << options[:association].to_sym
+    end
+
+    def get_whitelist_associations(type, class_name)
+      Array(@whitelist[type][class_name])
+    end
+
+    def reset_whitelist
+      @whitelist = {:n_plus_one_query => {}, :unused_eager_loading => {}, :counter_cache => {}}
     end
 
     def bullet_logger=(active)
       if active
-        bullet_log_file = File.open('log/bullet.log', 'a+')
-        bullet_log_file.sync
+        require 'fileutils'
+        root_path = "#{rails? ? Rails.root.to_s : Dir.pwd}"
+        FileUtils.mkdir_p(root_path + '/log')
+        bullet_log_file = File.open("#{root_path}/log/bullet.log", 'a+')
+        bullet_log_file.sync = true
         UniformNotifier.customized_logger = bullet_log_file
       end
     end
 
+    def debug(title, message)
+      puts "[Bullet][#{title}] #{message}" if ENV['BULLET_DEBUG'] == 'true'
+    end
+
     def start_request
-      notification_collector.reset
-      DETECTORS.each { |bullet| bullet.start_request }
+      Thread.current[:bullet_start] = true
+      Thread.current[:bullet_notification_collector] = Bullet::NotificationCollector.new
+
+      Thread.current[:bullet_object_associations] = Bullet::Registry::Base.new
+      Thread.current[:bullet_call_object_associations] = Bullet::Registry::Base.new
+      Thread.current[:bullet_possible_objects] = Bullet::Registry::Object.new
+      Thread.current[:bullet_impossible_objects] = Bullet::Registry::Object.new
+      Thread.current[:bullet_inversed_objects] = Bullet::Registry::Base.new
+      Thread.current[:bullet_eager_loadings] = Bullet::Registry::Association.new
+
+      Thread.current[:bullet_counter_possible_objects] ||= Bullet::Registry::Object.new
+      Thread.current[:bullet_counter_impossible_objects] ||= Bullet::Registry::Object.new
     end
 
     def end_request
-      DETECTORS.each { |bullet| bullet.end_request }
+      Thread.current[:bullet_start] = nil
+      Thread.current[:bullet_notification_collector] = nil
+
+      Thread.current[:bullet_object_associations] = nil
+      Thread.current[:bullet_call_object_associations] = nil
+      Thread.current[:bullet_possible_objects] = nil
+      Thread.current[:bullet_impossible_objects] = nil
+      Thread.current[:bullet_inversed_objects] = nil
+      Thread.current[:bullet_eager_loadings] = nil
+
+      Thread.current[:bullet_counter_possible_objects] = nil
+      Thread.current[:bullet_counter_impossible_objects] = nil
     end
 
-    def clear
-      DETECTORS.each { |bullet| bullet.clear }
+    def start?
+      Thread.current[:bullet_start]
     end
 
     def notification_collector
-      @notification_collector ||= Bullet::NotificationCollector.new
+      Thread.current[:bullet_notification_collector]
     end
 
     def notification?
-      Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
+      return unless start?
+      Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
       notification_collector.notifications_present?
     end
 
@@ -106,6 +158,34 @@ module Bullet
       end
     end
 
+    def footer_info
+      info = []
+      for_each_active_notifier_with_notification do |notification|
+        info << notification.short_notice
+      end
+      info
+    end
+
+    def warnings
+      notification_collector.collection.inject({}) do |warnings, notification|
+        warning_type = notification.class.to_s.split(':').last.tableize
+        warnings[warning_type] ||= []
+        warnings[warning_type] << notification
+        warnings
+      end
+    end
+
+    def profile
+      Bullet.start_request if Bullet.enable?
+
+      yield
+
+      if Bullet.enable? && Bullet.notification?
+        Bullet.perform_out_of_channel_notifications
+      end
+      Bullet.end_request if Bullet.enable?
+    end
+
     private
       def for_each_active_notifier_with_notification
         UniformNotifier.active_notifiers.each do |notifier|

data/perf/benchmark.rb

@@ -27,7 +27,7 @@ class User < ActiveRecord::Base
 end
 
 # create database bullet_benchmark;
-ActiveRecord::Base.establish_connection(:adapter => 'mysql', :database => 'bullet_benchmark', :server => '/tmp/mysql.socket', :username => 'root')
+ActiveRecord::Base.establish_connection(:adapter => 'mysql2', :database => 'bullet_benchmark', :server => '/tmp/mysql.socket', :username => 'root')
 
 ActiveRecord::Base.connection.tables.each do |table|
   ActiveRecord::Base.connection.drop_table(table)
@@ -79,8 +79,6 @@ puts "Start benchmarking..."
 
 Bullet.enable = true
 
-PerfTools::CpuProfiler.start(ARGV[0]|| "benchmark_profile") if defined? PerfTools
-
 Benchmark.bm(70) do |bm|
   bm.report("Querying & Iterating #{posts_size} Posts with #{comments_size} Comments and #{users_size} Users") do
     10.times do
@@ -98,7 +96,6 @@ Benchmark.bm(70) do |bm|
   end
 end
 
-PerfTools::CpuProfiler.stop if defined? PerfTools
 puts "End benchmarking..."
 
 

data/spec/bullet/detector/association_spec.rb

@@ -7,86 +7,18 @@ module Bullet
         @post1 = Post.first
         @post2 = Post.last
       end
-      before(:each) { Association.clear }
-
-      context ".start_request" do
-        it "should set @@checked to false" do
-          Association.start_request
-          Association.class_variable_get(:@@checked).should be_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
-        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_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)
-        end
-      end
-
-      context ".add_possible_objects" do
-        it "should add possible objects" do
-          Association.add_possible_objects([@post1, @post2])
-          Association.send(:possible_objects).should be_include(@post1.bullet_ar_key)
-          Association.send(:possible_objects).should be_include(@post2.bullet_ar_key)
-        end
-
-        it "should not raise error if object is nil" do
-          lambda { Association.add_possible_objects(nil) }.should_not raise_error
-        end
-      end
-
-      context ".add_impossible_object" do
-        it "should add impossible object" do
-          Association.add_impossible_object(@post1)
-          Association.send(:impossible_objects).should be_include(@post1.bullet_ar_key)
-        end
-      end
-
-      context ".add_eager_loadings" do
-        it "should add objects, associations pair when eager_loadings are empty" do
-          Association.add_eager_loadings([@post1, @post2], :associations)
-          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key, @post2.bullet_ar_key], :associations)
-        end
-
-        it "should add objects, associations pair for existing eager_loadings" do
-          Association.add_eager_loadings([@post1, @post2], :association1)
-          Association.add_eager_loadings([@post1, @post2], :association2)
-          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key, @post2.bullet_ar_key], :association1)
-          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key, @post2.bullet_ar_key], :association2)
-        end
-
-        it "should merge objects, associations pair for existing eager_loadings" do
-          Association.add_eager_loadings([@post1], :association1)
-          Association.add_eager_loadings([@post1, @post2], :association2)
-          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key], :association1)
-          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key], :association2)
-          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key, @post2.bullet_ar_key], :association2)
-        end
-
-        it "should delete objects, associations pair for existing eager_loadings" do
-          Association.add_eager_loadings([@post1, @post2], :association1)
-          Association.add_eager_loadings([@post1], :association2)
-          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key], :association1)
-          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key], :association2)
-          Association.send(:eager_loadings).should be_include([@post2.bullet_ar_key], :association1)
+          expect(Association.send(:call_object_associations)).to be_include(@post1.bullet_key, :associations)
         end
       end
     end

data/spec/bullet/detector/base_spec.rb

@@ -3,12 +3,6 @@ require 'spec_helper'
 module Bullet
   module Detector
     describe Base do
-      context ".end_request" do
-        it "should call clear" do
-          Base.should_receive(:clear)
-          Base.end_request
-        end
-      end
     end
   end
 end

data/spec/bullet/detector/counter_cache_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe CounterCache do
+      before :all do
+        @post1 = Post.first
+        @post2 = Post.last
+      end
+
+      context ".add_counter_cache" do
+        it "should create notification if conditions met" do
+          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_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
+          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_key, [:comments]).and_return(false)
+          expect(CounterCache).to receive(:create_notification).never
+          CounterCache.add_counter_cache(@post1, [:comments])
+        end
+      end
+
+      context ".add_possible_objects" do
+        it "should add possible objects" do
+          CounterCache.add_possible_objects([@post1, @post2])
+          expect(CounterCache.send(:possible_objects)).to be_include(@post1.bullet_key)
+          expect(CounterCache.send(:possible_objects)).to be_include(@post2.bullet_key)
+        end
+
+        it "should add impossible object" do
+          CounterCache.add_impossible_object(@post1)
+          expect(CounterCache.send(:impossible_objects)).to be_include(@post1.bullet_key)
+        end
+      end
+
+      context ".conditions_met?" do
+        it "should be true when object is possible, not impossible" do
+          CounterCache.add_possible_objects(@post1)
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq true
+        end
+
+        it "should be false when object is not possible" do
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_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)
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq false
+        end
+      end
+    end
+  end
+end

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -3,17 +3,14 @@ require 'spec_helper'
 module Bullet
   module Detector
     describe NPlusOneQuery do
-      before(:all) { @post = Post.first }
-      before(:each) { NPlusOneQuery.clear }
+      before(:all) do
+        @post = Post.first
+        @post2 = Post.last
+      end
 
       context ".call_association" do
-        it "should set @@checked to true" do
-          NPlusOneQuery.call_association(@post, :associations)
-          NPlusOneQuery.class_variable_get(:@@checked).should be_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
@@ -21,74 +18,121 @@ 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_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_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_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_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_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_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_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_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_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_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_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(true)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_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_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_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
+
+      context ".caller_in_project" do
+        it "should include only paths that are in the project" do
+          in_project = File.join(Dir.pwd, 'abc', 'abc.rb')
+          not_in_project = '/def/def.rb'
+
+          expect(NPlusOneQuery).to receive(:caller).and_return([in_project, not_in_project])
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:create_notification).with([in_project], "Post", :association)
+          NPlusOneQuery.call_association(@post, :association)
+        end
+
+        context "stacktrace_includes" do
+          before { Bullet.stacktrace_includes = [ 'def' ] }
+          after { Bullet.stacktrace_includes = nil }
+
+          it "should include paths that are in the stacktrace_include list" do
+            in_project = File.join(Dir.pwd, 'abc', 'abc.rb')
+            included_gem = '/def/def.rb'
+            excluded_gem = '/ghi/ghi.rb'
+
+            expect(NPlusOneQuery).to receive(:caller).and_return([in_project, included_gem, excluded_gem])
+            expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+            expect(NPlusOneQuery).to receive(:create_notification).with([in_project, included_gem], "Post", :association)
+            NPlusOneQuery.call_association(@post, :association)
+          end
+        end
+      end
+
+      context ".add_possible_objects" do
+        it "should add possible objects" do
+          NPlusOneQuery.add_possible_objects([@post, @post2])
+          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post.bullet_key)
+          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post2.bullet_key)
+        end
+
+        it "should not raise error if object is nil" do
+          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)
+          expect(NPlusOneQuery.send(:impossible_objects)).to be_include(@post.bullet_key)
+        end
+      end
     end
   end
 end

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe UnusedEagerLoading do
+      before(:all) do
+        @post = Post.first
+        @post2 = Post.last
+      end
+
+      context ".call_associations" do
+        it "should get empty array if eager_loadings" do
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_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)
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_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)
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to be_empty
+        end
+      end
+
+      context ".diff_object_associations" do
+        it "should return associations not exist in call_association" do
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_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)
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to be_empty
+        end
+      end
+
+      context ".check_unused_preload_associations" do
+        it "should create notification if object_association_diff is not empty" do
+          UnusedEagerLoading.add_object_associations(@post, :association)
+          expect(UnusedEagerLoading).to receive(:create_notification).with("Post", [:association])
+          UnusedEagerLoading.check_unused_preload_associations
+        end
+
+        it "should not create notification if object_association_diff is empty" do
+          UnusedEagerLoading.add_object_associations(@post, :association)
+          UnusedEagerLoading.add_eager_loadings([@post], :association)
+          UnusedEagerLoading.add_call_object_associations(@post, :association)
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to be_empty
+          expect(UnusedEagerLoading).not_to receive(:create_notification).with("Post", [:association])
+          UnusedEagerLoading.check_unused_preload_associations
+        end
+      end
+
+      context ".add_eager_loadings" do
+        it "should add objects, associations pair when eager_loadings are empty" do
+          UnusedEagerLoading.add_eager_loadings([@post, @post2], :associations)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_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)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_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)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_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)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post2.bullet_key], :association1)
+        end
+      end
+    end
+  end
+end