mongoid 5.4.0 → 6.4.8

data/spec/mongoid/query_cache_spec.rb

@@ -7,6 +7,111 @@ 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
+      relations.first.mongo_client.cluster.next_primary
+    end
+
+    before do
+      person = Person.create
+      3.times do
+        person.send(relation).create
+      end
+      person.save
+    end
+
+    let!(:relations) do
+      Person.first.send(relation).to_a
+    end
+
+    context 'when the association is has-many' do
+
+      let(:relation) do
+        :posts
+      end
+
+      context 'when query cache is disabled' do
+
+        before do
+          Mongoid::QueryCache.enabled = false
+        end
+
+        it 'queries for each access to the base' do
+          expect_query(relations.size) do
+            relations.each do |object|
+              object.person
+            end
+          end
+        end
+      end
+
+      context 'when query cache is enabled' do
+
+        before do
+          Mongoid::QueryCache.enabled = true
+        end
+
+        it 'queries only once for the base' do
+          expect_query(1) do
+            relations.each do |object|
+              object.person
+            end
+          end
+        end
+      end
+    end
+
+    context 'when the association is embeds-many' do
+
+      let(:relation) do
+        :symptoms
+      end
+
+      context 'when query cache is disabled' do
+
+        before do
+          Mongoid::QueryCache.enabled = false
+        end
+
+        it 'does not query for access to the base' do
+          expect(server).to receive(:context).exactly(0).times.and_call_original
+          relations.each do |object|
+            object.person
+          end
+        end
+      end
+
+      context 'when query cache is enabled' do
+
+        before do
+          Mongoid::QueryCache.enabled = true
+        end
+
+        it 'does not query for access to the base' do
+          expect(server).to receive(:context).exactly(0).times.and_call_original
+          relations.each do |object|
+            object.person
+          end
+        end
+      end
+    end
+  end
+
   context "when querying for a single document" do
 
     [ :first, :one, :last ].each do |method|
@@ -116,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
 
@@ -123,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
@@ -136,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
@@ -152,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
@@ -165,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
@@ -187,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
@@ -228,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|
@@ -339,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
@@ -358,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/relations/accessors_spec.rb

@@ -728,7 +728,7 @@ describe Mongoid::Relations::Accessors do
         game.save
       end
 
-      it "keeps the the foreign key as ObjectID" do
+      it "keeps the foreign key as ObjectID" do
         expect(game.reload.person_id).to eq(person.id)
       end
     end

data/spec/mongoid/relations/auto_save_spec.rb

@@ -70,13 +70,44 @@ describe Mongoid::Relations::AutoSave do
 
         context "when saving a new parent document" do
 
-          before do
-            person.drugs << drug
-            person.save
+          context 'when persistence options are not set on the parent' do
+            before do
+              person.drugs << drug
+              person.save
+            end
+
+            it "saves the relation" do
+              expect(drug).to be_persisted
+            end
           end
 
-          it "saves the relation" do
-            expect(drug).to be_persisted
+          context 'when persistence options are set on the parent' do
+
+            let(:other_database) do
+              :other
+            end
+
+            after do
+              Person.with(database: other_database) do |person_class|
+                person_class.delete_all
+              end
+              Drug.with(database: other_database) do |drug_class|
+                drug_class.delete_all
+              end
+            end
+
+            before do
+              person.with(database: other_database) do |per|
+                per.drugs << drug
+                per.save
+              end
+            end
+
+            it 'saves the relation with the persistence options' do
+              Drug.with(database: other_database) do |drug_class|
+                expect(drug_class.count).to eq(1)
+              end
+            end
           end
         end
 
@@ -160,7 +191,9 @@ describe Mongoid::Relations::AutoSave do
           it "sends one insert" do
             account.name = "account"
             expect_query(1) do
-              person.with(write: {w:0}).save
+              person.with(write: {w:0}) do |_person|
+                _person.save
+              end
             end
           end
         end

data/spec/mongoid/relations/bindings/referenced/many_to_many_spec.rb

@@ -43,11 +43,11 @@ describe Mongoid::Relations::Bindings::Referenced::ManyToMany do
       end
 
       it "syncs the base" do
-        expect(person).to be_synced("preference_ids")
+        expect(person._synced?("preference_ids")).to be(true)
       end
 
       it "syncs the inverse" do
-        expect(preference_two).to be_synced("person_ids")
+        expect(preference_two._synced?("person_ids")).to be(true)
       end
     end
 
@@ -98,11 +98,11 @@ describe Mongoid::Relations::Bindings::Referenced::ManyToMany do
       end
 
       it "syncs the base" do
-        expect(person).to be_synced("preference_ids")
+        expect(person._synced?("preference_ids")).to be(true)
       end
 
       it "syncs the inverse" do
-        expect(preference).to be_synced("person_ids")
+        expect(preference._synced?("person_ids")).to be(true)
       end
     end
 

data/spec/mongoid/relations/builders_spec.rb

@@ -185,20 +185,47 @@ describe Mongoid::Relations::Builders do
 
         context "when a document already exists" do
 
-          let!(:game_two) do
-            person.create_game(name: "Skyrim")
-          end
+          context "when the relation belongs_to is already set" do
 
-          it "replaces the existing document" do
-            expect(person.game).to eq(game_two)
-          end
+            let!(:game_one) do
+              game = person.create_game(name: "Starcraft")
+              game.person = person
+            end
+
+            let!(:game_two) do
+              person.create_game(name: "Skyrim")
+            end
+
+            it "replaces the existing document" do
+              expect(person.game).to eq(game_two)
+            end
+
+            it "persists the change" do
+              expect(person.game(true)).to eq(game_two)
+            end
 
-          it "persists the change" do
-            expect(person.game(true)).to eq(game_two)
+            it "removes the old document from the database" do
+              expect(Game.collection.find.count).to eq(1)
+            end
           end
 
-          it "removes the old document from the database" do
-            expect(Game.collection.find.count).to eq(1)
+          context 'when the relation belongs_to is not already set' do
+
+            let!(:game_two) do
+              person.create_game(name: "Skyrim")
+            end
+
+            it "replaces the existing document" do
+              expect(person.game).to eq(game_two)
+            end
+
+            it "persists the change" do
+              expect(person.game(true)).to eq(game_two)
+            end
+
+            it "removes the old document from the database" do
+              expect(Game.collection.find.count).to eq(1)
+            end
           end
         end
       end

data/spec/mongoid/relations/counter_cache_spec.rb

@@ -34,7 +34,7 @@ describe Mongoid::Relations::CounterCache do
       it "expect to raise an error" do
         expect {
           person.reset_counters(:not_exist)
-        }.to raise_error
+        }.to raise_error(NoMethodError)
       end
     end
 
@@ -85,6 +85,26 @@ describe Mongoid::Relations::CounterCache do
         expect(subscription.reload[:packs_count]).to eq(1)
       end
     end
+
+    context 'when there are persistence options set' do
+
+      let(:subscription) do
+        Subscription.new
+      end
+
+      before do
+        subscription.with(collection: 'other') do |sub|
+          sub.save
+          sub.packs.create
+        end
+      end
+
+      it 'applies the persistence options when resetting the counter' do
+        subscription.with(collection: 'other') do |sub|
+          expect(sub.reload[:packs_count]).to eq(1)
+        end
+      end
+    end
   end
 
   describe ".reset_counters" do
@@ -111,7 +131,7 @@ describe Mongoid::Relations::CounterCache do
       it "expect to raise an error" do
         expect {
           Person.reset_counters "1", :drugs
-        }.to raise_error
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
       end
     end
 
@@ -124,7 +144,7 @@ describe Mongoid::Relations::CounterCache do
       it "expect to raise an error" do
         expect {
           Person.reset_counters person.id, :not_exist
-        }.to raise_error
+        }.to raise_error(NoMethodError)
       end
     end
 
@@ -256,6 +276,26 @@ describe Mongoid::Relations::CounterCache do
         expect(person.reload.drugs_count).to eq(3)
       end
     end
+
+    context 'when there are persistence options set' do
+
+      let(:person) do
+        Person.new
+      end
+
+      before do
+        person.with(collection: 'other') do |per|
+          per.save
+          per.drugs.create
+        end
+      end
+
+      it 'applies the persistence options when resetting the counter' do
+        person.with(collection: 'other') do |per|
+          expect(per.drugs_count).to eq(1)
+        end
+      end
+    end
   end
 
   describe "#decrement_counter" do
@@ -286,6 +326,27 @@ describe Mongoid::Relations::CounterCache do
         expect(person.reload.drugs_count).to eq(0)
       end
     end
+
+    context 'when there are persistence options set' do
+
+      let(:person) do
+        Person.new
+      end
+
+      before do
+        person.with(collection: 'other') do |per|
+          per.save
+          drug = per.drugs.create
+          drug.destroy
+        end
+      end
+
+      it 'applies the persistence options when resetting the counter' do
+        person.with(collection: 'other') do |per|
+          expect(per.reload.drugs_count).to eq(0)
+        end
+      end
+    end
   end
 
   describe "#add_counter_cache_callbacks" do

data/spec/mongoid/relations/eager/has_and_belongs_to_many_spec.rb

@@ -113,5 +113,21 @@ describe Mongoid::Relations::Eager::HasAndBelongsToMany do
         end
       end
     end
+
+    context "when some related documents no longer exist" do
+      before do
+        # Deleting the first one to meet Builders::Referenced::ManyToMany#query?
+        House.collection.find(_id: Person.first.house_ids.first).delete_one
+      end
+
+      it "does not accidentally trigger an extra query" do
+        expect_query(2) do
+          Person.asc(:_id).includes(:houses).each do |person|
+            expect(person.houses).to_not be_nil
+            expect(person.houses.length).to be(2)
+          end
+        end
+      end
+    end
   end
 end

data/spec/mongoid/relations/eager_spec.rb

@@ -181,6 +181,46 @@ describe Mongoid::Relations::Eager do
         expect(Mongoid::Relations::Eager::HasAndBelongsToMany).to receive(:new).with([houses_metadata], docs).once.and_call_original
         context.eager_load(docs)
       end
+
+      context 'when one of the eager loading definitions is nested' do
+
+        before do
+          class User
+            include Mongoid::Document
+          end
+
+          class Unit
+            include Mongoid::Document
+          end
+
+          class Booking
+            include Mongoid::Document
+            belongs_to :unit
+            has_many :vouchers
+          end
+
+          class Voucher
+            include Mongoid::Document
+            belongs_to :booking
+            belongs_to :created_by, class_name: 'User'
+          end
+        end
+
+        it 'successfully loads all relations' do
+          user = User.create
+          unit = Unit.create
+          booking = Booking.create(unit: unit)
+          Voucher.create(booking: booking, created_by: user)
+
+          vouchers = Voucher.includes(:created_by, booking: [:unit])
+
+          vouchers.each do |voucher|
+            expect(voucher.created_by).to eql(user)
+            expect(voucher.booking).to eql(booking)
+            expect(voucher.booking.unit).to eql(unit)
+          end
+        end
+      end
     end
 
     context "when including two of the same relation type" do