bullet 5.7.5 → 6.1.4

data/spec/bullet/detector/counter_cache_spec.rb

@@ -12,15 +12,15 @@ module Bullet
 
       context '.add_counter_cache' do
         it 'should create notification if conditions met' do
-          expect(CounterCache).to receive(:conditions_met?).with(@post1, [:comments]).and_return(true)
-          expect(CounterCache).to receive(:create_notification).with('Post', [:comments])
-          CounterCache.add_counter_cache(@post1, [:comments])
+          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, [:comments]).and_return(false)
+          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, [:comments])
+          CounterCache.add_counter_cache(@post1, %i[comments])
         end
       end
 
@@ -47,7 +47,7 @@ module Bullet
           expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
         end
 
-        it 'should be true when object is possible, and impossible' do
+        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

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -76,8 +76,8 @@ module Bullet
       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
 
@@ -101,6 +101,29 @@ module Bullet
             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
 
@@ -126,7 +149,11 @@ module Bullet
 
             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

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -36,12 +36,14 @@ module Bullet
         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'] }
+        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)
@@ -53,7 +55,9 @@ module Bullet
           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.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
@@ -62,14 +66,23 @@ 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)
-          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
           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

data/spec/bullet/ext/object_spec.rb

@@ -17,23 +17,28 @@ describe Object do
     end
   end
 
-  context 'primary_key_value' 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
       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
       post = Post.first
       allow(Post).to receive(:primary_keys).and_return(%i[category_id writer_id])
-      expect(post.primary_key_value).to eq("#{post.category_id},#{post.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/notification/base_spec.rb

@@ -26,9 +26,7 @@ module Bullet
         end
 
         it 'should leverage ENV parameter' do
-          temp_env_variable('USER', 'bogus') do
-            expect(subject.whoami).to eq('user: bogus')
-          end
+          temp_env_variable('USER', 'bogus') { expect(subject.whoami).to eq('user: bogus') }
         end
 
         it 'should return blank if no user available' do

data/spec/bullet/notification/n_plus_one_query_spec.rb

@@ -7,9 +7,22 @@ module Bullet
     describe NPlusOneQuery do
       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 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

data/spec/bullet/notification/unused_eager_loading_spec.rb

@@ -7,7 +7,11 @@ module Bullet
     describe UnusedEagerLoading do
       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 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

data/spec/bullet/rack_spec.rb

@@ -45,9 +45,9 @@ module Bullet
         expect(middleware).not_to be_empty(response)
       end
 
-      it 'should be true if response is not found' do
+      it 'should be false if response is not found' do
         response = ['Not Found']
-        expect(middleware).to be_empty(response)
+        expect(middleware).not_to be_empty(response)
       end
 
       it 'should be true if response body is empty' do
@@ -67,11 +67,12 @@ module Bullet
 
         it 'should change response body if notification is active' do
           expect(Bullet).to receive(:notification?).and_return(true)
+          expect(Bullet).to receive(:console_enabled?).and_return(true)
           expect(Bullet).to receive(:gather_inline_notifications).and_return('<bullet></bullet>')
           expect(Bullet).to receive(:perform_out_of_channel_notifications)
-          status, headers, response = middleware.call('Content-Type' => 'text/html')
+          _, headers, response = middleware.call('Content-Type' => 'text/html')
           expect(headers['Content-Length']).to eq('56')
-          expect(response).to eq(['<html><head></head><body><bullet></bullet></body></html>'])
+          expect(response).to eq(%w[<html><head></head><body><bullet></bullet></body></html>])
         end
 
         it 'should set the right Content-Length if response body contains accents' do
@@ -79,10 +80,136 @@ module Bullet
           response.body = '<html><head></head><body>é</body></html>'
           app.response = response
           expect(Bullet).to receive(:notification?).and_return(true)
+          allow(Bullet).to receive(:console_enabled?).and_return(true)
           expect(Bullet).to receive(:gather_inline_notifications).and_return('<bullet></bullet>')
-          status, headers, response = middleware.call('Content-Type' => 'text/html')
+          _, headers, response = middleware.call('Content-Type' => 'text/html')
           expect(headers['Content-Length']).to eq('58')
         end
+
+        context 'with injection notifiers' do
+          before do
+            expect(Bullet).to receive(:notification?).and_return(true)
+            allow(Bullet).to receive(:gather_inline_notifications).and_return('<bullet></bullet>')
+            allow(middleware).to receive(:xhr_script).and_return('<script></script>')
+            allow(middleware).to receive(:footer_note).and_return('footer')
+            expect(Bullet).to receive(:perform_out_of_channel_notifications)
+          end
+
+          it 'should change response body if add_footer is true' do
+            expect(Bullet).to receive(:add_footer).exactly(3).times.and_return(true)
+            _, headers, response = middleware.call('Content-Type' => 'text/html')
+
+            expect(headers['Content-Length']).to eq((73 + middleware.send(:footer_note).length).to_s)
+            expect(response).to eq(%w[<html><head></head><body>footer<bullet></bullet><script></script></body></html>])
+          end
+
+          it 'should change response body for html safe string if add_footer is true' do
+            expect(Bullet).to receive(:add_footer).exactly(3).times.and_return(true)
+            app.response = Support::ResponseDouble.new.tap do |response|
+              response.body = ActiveSupport::SafeBuffer.new('<html><head></head><body></body></html>')
+            end
+            _, headers, response = middleware.call('Content-Type' => 'text/html')
+
+            expect(headers['Content-Length']).to eq((73 + middleware.send(:footer_note).length).to_s)
+            expect(response).to eq(%w[<html><head></head><body>footer<bullet></bullet><script></script></body></html>])
+          end
+
+          it 'should add the footer-text header for non-html requests when add_footer is true' do
+            allow(Bullet).to receive(:add_footer).at_least(:once).and_return(true)
+            allow(Bullet).to receive(:footer_info).and_return(['footer text'])
+            app.headers = {'Content-Type' => 'application/json'}
+            _, headers, _response = middleware.call({})
+            expect(headers).to include('X-bullet-footer-text' => '["footer text"]')
+          end
+
+          it 'should change response body if console_enabled is true' do
+            expect(Bullet).to receive(:console_enabled?).and_return(true)
+            _, headers, response = middleware.call('Content-Type' => 'text/html')
+            expect(headers['Content-Length']).to eq('56')
+            expect(response).to eq(%w[<html><head></head><body><bullet></bullet></body></html>])
+          end
+
+          it 'should change response body for html safe string if console_enabled is true' do
+            expect(Bullet).to receive(:console_enabled?).and_return(true)
+            app.response = Support::ResponseDouble.new.tap do |response|
+              response.body = ActiveSupport::SafeBuffer.new('<html><head></head><body></body></html>')
+            end
+            _, headers, response = middleware.call('Content-Type' => 'text/html')
+            expect(headers['Content-Length']).to eq('56')
+            expect(response).to eq(%w[<html><head></head><body><bullet></bullet></body></html>])
+          end
+
+          it 'should add headers for non-html requests when console_enabled is true' do
+            allow(Bullet).to receive(:console_enabled?).at_least(:once).and_return(true)
+            allow(Bullet).to receive(:text_notifications).and_return(['text notifications'])
+            app.headers = {'Content-Type' => 'application/json'}
+            _, headers, _response = middleware.call({})
+            expect(headers).to include('X-bullet-console-text' => '["text notifications"]')
+          end
+
+          it "shouldn't change response body unnecessarily" do
+            expected_response = Support::ResponseDouble.new 'Actual body'
+            app.response = expected_response
+            _, _, response = middleware.call({})
+            expect(response).to eq(expected_response)
+          end
+
+          it "shouldn't add headers unnecessarily" do
+            app.headers = {'Content-Type' => 'application/json'}
+            _, headers, _response = middleware.call({})
+            expect(headers).not_to include('X-bullet-footer-text')
+            expect(headers).not_to include('X-bullet-console-text')
+          end
+
+          context "when skip_http_headers is enabled" do
+            before do
+              allow(Bullet).to receive(:skip_http_headers).and_return(true)
+            end
+
+            it 'should include the footer but not the xhr script tag if add_footer is true' do
+              expect(Bullet).to receive(:add_footer).at_least(:once).and_return(true)
+              _, headers, response = middleware.call({})
+
+              expect(headers['Content-Length']).to eq((56 + middleware.send(:footer_note).length).to_s)
+              expect(response).to eq(%w[<html><head></head><body>footer<bullet></bullet></body></html>])
+            end
+
+            it 'should not include the xhr script tag if console_enabled is true' do
+              expect(Bullet).to receive(:console_enabled?).and_return(true)
+              _, headers, response = middleware.call({})
+              expect(headers['Content-Length']).to eq('56')
+              expect(response).to eq(%w[<html><head></head><body><bullet></bullet></body></html>])
+            end
+
+            it 'should not add the footer-text header for non-html requests when add_footer is true' do
+              allow(Bullet).to receive(:add_footer).at_least(:once).and_return(true)
+              app.headers = {'Content-Type' => 'application/json'}
+              _, headers, _response = middleware.call({})
+              expect(headers).not_to include('X-bullet-footer-text')
+            end
+
+            it 'should not add headers for non-html requests when console_enabled is true' do
+              allow(Bullet).to receive(:console_enabled?).at_least(:once).and_return(true)
+              app.headers = {'Content-Type' => 'application/json'}
+              _, headers, _response = middleware.call({})
+              expect(headers).not_to include('X-bullet-console-text')
+            end
+          end
+        end
+
+        context 'when skip_html_injection is enabled' do
+          it 'should not try to inject html' do
+            expected_response = Support::ResponseDouble.new 'Actual body'
+            app.response = expected_response
+            allow(Bullet).to receive(:notification?).and_return(true)
+            allow(Bullet).to receive(:skip_html_injection?).and_return(true)
+            expect(Bullet).to receive(:gather_inline_notifications).never
+            expect(middleware).to receive(:xhr_script).never
+            expect(Bullet).to receive(:perform_out_of_channel_notifications)
+            _, _, response = middleware.call('Content-Type' => 'text/html')
+            expect(response).to eq(expected_response)
+          end
+        end
       end
 
       context 'when Bullet is disabled' do
@@ -95,6 +222,14 @@ module Bullet
       end
     end
 
+    context '#set_header' do
+      it 'should truncate headers to under 8kb' do
+        long_header = ['a' * 1_024] * 10
+        expected_res = (['a' * 1_024] * 7).to_json
+        expect(middleware.set_header({}, 'Dummy-Header', long_header)).to eq(expected_res)
+      end
+    end
+
     describe '#response_body' do
       let(:response) { double }
       let(:body_string) { '<html><body>My Body</body></html>' }

data/spec/bullet/registry/association_spec.rb

@@ -16,11 +16,11 @@ module Bullet
 
       context '#similarly_associated' do
         it 'should return similarly associated keys' do
-          expect(subject.similarly_associated('key1', Set.new(['value']))).to eq(%w[key1 key2])
+          expect(subject.similarly_associated('key1', Set.new(%w[value]))).to eq(%w[key1 key2])
         end
 
         it 'should return empty if key does not exist' do
-          expect(subject.similarly_associated('key3', Set.new(['value']))).to be_empty
+          expect(subject.similarly_associated('key3', Set.new(%w[value]))).to be_empty
         end
       end
     end

data/spec/bullet/registry/base_spec.rb

@@ -9,7 +9,7 @@ module Bullet
 
       context '#[]' do
         it 'should get value by key' do
-          expect(subject['key']).to eq(Set.new(['value']))
+          expect(subject['key']).to eq(Set.new(%w[value]))
         end
       end
 

data/spec/bullet_spec.rb

@@ -17,9 +17,7 @@ describe Bullet, focused: true do
       end
 
       context 'disable Bullet' do
-        before do
-          Bullet.enable = false
-        end
+        before { Bullet.enable = false }
 
         it 'should be disabled' do
           expect(subject).to_not be_enable
@@ -27,8 +25,8 @@ describe Bullet, focused: true do
 
         context 'enable Bullet again without patching again the orms' do
           before do
-            expect(Bullet::Mongoid).not_to receive(:enable) if defined? Bullet::Mongoid
-            expect(Bullet::ActiveRecord).not_to receive(:enable) if defined? Bullet::ActiveRecord
+            expect(Bullet::Mongoid).not_to receive(:enable) if defined?(Bullet::Mongoid)
+            expect(Bullet::ActiveRecord).not_to receive(:enable) if defined?(Bullet::ActiveRecord)
             Bullet.enable = true
           end
 
@@ -42,9 +40,7 @@ describe Bullet, focused: true do
 
   describe '#start?' do
     context 'when bullet is disabled' do
-      before(:each) do
-        Bullet.enable = false
-      end
+      before(:each) { Bullet.enable = false }
 
       it 'should not be started' do
         expect(Bullet).not_to be_start
@@ -53,28 +49,19 @@ describe Bullet, focused: true do
   end
 
   describe '#debug' do
-    before(:each) do
-      $stdout = StringIO.new
-    end
+    before(:each) { $stdout = StringIO.new }
 
-    after(:each) do
-      $stdout = STDOUT
-    end
+    after(:each) { $stdout = STDOUT }
 
     context 'when debug is enabled' do
-      before(:each) do
-        ENV['BULLET_DEBUG'] = 'true'
-      end
+      before(:each) { ENV['BULLET_DEBUG'] = 'true' }
 
-      after(:each) do
-        ENV['BULLET_DEBUG'] = 'false'
-      end
+      after(:each) { ENV['BULLET_DEBUG'] = 'false' }
 
       it 'should output debug information' do
         Bullet.debug('debug_message', 'this is helpful information')
 
-        expect($stdout.string)
-          .to eq("[Bullet][debug_message] this is helpful information\n")
+        expect($stdout.string).to eq("[Bullet][debug_message] this is helpful information\n")
       end
     end
 
@@ -125,13 +112,7 @@ describe Bullet, focused: true do
     end
 
     context 'when called with Rack environment hash' do
-      let(:env) {
-        {
-          'REQUEST_METHOD' => 'GET',
-          'PATH_INFO' => '/path',
-          'QUERY_STRING' => 'foo=bar'
-        }
-      }
+      let(:env) { { 'REQUEST_METHOD' => 'GET', 'PATH_INFO' => '/path', 'QUERY_STRING' => 'foo=bar' } }
 
       context "when env['REQUEST_URI'] is nil" do
         before { env['REQUEST_URI'] = nil }