bullet 2.2.0 → 2.3.0

data/spec/bullet/detector/counter_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe Counter do
+      before :all do
+        @post1 = Post.first
+        @post2 = Post.last
+      end
+      before(:each) { Counter.clear }
+
+      context ".clear" do
+        it "should clear all class variables" do
+          Counter.clear
+          Counter.class_variable_get(:@@possible_objects).should be_nil
+          Counter.class_variable_get(:@@impossible_objects).should be_nil
+        end
+      end
+
+      context ".add_counter_cache" do
+        it "should create notification if conditions met" do
+          Counter.should_receive(:conditions_met?).with(@post1.ar_key, [:comments]).and_return(true)
+          Counter.should_receive(:create_notification).with("Post", [:comments])
+          Counter.add_counter_cache(@post1, [:comments])
+        end
+
+        it "should not create notification if conditions not met" do
+          Counter.should_receive(:conditions_met?).with(@post1.ar_key, [:comments]).and_return(false)
+          Counter.should_receive(:create_notification).never
+          Counter.add_counter_cache(@post1, [:comments])
+        end
+      end
+
+      context ".add_possible_objects" do
+        it "should add possible objects" do
+          Counter.add_possible_objects([@post1, @post2])
+          Counter.send(:possible_objects).should be_include(@post1.ar_key)
+          Counter.send(:possible_objects).should be_include(@post2.ar_key)
+        end
+
+        it "should add impossible object" do
+          Counter.add_impossible_object(@post1)
+          Counter.send(:impossible_objects).should be_include(@post1.ar_key)
+        end
+      end
+
+      context ".conditions_met?" do
+        it "should be true when object is possible, not impossible" do
+          Counter.add_possible_objects(@post1)
+          Counter.send(:conditions_met?, @post1.ar_key, :associations).should be_true
+        end
+
+        it "should be false when object is not possible" do
+          Counter.send(:conditions_met?, @post1.ar_key, :associations).should be_false
+        end
+
+        it "should be true when object is possible, and impossible" do
+          Counter.add_possible_objects(@post1)
+          Counter.add_impossible_object(@post1)
+          Counter.send(:conditions_met?, @post1.ar_key, :associations).should be_false
+        end
+      end
+    end
+  end
+end

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe NPlusOneQuery do
+      before(:all) { @post = Post.first }
+      before(:each) { NPlusOneQuery.clear }
+
+      context ".call_association" do
+        it "should set @@checked to true" do
+          NPlusOneQuery.call_association(@post, :associations)
+          NPlusOneQuery.class_variable_get(:@@checked).should be_true
+        end
+
+        it "should add call_object_associations" do
+          NPlusOneQuery.should_receive(:add_call_object_associations).with(@post, :associations)
+          NPlusOneQuery.call_association(@post, :associations)
+        end
+      end
+
+      context ".possible?" do
+        it "should be true if possible_objects contain" do
+          NPlusOneQuery.add_possible_objects(@post)
+          NPlusOneQuery.send(:possible?, @post.ar_key).should be_true
+        end
+      end
+
+      context ".impossible?" do
+        it "should be true if impossible_objects contain" do
+          NPlusOneQuery.add_impossible_object(@post)
+          NPlusOneQuery.send(:impossible?, @post.ar_key).should be_true
+        end
+      end
+
+      context ".association?" do
+        it "should be true if object, associations pair is already existed" do
+          NPlusOneQuery.add_object_associations(@post, :association)
+          NPlusOneQuery.send(:association?, @post.ar_key, :association).should be_true
+        end
+
+        it "should be false if object, association pair is not existed" do
+          NPlusOneQuery.add_object_associations(@post, :association1)
+          NPlusOneQuery.send(:association?, @post.ar_key, :associatio2).should be_false
+        end
+      end
+
+      context ".conditions_met?" do
+        it "should be true if object is possible, not impossible and object, associations pair is not already existed" do
+          NPlusOneQuery.stub(:possible?).with(@post.ar_key).and_return(true)
+          NPlusOneQuery.stub(:impossible?).with(@post.ar_key).and_return(false)
+          NPlusOneQuery.stub(:association?).with(@post.ar_key, :associations).and_return(false)
+          NPlusOneQuery.send(:conditions_met?, @post.ar_key, :associations).should be_true
+        end
+
+        it "should be false if object is not possible, not impossible and object, associations pair is not already existed" do
+          NPlusOneQuery.stub(:possible?).with(@post.ar_key).and_return(false)
+          NPlusOneQuery.stub(:impossible?).with(@post.ar_key).and_return(false)
+          NPlusOneQuery.stub(:association?).with(@post.ar_key, :associations).and_return(false)
+          NPlusOneQuery.send(:conditions_met?, @post.ar_key, :associations).should be_false
+        end
+
+        it "should be false if object is possible, but impossible and object, associations pair is not already existed" do
+          NPlusOneQuery.stub(:possible?).with(@post.ar_key).and_return(true)
+          NPlusOneQuery.stub(:impossible?).with(@post.ar_key).and_return(true)
+          NPlusOneQuery.stub(:association?).with(@post.ar_key, :associations).and_return(false)
+          NPlusOneQuery.send(:conditions_met?, @post.ar_key, :associations).should be_false
+        end
+
+        it "should be false if object is possible, not impossible and object, associations pair is already existed" do
+          NPlusOneQuery.stub(:possible?).with(@post.ar_key).and_return(true)
+          NPlusOneQuery.stub(:impossible?).with(@post.ar_key).and_return(false)
+          NPlusOneQuery.stub(:association?).with(@post.ar_key, :associations).and_return(true)
+          NPlusOneQuery.send(:conditions_met?, @post.ar_key, :associations).should be_false
+        end
+      end
+
+      context ".call_association" do
+        it "should create notification if conditions met" do
+          NPlusOneQuery.should_receive(:conditions_met?).with(@post.ar_key, :association).and_return(true)
+          NPlusOneQuery.should_receive(:caller_in_project).and_return(["caller"])
+          NPlusOneQuery.should_receive(:create_notification).with(["caller"], "Post", :association)
+          NPlusOneQuery.call_association(@post, :association)
+        end
+
+        it "should not create notification if conditions not met" do
+          NPlusOneQuery.should_receive(:conditions_met?).with(@post.ar_key, :association).and_return(false)
+          NPlusOneQuery.should_not_receive(:caller_in_project!)
+          NPlusOneQuery.should_not_receive(:create_notification).with("Post", :association)
+          NPlusOneQuery.call_association(@post, :association)
+        end
+      end
+    end
+  end
+end

data/spec/bullet/detector/unused_eager_association_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe UnusedEagerAssociation do
+      before(:all) { @post = Post.first }
+      before(:each) { UnusedEagerAssociation.clear }
+
+      context ".call_associations" do
+        it "should get empty array if eager_loadgins" do
+          UnusedEagerAssociation.send(:call_associations, @post.ar_key, Set.new([:association])).should be_empty
+        end
+
+        it "should get call associations if object and association are both in eager_loadings and call_object_associations" do
+          UnusedEagerAssociation.add_eager_loadings(@post, :association)
+          UnusedEagerAssociation.add_call_object_associations(@post, :association)
+          UnusedEagerAssociation.send(:call_associations, @post.ar_key, Set.new([:association])).should == [:association]
+        end
+
+        it "should not get call associations if not exist in call_object_associations" do
+          UnusedEagerAssociation.add_eager_loadings(@post, :association)
+          UnusedEagerAssociation.send(:call_associations, @post.ar_key, Set.new([:association])).should be_empty
+        end
+      end
+
+      context ".diff_object_association" do
+        it "should return associations not exist in call_association" do
+          UnusedEagerAssociation.send(:diff_object_association, @post.ar_key, Set.new([:association])).should == [:association]
+        end
+
+        it "should return empty if associations exist in call_association" do
+          UnusedEagerAssociation.add_eager_loadings(@post, :association)
+          UnusedEagerAssociation.add_call_object_associations(@post, :association)
+          UnusedEagerAssociation.send(:diff_object_association, @post.ar_key, Set.new([:association])).should be_empty
+        end
+      end
+
+      context ".check_unused_preload_associations" do
+        it "should set @@checked to true" do
+          UnusedEagerAssociation.check_unused_preload_associations
+          UnusedEagerAssociation.class_variable_get(:@@checked).should be_true
+        end
+
+        it "should create notification if object_association_diff is not empty" do
+          UnusedEagerAssociation.add_object_associations(@post, :association)
+          UnusedEagerAssociation.should_receive(:create_notification).with("Post", [:association])
+          UnusedEagerAssociation.check_unused_preload_associations
+        end
+
+        it "should not create notification if object_association_diff is empty" do
+          UnusedEagerAssociation.clear
+          UnusedEagerAssociation.add_object_associations(@post, :association)
+          UnusedEagerAssociation.add_eager_loadings(@post, :association)
+          UnusedEagerAssociation.add_call_object_associations(@post, :association)
+          UnusedEagerAssociation.send(:diff_object_association, @post.ar_key, Set.new([:association])).should be_empty
+          UnusedEagerAssociation.should_not_receive(:create_notification).with("Post", [:association])
+          UnusedEagerAssociation.check_unused_preload_associations
+        end
+      end
+    end
+  end
+end

data/spec/bullet/notification/base_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Bullet
+  module Notification
+    describe Base do
+      subject { Base.new(Post, [:comments, :votes]) }
+
+      context "#title" do
+        it "should raise NoMethodError" do
+          lambda { subject.title }.should raise_error(NoMethodError)
+        end
+      end
+
+      context "#body" do
+        it "should raise NoMethodError" do
+          lambda { subject.body }.should raise_error(NoMethodError)
+        end
+      end
+
+      context "#whoami" do
+        it "should display user name" do
+          user = `whoami`.chomp
+          subject.whoami.should == "user: #{user}"
+        end
+      end
+
+      context "#body_with_caller" do
+        it "should return body" do
+          subject.stub(:body => "body")
+          subject.body_with_caller.should == "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"
+        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"
+        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")
+          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")
+          subject.notify_out_of_channel
+        end
+      end
+    end
+  end
+end

data/spec/bullet/notification/counter_cache_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module Bullet
+  module Notification
+    describe CounterCache do
+      subject { CounterCache.new(Post, [:comments, :votes]) }
+
+      its(:body) { should == "  Post => [:comments, :votes]" }
+      its(:title) { should == "Need Counter Cache" }
+    end
+  end
+end

data/spec/bullet/notification/n_plus_one_query_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Bullet
+  module Notification
+    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" }
+    end
+  end
+end

data/spec/bullet/notification/unused_eager_loading_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module Bullet
+  module Notification
+    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" }
+    end
+  end
+end

data/spec/bullet/notification_collector_spec.rb

@@ -0,0 +1,32 @@
+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")
+        subject.collection.should be_include("value1")
+      end
+    end
+
+    context "#reset" do
+      it "should reset collector" do
+        subject.reset
+        subject.collection.should be_empty
+      end
+    end
+
+    context "#notifications_present?" do
+      it "should be true if collection is not empty" do
+        subject.should be_notifications_present
+      end
+
+      it "should be false if collection is empty" do
+        subject.reset
+        subject.should_not be_notifications_present
+      end
+    end
+  end
+end

data/spec/bullet/rack_spec.rb

@@ -1,39 +1,95 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
+module Bullet
+  describe Rack do
+    let(:middleware) { Bullet::Rack.new app }
+    let(:app) { Support::AppDouble.new }
 
-describe Bullet::Rack do
-  let(:middleware) { Bullet::Rack.new app }
-  let(:app) { 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)
+      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)
+      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)
+      end
 
-  describe "#call" do
-    context "when Bullet is enabled" do
-      before(:each) { Bullet.enable = true }
+      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)
+      end
+    end
 
-      it "should invoke Bullet.start_request" do
-        Bullet.should_receive(:start_request)
-        middleware.call([])
+    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)
       end
 
-      it "should invoke Bullet.end_request" do
-        Bullet.should_receive(:end_request)
-        middleware.call([])
+      it "should be tru if response is not found" do
+        response = ["Not Found"]
+        middleware.should be_empty(response)
       end
 
-      it "should return original response body" do
-        expected_response = ResponseDouble.new "Actual body"
-        app.response = expected_response
-        status, headers, response = middleware.call([])
-        response.should eq expected_response
+      it "should be true if response body is empty" do
+        response = stub(:body => "")
+        middleware.should be_empty(response)
       end
     end
 
-    context "when Bullet is disabled" do
-      before(:each) { Bullet.enable = false }
-      after(:each) { Bullet.enable = true }
+    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
+        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)
+          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>"]
+        end
+      end
+
+      context "when Bullet is disabled" do
+        before(:each) { Bullet.stub(:enable?, false) }
 
-      it "should not call Bullet.start_request" do
-        Bullet.should_not_receive(:start_request)
-        middleware.call([])
+        it "should not call Bullet.start_request" do
+          Bullet.should_not_receive(:start_request)
+          middleware.call([])
+        end
       end
     end
   end

data/spec/bullet/registry/association_spec.rb

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

data/spec/bullet/registry/base_spec.rb

@@ -0,0 +1,44 @@
+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
+          subject["key"].should == Set.new(["value"])
+        end
+      end
+
+      context "#delete" do
+        it "should delete key" do
+          subject.delete("key")
+          subject["key"].should 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"])
+        end
+
+        it "should add value with array" do
+          subject.add("key", ["value1", "value2"])
+          subject["key"].should == Set.new(["value", "value1", "value2"])
+        end
+      end
+
+      context "#include?" do
+        it "should include key/value" do
+          subject.include?("key", "value").should be_true
+        end
+
+        it "should not include wrong key/value" do
+          subject.include?("key", "val").should be_false
+        end
+      end
+    end
+  end
+end

data/spec/bullet/registry/object_spec.rb

@@ -0,0 +1,25 @@
+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.ar_key) } }
+
+      context "#include?" do
+        it "should include the object" do
+          subject.should be_include(post.ar_key)
+        end
+      end
+
+      context "#add" do
+        it "should add an object" do
+          subject.add(another_post.ar_key)
+          subject.should be_include(another_post.ar_key)
+        end
+      end
+    end
+  end
+end

data/spec/integration/association_for_chris_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+# This test is just used for http://github.com/flyerhzm/bullet/issues/#issue/14
+describe Bullet::Detector::Association do
+  before(:each) do
+    Bullet.clear
+    Bullet.start_request
+  end
+
+  after(:each) do
+    Bullet.end_request
+  end
+
+  describe "for chris" do
+    it "should detect unpreload association from deal to hotel" do
+      Deal.all.each do |deal|
+        deal.hotel.location.name
+      end
+      Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Deal, :hotel)
+    end
+
+    it "should detect unpreload association from hotel to location" do
+      Deal.includes(:hotel).each do |deal|
+        deal.hotel.location.name
+      end
+      Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Hotel, :location)
+    end
+
+    it "should not detect unpreload association" do
+      Deal.includes({:hotel => :location}).each do |deal|
+        deal.hotel.location.name
+      end
+      Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
+      Bullet::Detector::Association.should_not be_has_unused_preload_associations
+    end
+  end
+end

data/spec/integration/association_for_peschkaj_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+# This test is just used for http://github.com/flyerhzm/bullet/issues#issue/20
+describe Bullet::Detector::Association do
+  before(:each) do
+    Bullet.clear
+    Bullet.start_request
+  end
+
+  after(:each) do
+    Bullet.end_request
+  end
+
+  describe "for peschkaj" do
+    it "should not detect unused preload associations" do
+      category = Category.includes({:submissions => :user}).order("id DESC").find_by_name('first')
+      category.submissions.map do |submission|
+        submission.name
+        submission.user.name
+      end
+      Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
+      Bullet::Detector::Association.should_not be_unused_preload_associations_for(Category, :submissions)
+      Bullet::Detector::Association.should_not be_unused_preload_associations_for(Submission, :user)
+    end
+  end
+end