mongoid 6.4.8 → 7.0.0.beta

data/spec/mongoid/query_cache_spec.rb

@@ -7,20 +7,6 @@ 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
@@ -52,10 +38,9 @@ describe Mongoid::QueryCache do
         end
 
         it 'queries for each access to the base' do
-          expect_query(relations.size) do
-            relations.each do |object|
-              object.person
-            end
+          expect(server).to receive(:with_connection).exactly(relations.size).times.and_call_original
+          relations.each do |object|
+            object.person
           end
         end
       end
@@ -67,10 +52,9 @@ describe Mongoid::QueryCache do
         end
 
         it 'queries only once for the base' do
-          expect_query(1) do
-            relations.each do |object|
-              object.person
-            end
+          expect(server).to receive(:with_connection).exactly(1).times.and_call_original
+          relations.each do |object|
+            object.person
           end
         end
       end
@@ -221,10 +205,6 @@ 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
 
@@ -232,9 +212,7 @@ describe Mongoid::QueryCache do
 
           it "uses the cache" 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])
+              game.ratings.where(:value.gt => 5).limit(2).asc(:id).to_a
             end
           end
         end
@@ -247,23 +225,14 @@ 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
-              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])
+              game.ratings.where(:value.gt => 5).limit(2).asc(:id).to_a
             end
           end
         end
@@ -272,9 +241,7 @@ describe Mongoid::QueryCache do
 
           it "queries again" do
             expect_query(1) do
-              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])
+              game.ratings.where(:value.gt => 5).asc(:id).to_a
             end
           end
         end
@@ -287,34 +254,21 @@ 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
-            result = game.ratings.where(:value.gt => 5).asc(:id).first
-            expect(result['value']).to eq(6)
+            game.ratings.where(:value.gt => 5).asc(:id).first
           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
-            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"])
+            Band.limit(2).all.to_a
           end
         end
       end
@@ -322,16 +276,12 @@ describe Mongoid::QueryCache do
       context "when specifying a different skip value" do
 
         before 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
           expect_query(1) do
-            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"])
+            Band.limit(2).skip(3).all.to_a
           end
         end
       end
@@ -367,25 +317,6 @@ 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|
@@ -497,15 +428,15 @@ describe Mongoid::QueryCache do
   context "when querying a very large collection" do
 
     before do
-      100.times { Band.create! }
+      123.times { Band.create! }
     end
 
     it "returns the right number of records" do
-      expect(Band.all.to_a.length).to eq(100)
+      expect(Band.all.to_a.length).to eq(123)
     end
 
     it "#pluck returns the same count of objects" do
-      expect(Band.pluck(:name).length).to eq(100)
+      expect(Band.pluck(:name).length).to eq(123)
     end
 
     context "when loading all the documents" do
@@ -516,12 +447,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(100)
+          expect(Band.all.to_a.length).to eq(123)
         end
       end
 
       it "returns the same count of objects when using #pluck" do
-        expect(Band.pluck(:name).length).to eq(100)
+        expect(Band.pluck(:name).length).to eq(123)
       end
     end
   end

data/spec/mongoid/relations/proxy_spec.rb

@@ -1,124 +1,124 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Proxy do
-
-  describe '#with', if: non_legacy_server? do
-
-    let(:circus) do
-      Circus.new
-    end
-
-    let(:animal) do
-      Animal.new
-    end
-
-    before do
-      circus.animals << animal
-      circus.save
-    end
-
-    it 'uses the new persistence options' do
-      expect {
-        animal.with(write: { w: 100 }) do |an|
-          an.update_attribute(:name, 'kangaroo')
-        end
-      }.to raise_exception(Mongo::Error::OperationFailure)
-    end
-  end
-
-  describe "#find" do
-    let(:person) do
-      Person.create
-    end
-
-    let(:messages) do
-      person.messages
-    end
-
-    let(:msg1) do
-      messages.create(body: 'msg1')
-    end
-
-    it "returns nil with no arguments" do
-      expect(messages.find).to be_nil
-      expect(messages.send(:find)).to be_nil
-      expect(messages.__send__(:find)).to be_nil
-      expect(messages.public_send(:find)).to be_nil
-    end
-
-    it "returns the object corresponding to the id" do
-      expect(messages.find(msg1.id)).to eq(msg1)
-      expect(messages.send(:find, msg1.id)).to eq(msg1)
-      expect(messages.__send__(:find, msg1.id)).to eq(msg1)
-      expect(messages.public_send(:find, msg1.id)).to eq(msg1)
-    end
-  end
-
-  describe "#extend" do
-
-    before(:all) do
-      Person.reset_callbacks(:validate)
-      module Testable
-      end
-    end
-
-    after(:all) do
-      Object.send(:remove_const, :Testable)
-    end
-
-    let(:person) do
-      Person.create
-    end
-
-    let(:name) do
-      person.build_name
-    end
-
-    before do
-      name.namable.extend(Testable)
-    end
-
-    it "extends the proxied object" do
-      expect(person).to be_a(Testable)
-    end
-
-    context "when extending from the relation definition" do
-
-      let!(:address) do
-        person.addresses.create(street: "hobrecht")
-      end
-
-      let(:found) do
-        person.addresses.find_by_street("hobrecht")
-      end
-
-      it "extends the proxy" do
-        expect(found).to eq(address)
-      end
-    end
-  end
-
-  describe "equality" do
-    let(:messages) do
-      Person.create.messages
-    end
-
-    it "is #equal? to itself" do
-      expect(messages.equal?(messages)).to eq(true)
-    end
-
-    it "is == to itself" do
-      expect(messages == messages).to eq(true)
-    end
-
-    it "is not #equal? to its target" do
-      expect(messages.equal?(messages.target)).to eq(false)
-      expect(messages.target.equal?(messages)).to eq(false)
-    end
-
-    it "is == to its target" do
-      expect(messages == messages.target).to eq(true)
-      expect(messages.target == messages).to eq(true)
-    end
-  end
-end
+# require "spec_helper"
+#
+# describe Mongoid::Relations::Proxy do
+#
+#   describe '#with', if: non_legacy_server? do
+#
+#     let(:circus) do
+#       Circus.new
+#     end
+#
+#     let(:animal) do
+#       Animal.new
+#     end
+#
+#     before do
+#       circus.animals << animal
+#       circus.save
+#     end
+#
+#     it 'uses the new persistence options' do
+#       expect {
+#         animal.with(write: { w: 100 }) do |an|
+#           an.update_attribute(:name, 'kangaroo')
+#         end
+#       }.to raise_exception(Mongo::Error::OperationFailure)
+#     end
+#   end
+#
+#   describe "#find" do
+#     let(:person) do
+#       Person.create
+#     end
+#
+#     let(:messages) do
+#       person.messages
+#     end
+#
+#     let(:msg1) do
+#       messages.create(body: 'msg1')
+#     end
+#
+#     it "returns nil with no arguments" do
+#       expect(messages.find).to be_nil
+#       expect(messages.send(:find)).to be_nil
+#       expect(messages.__send__(:find)).to be_nil
+#       expect(messages.public_send(:find)).to be_nil
+#     end
+#
+#     it "returns the object corresponding to the id" do
+#       expect(messages.find(msg1.id)).to eq(msg1)
+#       expect(messages.send(:find, msg1.id)).to eq(msg1)
+#       expect(messages.__send__(:find, msg1.id)).to eq(msg1)
+#       expect(messages.public_send(:find, msg1.id)).to eq(msg1)
+#     end
+#   end
+#
+#   describe "#extend" do
+#
+#     before(:all) do
+#       Person.reset_callbacks(:validate)
+#       module Testable
+#       end
+#     end
+#
+#     after(:all) do
+#       Object.send(:remove_const, :Testable)
+#     end
+#
+#     let(:person) do
+#       Person.create
+#     end
+#
+#     let(:name) do
+#       person.build_name
+#     end
+#
+#     before do
+#       name.namable.extend(Testable)
+#     end
+#
+#     it "extends the proxied object" do
+#       expect(person).to be_a(Testable)
+#     end
+#
+#     context "when extending from the relation definition" do
+#
+#       let!(:address) do
+#         person.addresses.create(street: "hobrecht")
+#       end
+#
+#       let(:found) do
+#         person.addresses.find_by_street("hobrecht")
+#       end
+#
+#       it "extends the proxy" do
+#         expect(found).to eq(address)
+#       end
+#     end
+#   end
+#
+#   describe "equality" do
+#     let(:messages) do
+#       Person.create.messages
+#     end
+#
+#     it "is #equal? to itself" do
+#       expect(messages.equal?(messages)).to eq(true)
+#     end
+#
+#     it "is == to itself" do
+#       expect(messages == messages).to eq(true)
+#     end
+#
+#     it "is not #equal? to its target" do
+#       expect(messages.equal?(messages.target)).to eq(false)
+#       expect(messages.target.equal?(messages)).to eq(false)
+#     end
+#
+#     it "is == to its target" do
+#       expect(messages == messages.target).to eq(true)
+#       expect(messages.target == messages).to eq(true)
+#     end
+#   end
+# end