mongoid 6.4.1 → 6.4.8

data/spec/mongoid/persistable/incrementable_spec.rb

@@ -66,15 +66,15 @@ describe Mongoid::Persistable::Incrementable do
       context "when providing big decimal values" do
 
         let(:five) do
-          BigDecimal.new("5.0")
+          BigDecimal("5.0")
         end
 
         let(:neg_ten) do
-          BigDecimal.new("-10.0")
+          BigDecimal("-10.0")
         end
 
         let(:thirty) do
-          BigDecimal.new("30.0")
+          BigDecimal("30.0")
         end
 
         let!(:inc) do
@@ -151,15 +151,15 @@ describe Mongoid::Persistable::Incrementable do
       context "when providing big decimal values" do
 
         let(:five) do
-          BigDecimal.new("5.0")
+          BigDecimal("5.0")
         end
 
         let(:neg_ten) do
-          BigDecimal.new("-10.0")
+          BigDecimal("-10.0")
         end
 
         let(:thirty) do
-          BigDecimal.new("30.0")
+          BigDecimal("30.0")
         end
 
         let!(:inc) do

data/spec/mongoid/persistable/settable_spec.rb

@@ -315,6 +315,25 @@ describe Mongoid::Persistable::Settable do
         end
       end
 
+      context 'when a leaf value in the nested hash is updated to a number' do
+
+        let(:church) do
+          Church.new.tap do |a|
+            a.location = {'address' => {'city' => 'Berlin', 'street' => 'Yorckstr'}}
+            a.name = 'Church1'
+            a.save
+          end
+        end
+
+        before do
+          church.set('location.address.city' => 12345)
+        end
+
+        it 'updates the nested value to the correct value' do
+          expect(church.name).to eq('Church1')
+          expect(church.location).to eql({'address' => {'city' => 12345, 'street' => 'Yorckstr'}})
+        end
+      end
 
       context 'when the nested hash is many levels deep' do
 

data/spec/mongoid/query_cache_spec.rb

@@ -7,6 +7,20 @@ describe Mongoid::QueryCache do
     Mongoid::QueryCache.cache { spec.run }
   end
 
+  before(:all) do
+    # It is likely that there are other session leaks in the driver
+    # and/or Mongoid that are unrelated to the query cache. Clear the
+    # SessionRegistry at the start of these tests in order to detect leaks that
+    # occur only within the scope of these tests.
+    #
+    # Other session leaks will be detected and addressed as part of RUBY-2391.
+    SessionRegistry.instance.clear_registry
+  end
+
+  after do
+    SessionRegistry.instance.verify_sessions_ended!
+  end
+
   context 'when iterating over objects sharing the same base' do
 
     let(:server) do
@@ -38,9 +52,10 @@ describe Mongoid::QueryCache do
         end
 
         it 'queries for each access to the base' do
-          expect(server).to receive(:with_connection).exactly(relations.size).times.and_call_original
-          relations.each do |object|
-            object.person
+          expect_query(relations.size) do
+            relations.each do |object|
+              object.person
+            end
           end
         end
       end
@@ -52,9 +67,10 @@ describe Mongoid::QueryCache do
         end
 
         it 'queries only once for the base' do
-          expect(server).to receive(:with_connection).exactly(1).times.and_call_original
-          relations.each do |object|
-            object.person
+          expect_query(1) do
+            relations.each do |object|
+              object.person
+            end
           end
         end
       end
@@ -205,6 +221,10 @@ describe Mongoid::QueryCache do
         end
 
         before do
+          10.times do |i|
+            game.ratings << Rating.create!(value: i+1)
+          end
+
           game.ratings.where(:value.gt => 5).asc(:id).all.to_a
         end
 
@@ -212,7 +232,9 @@ describe Mongoid::QueryCache do
 
           it "uses the cache" do
             expect_no_queries do
-              game.ratings.where(:value.gt => 5).limit(2).asc(:id).to_a
+              result = game.ratings.where(:value.gt => 5).limit(2).asc(:id).to_a
+              expect(result.length).to eq(2)
+              expect(result.map { |r| r['value'] }).to eq([6, 7])
             end
           end
         end
@@ -225,14 +247,23 @@ describe Mongoid::QueryCache do
         end
 
         before do
+          10.times do |i|
+            game.ratings << Rating.create!(value: i+1)
+          end
+
           game.ratings.where(:value.gt => 5).limit(3).asc(:id).all.to_a
         end
 
         context "when the next query has a limit" do
+          # Server versions older than 3.2 also perform a killCursors operation,
+          # which causes this test to fail.
+          min_server_version '3.2'
 
           it "queries again" do
             expect_query(1) do
-              game.ratings.where(:value.gt => 5).limit(2).asc(:id).to_a
+              result = game.ratings.where(:value.gt => 5).limit(2).asc(:id).to_a
+              expect(result.length).to eq(2)
+              expect(result.map { |r| r['value'] }).to eq([6, 7])
             end
           end
         end
@@ -241,7 +272,9 @@ describe Mongoid::QueryCache do
 
           it "queries again" do
             expect_query(1) do
-              game.ratings.where(:value.gt => 5).asc(:id).to_a
+              result = game.ratings.where(:value.gt => 5).asc(:id).to_a
+              expect(result.length).to eq(5)
+              expect(result.map { |r| r['value'] }).to eq([6, 7, 8, 9, 10])
             end
           end
         end
@@ -254,21 +287,34 @@ describe Mongoid::QueryCache do
         end
 
         before do
+          10.times do |i|
+            game.ratings << Rating.create!(value: i+1)
+          end
+
           game.ratings.where(:value.gt => 5).asc(:id).all.to_a
         end
 
         it "does not query again" do
           expect_no_queries do
-            game.ratings.where(:value.gt => 5).asc(:id).first
+            result = game.ratings.where(:value.gt => 5).asc(:id).first
+            expect(result['value']).to eq(6)
           end
         end
       end
 
       context "when limiting the result" do
+        before do
+          Band.destroy_all
+
+          5.times { |i| Band.create!(name: "Band #{i}") }
+          Band.all.to_a
+        end
 
         it "does not query again" do
           expect_query(0) do
-            Band.limit(2).all.to_a
+            result = Band.limit(2).all.to_a
+            expect(result.length).to eq(2)
+            expect(result.map { |r| r["name"] }).to eq(["Band 0", "Band 1"])
           end
         end
       end
@@ -276,12 +322,16 @@ describe Mongoid::QueryCache do
       context "when specifying a different skip value" do
 
         before do
-          Band.limit(2).skip(1).all.to_a
+          Band.destroy_all
+
+          5.times { |i| Band.create!(name: "Band #{i}") }
         end
 
         it "queries again" do
           expect_query(1) do
-            Band.limit(2).skip(3).all.to_a
+            result = Band.limit(2).skip(3).all.to_a
+            expect(result.length).to eq(2)
+            expect(result.map { |r| r["name"] }).to eq(["Band 3", "Band 4"])
           end
         end
       end
@@ -317,6 +367,25 @@ describe Mongoid::QueryCache do
       end
     end
 
+    context 'when querying colleciton larger than the batch size' do
+      before do
+        Band.destroy_all
+        101.times { |i| Band.create!(_id: i) }
+      end
+
+      it 'does not raise an exception when querying multiple times' do
+        expect do
+          results1 = Band.all.to_a
+          expect(results1.length).to eq(101)
+          expect(results1.map { |band| band["_id"] }).to eq([*0..100])
+
+          results2 = Band.all.to_a
+          expect(results2.length).to eq(101)
+          expect(results2.map { |band| band["_id"] }).to eq([*0..100])
+        end.not_to raise_error
+      end
+    end
+
     context "when query caching is enabled and the batch_size is set" do
 
       around(:each) do |example|
@@ -428,15 +497,15 @@ describe Mongoid::QueryCache do
   context "when querying a very large collection" do
 
     before do
-      123.times { Band.create! }
+      100.times { Band.create! }
     end
 
     it "returns the right number of records" do
-      expect(Band.all.to_a.length).to eq(123)
+      expect(Band.all.to_a.length).to eq(100)
     end
 
     it "#pluck returns the same count of objects" do
-      expect(Band.pluck(:name).length).to eq(123)
+      expect(Band.pluck(:name).length).to eq(100)
     end
 
     context "when loading all the documents" do
@@ -447,12 +516,12 @@ describe Mongoid::QueryCache do
 
       it "caches the complete result of the query" do
         expect_no_queries do
-          expect(Band.all.to_a.length).to eq(123)
+          expect(Band.all.to_a.length).to eq(100)
         end
       end
 
       it "returns the same count of objects when using #pluck" do
-        expect(Band.pluck(:name).length).to eq(123)
+        expect(Band.pluck(:name).length).to eq(100)
       end
     end
   end

data/spec/mongoid/scopable_spec.rb

@@ -1130,6 +1130,19 @@ describe Mongoid::Scopable do
     it "sets the threading options" do
       Band.without_default_scope do
         expect(Mongoid::Threaded).to be_executing(:without_default_scope)
+        expect(Mongoid::Threaded.without_default_scope?(Band)).to be(true)
+      end
+    end
+
+    it "suppresses default scope on the given model within the given block" do
+      Appointment.without_default_scope do
+        expect(Appointment.all.selector).to be_empty
+      end
+    end
+
+    it "does not affect other models' default scopes within the given block" do
+      Appointment.without_default_scope do
+        expect(Audio.all.selector).not_to be_empty
       end
     end
   end

data/spec/mongoid/threaded_spec.rb

@@ -233,4 +233,72 @@ describe Mongoid::Threaded do
       end
     end
   end
+
+  describe "#begin_without_default_scope" do
+
+    let(:klass) do
+      Appointment
+    end
+
+    after do
+      described_class.exit_without_default_scope(klass)
+    end
+
+    it "adds the given class to the without_default_scope stack" do
+      described_class.begin_without_default_scope(klass)
+
+      expect(described_class.stack(:without_default_scope)).to include(klass)
+    end
+  end
+
+  describe "#exit_without_default_scope" do
+
+    let(:klass) do
+      Appointment
+    end
+
+    before do
+      described_class.begin_without_default_scope(klass)
+    end
+
+    it "removes the given class from the without_default_scope stack" do
+      described_class.exit_without_default_scope(klass)
+
+      expect(described_class.stack(:without_default_scope)).not_to include(klass)
+    end
+  end
+
+  describe "#without_default_scope?" do
+
+    let(:klass) do
+      Appointment
+    end
+
+    context "when klass has begun without_default_scope" do
+
+      before do
+        described_class.begin_without_default_scope(klass)
+      end
+
+      after do
+        described_class.exit_without_default_scope(klass)
+      end
+
+      it "returns true" do
+        expect(described_class.without_default_scope?(klass)).to be(true)
+      end
+    end
+
+    context "when klass has exited without_default_scope" do
+
+      before do
+        described_class.begin_without_default_scope(klass)
+        described_class.exit_without_default_scope(klass)
+      end
+
+      it "returns false" do
+        expect(described_class.without_default_scope?(klass)).to be(false)
+      end
+    end
+  end
 end

data/spec/rails/controller_extension/controller_runtime_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+require "mongoid/railties/controller_runtime"
+
+describe "Mongoid::Railties::ControllerRuntime" do
+  controller_runtime = Mongoid::Railties::ControllerRuntime
+  collector = controller_runtime::Collector
+
+  def set_metric value
+    Thread.current["Mongoid.controller_runtime"] = value
+  end
+
+  def clear_metric!
+    set_metric 0
+  end
+
+  describe "Collector" do
+
+    it "stores the metric in thread-safe manner" do
+      clear_metric!
+      expect(collector.runtime).to eq(0)
+      set_metric 42
+      expect(collector.runtime).to eq(42)
+    end
+
+    it "sets metric on both succeeded and failed" do
+      instance = collector.new
+      event_payload = OpenStruct.new duration: 42
+
+      clear_metric!
+      instance.succeeded event_payload
+      expect(collector.runtime).to eq(42)
+
+      clear_metric!
+      instance.failed event_payload
+      expect(collector.runtime).to eq(42)
+    end
+
+    it "resets the metric and returns the value" do
+      clear_metric!
+      expect(collector.reset_runtime).to eq(0)
+      set_metric 42
+      expect(collector.reset_runtime).to eq(42)
+      expect(collector.runtime).to eq(0)
+    end
+
+  end
+
+  reference_controller_class = Class.new do
+    def process_action *_
+      @process_action = true
+    end
+
+    def cleanup_view_runtime *_
+      @cleanup_view_runtime.call
+    end
+
+    def append_info_to_payload *_
+      @append_info_to_payload = true
+    end
+
+    def self.log_process_action *_
+      @log_process_action.call
+    end
+  end
+
+  controller_class = Class.new reference_controller_class do
+    include controller_runtime::ControllerExtension
+  end
+
+  let(:controller){ controller_class.new }
+
+  it "resets the metric before each action" do
+    set_metric 42
+    controller.send(:process_action, 'foo')
+    expect(collector.runtime).to be(0)
+    expect(controller.instance_variable_get "@process_action").to be(true)
+  end
+
+  it "strips the metric of other sources of the runtime" do
+    set_metric 1
+    controller.instance_variable_set "@cleanup_view_runtime", ->{
+      controller.instance_variable_set "@cleanup_view_runtime", true
+      set_metric 13
+      42
+    }
+    returned = controller.send :cleanup_view_runtime
+    expect(controller.instance_variable_get "@cleanup_view_runtime").to be(true)
+    expect(controller.mongoid_runtime).to eq(14)
+    expect(returned).to be(29)
+  end
+
+  it "appends the metric to payload" do
+    payload = {}
+    set_metric 42
+    controller.send :append_info_to_payload, payload
+    expect(controller.instance_variable_get "@append_info_to_payload").to be(true)
+    expect(payload[:mongoid_runtime]).to eq(42)
+  end
+
+  it "adds metric to log message" do
+    controller_class.instance_variable_set "@log_process_action", ->{
+      controller_class.instance_variable_set "@log_process_action", true
+      []
+    }
+    messages = controller_class.log_process_action mongoid_runtime: 42.101
+    expect(controller_class.instance_variable_get "@log_process_action").to be(true)
+    expect(messages).to eq(["MongoDB: 42.1ms"])
+  end
+
+end