bullet 7.0.7 → 7.1.6

data/Hacking.md

@@ -1,75 +0,0 @@
-# Bullet Overview for Developers
-
-This file aims to give developers a quick tour of the bullet internals, making
-it (hopefully) easier to extend or enhance the Bullet gem.
-
-## General Control Flow aka. 10000 Meter View
-
-When Rails is initialized, Bullet will extend ActiveRecord (and if you're using
-Rails 2.x ActiveController too) with the relevant modules and methods found
-in lib/bullet/active_recordX.rb and lib/bullet/action_controller2.rb. If you're
-running Rails 3, Bullet will integrate itself as a middleware into the Rack
-stack, so ActionController does not need to be extended.
-
-The ActiveRecord extensions will call methods in a given detector class, when
-certain methods are called.
-
-Detector classes contain all the logic to recognize
-a noteworthy event. If such an event is detected, an instance of the
-corresponding Notification class is created and stored in a Set instance in the
-main Bullet module (the 'notification collector').
-
-Notification instances contain the message that will be displayed, and will
-use a Presenter class to display their message to the user.
-
-So the flow of a request goes like this:
-
-1. Bullet.start_request is called, which resets all the detectors and empties
-   the notification collector
-2. The request is handled by Rails, and the installed ActiveRecord extensions
-   trigger Detector callbacks
-3. Detectors once called, will determine whether something noteworthy happened.
-   If yes, then a Notification is created and stored in the notification collector.
-4. Rails finishes handling the request
-5. For each notification in the collector, Bullet will iterate over each
-   Presenter and will try to generate an inline message that will be appended to
-   the generated response body.
-6. The response is returned to the client.
-7. Bullet will try to generate an out-of-channel message for each notification.
-8. Bullet calls end_request for each detector.
-9. Goto 1.
-
-## Adding Notification Types
-
-If you want to add more kinds of things that Bullet can detect, a little more
-work is needed than if you were just adding a Presenter, but the concepts are
-similar.
-
-* Add the class to the DETECTORS constant in the main Bullet module
-* Add (if needed) Rails monkey patches to Bullet.enable
-* Add an autoload directive to lib/bullet/detector.rb
-* Create a corresponding notification class in the Bullet::Notification namespace
-* Add an autoload directive to lib/bullet/notification.rb
-
-As a rule of thumb, you can assume that each Detector will have its own
-Notification class. If you follow the principle of Separation of Concerns I
-can't really think of an example where one would deviate from this rule.
-
-Since the detection of pathological associations is a bit hairy, I'd recommend
-having a look at the counter cache detector and associated notification to get
-a feel for what is needed to get off the ground.
-
-### Detectors
-
-The only things you'll need to consider when building your Detector class is
-that it will need to supply the .start_request, .end_request and .clear class
-methods.
-
-Simple implementations are provided by Bullet::Detector::Base for start_request
-and end_request, you will have to supply your own clear method.
-
-### Notifications
-
-For notifications you will want to supply a #title and #body instance method,
-and check to see if the #initialize and #full_notice methods in the
-Bullet::Notification::Base class fit your needs.

data/Rakefile

@@ -1,51 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('lib', __dir__)
-require 'bundler'
-Bundler.setup
-
-require 'rake'
-require 'rspec'
-require 'rspec/core/rake_task'
-
-require 'bullet/version'
-
-task :build do
-  system 'gem build bullet.gemspec'
-end
-
-task install: :build do
-  system "sudo gem install bullet-#{Bullet::VERSION}.gem"
-end
-
-task release: :build do
-  puts "Tagging #{Bullet::VERSION}..."
-  system "git tag -a #{Bullet::VERSION} -m 'Tagging #{Bullet::VERSION}'"
-  puts 'Pushing to Github...'
-  system 'git push --tags'
-  puts 'Pushing to rubygems.org...'
-  system "gem push bullet-#{Bullet::VERSION}.gem"
-end
-
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-end
-
-RSpec::Core::RakeTask.new('spec:progress') do |spec|
-  spec.rspec_opts = %w[--format progress]
-  spec.pattern = 'spec/**/*_spec.rb'
-end
-
-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/bullet.gemspec

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
-
-require 'bullet/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'bullet'
-  s.version     = Bullet::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Richard Huang']
-  s.email       = ['flyerhzm@gmail.com']
-  s.homepage    = 'https://github.com/flyerhzm/bullet'
-  s.summary     = 'help to kill N+1 queries and unused eager loading.'
-  s.description = 'help to kill N+1 queries and unused eager loading.'
-  s.metadata    = {
-    'changelog_uri' => 'https://github.com/flyerhzm/bullet/blob/master/CHANGELOG.md',
-    'source_code_uri' => 'https://github.com/flyerhzm/bullet'
-  }
-
-  s.license = 'MIT'
-
-  s.required_ruby_version = '>= 2.3'
-  s.required_rubygems_version = '>= 1.3.6'
-
-  s.add_runtime_dependency 'activesupport', '>= 3.0.0'
-  s.add_runtime_dependency 'uniform_notifier', '~> 1.11'
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths = ['lib']
-end

data/perf/benchmark.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH << 'lib'
-require 'benchmark'
-require 'rails'
-require 'active_record'
-require 'activerecord-import'
-require 'bullet'
-
-begin
-  require 'perftools'
-rescue LoadError
-  puts "Could not load perftools.rb, profiling won't be possible"
-end
-
-class Post < ActiveRecord::Base
-  belongs_to :user
-  has_many :comments
-end
-
-class Comment < ActiveRecord::Base
-  belongs_to :user
-  belongs_to :post
-end
-
-class User < ActiveRecord::Base
-  has_many :posts
-  has_many :comments
-end
-
-# create database bullet_benchmark;
-ActiveRecord::Base.establish_connection(
-  adapter: 'mysql2',
-  database: 'bullet_benchmark',
-  server: '/tmp/mysql.socket',
-  username: 'root'
-)
-
-ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
-
-ActiveRecord::Schema.define(version: 1) do
-  create_table :posts do |t|
-    t.column :title, :string
-    t.column :body, :string
-    t.column :user_id, :integer
-  end
-
-  create_table :comments do |t|
-    t.column :body, :string
-    t.column :post_id, :integer
-    t.column :user_id, :integer
-  end
-
-  create_table :users do |t|
-    t.column :name, :string
-  end
-end
-
-users_size = 100
-posts_size = 1_000
-comments_size = 10_000
-users = []
-users_size.times { |i| users << User.new(name: "user#{i}") }
-User.import users
-users = User.all
-
-posts = []
-posts_size.times { |i| posts << Post.new(title: "Title #{i}", body: "Body #{i}", user: users[i % 100]) }
-Post.import posts
-posts = Post.all
-
-comments = []
-comments_size.times { |i| comments << Comment.new(body: "Comment #{i}", post: posts[i % 1_000], user: users[i % 100]) }
-Comment.import comments
-
-puts 'Start benchmarking...'
-
-Bullet.enable = true
-
-Benchmark.bm(70) do |bm|
-  bm.report("Querying & Iterating #{posts_size} Posts with #{comments_size} Comments and #{users_size} Users") do
-    10.times do
-      Bullet.start_request
-      Post.select('SQL_NO_CACHE *').includes(:user, comments: :user).each do |p|
-        p.title
-        p.user.name
-        p.comments.each do |c|
-          c.body
-          c.user.name
-        end
-      end
-      Bullet.end_request
-    end
-  end
-end
-
-puts 'End benchmarking...'
-
-# Run benchmark with bundler
-#
-#     bundle exec ruby perf/benchmark.rb
-#
-# bullet 2.3.0 with rails 3.2.2
-#                                                                              user     system      total        real
-# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       16.460000   0.190000  16.650000 ( 16.968246)
-#
-# bullet 2.3.0 with rails 3.1.4
-#                                                                              user     system      total        real
-# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       14.600000   0.130000  14.730000 ( 14.937590)
-#
-# bullet 2.3.0 with rails 3.0.12
-#                                                                              user     system      total        real
-# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       26.120000   0.430000  26.550000 ( 27.179304)
-#
-#
-# bullet 2.2.1 with rails 3.0.12
-#                                                                              user     system      total        real
-# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       29.970000   0.270000  30.240000 ( 30.452083)

data/rails/init.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require 'bullet'

data/spec/bullet/detector/association_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Detector
-    describe Association do
-      before :all do
-        @post1 = Post.first
-        @post2 = Post.last
-      end
-
-      context '.add_object_association' do
-        it 'should add object, associations pair' do
-          Association.add_object_associations(@post1, :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)
-          expect(Association.send(:call_object_associations)).to be_include(@post1.bullet_key, :associations)
-        end
-      end
-    end
-  end
-end

data/spec/bullet/detector/base_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Detector
-    describe Base do
-    end
-  end
-end

data/spec/bullet/detector/counter_cache_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-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, %i[comments]).and_return(true)
-          expect(CounterCache).to receive(:create_notification).with('Post', %i[comments])
-          CounterCache.add_counter_cache(@post1, %i[comments])
-        end
-
-        it 'should not create notification if conditions not met' do
-          expect(CounterCache).to receive(:conditions_met?).with(@post1, %i[comments]).and_return(false)
-          expect(CounterCache).to receive(:create_notification).never
-          CounterCache.add_counter_cache(@post1, %i[comments])
-        end
-      end
-
-      context '.add_possible_objects' do
-        it 'should add possible objects' do
-          CounterCache.add_possible_objects([@post1, @post2])
-          expect(CounterCache.possible_objects).to be_include(@post1.bullet_key)
-          expect(CounterCache.possible_objects).to be_include(@post2.bullet_key)
-        end
-
-        it 'should add impossible object' do
-          CounterCache.add_impossible_object(@post1)
-          expect(CounterCache.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.conditions_met?(@post1, :associations)).to eq true
-        end
-
-        it 'should be false when object is not possible' do
-          expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
-        end
-
-        it 'should be false when object is possible, and impossible' do
-          CounterCache.add_possible_objects(@post1)
-          CounterCache.add_impossible_object(@post1)
-          expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
-        end
-      end
-    end
-  end
-end

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Detector
-    describe NPlusOneQuery do
-      before(:all) do
-        @post = Post.first
-        @post2 = Post.last
-      end
-
-      context '.call_association' do
-        it 'should add call_object_associations' do
-          expect(NPlusOneQuery).to receive(:add_call_object_associations).with(@post, :associations)
-          NPlusOneQuery.call_association(@post, :associations)
-        end
-      end
-
-      context '.possible?' do
-        it 'should be true if possible_objects contain' do
-          NPlusOneQuery.add_possible_objects(@post)
-          expect(NPlusOneQuery.possible?(@post)).to eq true
-        end
-      end
-
-      context '.impossible?' do
-        it 'should be true if impossible_objects contain' do
-          NPlusOneQuery.add_impossible_object(@post)
-          expect(NPlusOneQuery.impossible?(@post)).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)
-          expect(NPlusOneQuery.association?(@post, :association)).to eq true
-        end
-
-        it 'should be false if object, association pair is not existed' do
-          NPlusOneQuery.add_object_associations(@post, :association1)
-          expect(NPlusOneQuery.association?(@post, :association2)).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
-          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
-          expect(NPlusOneQuery.conditions_met?(@post, :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
-          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(false)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
-          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
-        end
-
-        it 'should be false if object is possible, but impossible and object, associations pair is not already existed' do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(true)
-          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
-          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
-        end
-
-        it 'should be false if object is possible, not impossible and object, associations pair is already existed' do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(true)
-          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
-        end
-      end
-
-      context '.call_association' do
-        it 'should create notification if conditions met' do
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
-          expect(NPlusOneQuery).to receive(:caller_in_project).and_return(%w[caller])
-          expect(NPlusOneQuery).to receive(:create_notification).with(%w[caller], 'Post', :association)
-          NPlusOneQuery.call_association(@post, :association)
-        end
-
-        it 'should not create notification if conditions not met' do
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :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
-
-        context 'stacktrace_excludes' do
-          before { Bullet.stacktrace_excludes = [/def/] }
-          after { Bullet.stacktrace_excludes = nil }
-
-          it 'should not create notification when stacktrace contains paths that are in the exclude list' do
-            in_project = OpenStruct.new(absolute_path: File.join(Dir.pwd, 'abc', 'abc.rb'))
-            included_path = OpenStruct.new(absolute_path: '/ghi/ghi.rb')
-            excluded_path = OpenStruct.new(absolute_path: '/def/def.rb')
-
-            expect(NPlusOneQuery).to receive(:caller_locations).and_return([in_project, included_path, excluded_path])
-            expect(NPlusOneQuery).to_not receive(:create_notification)
-            NPlusOneQuery.call_association(@post, :association)
-          end
-
-          # just a sanity spec to make sure the following spec works correctly
-          it "should create notification when stacktrace contains methods that aren't in the exclude list" do
-            method = NPlusOneQuery.method(:excluded_stacktrace_path?).source_location
-            in_project = OpenStruct.new(absolute_path: File.join(Dir.pwd, 'abc', 'abc.rb'))
-            excluded_path = OpenStruct.new(absolute_path: method.first, lineno: method.last)
-
-            expect(NPlusOneQuery).to receive(:caller_locations).at_least(1).and_return([in_project, excluded_path])
-            expect(NPlusOneQuery).to receive(:conditions_met?).and_return(true)
-            expect(NPlusOneQuery).to receive(:create_notification)
-            NPlusOneQuery.call_association(@post, :association)
-          end
-
-          it 'should not create notification when stacktrace contains methods that are in the exclude list' do
-            method = NPlusOneQuery.method(:excluded_stacktrace_path?).source_location
-            Bullet.stacktrace_excludes = [method]
-            in_project = OpenStruct.new(absolute_path: File.join(Dir.pwd, 'abc', 'abc.rb'))
-            excluded_path = OpenStruct.new(absolute_path: method.first, lineno: method.last)
-
-            expect(NPlusOneQuery).to receive(:caller_locations).and_return([in_project, excluded_path])
-            expect(NPlusOneQuery).to_not receive(:create_notification)
-            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.possible_objects).to be_include(@post.bullet_key)
-          expect(NPlusOneQuery.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.impossible_objects).to be_include(@post.bullet_key)
-        end
-      end
-    end
-  end
-end

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Detector
-    describe UnusedEagerLoading do
-      before(:all) do
-        @post = Post.first
-        @post2 = Post.all[1]
-        @post3 = 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
-        let(:paths) { %w[/dir1 /dir1/subdir] }
-        it 'should create notification if object_association_diff is not empty' do
-          UnusedEagerLoading.add_object_associations(@post, :association)
-          allow(UnusedEagerLoading).to receive(:caller_in_project).and_return(paths)
-          expect(UnusedEagerLoading).to receive(:create_notification).with(paths, '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
-
-        it 'should create call stack for notification' do
-          UnusedEagerLoading.add_object_associations(@post, :association)
-          expect(UnusedEagerLoading.send(:call_stacks).registry).not_to be_empty
-        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([@post2.bullet_key], :association2)
-        end
-
-        it 'should vmerge objects recursively, associations pair for existing eager_loadings' do
-          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
-          UnusedEagerLoading.add_eager_loadings([@post, @post3], :association1)
-          UnusedEagerLoading.add_eager_loadings([@post, @post3], :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)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post3.bullet_key], :association1)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post3.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