bullet_instructure 4.0.2

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe NPlusOneQuery do
+      before(:all) do
+        @post = Post.first
+        @post2 = Post.last
+      end
+
+      context ".call_association" do
+        it "should add call_object_associations" do
+          expect(NPlusOneQuery).to 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)
+          expect(NPlusOneQuery.send(:possible?, @post.bullet_key)).to eq true
+        end
+      end
+
+      context ".impossible?" do
+        it "should be true if impossible_objects contain" do
+          NPlusOneQuery.add_impossible_object(@post)
+          expect(NPlusOneQuery.send(:impossible?, @post.bullet_key)).to eq true
+        end
+      end
+
+      context ".association?" do
+        it "should be true if object, associations pair is already existed" do
+          NPlusOneQuery.add_object_associations(@post, :association)
+          expect(NPlusOneQuery.send(:association?, @post.bullet_key, :association)).to eq true
+        end
+
+        it "should be false if object, association pair is not existed" do
+          NPlusOneQuery.add_object_associations(@post, :association1)
+          expect(NPlusOneQuery.send(:association?, @post.bullet_key, :associatio2)).to eq 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
+          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq true
+        end
+
+        it "should be false if object is not possible, not impossible and object, associations pair is not already existed" do
+          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq false
+        end
+
+        it "should be false if object is possible, but impossible and object, associations pair is not already existed" do
+          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq false
+        end
+
+        it "should be false if object is possible, not impossible and object, associations pair is already existed" do
+          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(true)
+          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq false
+        end
+      end
+
+      context ".call_association" do
+        it "should create notification if conditions met" do
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:caller_in_project).and_return(["caller"])
+          expect(NPlusOneQuery).to receive(:create_notification).with(["caller"], "Post", :association)
+          NPlusOneQuery.call_association(@post, :association)
+        end
+
+        it "should not create notification if conditions not met" do
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(false)
+          expect(NPlusOneQuery).not_to receive(:caller_in_project!)
+          expect(NPlusOneQuery).not_to receive(:create_notification).with("Post", :association)
+          NPlusOneQuery.call_association(@post, :association)
+        end
+      end
+
+      context ".caller_in_project" do
+        it "should include only paths that are in the project" do
+          in_project = File.join(Dir.pwd, 'abc', 'abc.rb')
+          not_in_project = '/def/def.rb'
+
+          expect(NPlusOneQuery).to receive(:caller).and_return([in_project, not_in_project])
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:create_notification).with([in_project], "Post", :association)
+          NPlusOneQuery.call_association(@post, :association)
+        end
+
+        context "stacktrace_includes" do
+          before { Bullet.stacktrace_includes = [ 'def' ] }
+          after { Bullet.stacktrace_includes = nil }
+
+          it "should include paths that are in the stacktrace_include list" do
+            in_project = File.join(Dir.pwd, 'abc', 'abc.rb')
+            included_gem = '/def/def.rb'
+            excluded_gem = '/ghi/ghi.rb'
+
+            expect(NPlusOneQuery).to receive(:caller).and_return([in_project, included_gem, excluded_gem])
+            expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+            expect(NPlusOneQuery).to receive(:create_notification).with([in_project, included_gem], "Post", :association)
+            NPlusOneQuery.call_association(@post, :association)
+          end
+        end
+      end
+
+      context ".add_possible_objects" do
+        it "should add possible objects" do
+          NPlusOneQuery.add_possible_objects([@post, @post2])
+          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post.bullet_key)
+          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post2.bullet_key)
+        end
+
+        it "should not raise error if object is nil" do
+          expect { NPlusOneQuery.add_possible_objects(nil) }.not_to raise_error
+        end
+      end
+
+      context ".add_impossible_object" do
+        it "should add impossible object" do
+          NPlusOneQuery.add_impossible_object(@post)
+          expect(NPlusOneQuery.send(:impossible_objects)).to be_include(@post.bullet_key)
+        end
+      end
+    end
+  end
+end

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe UnusedEagerLoading do
+      before(:all) do
+        @post = Post.first
+        @post2 = Post.last
+      end
+
+      context ".call_associations" do
+        it "should get empty array if eager_loadings" do
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to be_empty
+        end
+
+        it "should get call associations if object and association are both in eager_loadings and call_object_associations" do
+          UnusedEagerLoading.add_eager_loadings([@post], :association)
+          UnusedEagerLoading.add_call_object_associations(@post, :association)
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to eq([:association])
+        end
+
+        it "should not get call associations if not exist in call_object_associations" do
+          UnusedEagerLoading.add_eager_loadings([@post], :association)
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to be_empty
+        end
+      end
+
+      context ".diff_object_associations" do
+        it "should return associations not exist in call_association" do
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to eq([:association])
+        end
+
+        it "should return empty if associations exist in call_association" do
+          UnusedEagerLoading.add_eager_loadings([@post], :association)
+          UnusedEagerLoading.add_call_object_associations(@post, :association)
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to be_empty
+        end
+      end
+
+      context ".check_unused_preload_associations" do
+        it "should create notification if object_association_diff is not empty" do
+          UnusedEagerLoading.add_object_associations(@post, :association)
+          expect(UnusedEagerLoading).to receive(:create_notification).with("Post", [:association])
+          UnusedEagerLoading.check_unused_preload_associations
+        end
+
+        it "should not create notification if object_association_diff is empty" do
+          UnusedEagerLoading.add_object_associations(@post, :association)
+          UnusedEagerLoading.add_eager_loadings([@post], :association)
+          UnusedEagerLoading.add_call_object_associations(@post, :association)
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to be_empty
+          expect(UnusedEagerLoading).not_to receive(:create_notification).with("Post", [:association])
+          UnusedEagerLoading.check_unused_preload_associations
+        end
+      end
+
+      context ".add_eager_loadings" do
+        it "should add objects, associations pair when eager_loadings are empty" do
+          UnusedEagerLoading.add_eager_loadings([@post, @post2], :associations)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_key], :associations)
+        end
+
+        it "should add objects, associations pair for existing eager_loadings" do
+          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
+          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_key], :association2)
+        end
+
+        it "should merge objects, associations pair for existing eager_loadings" do
+          UnusedEagerLoading.add_eager_loadings([@post], :association1)
+          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_key], :association2)
+        end
+
+        it "should delete objects, associations pair for existing eager_loadings" do
+          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
+          UnusedEagerLoading.add_eager_loadings([@post], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post2.bullet_key], :association1)
+        end
+      end
+    end
+  end
+end

data/spec/bullet/ext/object_spec.rb

@@ -0,0 +1,17 @@
+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 namesapce and id composition" do
+        post = Mongoid::Post.first
+        expect(post.bullet_key).to eq("Mongoid::Post:#{post.id}")
+      end
+    end
+  end
+end

data/spec/bullet/ext/string_spec.rb

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

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+module Bullet
+  module Notification
+    describe Base do
+      subject { Base.new(Post, [: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
+      end
+
+      context "#body_with_caller" do
+        it "should return body" do
+          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
+          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
+          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
+      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

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

data/spec/bullet/notification/n_plus_one_query_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Bullet
+  module Notification
+    describe NPlusOneQuery do
+      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: :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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module Bullet
+  module Notification
+    describe UnusedEagerLoading do
+      subject { UnusedEagerLoading.new(Post, [:comments, :votes], "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

@@ -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")
+        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

@@ -0,0 +1,97 @@
+# encoding: utf-8
+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
+
+      it "should be false if response body doesn't contain html tag" do
+        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>")
+        expect(middleware).not_to be_empty(response)
+      end
+
+      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 => "")
+        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).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"}])
+          expect(headers["Content-Length"]).to eq("58")
+        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
+  end
+end