mongoid 6.4.8 → 7.0.0

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
@@ -45,32 +31,16 @@ describe Mongoid::QueryCache do
         :posts
       end
 
-      context 'when query cache is disabled' do
+      context 'does not query for the relation and instead sets the base' 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
+          expect(server).to receive(:with_connection).exactly(0).times.and_call_original
+          relations.each do |object|
+            object.person
           end
         end
       end
@@ -221,10 +191,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 +198,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 +211,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 +227,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 +240,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 +262,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 +303,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 +414,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 +433,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

data/spec/mongoid/scopable_spec.rb

@@ -1130,19 +1130,6 @@ 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/shardable_spec.rb

@@ -49,23 +49,43 @@ describe Mongoid::Shardable do
     end
   end
 
-  describe "#shard_key_selector" do
+  describe '#shard_key_selector' do
+    subject { instance.shard_key_selector }
+    let(:klass) { Band }
+    let(:value) { 'a-brand-name' }
 
-    let(:klass) do
-      Band
-    end
+    before { klass.shard_key(:name) }
 
-    let(:object) do
-      klass.new
-    end
+    context 'when record is new' do
+      let(:instance) { klass.new(name: value) }
 
-    before do
-      klass.shard_key(:name)
-      object.name = "Jo"
+      it { is_expected.to eq({ 'name' => value }) }
+
+      context 'changing shard key value' do
+        let(:new_value) { 'a-new-value' }
+
+        before do
+          instance.name = new_value
+        end
+
+        it { is_expected.to eq({ 'name' => new_value }) }
+      end
     end
 
-    it "returns a hash of shard key names and values" do
-      expect(object.shard_key_selector).to eq({ "name" => "Jo" })
+    context 'when record is persisted' do
+      let(:instance) { klass.create(name: value) }
+
+      it { is_expected.to eq({ 'name' => value }) }
+
+      context 'changing shard key value' do
+        let(:new_value) { 'a-new-value' }
+
+        before do
+          instance.name = new_value
+        end
+
+        it { is_expected.to eq({ 'name' => value }) }
+      end
     end
   end
 end

data/spec/mongoid/threaded_spec.rb

@@ -233,72 +233,4 @@ 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/mongoid/validatable/associated_spec.rb

@@ -171,7 +171,7 @@ describe Mongoid::Validatable::AssociatedValidator do
         end
       end
 
-      context "when the assocation has all valid documents" do
+      context "when the association has all valid documents" do
 
         let(:associated) do
           double(valid?: true, flagged_for_destroy?: false)

data/spec/mongoid/validatable/presence_spec.rb

@@ -211,13 +211,14 @@ describe Mongoid::Validatable::PresenceValidator do
 
     context "when the relation is a has one" do
 
-      before do
+      around do |example|
+        original_relations = Person.relations
+        Person.has_one :game, autosave: true
         Person.validates :game, presence: true
-      end
-
-      after do
+        example.run
         Person.reset_callbacks(:save)
         Person.reset_callbacks(:validate)
+        Person.relations = original_relations
       end
 
       context "when the relation is new" do
@@ -249,7 +250,7 @@ describe Mongoid::Validatable::PresenceValidator do
     context "when the relation is a has one and autosave is false" do
 
       before do
-        Person.relations["game"][:autosave] = false
+        Person.relations["game"].options[:autosave] = false
         Person.validates :game, presence: true
       end
 
@@ -258,7 +259,7 @@ describe Mongoid::Validatable::PresenceValidator do
       end
 
       it "does not change autosave on the relation" do
-        expect(Person.relations["game"][:autosave]).to be false
+        expect(Person.relations["game"].autosave?).to be false
       end
 
       context "when the relation is new" do

data/spec/mongoid/validatable_spec.rb

@@ -34,7 +34,7 @@ describe Mongoid::Validatable do
       end
 
       let(:documents) do
-        Mongoid::Relations::Targets::Enumerable.new([ address ])
+        Mongoid::Association::Referenced::HasMany::Targets::Enumerable.new([ address ])
       end
 
       before do