bullet 4.0.0 → 4.13.1

data/spec/bullet/ext/object_spec.rb

@@ -1,20 +1,31 @@
 require 'spec_helper'
 
 describe Object do
-  context "bullet_ar_key" do
+  context "bullet_key" do
     it "should return class and id composition" do
       post = Post.first
-      post.bullet_ar_key.should == "Post:#{post.id}"
+      expect(post.bullet_key).to eq("Post:#{post.id}")
     end
 
-    begin
-      require 'mongoid'
-
+    if mongoid?
       it "should return class with namesapce and id composition" do
         post = Mongoid::Post.first
-        post.bullet_ar_key.should == "Mongoid::Post:#{post.id}"
+        expect(post.bullet_key).to eq("Mongoid::Post:#{post.id}")
       end
-    rescue LoadError
+    end
+  end
+
+  context "primary_key_value" do
+    it "should return id" do
+      post = Post.first
+      expect(post.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)
+      Post.primary_key = 'id'
     end
   end
 end

data/spec/bullet/ext/string_spec.rb

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

data/spec/bullet/notification/base_spec.rb

@@ -7,58 +7,111 @@ module Bullet
 
       context "#title" do
         it "should raise NoMethodError" do
-          lambda { subject.title }.should raise_error(NoMethodError)
+          expect { subject.title }.to raise_error(NoMethodError)
         end
       end
 
       context "#body" do
         it "should raise NoMethodError" do
-          lambda { subject.body }.should raise_error(NoMethodError)
+          expect { subject.body }.to raise_error(NoMethodError)
         end
       end
 
       context "#whoami" do
         it "should display user name" do
           user = `whoami`.chomp
-          subject.whoami.should == "user: #{user}"
+          expect(subject.whoami).to eq("user: #{user}")
         end
+
+        it "should leverage ENV parameter" do
+          temp_env_variable("USER", "bogus") do
+            expect(subject.whoami).to eq("user: bogus")
+          end
+        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
-          subject.stub(:body => "body")
-          subject.body_with_caller.should == "body"
+          allow(subject).to receive(:body).and_return("body")
+          expect(subject.body_with_caller).to eq("body")
         end
       end
 
       context "#standard_notice" do
         it "should return title + body" do
-          subject.stub(:title => "title", :body => "body")
-          subject.standard_notice.should == "title\nbody"
+          allow(subject).to receive(:title).and_return("title")
+          allow(subject).to receive(:body).and_return("body")
+          expect(subject.standard_notice).to eq("title\nbody")
         end
       end
 
       context "#full_notice" do
         it "should return whoami + url + title + body_with_caller" do
-          subject.stub(:whoami => "whoami", :url => "url", :title => "title", :body_with_caller => "body_with_caller")
-          subject.full_notice.should == "whoami\nurl\ntitle\nbody_with_caller"
+          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.full_notice).to eq("whoami\nurl\ntitle\nbody_with_caller")
+        end
+
+        it "should return url + title + body_with_caller" do
+          allow(subject).to receive(:whoami).and_return("")
+          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.full_notice).to eq("url\ntitle\nbody_with_caller")
+        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 = stub
-          subject.stub(:notifier => notifier, :full_notice => "full_notice")
-          notifier.should_receive(:inline_notify).with("full_notice")
+          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 = stub
-          subject.stub(:notifier => notifier, :full_notice => "full_notice")
-          notifier.should_receive(:out_of_channel_notify).with("full_notice")
+          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

data/spec/bullet/notification/counter_cache_spec.rb

@@ -5,8 +5,8 @@ module Bullet
     describe CounterCache do
       subject { CounterCache.new(Post, [:comments, :votes]) }
 
-      its(:body) { should == "  Post => [:comments, :votes]" }
-      its(:title) { should == "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

@@ -5,9 +5,10 @@ module Bullet
     describe NPlusOneQuery do
       subject { NPlusOneQuery.new([["caller1", "caller2"]], Post, [:comments, :votes], "path") }
 
-      its(:body_with_caller) { should == "  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]\nN+1 Query method call stack\n  caller1\n  caller2" }
-      its(:body) { should == "  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]" }
-      its(:title) { should == "N+1 Query in path" }
+      it { expect(subject.body_with_caller).to eq("  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]\nN+1 Query method call stack\n  caller1\n  caller2") }
+      it { expect([ subject.body_with_caller, subject.body_with_caller]).to eq([ "  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]\nN+1 Query method call stack\n  caller1\n  caller2", "  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]\nN+1 Query method call stack\n  caller1\n  caller2" ]) }
+      it { expect(subject.body).to eq("  Post => [:comments, :votes]\n  Add to your finder: :include => [:comments, :votes]") }
+      it { expect(subject.title).to eq("N+1 Query in path") }
     end
   end
 end

data/spec/bullet/notification/unused_eager_loading_spec.rb

@@ -5,8 +5,8 @@ module Bullet
     describe UnusedEagerLoading do
       subject { UnusedEagerLoading.new(Post, [:comments, :votes], "path") }
 
-      its(:body) { should == "  Post => [:comments, :votes]\n  Remove from your finder: :include => [:comments, :votes]" }
-      its(:title) { should == "Unused Eager Loading in path" }
+      it { expect(subject.body).to eq("  Post => [:comments, :votes]\n  Remove from your finder: :include => [:comments, :votes]") }
+      it { expect(subject.title).to eq("Unused Eager Loading in path") }
     end
   end
 end

data/spec/bullet/notification_collector_spec.rb

@@ -7,25 +7,25 @@ module Bullet
     context "#add" do
       it "should add a value" do
         subject.add("value1")
-        subject.collection.should be_include("value1")
+        expect(subject.collection).to be_include("value1")
       end
     end
 
     context "#reset" do
       it "should reset collector" do
         subject.reset
-        subject.collection.should be_empty
+        expect(subject.collection).to be_empty
       end
     end
 
     context "#notifications_present?" do
       it "should be true if collection is not empty" do
-        subject.should be_notifications_present
+        expect(subject).to be_notifications_present
       end
 
       it "should be false if collection is empty" do
         subject.reset
-        subject.should_not be_notifications_present
+        expect(subject).not_to be_notifications_present
       end
     end
   end

data/spec/bullet/rack_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 
 module Bullet
@@ -5,89 +6,89 @@ module Bullet
     let(:middleware) { Bullet::Rack.new app }
     let(:app) { Support::AppDouble.new }
 
-    context "#no_browser_cache" do
-      it "should add no cache meta in http headers" do
-        headers = {}
-        middleware.no_browser_cache(headers)
-        headers["Cache-Control"].should == "no-cache, no-store, max-age=0, must-revalidate"
-        headers["Pragma"].should == "no-cache"
-        headers["Expires"].should == "Wed, 09 Sep 2009 09:09:09 GMT"
-      end
-    end
-
     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 = stub(:body => "<html><head></head><body></body></html>")
-        middleware.should be_html_request(headers, response)
+        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 = stub(:body => "<html><head></head><body></body></html>")
-        middleware.should_not be_html_request(headers, response)
+        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 = stub(:body => "<html><head></head><body></body></html>")
-        middleware.should_not be_html_request(headers, response)
+        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 = stub(:body => "<div>Partial</div>")
-        middleware.should_not be_html_request(headers, response)
+        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 = stub(:body => "<html><head></head><body></body></html>")
-        middleware.should_not be_empty(response)
+        response = double(:body => "<html><head></head><body></body></html>")
+        expect(middleware).not_to be_empty(response)
       end
 
-      it "should be tru if response is not found" do
+      it "should be true if response is not found" do
         response = ["Not Found"]
-        middleware.should be_empty(response)
+        expect(middleware).to be_empty(response)
       end
 
       it "should be true if response body is empty" do
-        response = stub(:body => "")
-        middleware.should be_empty(response)
+        response = double(:body => "")
+        expect(middleware).to be_empty(response)
       end
     end
 
     context "#call" do
       context "when Bullet is enabled" do
-        it "should invoke Bullet.start_request and Bullet.end_request" do
-          Bullet.should_receive(:start_request)
-          Bullet.should_receive(:end_request)
-          middleware.call([])
-        end
-
         it "should return original response body" do
           expected_response = Support::ResponseDouble.new "Actual body"
           app.response = expected_response
-          status, headers, response = middleware.call([])
-          response.should == expected_response
+          _, _, response = middleware.call([])
+          expect(response).to eq(expected_response)
         end
 
         it "should change response body if notification is active" do
-          Bullet.should_receive(:notification?).and_return(true)
-          Bullet.should_receive(:gather_inline_notifications).and_return("<bullet></bullet>")
-          Bullet.should_receive(:perform_out_of_channel_notifications)
+          expect(Bullet).to receive(:notification?).and_return(true).twice
+          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([200, {"Content-Type" => "text/html"}])
+          expect(headers["Content-Length"]).to eq("56")
+          expect(response).to eq(["<html><head></head><body></body></html><bullet></bullet>"])
+        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).twice
+          expect(Bullet).to receive(:gather_inline_notifications).and_return("<bullet></bullet>")
           status, headers, response = middleware.call([200, {"Content-Type" => "text/html"}])
-          headers["Content-Length"].should == "56"
-          response.should == ["<html><head></head><body></body></html><bullet></bullet>"]
+          expect(headers["Content-Length"]).to eq("58")
         end
       end
 
       context "when Bullet is disabled" do
-        before(:each) { Bullet.stub(:enable?, false) }
+        before(:each) { allow(Bullet).to receive(:enable?).and_return(false) }
 
         it "should not call Bullet.start_request" do
-          Bullet.should_not_receive(:start_request)
+          expect(Bullet).not_to receive(:start_request)
           middleware.call([])
         end
       end

data/spec/bullet/registry/association_spec.rb

@@ -8,17 +8,17 @@ module Bullet
       context "#merge" do
         it "should merge key/value" do
           subject.merge("key0", "value0")
-          subject["key0"].should be_include("value0")
+          expect(subject["key0"]).to be_include("value0")
         end
       end
 
       context "#similarly_associated" do
         it "should return similarly associated keys" do
-          subject.similarly_associated("key1", Set.new(["value"])).should == ["key1", "key2"]
+          expect(subject.similarly_associated("key1", Set.new(["value"]))).to eq(["key1", "key2"])
         end
 
         it "should return empty if key does not exist" do
-          subject.similarly_associated("key3", Set.new(["value"])).should be_empty
+          expect(subject.similarly_associated("key3", Set.new(["value"]))).to be_empty
         end
       end
     end

data/spec/bullet/registry/base_spec.rb

@@ -7,36 +7,36 @@ module Bullet
 
       context "#[]" do
         it "should get value by key" do
-          subject["key"].should == Set.new(["value"])
+          expect(subject["key"]).to eq(Set.new(["value"]))
         end
       end
 
       context "#delete" do
         it "should delete key" do
           subject.delete("key")
-          subject["key"].should be_nil
+          expect(subject["key"]).to be_nil
         end
       end
 
       context "#add" do
         it "should add value with string" do
           subject.add("key", "new_value")
-          subject["key"].should == Set.new(["value", "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"])
-          subject["key"].should == Set.new(["value", "value1", "value2"])
+          expect(subject["key"]).to eq(Set.new(["value", "value1", "value2"]))
         end
       end
 
       context "#include?" do
         it "should include key/value" do
-          subject.include?("key", "value").should be_true
+          expect(subject.include?("key", "value")).to eq true
         end
 
         it "should not include wrong key/value" do
-          subject.include?("key", "val").should be_false
+          expect(subject.include?("key", "val")).to eq false
         end
       end
     end

data/spec/bullet/registry/object_spec.rb

@@ -1,23 +1,22 @@
 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_ar_key) } }
+      subject { Object.new.tap { |object| object.add(post.bullet_key) } }
 
       context "#include?" do
         it "should include the object" do
-          subject.should be_include(post.bullet_ar_key)
+          expect(subject).to be_include(post.bullet_key)
         end
       end
 
       context "#add" do
         it "should add an object" do
-          subject.add(another_post.bullet_ar_key)
-          subject.should be_include(another_post.bullet_ar_key)
+          subject.add(another_post.bullet_key)
+          expect(subject).to be_include(another_post.bullet_key)
         end
       end
     end

data/spec/bullet_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Bullet, focused: true do
+  subject { Bullet }
+
+  describe '#enable' do
+
+    context 'enable Bullet' do
+      before do
+        # Bullet.enable
+        # Do nothing. Bullet has already been enabled for the whole test suite.
+      end
+
+      it 'should be enabled' do
+        expect(subject).to be_enable
+      end
+
+      context 'disable Bullet' do
+        before do
+          Bullet.enable = false
+        end
+
+        it 'should be disabled' do
+          expect(subject).to_not be_enable
+        end
+
+        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
+            Bullet.enable = true
+          end
+
+          it 'should be enabled again' do
+            expect(subject).to be_enable
+          end
+        end
+      end
+    end
+  end
+end