bullet 6.1.0 → 7.0.7

data/lib/generators/bullet/install_generator.rb

@@ -10,40 +10,37 @@ module Bullet
 
       def enable_in_development
         environment(nil, env: 'development') do
-          <<-"FILE"
-
-  config.after_initialize do
-    Bullet.enable        = true
-    Bullet.alert         = true
-    Bullet.bullet_logger = true
-    Bullet.console       = true
-  # Bullet.growl         = true
-    Bullet.rails_logger  = true
-    Bullet.add_footer    = true
-  end
+          <<~FILE
+            config.after_initialize do
+              Bullet.enable        = true
+              Bullet.alert         = true
+              Bullet.bullet_logger = true
+              Bullet.console       = true
+              Bullet.rails_logger  = true
+              Bullet.add_footer    = true
+            end
+
           FILE
-            .strip
         end
 
         say 'Enabled bullet in config/environments/development.rb'
       end
 
       def enable_in_test
-        if yes?('Would you like to enable bullet in test environment? (y/n)')
-          environment(nil, env: 'test') do
-            <<-"FILE"
-
-  config.after_initialize do
-    Bullet.enable        = true
-    Bullet.bullet_logger = true
-    Bullet.raise         = true # raise an error if n+1 query occurs
-  end
-            FILE
-              .strip
-          end
+        return unless yes?('Would you like to enable bullet in test environment? (y/n)')
 
-          say 'Enabled bullet in config/environments/test.rb'
+        environment(nil, env: 'test') do
+          <<~FILE
+            config.after_initialize do
+              Bullet.enable        = true
+              Bullet.bullet_logger = true
+              Bullet.raise         = true # raise an error if n+1 query occurs
+            end
+
+          FILE
         end
+
+        say 'Enabled bullet in config/environments/test.rb'
       end
     end
   end

data/perf/benchmark.rb

@@ -30,7 +30,10 @@ end
 
 # create database bullet_benchmark;
 ActiveRecord::Base.establish_connection(
-  adapter: 'mysql2', database: 'bullet_benchmark', server: '/tmp/mysql.socket', username: 'root'
+  adapter: 'mysql2',
+  database: 'bullet_benchmark',
+  server: '/tmp/mysql.socket',
+  username: 'root'
 )
 
 ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }

data/spec/bullet/detector/counter_cache_spec.rb

@@ -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

@@ -39,7 +39,7 @@ module Bullet
 
         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
+          expect(NPlusOneQuery.association?(@post, :association2)).to eq false
         end
       end
 
@@ -127,38 +127,6 @@ module Bullet
         end
       end
 
-      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_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)
-          NPlusOneQuery.call_association(@post, :association)
-        end
-
-        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 = 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_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
-            )
-            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])

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -13,27 +13,27 @@ module Bullet
 
       context '.call_associations' do
         it 'should get empty array if eager_loadings' do
-          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new(%i[association]))).to be_empty
+          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(%i[association]))).to eq(
-            %i[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(%i[association]))).to be_empty
+          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(%i[association]))).to eq(
-            %i[association]
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to eq(
+            [:association]
           )
         end
 
@@ -41,7 +41,7 @@ module Bullet
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
           expect(
-            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new(%i[association]))
+            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))
           ).to be_empty
         end
       end
@@ -51,7 +51,7 @@ module Bullet
         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', %i[association])
+          expect(UnusedEagerLoading).to receive(:create_notification).with(paths, 'Post', [:association])
           UnusedEagerLoading.check_unused_preload_associations
         end
 
@@ -60,11 +60,16 @@ module Bullet
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
           expect(
-            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new(%i[association]))
+            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))
           ).to be_empty
-          expect(UnusedEagerLoading).not_to receive(:create_notification).with('Post', %i[association])
+          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

data/spec/bullet/ext/object_spec.rb

@@ -10,7 +10,7 @@ describe Object do
     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

data/spec/bullet/notification/base_spec.rb

@@ -74,8 +74,8 @@ module Bullet
         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
@@ -84,8 +84,8 @@ module Bullet
         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/n_plus_one_query_spec.rb

@@ -21,9 +21,7 @@ module Bullet
         )
       end
       it do
-        expect(subject.body).to eq(
-          "  Post => [:comments, :votes]\n  Add to your query: .includes([:comments, :votes])"
-        )
+        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

data/spec/bullet/rack_spec.rb

@@ -31,12 +31,6 @@ module Bullet
         response = double(body: '<html><head></head><body></body></html>')
         expect(middleware).not_to be_html_request(headers, response)
       end
-
-      it "should be false if response body doesn't contain html tag" do
-        headers = { 'Content-Type' => 'text/html' }
-        response = double(body: '<div>Partial</div>')
-        expect(middleware).not_to be_html_request(headers, response)
-      end
     end
 
     context 'empty?' do
@@ -54,6 +48,11 @@ module Bullet
         response = double(body: '')
         expect(middleware).to be_empty(response)
       end
+
+      it 'should be true if no response body' do
+        response = double
+        expect(middleware).to be_empty(response)
+      end
     end
 
     context '#call' do
@@ -67,9 +66,8 @@ module Bullet
 
         it 'should change response body if notification is active' do
           expect(Bullet).to receive(:notification?).and_return(true)
-          allow(Bullet).to receive(:skip_html_injection?).and_return(false)
+          expect(Bullet).to receive(:console_enabled?).and_return(true)
           expect(Bullet).to receive(:gather_inline_notifications).and_return('<bullet></bullet>')
-          expect(middleware).to receive(:xhr_script).and_return('')
           expect(Bullet).to receive(:perform_out_of_channel_notifications)
           _, headers, response = middleware.call('Content-Type' => 'text/html')
           expect(headers['Content-Length']).to eq('56')
@@ -81,9 +79,140 @@ 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>')
           _, headers, response = middleware.call('Content-Type' => 'text/html')
-          expect(headers['Content-Length']).to eq((58 + middleware.send(:xhr_script).length).to_s)
+          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 include CSP nonce in inline script if console_enabled and a CSP is applied' do
+            allow(Bullet).to receive(:add_footer).at_least(:once).and_return(true)
+            expect(Bullet).to receive(:console_enabled?).and_return(true)
+            allow(middleware).to receive(:xhr_script).and_call_original
+
+            nonce = '+t9/wTlgG6xbHxXYUaDNzQ=='
+            app.headers = {
+              'Content-Type' => 'text/html',
+              'Content-Security-Policy' => "default-src 'self' https:; script-src 'self' https: 'nonce-#{nonce}'"
+            }
+
+            _, headers, response = middleware.call('Content-Type' => 'text/html')
+
+            size = 56 + middleware.send(:footer_note).length + middleware.send(:xhr_script, nonce).length
+            expect(headers['Content-Length']).to eq(size.to_s)
+          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
@@ -148,6 +277,20 @@ module Bullet
           expect(middleware.response_body(response)).to eq body_string
         end
       end
+
+      begin
+        require 'rack/files'
+
+        context 'when `response` is a Rack::Files::Iterator' do
+          let(:response) { instance_double(::Rack::Files::Iterator) }
+          before { allow(response).to receive(:is_a?).with(::Rack::Files::Iterator) { true } }
+
+          it 'should return nil' do
+            expect(middleware.response_body(response)).to be_nil
+          end
+        end
+      rescue LoadError
+      end
     end
   end
 end

data/spec/bullet/stack_trace_filter_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Bullet
+  RSpec.describe StackTraceFilter do
+    let(:dummy_class) { Class.new { extend StackTraceFilter } }
+    let(:root_path) { Dir.pwd }
+    let(:bundler_path) { Bundler.bundle_path }
+
+    describe '#caller_in_project' do
+      it 'gets the caller in the project' do
+        expect(dummy_class).to receive(:call_stacks).and_return({
+          'Post:1' => [
+            File.join(root_path, 'lib/bullet.rb'),
+            File.join(root_path, 'vendor/uniform_notifier.rb'),
+            File.join(bundler_path, 'rack.rb')
+          ]
+        })
+        expect(dummy_class.caller_in_project('Post:1')).to eq([
+          File.join(root_path, 'lib/bullet.rb')
+        ])
+      end
+    end
+  end
+end

data/spec/bullet_spec.rb

@@ -74,31 +74,31 @@ describe Bullet, focused: true do
     end
   end
 
-  describe '#add_whitelist' do
+  describe '#add_safelist' do
     context "for 'special' class names" do
-      it 'is added to the whitelist successfully' do
-        Bullet.add_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
-        expect(Bullet.get_whitelist_associations(:n_plus_one_query, 'Klass')).to include :department
+      it 'is added to the safelist successfully' do
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+        expect(Bullet.get_safelist_associations(:n_plus_one_query, 'Klass')).to include :department
       end
     end
   end
 
-  describe '#delete_whitelist' do
+  describe '#delete_safelist' do
     context "for 'special' class names" do
-      it 'is deleted from the whitelist successfully' do
-        Bullet.add_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
-        Bullet.delete_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
-        expect(Bullet.whitelist[:n_plus_one_query]).to eq({})
+      it 'is deleted from the safelist successfully' do
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+        Bullet.delete_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+        expect(Bullet.safelist[:n_plus_one_query]).to eq({})
       end
     end
 
     context 'when exists multiple definitions' do
-      it 'is deleted from the whitelist successfully' do
-        Bullet.add_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
-        Bullet.add_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :team)
-        Bullet.delete_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :team)
-        expect(Bullet.get_whitelist_associations(:n_plus_one_query, 'Klass')).to include :department
-        expect(Bullet.get_whitelist_associations(:n_plus_one_query, 'Klass')).to_not include :team
+      it 'is deleted from the safelist successfully' do
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :team)
+        Bullet.delete_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :team)
+        expect(Bullet.get_safelist_associations(:n_plus_one_query, 'Klass')).to include :department
+        expect(Bullet.get_safelist_associations(:n_plus_one_query, 'Klass')).to_not include :team
       end
     end
   end