bullet 5.6.0 → 5.7.0

data/spec/bullet/notification/base_spec.rb

@@ -5,41 +5,41 @@ module Bullet
     describe Base do
       subject { Base.new(Post, [: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")
+        it 'should leverage ENV parameter' do
+          temp_env_variable('USER', 'bogus') do
+            expect(subject.whoami).to eq('user: bogus')
           end
         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,29 +50,28 @@ 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)
@@ -81,8 +80,8 @@ module Bullet
         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)

data/spec/bullet/notification/counter_cache_spec.rb

@@ -5,8 +5,8 @@ module Bullet
     describe CounterCache do
       subject { CounterCache.new(Post, [: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

@@ -3,12 +3,12 @@ require 'spec_helper'
 module Bullet
   module Notification
     describe NPlusOneQuery do
-      subject { NPlusOneQuery.new([["caller1", "caller2"]], Post, [:comments, :votes], "path") }
+      subject { NPlusOneQuery.new([['caller1', 'caller2']], Post, [: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_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 { expect(subject.title).to eq('USE eager loading in path') }
     end
   end
 end

data/spec/bullet/notification/unused_eager_loading_spec.rb

@@ -3,10 +3,10 @@ require 'spec_helper'
 module Bullet
   module Notification
     describe UnusedEagerLoading do
-      subject { UnusedEagerLoading.new([""], Post, [:comments, :votes], "path") }
+      subject { UnusedEagerLoading.new([''], Post, [: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 { expect(subject.title).to eq('AVOID eager loading in path') }
     end
   end
 end

data/spec/bullet/notification_collector_spec.rb

@@ -2,28 +2,28 @@ require 'spec_helper'
 
 module Bullet
   describe NotificationCollector do
-    subject { NotificationCollector.new.tap { |collector| collector.add("value") } }
+    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")
+    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
+    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
+    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
+      it 'should be false if collection is empty' do
         subject.reset
         expect(subject).not_to be_notifications_present
       end

data/spec/bullet/rack_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+
 require 'spec_helper'
 
 module Bullet
@@ -6,120 +6,120 @@ module Bullet
     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>")
+    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"}
+      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
+      it 'should be false if there is no Content-Type header' do
         headers = {}
-        response = double(:body => "<html><head></head><body></body></html>")
+        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>")
+      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
 
       it "should be false if response body doesn't contain html tag" do
-        headers = {"Content-Type" => "text/html"}
-        response = double(:body => "<div>Partial</div>")
+        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
-      it "should be false if response is a string and not empty" do
-        response = double(:body => "<html><head></head><body></body></html>")
+    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 true if response is not found" do
-        response = ["Not Found"]
+      it 'should be true if response is not found' do
+        response = ['Not Found']
         expect(middleware).to be_empty(response)
       end
 
-      it "should be true if response body is empty" do
-        response = double(:body => "")
+      it 'should be true if response body is empty' do
+        response = double(:body => '')
         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"
+    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
+        it 'should change response body if notification is active' do
           expect(Bullet).to receive(:notification?).and_return(true)
-          expect(Bullet).to receive(:gather_inline_notifications).and_return("<bullet></bullet>")
+          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"})
-          expect(headers["Content-Length"]).to eq("56")
-          expect(response).to eq(["<html><head></head><body><bullet></bullet></body></html>"])
+          status, 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>'])
         end
 
-        it "should set the right Content-Length if response body contains accents" do
+        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>"
+          response.body = '<html><head></head><body>é</body></html>'
           app.response = response
           expect(Bullet).to receive(:notification?).and_return(true)
-          expect(Bullet).to receive(:gather_inline_notifications).and_return("<bullet></bullet>")
-          status, headers, response = middleware.call({"Content-Type" => "text/html"})
-          expect(headers["Content-Length"]).to eq("58")
+          expect(Bullet).to receive(:gather_inline_notifications).and_return('<bullet></bullet>')
+          status, headers, response = middleware.call({ 'Content-Type' => 'text/html' })
+          expect(headers['Content-Length']).to eq('58')
         end
       end
 
-      context "when Bullet is disabled" do
+      context 'when Bullet is disabled' do
         before(:each) { allow(Bullet).to receive(:enable?).and_return(false) }
 
-        it "should not call Bullet.start_request" do
+        it 'should not call Bullet.start_request' do
           expect(Bullet).not_to receive(:start_request)
           middleware.call({})
         end
       end
     end
 
-    describe "#response_body" do
+    describe '#response_body' do
       let(:response) { double }
-      let(:body_string) { "<html><body>My Body</body></html>" }
+      let(:body_string) { '<html><body>My Body</body></html>' }
 
-      context "when `response` responds to `body`" do
+      context 'when `response` responds to `body`' do
         before { allow(response).to receive(:body).and_return(body) }
 
-        context "when `body` returns an Array" do
+        context 'when `body` returns an Array' do
           let(:body) { [body_string, 'random string'] }
-          it "should return the plain body string" do
+          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
+        context 'when `body` does not return an Array' do
           let(:body) { body_string }
-          it "should return the plain body string" do
+          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
+      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
+        it 'should return the plain body string' do
           expect(middleware.response_body(response)).to eq body_string
         end
       end

data/spec/bullet/registry/association_spec.rb

@@ -3,22 +3,22 @@ require 'spec_helper'
 module Bullet
   module Registry
     describe Association do
-      subject { Association.new.tap { |association| association.add(["key1", "key2"], "value") } }
+      subject { Association.new.tap { |association| association.add(['key1', 'key2'], 'value') } }
 
-      context "#merge" do
-        it "should merge key/value" do
-          subject.merge("key0", "value0")
-          expect(subject["key0"]).to be_include("value0")
+      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(["value"]))).to eq(["key1", "key2"])
+      context '#similarly_associated' do
+        it 'should return similarly associated keys' do
+          expect(subject.similarly_associated('key1', Set.new(['value']))).to eq(['key1', 'key2'])
         end
 
-        it "should return empty if key does not exist" do
-          expect(subject.similarly_associated("key3", Set.new(["value"]))).to be_empty
+        it 'should return empty if key does not exist' do
+          expect(subject.similarly_associated('key3', Set.new(['value']))).to be_empty
         end
       end
     end

data/spec/bullet/registry/base_spec.rb

@@ -3,40 +3,40 @@ require 'spec_helper'
 module Bullet
   module Registry
     describe Base do
-      subject { Base.new.tap { |base| base.add("key", "value") } }
+      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(["value"]))
+      context '#[]' do
+        it 'should get value by key' do
+          expect(subject['key']).to eq(Set.new(['value']))
         end
       end
 
-      context "#delete" do
-        it "should delete key" do
-          subject.delete("key")
-          expect(subject["key"]).to be_nil
+      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(["value", "new_value"]))
+      context '#add' do
+        it 'should add value with string' do
+          subject.add('key', 'new_value')
+          expect(subject['key']).to eq(Set.new(['value', 'new_value']))
         end
 
-        it "should add value with array" do
-          subject.add("key", ["value1", "value2"])
-          expect(subject["key"]).to eq(Set.new(["value", "value1", "value2"]))
+        it 'should add value with array' do
+          subject.add('key', ['value1', 'value2'])
+          expect(subject['key']).to eq(Set.new(['value', 'value1', 'value2']))
         end
       end
 
-      context "#include?" do
-        it "should include key/value" do
-          expect(subject.include?("key", "value")).to eq true
+      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
+        it 'should not include wrong key/value' do
+          expect(subject.include?('key', 'val')).to eq false
         end
       end
     end

data/spec/bullet/registry/object_spec.rb

@@ -7,14 +7,14 @@ module Bullet
       let(:another_post) { Post.last }
       subject { Object.new.tap { |object| object.add(post.bullet_key) } }
 
-      context "#include?" do
-        it "should include the object" do
+      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
+      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

data/spec/bullet_spec.rb

@@ -4,7 +4,6 @@ describe Bullet, focused: true do
   subject { Bullet }
 
   describe '#enable' do
-
     context 'enable Bullet' do
       before do
         # Bullet.enable
@@ -95,6 +94,26 @@ describe Bullet, focused: true do
     end
   end
 
+  describe '#delete_whitelist' 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({})
+      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
+      end
+    end
+  end
+
   describe '#perform_out_of_channel_notifications' do
     let(:notification) { double }