bullet 7.0.6 → 7.1.0

data/spec/bullet/ext/object_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Object 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 namespace and id composition' do
-        post = Mongoid::Post.first
-        expect(post.bullet_key).to eq("Mongoid::Post:#{post.id}")
-      end
-    end
-  end
-
-  context 'bullet_primary_key_value' do
-    it 'should return id' do
-      post = Post.first
-      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.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.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,15 +0,0 @@
-# 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')
-    end
-
-    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,94 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Notification
-    describe Base do
-      subject { Base.new(Post, %i[comments votes]) }
-
-      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
-          expect { subject.body }.to raise_error(NoMethodError)
-        end
-      end
-
-      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') { 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('')
-          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('')
-          end
-        end
-
-        def temp_env_variable(name, value)
-          old_value = ENV[name]
-          ENV[name] = value
-          yield
-        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')
-          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')
-        end
-      end
-
-      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 })
-          subject.notify_inline
-        end
-      end
-
-      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 })
-          subject.notify_out_of_channel
-        end
-      end
-    end
-  end
-end

data/spec/bullet/notification/counter_cache_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Notification
-    describe CounterCache do
-      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') }
-    end
-  end
-end

data/spec/bullet/notification/n_plus_one_query_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Notification
-    describe NPlusOneQuery do
-      subject { NPlusOneQuery.new([%w[caller1 caller2]], Post, %i[comments votes], '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,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Notification
-    describe UnusedEagerLoading do
-      subject { UnusedEagerLoading.new([''], Post, %i[comments votes], '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

data/spec/bullet/notification_collector_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  describe NotificationCollector do
-    subject { NotificationCollector.new.tap { |collector| collector.add('value') } }
-
-    context '#add' do
-      it 'should add a value' do
-        subject.add('value1')
-        expect(subject.collection).to be_include('value1')
-      end
-    end
-
-    context '#reset' do
-      it 'should reset collector' do
-        subject.reset
-        expect(subject.collection).to be_empty
-      end
-    end
-
-    context '#notifications_present?' do
-      it 'should be true if collection is not empty' do
-        expect(subject).to be_notifications_present
-      end
-
-      it 'should be false if collection is empty' do
-        subject.reset
-        expect(subject).not_to be_notifications_present
-      end
-    end
-  end
-end

data/spec/bullet/rack_spec.rb

@@ -1,296 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  describe Rack do
-    let(:middleware) { Bullet::Rack.new app }
-    let(:app) { Support::AppDouble.new }
-
-    context '#html_request?' do
-      it 'should be true if Content-Type is text/html and http body contains html tag' do
-        headers = { 'Content-Type' => 'text/html' }
-        response = double(body: '<html><head></head><body></body></html>')
-        expect(middleware).to be_html_request(headers, response)
-      end
-
-      it 'should be true if Content-Type is text/html and http body contains html tag with attributes' do
-        headers = { 'Content-Type' => 'text/html' }
-        response = double(body: "<html attr='hello'><head></head><body></body></html>")
-        expect(middleware).to be_html_request(headers, response)
-      end
-
-      it 'should be false if there is no Content-Type header' do
-        headers = {}
-        response = double(body: '<html><head></head><body></body></html>')
-        expect(middleware).not_to be_html_request(headers, response)
-      end
-
-      it 'should be false if Content-Type is javascript' do
-        headers = { 'Content-Type' => 'text/javascript' }
-        response = double(body: '<html><head></head><body></body></html>')
-        expect(middleware).not_to be_html_request(headers, response)
-      end
-    end
-
-    context 'empty?' do
-      it 'should be false if response is a string and not empty' do
-        response = double(body: '<html><head></head><body></body></html>')
-        expect(middleware).not_to be_empty(response)
-      end
-
-      it 'should be false if response is not found' do
-        response = ['Not Found']
-        expect(middleware).not_to be_empty(response)
-      end
-
-      it 'should be true if response body is empty' do
-        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
-      context 'when Bullet is enabled' do
-        it 'should return original response body' do
-          expected_response = Support::ResponseDouble.new 'Actual body'
-          app.response = expected_response
-          _, _, response = middleware.call({})
-          expect(response).to eq(expected_response)
-        end
-
-        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)
-          _, 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 set the right Content-Length if response body contains accents' do
-          response = Support::ResponseDouble.new
-          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')
-        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
-          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
-        before(:each) { allow(Bullet).to receive(:enable?).and_return(false) }
-
-        it 'should not call Bullet.start_request' do
-          expect(Bullet).not_to receive(:start_request)
-          middleware.call({})
-        end
-      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>' }
-
-      context 'when `response` responds to `body`' do
-        before { allow(response).to receive(:body).and_return(body) }
-
-        context 'when `body` returns an Array' do
-          let(:body) { [body_string, 'random string'] }
-          it 'should return the plain body string' do
-            expect(middleware.response_body(response)).to eq body_string
-          end
-        end
-
-        context 'when `body` does not return an Array' do
-          let(:body) { body_string }
-          it 'should return the plain body string' do
-            expect(middleware.response_body(response)).to eq body_string
-          end
-        end
-      end
-
-      context 'when `response` does not respond to `body`' do
-        before { allow(response).to receive(:first).and_return(body_string) }
-
-        it 'should return the plain body string' do
-          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/registry/association_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Registry
-    describe Association do
-      subject { Association.new.tap { |association| association.add(%w[key1 key2], 'value') } }
-
-      context '#merge' do
-        it 'should merge key/value' do
-          subject.merge('key0', 'value0')
-          expect(subject['key0']).to be_include('value0')
-        end
-      end
-
-      context '#similarly_associated' do
-        it 'should return similarly associated keys' do
-          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(%w[value]))).to be_empty
-        end
-      end
-    end
-  end
-end

data/spec/bullet/registry/base_spec.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Registry
-    describe Base do
-      subject { Base.new.tap { |base| base.add('key', 'value') } }
-
-      context '#[]' do
-        it 'should get value by key' do
-          expect(subject['key']).to eq(Set.new(%w[value]))
-        end
-      end
-
-      context '#delete' do
-        it 'should delete key' do
-          subject.delete('key')
-          expect(subject['key']).to be_nil
-        end
-      end
-
-      context '#add' do
-        it 'should add value with string' do
-          subject.add('key', 'new_value')
-          expect(subject['key']).to eq(Set.new(%w[value new_value]))
-        end
-
-        it 'should add value with array' do
-          subject.add('key', %w[value1 value2])
-          expect(subject['key']).to eq(Set.new(%w[value value1 value2]))
-        end
-      end
-
-      context '#include?' do
-        it 'should include key/value' do
-          expect(subject.include?('key', 'value')).to eq true
-        end
-
-        it 'should not include wrong key/value' do
-          expect(subject.include?('key', 'val')).to eq false
-        end
-      end
-    end
-  end
-end

data/spec/bullet/registry/object_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Registry
-    describe Object do
-      let(:post) { Post.first }
-      let(:another_post) { Post.last }
-      subject { Object.new.tap { |object| object.add(post.bullet_key) } }
-
-      context '#include?' do
-        it 'should include the object' do
-          expect(subject).to be_include(post.bullet_key)
-        end
-      end
-
-      context '#add' do
-        it 'should add an object' do
-          subject.add(another_post.bullet_key)
-          expect(subject).to be_include(another_post.bullet_key)
-        end
-      end
-    end
-  end
-end

data/spec/bullet/stack_trace_filter_spec.rb

@@ -1,26 +0,0 @@
-# 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