mongoid 7.1.11 → 7.2.0.rc1

data/spec/mongoid/query_cache_spec.rb

@@ -24,6 +24,210 @@ describe Mongoid::QueryCache do
     SessionRegistry.instance.verify_sessions_ended!
   end
 
+  describe '#cache' do
+    context 'with driver query cache' do
+      min_driver_version '2.14'
+
+      context 'when query cache is not enabled' do
+        before do
+          Mongoid::QueryCache.enabled = false
+        end
+
+        it 'turns on the query cache within the block' do
+          expect(Mongoid::QueryCache.enabled?).to be false
+
+          Mongoid::QueryCache.cache do
+            expect(Mongoid::QueryCache.enabled?).to be true
+          end
+
+          expect(Mongoid::QueryCache.enabled?).to be false
+        end
+      end
+
+      context 'when query cache is enabled' do
+        before do
+          Mongoid::QueryCache.enabled = true
+        end
+
+        it 'keeps the query cache enabled within the block' do
+          expect(Mongoid::QueryCache.enabled?).to be true
+
+          Mongoid::QueryCache.cache do
+            expect(Mongoid::QueryCache.enabled?).to be true
+          end
+
+          expect(Mongoid::QueryCache.enabled?).to be true
+        end
+      end
+
+      context 'nested inside #uncached' do
+        it 'turns on the query cache in the block' do
+          Mongoid::QueryCache.uncached do
+            expect(Mongoid::QueryCache.enabled?).to be false
+
+            Mongoid::QueryCache.cache do
+              expect(Mongoid::QueryCache.enabled?).to be true
+            end
+
+            expect(Mongoid::QueryCache.enabled?).to be false
+          end
+        end
+      end
+    end
+
+    context 'with mongoid query cache' do
+      max_driver_version '2.13'
+
+      context 'when query cache is not enabled' do
+        before do
+          Mongoid::QueryCache.enabled = false
+        end
+
+        it 'turns on the query cache within the block' do
+          expect(Mongoid::QueryCache.enabled?).to be false
+
+          Mongoid::QueryCache.cache do
+            expect(Mongoid::QueryCache.enabled?).to be true
+          end
+
+          expect(Mongoid::QueryCache.enabled?).to be false
+        end
+      end
+
+      context 'when query cache is enabled' do
+        before do
+          Mongoid::QueryCache.enabled = true
+        end
+
+        it 'keeps the query cache enabled within the block' do
+          expect(Mongoid::QueryCache.enabled?).to be true
+
+          Mongoid::QueryCache.cache do
+            expect(Mongoid::QueryCache.enabled?).to be true
+          end
+
+          expect(Mongoid::QueryCache.enabled?).to be true
+        end
+      end
+
+      context 'nested inside #uncached' do
+        it 'turns on the query cache in the block' do
+          Mongoid::QueryCache.uncached do
+            expect(Mongoid::QueryCache.enabled?).to be false
+
+            Mongoid::QueryCache.cache do
+              expect(Mongoid::QueryCache.enabled?).to be true
+            end
+
+            expect(Mongoid::QueryCache.enabled?).to be false
+          end
+        end
+      end
+    end
+  end
+
+  describe '#uncached' do
+    context 'with driver query cache' do
+      min_driver_version '2.14'
+
+      context 'when query cache is not enabled' do
+        before do
+          Mongoid::QueryCache.enabled = false
+        end
+
+        it 'keeps the query cache turned off within the block' do
+          expect(Mongoid::QueryCache.enabled?).to be false
+
+          Mongoid::QueryCache.uncached do
+            expect(Mongoid::QueryCache.enabled?).to be false
+          end
+
+          expect(Mongoid::QueryCache.enabled?).to be false
+        end
+      end
+
+      context 'when query cache is enabled' do
+        before do
+          Mongoid::QueryCache.enabled = true
+        end
+
+        it 'turns off the query cache within the block' do
+          expect(Mongoid::QueryCache.enabled?).to be true
+
+          Mongoid::QueryCache.uncached do
+            expect(Mongoid::QueryCache.enabled?).to be false
+          end
+
+          expect(Mongoid::QueryCache.enabled?).to be true
+        end
+      end
+
+      context 'nested inside #cache' do
+        it 'turns on the query cache in the block' do
+          Mongoid::QueryCache.cache do
+            expect(Mongoid::QueryCache.enabled?).to be true
+
+            Mongoid::QueryCache.uncached do
+              expect(Mongoid::QueryCache.enabled?).to be false
+            end
+
+            expect(Mongoid::QueryCache.enabled?).to be true
+          end
+        end
+      end
+    end
+
+    context 'with mongoid query cache' do
+      max_driver_version '2.13'
+
+      context 'when query cache is not enabled' do
+        before do
+          Mongoid::QueryCache.enabled = false
+        end
+
+        it 'keeps the query cache turned off within the block' do
+          expect(Mongoid::QueryCache.enabled?).to be false
+
+          Mongoid::QueryCache.uncached do
+            expect(Mongoid::QueryCache.enabled?).to be false
+          end
+
+          expect(Mongoid::QueryCache.enabled?).to be false
+        end
+      end
+
+      context 'when query cache is enabled' do
+        before do
+          Mongoid::QueryCache.enabled = true
+        end
+
+        it 'turns off the query cache within the block' do
+          expect(Mongoid::QueryCache.enabled?).to be true
+
+          Mongoid::QueryCache.uncached do
+            expect(Mongoid::QueryCache.enabled?).to be false
+          end
+
+          expect(Mongoid::QueryCache.enabled?).to be true
+        end
+      end
+
+      context 'nested inside #cache' do
+        it 'turns on the query cache in the block' do
+          Mongoid::QueryCache.cache do
+            expect(Mongoid::QueryCache.enabled?).to be true
+
+            Mongoid::QueryCache.uncached do
+              expect(Mongoid::QueryCache.enabled?).to be false
+            end
+
+            expect(Mongoid::QueryCache.enabled?).to be true
+          end
+        end
+      end
+    end
+  end
+
   context 'when iterating over objects sharing the same base' do
 
     let(:server) do
@@ -99,6 +303,111 @@ describe Mongoid::QueryCache do
     end
   end
 
+  context 'when driver query cache exists' do
+    min_driver_version '2.14'
+
+    before do
+      Band.all.to_a
+      Band.create!
+    end
+
+    it 'recognizes the driver query cache' do
+      expect(defined?(Mongo::QueryCache)).to_not be_nil
+    end
+
+    context 'when query cache enabled' do
+
+      it 'uses the driver query cache' do
+        expect(Mongo::QueryCache).to receive(:enabled=).and_call_original
+        Mongoid::QueryCache.enabled = true
+
+        expect(Mongoid::QueryCache.enabled?).to be(true)
+        expect(Mongo::QueryCache.enabled?).to be(true)
+      end
+    end
+
+    context 'when query cache disabled' do
+
+      it 'uses the driver query cache' do
+        expect(Mongo::QueryCache).to receive(:enabled=).and_call_original
+        Mongoid::QueryCache.enabled = false
+
+        expect(Mongoid::QueryCache.enabled?).to be(false)
+        expect(Mongo::QueryCache.enabled?).to be(false)
+      end
+    end
+
+    context 'when block is cached' do
+
+      before do
+        Mongoid::QueryCache.enabled = false
+      end
+
+      it 'uses the driver query cache' do
+        expect(Mongo::QueryCache).to receive(:cache).and_call_original
+        Mongoid::QueryCache.cache do
+          expect(Mongo::QueryCache).to receive(:enabled?).exactly(2).and_call_original
+          expect(Mongoid::QueryCache.enabled?).to be(true)
+          expect(Mongo::QueryCache.enabled?).to be(true)
+        end
+      end
+    end
+
+    context 'when block is uncached' do
+
+      before do
+        Mongoid::QueryCache.enabled = true
+      end
+
+      it 'uses the driver query cache' do
+        expect(Mongo::QueryCache).to receive(:uncached).and_call_original
+        Mongoid::QueryCache.uncached do
+          expect(Mongo::QueryCache).to receive(:enabled?).exactly(2).and_call_original
+          expect(Mongoid::QueryCache.enabled?).to be(false)
+          expect(Mongo::QueryCache.enabled?).to be(false)
+        end
+      end
+    end
+
+    context 'when clear_cache is used' do
+
+      before do
+        Band.all.to_a
+      end
+
+      it 'requires Mongoid to query again' do
+        expect_no_queries do
+          Band.all.to_a
+        end
+
+        Mongoid::QueryCache.clear_cache
+
+        expect_query(1) do
+          Band.all.to_a
+        end
+      end
+    end
+
+    context 'when query cache used and cleared' do
+      it 'uses the driver query cache' do
+        expect(Mongo::QueryCache).to receive(:set).once.and_call_original
+
+        expect_query(1) do
+          Band.all.to_a
+          Band.all.to_a
+        end
+      end
+    end
+  end
+
+  context 'when drivers query cache does not exist' do
+    max_driver_version '2.13'
+
+    it 'does not recognize the driver query cache' do
+      expect(defined?(Mongo::QueryCache)).to be_nil
+    end
+  end
+
   context "when querying for a single document" do
 
     [ :first, :one, :last ].each do |method|
@@ -148,24 +457,81 @@ describe Mongoid::QueryCache do
     end
 
     it 'returns all documents' do
-      expect(Person.all.to_a.count).to eq(3)
-      Person.first
-      expect(Person.all.to_a.count).to eq(3)
+      # Mongoid adds a sort by _id to the Person.first call, which is why
+      # these commands issue two queries instead of one.
+      expect_query(2) do
+        expect(Person.all.to_a.count).to eq(3)
+        Person.first
+        expect(Person.all.to_a.count).to eq(3)
+      end
+    end
+
+    it 'caches the query when order is specified' do
+      expect_query(1) do
+        expect(Person.order(_id: 1).all.to_a.count).to eq(3)
+        Person.first
+        expect(Person.order(_id: 1).all.to_a.count).to eq(3)
+      end
     end
 
     context 'with conditions specified' do
       it 'returns all documents' do
-        expect(Person.gt(age: 0).to_a.count).to eq(3)
-        Person.gt(age: 0).first
-        expect(Person.gt(age: 0).to_a.count).to eq(3)
+        # Mongoid adds a sort by _id to the Person.first call, which is why
+        # these commands issue two queries instead of one.
+        expect_query(2) do
+          expect(Person.gt(age: 0).to_a.count).to eq(3)
+          Person.gt(age: 0).first
+          expect(Person.gt(age: 0).to_a.count).to eq(3)
+        end
+      end
+
+      it 'caches the query when order is specified' do
+        expect_query(1) do
+          expect(Person.order(_id: 1).gt(age: 0).to_a.count).to eq(3)
+          Person.gt(age: 0).first
+          expect(Person.order(_id: 1).gt(age: 0).to_a.count).to eq(3)
+        end
       end
     end
 
     context 'with order specified' do
       it 'returns all documents' do
-        expect(Person.order_by(name: 1).to_a.count).to eq(3)
-        Person.order_by(name: 1).first
-        expect(Person.order_by(name: 1).to_a.count).to eq(3)
+        expect_query(1) do
+          expect(Person.order_by(name: 1).to_a.count).to eq(3)
+          Person.order_by(name: 1).first
+          expect(Person.order_by(name: 1).to_a.count).to eq(3)
+        end
+      end
+    end
+  end
+
+  context 'when using a block API' do
+    before do
+      Band.destroy_all
+      5.times { Band.create }
+    end
+
+    context '#any? with no block' do
+      it 'doesn\'t leak sessions' do
+        Band.all.any?
+      end
+    end
+
+    context '#all? with no block' do
+      it 'doesn\'t leak sessions' do
+        Band.all.all?
+      end
+    end
+
+    context '#none? with no block' do
+      it 'doesn\'t leak sessions' do
+        Band.all.none?
+      end
+    end
+
+    context '#one? with no block' do
+      it 'doesn\'t leak sessions' do
+        Band.all.one?
       end
     end
   end
@@ -259,7 +625,6 @@ describe Mongoid::QueryCache do
       end
 
       context "when the first query has a limit" do
-
         let(:game) do
           Game.create!(name: "2048")
         end
@@ -277,11 +642,28 @@ describe Mongoid::QueryCache do
           # which causes this test to fail.
           min_server_version '3.2'
 
-          it "queries again" do
-            expect_query(1) do
-              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])
+          context 'with driver query cache' do
+            min_driver_version '2.14'
+
+            # The driver query cache re-uses results with a larger limit
+            it 'does not query again' do
+              expect_no_queries do
+                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
+
+          context 'with mongoid query cache' do
+            max_driver_version '2.13'
+
+            it 'queries again' do
+              expect_query(1) do
+                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
         end
@@ -343,6 +725,7 @@ describe Mongoid::QueryCache do
           Band.destroy_all
 
           5.times { |i| Band.create!(name: "Band #{i}") }
+          Band.limit(2).skip(1).all.to_a
         end
 
         it "queries again" do
@@ -385,24 +768,24 @@ 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
+   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])
+     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
+         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
 
@@ -538,8 +921,10 @@ describe Mongoid::QueryCache do
         end
       end
 
-      it "returns the same count of objects when using #pluck" do
-        expect(Band.pluck(:name).length).to eq(99)
+      it "returns the same count of objects when using #pluck but doesn't cache" do
+        expect_query(1) do
+          expect(Band.pluck(:name).length).to eq(99)
+        end
       end
     end
   end
@@ -557,20 +942,36 @@ describe Mongoid::QueryCache do
       Mongoid::QueryCache.enabled = true
       10.times { Band.create! }
 
-      Band.batch_size(4).all.to_a
+      Band.batch_size(4).to_a
     end
 
-    it 'does not cache the result' do
-      expect(Band.all.map(&:id).size).to eq(10)
-    end
+    context 'with driver query cache' do
+      min_driver_version '2.14'
 
-    context 'when a batch size smaller than the result set is specified' do
-      let(:batch_size) do
-        4
+      # The driver query cache caches multi-batch cursors
+      it 'does cache the result' do
+        expect_no_queries do
+          expect(Band.all.map(&:id).size).to eq(10)
+        end
       end
+    end
+
+    context 'with mongoid query cache' do
+      max_driver_version '2.13'
 
       it 'does not cache the result' do
-        expect(Band.batch_size(batch_size).all.map(&:id).size).to eq(10)
+        expect_query(1) do
+          expect(Band.all.map(&:id).size).to eq(10)
+        end
+      end
+    end
+  end
+
+  context 'when storing in system collection' do
+    it 'does not cache the query' do
+      expect_query(2) do
+        SystemRole.all.to_a
+        SystemRole.all.to_a
       end
     end
   end

data/spec/mongoid/reloadable_spec.rb

@@ -353,5 +353,77 @@ describe Mongoid::Reloadable do
         expect(reloaded.readonly?).to be(false)
       end
     end
+
+    context 'on sharded cluster' do
+      require_topology :sharded
+
+      before(:all) do
+        CONFIG[:clients][:other] = CONFIG[:clients][:default].dup
+        CONFIG[:clients][:other][:database] = 'other'
+        Mongoid::Clients.clients.values.each(&:close)
+        Mongoid::Config.send(:clients=, CONFIG[:clients])
+        Mongoid::Clients.with_name(:other).subscribe(Mongo::Monitoring::COMMAND, EventSubscriber.new)
+      end
+
+      let(:subscriber) do
+        client = Mongoid::Clients.with_name(:other)
+        monitoring = client.send(:monitoring)
+        subscriber = monitoring.subscribers['Command'].find do |s|
+          s.is_a?(EventSubscriber)
+        end
+      end
+
+      let(:find_events) do
+        find_events = subscriber.started_events.select { |event| event.command_name.to_s == 'find' }
+      end
+
+      before do
+        subscriber.clear_events!
+      end
+
+      context 'without embedded document' do
+        let(:profile) do
+          Profile.with(client: :other) do |klass|
+            klass.create
+          end
+        end
+
+        before do
+          Profile.with(client: :other) do
+            profile.reload
+          end
+        end
+
+        it 'uses the shard key to reload the document' do
+          expect(find_events.length). to eq(1)
+
+          event = find_events.first
+          expect(event.command['filter'].keys).to include('name')
+        end
+      end
+
+
+      context 'with embedded document' do
+        let(:profile_image) do
+          Profile.with(client: :other) do |klass|
+            profile = klass.create
+            ProfileImage.create(profile: profile)
+          end
+        end
+
+        before do
+          Profile.with(client: :other) do
+            profile_image.reload
+          end
+        end
+
+        it 'uses the shard key to reload the embedded document' do
+          expect(find_events.length). to eq(1)
+
+          event = find_events.first
+          expect(event.command['filter'].keys).to include('name')
+        end
+      end
+    end
   end
 end

data/spec/mongoid/serializable_spec.rb

@@ -7,12 +7,30 @@ describe Mongoid::Serializable do
 
   describe "#field_names" do
 
-    let(:band) do
-      Band.new
+    let(:guitar) do
+      Guitar.new
     end
 
     it "does not duplicate fields" do
-      expect(band.send(:field_names, {})).to eq(band.fields.except("_type").keys.sort)
+      expect(guitar.send(:field_names, {})).to eq(guitar.fields.except("_type").keys.sort)
+    end
+
+    context "when using a custom discriminator_key" do 
+      before do 
+        Instrument.discriminator_key = "dkey"
+      end
+
+      after do 
+        Instrument.discriminator_key = nil
+      end
+
+      let(:guitar) do
+        Guitar.new
+      end
+  
+      it "includes _type but does not include the new discriminator key" do
+        expect(guitar.send(:field_names, {})).to eq(guitar.fields.except("dkey").keys.sort)
+      end
     end
   end