bullet 2.2.1 → 2.3.0

data/lib/bullet/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 module Bullet
-  VERSION = "2.2.1"
+  VERSION = "2.3.0"
 end
 

data/perf/benchmark.rb

@@ -83,16 +83,18 @@ PerfTools::CpuProfiler.start(ARGV[0]|| "benchmark_profile") if defined? PerfTool
 
 Benchmark.bm(70) do |bm|
   bm.report("Querying & Iterating #{posts_size} Posts with #{comments_size} Comments and #{users_size} Users") do
-    Bullet.start_request
-    Post.select("SQL_NO_CACHE *").includes(:user, :comments => :user).each do |p|
-      p.title
-      p.user.name
-      p.comments.each do |c|
-        c.body
-        c.user.name
+    10.times do
+      Bullet.start_request
+      Post.select("SQL_NO_CACHE *").includes(:user, :comments => :user).each do |p|
+        p.title
+        p.user.name
+        p.comments.each do |c|
+          c.body
+          c.user.name
+        end
       end
+      Bullet.end_request
     end
-    Bullet.end_request
   end
 end
 
@@ -100,7 +102,23 @@ PerfTools::CpuProfiler.stop if defined? PerfTools
 puts "End benchmarking..."
 
 
-# 2.0.1
-#                                                                             user     system      total        real
-# Querying & Iterating 100 Posts with 10000 Comments and 100 Users        2.290000   0.050000   2.340000 (  2.366174)
-
+# Run benchmark with bundler
+#
+#     bundle exec ruby perf/benchmark.rb
+#
+# bullet 2.3.0 with rails 3.2.2
+#                                                                              user     system      total        real
+# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       16.460000   0.190000  16.650000 ( 16.968246)
+#
+# bullet 2.3.0 with rails 3.1.4
+#                                                                              user     system      total        real
+# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       14.600000   0.130000  14.730000 ( 14.937590)
+#
+# bullet 2.3.0 with rails 3.0.12
+#                                                                              user     system      total        real
+# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       26.120000   0.430000  26.550000 ( 27.179304)
+#
+#
+# bullet 2.2.1 with rails 3.0.12
+#                                                                              user     system      total        real
+# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       29.970000   0.270000  30.240000 ( 30.452083)

data/spec/bullet/detector/association_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe Association do
+      before :all do
+        @post1 = Post.first
+        @post2 = Post.last
+      end
+      before(:each) { Association.clear }
+
+      context ".start_request" do
+        it "should set @@checked to false" do
+          Association.start_request
+          Association.class_variable_get(:@@checked).should be_false
+        end
+      end
+
+      context ".clear" do
+        it "should clear all class variables" do
+          Association.clear
+          Association.class_variable_get(:@@object_associations).should be_nil
+          Association.class_variable_get(:@@possible_objects).should be_nil
+          Association.class_variable_get(:@@impossible_objects).should be_nil
+          Association.class_variable_get(:@@call_object_associations).should be_nil
+          Association.class_variable_get(:@@eager_loadings).should be_nil
+        end
+      end
+
+      context ".add_object_association" do
+        it "should add object, associations pair" do
+          Association.add_object_associations(@post1, :associations)
+          Association.send(:object_associations).should be_include(@post1.ar_key, :associations)
+        end
+      end
+
+      context ".add_call_object_associations" do
+        it "should add call object, associations pair" do
+          Association.add_call_object_associations(@post1, :associations)
+          Association.send(:call_object_associations).should be_include(@post1.ar_key, :associations)
+        end
+      end
+
+      context ".add_possible_objects" do
+        it "should add possible objects" do
+          Association.add_possible_objects([@post1, @post2])
+          Association.send(:possible_objects).should be_include(@post1.ar_key)
+          Association.send(:possible_objects).should be_include(@post2.ar_key)
+        end
+      end
+
+      context ".add_impossible_object" do
+        it "should add impossible object" do
+          Association.add_impossible_object(@post1)
+          Association.send(:impossible_objects).should be_include(@post1.ar_key)
+        end
+      end
+
+      context ".add_eager_loadings" do
+        it "should add objects, associations pair when eager_loadings are empty" do
+          Association.add_eager_loadings([@post1, @post2], :associations)
+          Association.send(:eager_loadings).should be_include([@post1.ar_key, @post2.ar_key], :associations)
+        end
+
+        it "should add objects, associations pair for existing eager_loadings" do
+          Association.add_eager_loadings([@post1, @post2], :association1)
+          Association.add_eager_loadings([@post1, @post2], :association2)
+          Association.send(:eager_loadings).should be_include([@post1.ar_key, @post2.ar_key], :association1)
+          Association.send(:eager_loadings).should be_include([@post1.ar_key, @post2.ar_key], :association2)
+        end
+
+        it "should merge objects, associations pair for existing eager_loadings" do
+          Association.add_eager_loadings(@post1, :association1)
+          Association.add_eager_loadings([@post1, @post2], :association2)
+          Association.send(:eager_loadings).should be_include([@post1.ar_key], :association1)
+          Association.send(:eager_loadings).should be_include([@post1.ar_key], :association2)
+          Association.send(:eager_loadings).should be_include([@post1.ar_key, @post2.ar_key], :association2)
+        end
+
+        it "should delete objects, associations pair for existing eager_loadings" do
+          Association.add_eager_loadings([@post1, @post2], :association1)
+          Association.add_eager_loadings(@post1, :association2)
+          Association.send(:eager_loadings).should be_include([@post1.ar_key], :association1)
+          Association.send(:eager_loadings).should be_include([@post1.ar_key], :association2)
+          Association.send(:eager_loadings).should be_include([@post2.ar_key], :association1)
+        end
+      end
+    end
+  end
+end

data/spec/bullet/detector/base_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe Base do
+      context ".end_request" do
+        it "should call clear" do
+          Base.should_receive(:clear)
+          Base.end_request
+        end
+      end
+    end
+  end
+end

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