bullet 5.5.0 → 6.1.5

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Bullet
@@ -8,62 +10,62 @@ module Bullet
         @post2 = Post.last
       end
 
-      context ".call_association" do
-        it "should add call_object_associations" do
+      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
+      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
+      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
+      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
+        it 'should be false if object, association pair is not existed' do
           NPlusOneQuery.add_object_associations(@post, :association1)
           expect(NPlusOneQuery.association?(@post, :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
+      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
+        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
+        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
+        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)
@@ -71,79 +73,106 @@ module Bullet
         end
       end
 
-      context ".call_association" do
-        it "should create notification if conditions met" do
+      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(["caller"])
-          expect(NPlusOneQuery).to receive(:create_notification).with(["caller"], "Post", :association)
+          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
+        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)
+          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/ ] }
+        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 = File.join(Dir.pwd, 'abc', 'abc.rb')
-            included_path = '/ghi/ghi.rb'
-            excluded_path = '/def/def.rb'
+          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).and_return([in_project, included_path, excluded_path])
+            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 ".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'
+      context '.caller_in_project' do
+        it 'should include only paths that are in the project' do
+          in_project = OpenStruct.new(absolute_path: File.join(Dir.pwd, 'abc', 'abc.rb'))
+          not_in_project = OpenStruct.new(absolute_path: '/def/def.rb')
 
-          expect(NPlusOneQuery).to receive(:caller).and_return([in_project, not_in_project])
+          expect(NPlusOneQuery).to receive(:caller_locations).and_return([in_project, not_in_project])
           expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
-          expect(NPlusOneQuery).to receive(:create_notification).with([in_project], "Post", :association)
+          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', /xyz/ ] }
+        context 'stacktrace_includes' do
+          before { Bullet.stacktrace_includes = ['def', /xyz/] }
           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_gems = ['/def/def.rb', 'xyz/xyz.rb']
-            excluded_gem = '/ghi/ghi.rb'
+          it 'should include paths that are in the stacktrace_include list' do
+            in_project = OpenStruct.new(absolute_path: File.join(Dir.pwd, 'abc', 'abc.rb'))
+            included_gems = [OpenStruct.new(absolute_path: '/def/def.rb'), OpenStruct.new(absolute_path: 'xyz/xyz.rb')]
+            excluded_gem = OpenStruct.new(absolute_path: '/ghi/ghi.rb')
 
-            expect(NPlusOneQuery).to receive(:caller).and_return([in_project, *included_gems, excluded_gem])
+            expect(NPlusOneQuery).to receive(:caller_locations).and_return([in_project, *included_gems, excluded_gem])
             expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
-            expect(NPlusOneQuery).to receive(:create_notification).with([in_project, *included_gems], "Post", :association)
+            expect(NPlusOneQuery).to receive(:create_notification).with(
+              [in_project, *included_gems],
+              'Post',
+              :association
+            )
             NPlusOneQuery.call_association(@post, :association)
           end
         end
       end
 
-      context ".add_possible_objects" do
-        it "should add possible objects" do
+      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
+        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
+      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

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Bullet
@@ -9,68 +11,85 @@ module Bullet
         @post3 = Post.last
       end
 
-      context ".call_associations" do
-        it "should get empty array if eager_loadings" do
+      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
+        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])
+          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
+        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])
+      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
+        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
+          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) { ["/dir1", "/dir1/subdir"] }
-        it "should create notification if object_association_diff is not empty" do
+      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])
+          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
+        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])
+          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
+      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)
+          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
+        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)
+          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
+        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)
@@ -78,7 +97,7 @@ module Bullet
           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
+        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)
@@ -89,7 +108,7 @@ module Bullet
           expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post3.bullet_key], :association2)
         end
 
-        it "should delete objects, associations pair for existing eager_loadings" do
+        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)

data/spec/bullet/ext/object_spec.rb

@@ -1,37 +1,44 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Object do
-  context "bullet_key" do
-    it "should return class and id composition" do
+  context 'bullet_key' do
+    it 'should return class and id composition' do
       post = Post.first
       expect(post.bullet_key).to eq("Post:#{post.id}")
     end
 
     if mongoid?
-      it "should return class with namesapce and id composition" do
+      it 'should return class with namespace and id composition' do
         post = Mongoid::Post.first
         expect(post.bullet_key).to eq("Mongoid::Post:#{post.id}")
       end
     end
   end
 
-  context "primary_key_value" do
-    it "should return id" do
+  context 'bullet_primary_key_value' do
+    it 'should return id' do
       post = Post.first
-      expect(post.primary_key_value).to eq(post.id)
+      expect(post.bullet_primary_key_value).to eq(post.id)
     end
 
-    it "should return primary key value" do
+    it 'should return primary key value' do
       post = Post.first
       Post.primary_key = 'name'
-      expect(post.primary_key_value).to eq(post.name)
+      expect(post.bullet_primary_key_value).to eq(post.name)
       Post.primary_key = 'id'
     end
 
-    it "should return value for multiple primary keys" do
+    it 'should return value for multiple primary keys' do
       post = Post.first
-      allow(Post).to receive(:primary_keys).and_return([:category_id, :writer_id])
-      expect(post.primary_key_value).to eq("#{post.category_id},#{post.writer_id}")
+      allow(Post).to receive(:primary_keys).and_return(%i[category_id writer_id])
+      expect(post.bullet_primary_key_value).to eq("#{post.category_id},#{post.writer_id}")
+    end
+
+    it 'it should return nil for unpersisted records' do
+      post = Post.new(id: 123)
+      expect(post.bullet_primary_key_value).to be_nil
     end
   end
 end

data/spec/bullet/ext/string_spec.rb

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

data/spec/bullet/notification/base_spec.rb

@@ -1,45 +1,45 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Bullet
   module Notification
     describe Base do
-      subject { Base.new(Post, [:comments, :votes]) }
+      subject { Base.new(Post, %i[comments votes]) }
 
-      context "#title" do
-        it "should raise NoMethodError" do
+      context '#title' do
+        it 'should raise NoMethodError' do
           expect { subject.title }.to raise_error(NoMethodError)
         end
       end
 
-      context "#body" do
-        it "should raise NoMethodError" do
+      context '#body' do
+        it 'should raise NoMethodError' do
           expect { subject.body }.to raise_error(NoMethodError)
         end
       end
 
-      context "#whoami" do
-        it "should display user name" do
+      context '#whoami' do
+        it 'should display user name' do
           user = `whoami`.chomp
           expect(subject.whoami).to eq("user: #{user}")
         end
 
-        it "should leverage ENV parameter" do
-          temp_env_variable("USER", "bogus") do
-            expect(subject.whoami).to eq("user: bogus")
-          end
+        it 'should leverage ENV parameter' do
+          temp_env_variable('USER', 'bogus') { expect(subject.whoami).to eq('user: bogus') }
         end
 
-        it "should return blank if no user available" do
-          temp_env_variable("USER", "") do
-            expect(subject).to receive(:`).with("whoami").and_return("")
-            expect(subject.whoami).to eq("")
+        it 'should return blank if no user available' do
+          temp_env_variable('USER', '') do
+            expect(subject).to receive(:`).with('whoami').and_return('')
+            expect(subject.whoami).to eq('')
           end
         end
 
-        it "should return blank if whoami is not available" do
-          temp_env_variable("USER", "") do
-            expect(subject).to receive(:`).with("whoami").and_raise(Errno::ENOENT)
-            expect(subject.whoami).to eq("")
+        it 'should return blank if whoami is not available' do
+          temp_env_variable('USER', '') do
+            expect(subject).to receive(:`).with('whoami').and_raise(Errno::ENOENT)
+            expect(subject.whoami).to eq('')
           end
         end
 
@@ -50,43 +50,42 @@ module Bullet
         ensure
           ENV[name] = old_value
         end
-
       end
 
-      context "#body_with_caller" do
-        it "should return body" do
-          allow(subject).to receive(:body).and_return("body")
-          allow(subject).to receive(:call_stack_messages).and_return("call_stack_messages")
+      context '#body_with_caller' do
+        it 'should return body' do
+          allow(subject).to receive(:body).and_return('body')
+          allow(subject).to receive(:call_stack_messages).and_return('call_stack_messages')
           expect(subject.body_with_caller).to eq("body\ncall_stack_messages\n")
         end
       end
 
-      context "#notification_data" do
-        it "should return notification data" do
-          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.notification_data).to eq(:user => "whoami", :url => "url", :title => "title", :body => "body_with_caller")
+      context '#notification_data' do
+        it 'should return notification data' do
+          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.notification_data).to eq(user: 'whoami', url: 'url', title: 'title', body: 'body_with_caller')
         end
       end
 
-      context "#notify_inline" do
-        it "should send full_notice to notifier" do
+      context '#notify_inline' do
+        it 'should send full_notice to notifier' do
           notifier = double
           allow(subject).to receive(:notifier).and_return(notifier)
-          allow(subject).to receive(:notification_data).and_return(:foo => :bar)
-          expect(notifier).to receive(:inline_notify).with(:foo => :bar)
+          allow(subject).to receive(:notification_data).and_return(foo: :bar)
+          expect(notifier).to receive(:inline_notify).with(foo: :bar)
           subject.notify_inline
         end
       end
 
-      context "#notify_out_of_channel" do
-        it "should send full_out_of_channel to notifier" do
+      context '#notify_out_of_channel' do
+        it 'should send full_out_of_channel to notifier' do
           notifier = double
           allow(subject).to receive(:notifier).and_return(notifier)
-          allow(subject).to receive(:notification_data).and_return(:foo => :bar)
-          expect(notifier).to receive(:out_of_channel_notify).with(:foo => :bar)
+          allow(subject).to receive(:notification_data).and_return(foo: :bar)
+          expect(notifier).to receive(:out_of_channel_notify).with(foo: :bar)
           subject.notify_out_of_channel
         end
       end

data/spec/bullet/notification/counter_cache_spec.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Bullet
   module Notification
     describe CounterCache do
-      subject { CounterCache.new(Post, [:comments, :votes]) }
+      subject { CounterCache.new(Post, %i[comments votes]) }
 
-      it { expect(subject.body).to eq("  Post => [:comments, :votes]") }
-      it { expect(subject.title).to eq("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

@@ -1,14 +1,29 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Bullet
   module Notification
     describe NPlusOneQuery do
-      subject { NPlusOneQuery.new([["caller1", "caller2"]], Post, [:comments, :votes], "path") }
+      subject { NPlusOneQuery.new([%w[caller1 caller2]], Post, %i[comments votes], 'path') }
 
-      it { expect(subject.body_with_caller).to eq("  Post => [:comments, :votes]\n  Add to your finder: :includes => [:comments, :votes]\nCall stack\n  caller1\n  caller2\n") }
-      it { expect([subject.body_with_caller, subject.body_with_caller]).to eq([ "  Post => [:comments, :votes]\n  Add to your finder: :includes => [:comments, :votes]\nCall stack\n  caller1\n  caller2\n", "  Post => [:comments, :votes]\n  Add to your finder: :includes => [:comments, :votes]\nCall stack\n  caller1\n  caller2\n" ]) }
-      it { expect(subject.body).to eq("  Post => [:comments, :votes]\n  Add to your finder: :includes => [:comments, :votes]") }
-      it { expect(subject.title).to eq("USE eager loading in path") }
+      it do
+        expect(subject.body_with_caller).to eq(
+          "  Post => [:comments, :votes]\n  Add to your query: .includes([:comments, :votes])\nCall stack\n  caller1\n  caller2\n"
+        )
+      end
+      it do
+        expect([subject.body_with_caller, subject.body_with_caller]).to eq(
+          [
+            "  Post => [:comments, :votes]\n  Add to your query: .includes([:comments, :votes])\nCall stack\n  caller1\n  caller2\n",
+            "  Post => [:comments, :votes]\n  Add to your query: .includes([:comments, :votes])\nCall stack\n  caller1\n  caller2\n"
+          ]
+        )
+      end
+      it do
+        expect(subject.body).to eq("  Post => [:comments, :votes]\n  Add to your query: .includes([:comments, :votes])")
+      end
+      it { expect(subject.title).to eq('USE eager loading in path') }
     end
   end
 end

data/spec/bullet/notification/unused_eager_loading_spec.rb

@@ -1,12 +1,18 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Bullet
   module Notification
     describe UnusedEagerLoading do
-      subject { UnusedEagerLoading.new([""], Post, [:comments, :votes], "path") }
+      subject { UnusedEagerLoading.new([''], Post, %i[comments votes], 'path') }
 
-      it { expect(subject.body).to eq("  Post => [:comments, :votes]\n  Remove from your finder: :includes => [:comments, :votes]") }
-      it { expect(subject.title).to eq("AVOID eager loading in path") }
+      it do
+        expect(subject.body).to eq(
+          "  Post => [:comments, :votes]\n  Remove from your query: .includes([:comments, :votes])"
+        )
+      end
+      it { expect(subject.title).to eq('AVOID eager loading in path') }
     end
   end
 end