mongoid 7.1.11 → 7.2.0.rc1

data/spec/mongoid/config_spec.rb

@@ -197,6 +197,34 @@ describe Mongoid::Config do
     end
   end
 
+  context 'when discriminator_key override' do
+    context 'is not set in the config' do
+      it 'has the value _type by default' do
+        Mongoid::Config.reset
+        configuration = CONFIG.merge(options: {})
+
+        Mongoid.configure { |config| config.load_configuration(configuration) }
+
+        expect(Mongoid::Config.discriminator_key).to be("_type")
+      end
+    end
+
+    context 'is set in the config' do
+      it 'sets the value' do
+        Mongoid::Config.reset
+        configuration = CONFIG.merge(options: {discriminator_key: "test"})
+
+        Mongoid.configure { |config| config.load_configuration(configuration) }
+
+        expect(Mongoid::Config.discriminator_key).to be("test")
+      end
+
+      it 'is set globally' do 
+        expect(Mongoid.discriminator_key).to be("test")
+      end
+    end
+  end
+
   describe "#load!" do
 
     before(:all) do

data/spec/mongoid/contextual/atomic_spec.rb

@@ -753,25 +753,12 @@ describe Mongoid::Contextual::Atomic do
       context.set(name: "Recoil")
     end
 
-    shared_examples 'writes as expected' do
-      it "sets existing fields" do
-        expect(depeche_mode.reload.name).to eq("Recoil")
-      end
-
-      it "sets non existent fields" do
-        expect(smiths.reload.name).to eq("Recoil")
-      end
+    it "sets existing fields" do
+      expect(depeche_mode.reload.name).to eq("Recoil")
     end
 
-    include_examples 'writes as expected'
-
-    context 'when fields being set have been projected out' do
-
-      let(:criteria) do
-        Band.only(:genres)
-      end
-
-      include_examples 'writes as expected'
+    it "sets non existent fields" do
+      expect(smiths.reload.name).to eq("Recoil")
     end
   end
 
@@ -801,28 +788,27 @@ describe Mongoid::Contextual::Atomic do
           context.unset(:name)
         end
 
-        it "unsets the fields from all documents" do
-          depeche_mode.reload
-          new_order.reload
-          expect(depeche_mode.name).to be_nil
-          expect(depeche_mode.years).to_not be_nil
-          expect(new_order.name).to be_nil
-          expect(new_order.years).to_not be_nil
+        it "unsets the first existing field" do
+          expect(depeche_mode.reload.name).to be_nil
+        end
+
+        it "unsets the last existing field" do
+          expect(new_order.reload.name).to be_nil
         end
       end
 
       context "when the field is aliased" do
+
         before do
           context.unset(:years)
         end
 
-        it "unsets the fields from all documents" do
-          depeche_mode.reload
-          new_order.reload
-          expect(depeche_mode.name).to_not be_nil
-          expect(depeche_mode.years).to be_nil
-          expect(new_order.name).to_not be_nil
-          expect(new_order.years).to be_nil
+        it "unsets the first existing field" do
+          expect(depeche_mode.reload.years).to be_nil
+        end
+
+        it "unsets the last existing field" do
+          expect(new_order.reload.years).to be_nil
         end
       end
     end
@@ -830,8 +816,7 @@ describe Mongoid::Contextual::Atomic do
     context "when unsetting multiple fields" do
 
       let!(:new_order) do
-        Band.create(name: "New Order", genres: %w[electro dub], years: 10,
-          likes: 200, rating: 4.3, origin: 'Space')
+        Band.create(name: "New Order", genres: [ "electro", "dub" ], years: 10)
       end
 
       let(:criteria) do
@@ -848,62 +833,27 @@ describe Mongoid::Contextual::Atomic do
           context.unset(:name, :genres)
         end
 
-        it "unsets the specified fields" do
-          new_order.reload
-          expect(new_order.name).to be_nil
-          expect(new_order.genres).to be_nil
-          expect(new_order.years).to_not be_nil
-          expect(new_order.likes).to_not be_nil
-          expect(new_order.rating).to_not be_nil
+        it "unsets name field" do
+          expect(new_order.reload.name).to be_nil
         end
-      end
 
-      context "when the field is aliased" do
-
-        before do
-          context.unset(:name, :years)
-        end
-
-        it "unsets the specified fields" do
-          new_order.reload
-          expect(new_order.name).to be_nil
-          expect(new_order.genres).to_not be_nil
-          expect(new_order.years).to be_nil
-          expect(new_order.likes).to_not be_nil
-          expect(new_order.rating).to_not be_nil
+        it "unsets genres field" do
+          expect(new_order.reload.genres).to be_nil
         end
       end
 
-      context "when using Hash arguments" do
+      context "when the field is aliased" do
 
         before do
-          context.unset({ years: true, likes: "" }, { rating: false, origin: nil })
-        end
-
-        it "unsets the specified fields" do
-          new_order.reload
-          expect(new_order.name).to_not be_nil
-          expect(new_order.genres).to_not be_nil
-          expect(new_order.years).to be_nil
-          expect(new_order.likes).to be_nil
-          expect(new_order.rating).to be_nil
-          expect(new_order.origin).to be_nil
+          context.unset(:name, :years)
         end
-      end
-
-      context "when mixing argument types" do
 
-        before do
-          context.unset(:name, [:years], { likes: "" }, { rating: false })
+        it "unsets the unaliased field" do
+          expect(new_order.reload.name).to be_nil
         end
 
-        it "unsets the specified fields" do
-          new_order.reload
-          expect(new_order.name).to be_nil
-          expect(new_order.genres).to_not be_nil
-          expect(new_order.years).to be_nil
-          expect(new_order.likes).to be_nil
-          expect(new_order.rating).to be_nil
+        it "unsets the aliased field" do
+          expect(new_order.reload.years).to be_nil
         end
       end
     end
@@ -932,9 +882,7 @@ describe Mongoid::Contextual::Atomic do
       end
 
       it "unsets the unaliased field" do
-        depeche_mode.reload
-        expect(depeche_mode.name).to be_nil
-        expect(depeche_mode.years).to_not be_nil
+        expect(depeche_mode.reload.name).to be_nil
       end
     end
   end

data/spec/mongoid/contextual/geo_near_spec.rb

@@ -59,7 +59,7 @@ describe Mongoid::Contextual::GeoNear do
       end
 
       it "is nil except for 4.0 sharded when it is 0" do
-        expect(geo_near.average_distance).to eq expected_value
+        expect(geo_near.average_distance).to be expected_value
       end
     end
   end

data/spec/mongoid/contextual/mongo_spec.rb

@@ -109,11 +109,8 @@ describe Mongoid::Contextual::Mongo do
         described_class.new(criteria.cache)
       end
 
-      before do
-        expect(context.view).to receive(:count).once.and_return(1)
-      end
-
       it "returns the count cached value after first call" do
+        expect(context.view).to receive(:count_documents).once.and_return(1)
         2.times { expect(context.count).to eq(1) }
       end
     end
@@ -195,6 +192,71 @@ describe Mongoid::Contextual::Mongo do
     end
   end
 
+  describe "#estimated_count" do
+
+    let!(:depeche) do
+      Band.create(name: "Depeche Mode")
+    end
+
+    let!(:new_order) do
+      Band.create(name: "New Order")
+    end
+
+    let(:criteria) do
+      Band.where
+    end
+
+    context "when not providing options" do
+      it 'returns the correct count' do
+        expect(criteria.estimated_count).to eq(2)
+      end
+    end
+
+    context "when providing options" do
+      it 'returns the correct count' do
+        expect(criteria.estimated_count(maxTimeMS: 1000)).to eq(2)
+      end
+    end
+
+    context "when context is cached" do
+
+      let(:context) do
+        described_class.new(criteria.cache)
+      end
+
+      it "returns the count cached value after first call" do
+        expect(context.view).to receive(:estimated_document_count).once.and_return(1)
+        2.times do
+          context.estimated_count
+        end
+      end
+    end
+
+    context "when the criteria contains a selector", :focus do
+      let(:criteria) do
+        Band.where(name: "New Order")
+      end
+
+      context "when not providing options" do
+        it 'raises an error' do
+          expect do
+            criteria.estimated_count
+          end.to raise_error(Mongoid::Errors::InvalidEstimatedCountCriteria)
+        end
+      end
+
+      context "when providing options" do
+        it 'raises an error' do
+          expect do
+            criteria.estimated_count(maxTimeMS: 1000)
+          end.to raise_error(Mongoid::Errors::InvalidEstimatedCountCriteria)
+        end
+      end
+    end
+  end
+
+
+
   [ :delete, :delete_all ].each do |method|
 
     describe "##{method}" do
@@ -1399,12 +1461,8 @@ describe Mongoid::Contextual::Mongo do
         end
 
         context "when calling more than once" do
-
-          before do
-            expect(context.view).to receive(:count).once.and_return(2)
-          end
-
           it "returns the cached value for subsequent calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(2)
             2.times { expect(context.send(method)).to eq(2) }
           end
         end
@@ -1413,10 +1471,10 @@ describe Mongoid::Contextual::Mongo do
 
           before do
             context.entries
-            expect(context.view).to receive(:count).once.and_return(2)
           end
 
           it "returns the cached value for all calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(2)
             expect(context.send(method)).to eq(2)
           end
 
@@ -1448,12 +1506,8 @@ describe Mongoid::Contextual::Mongo do
         end
 
         context "when calling more than once" do
-
-          before do
-            expect(context.view).to receive(:count).once.and_return(1)
-          end
-
           it "returns the cached value for subsequent calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(1)
             2.times { expect(context.send(method)).to eq(1) }
           end
         end
@@ -1462,10 +1516,10 @@ describe Mongoid::Contextual::Mongo do
 
           before do
             context.entries
-            expect(context.view).to receive(:count).once.and_return(1)
           end
 
           it "returns the cached value for all calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(1)
             expect(context.send(method)).to eq(1)
           end
 

data/spec/mongoid/copyable_spec.rb

@@ -195,7 +195,7 @@ describe Mongoid::Copyable do
           I18n.enforce_available_locales = false
           I18n.locale = 'pt_BR'
           person.addresses.type(ShipmentAddress).each { |address| address.shipping_name = "Título" }
-          person.save
+          person.save!
         end
 
         after do
@@ -353,6 +353,83 @@ describe Mongoid::Copyable do
             end
           end
         end
+
+        context "when using a custom discriminator_key" do
+          before do
+            Person.discriminator_key = "dkey"
+          end
+
+          after do
+            Person.discriminator_key = nil
+          end
+
+          let(:copy) do
+            person.send(method)
+          end
+
+          before do
+            person[:versions] = [ { number: 1 } ]
+          end
+
+          it "copys embeds many documents" do
+            expect(copy.addresses).to eq(person.addresses)
+          end
+
+          it "copys deep embeds many documents" do
+            expect(copy.name.translations).to eq(person.name.translations)
+          end
+
+          it "sets the embedded many documents as new" do
+            expect(copy.addresses.first).to be_new_record
+          end
+
+          it "sets the deep embedded many documents as new" do
+            expect(copy.name.translations.first).to be_new_record
+          end
+
+          it "creates new embeds many instances" do
+            expect(copy.addresses).to_not equal(person.addresses)
+          end
+
+          it "creates new deep embeds many instances" do
+            expect(copy.name.translations).to_not equal(person.name.translations)
+          end
+
+          it "copys embeds one documents" do
+            expect(copy.name).to eq(person.name)
+          end
+
+          it "flags the embeds one documents as new" do
+            expect(copy.name).to be_new_record
+          end
+
+          it "creates a new embeds one instance" do
+            expect(copy.name).to_not equal(person.name)
+          end
+
+          context "when saving the copy" do
+
+            let(:reloaded) do
+              copy.reload
+            end
+
+            before do
+              copy.save(validate: false)
+            end
+
+            it "persists the attributes" do
+              expect(reloaded.title).to eq("Sir")
+            end
+
+            it "persists the embeds many relation" do
+              expect(reloaded.addresses).to eq(person.addresses)
+            end
+
+            it "persists the embeds one relation" do
+              expect(reloaded.name).to eq(person.name)
+            end
+          end
+        end
       end
 
       context "when the document is not new" do
@@ -517,6 +594,81 @@ describe Mongoid::Copyable do
           end
         end
       end
+
+      context "when cloning a document with an embedded child class and a custom discriminator value" do
+
+        before do
+          ShipmentAddress.discriminator_value = "dvalue"
+        end
+
+        after do
+          ShipmentAddress.discriminator_value = nil
+        end
+
+        let!(:shipment_address) do
+          person.addresses.build({}, ShipmentAddress)
+        end
+
+        before do
+          person.save
+        end
+
+        let!(:from_db) do
+          Person.find(person.id)
+        end
+
+        let(:copy) do
+          from_db.send(method)
+        end
+
+        it "copys embeds many documents" do
+          expect(copy.addresses).to eq(person.addresses)
+        end
+      end
+
+      context 'when cloning a document with embedded child that uses inheritance' do
+        let(:original) do
+          CopyableSpec::A.new(influencers: [child_cls.new])
+        end
+
+        let(:copy) do
+          original.send(method)
+        end
+
+        context 'embedded child is root of hierarchy' do
+          let(:child_cls) do
+            CopyableSpec::Influencer
+          end
+
+          before do
+            # When embedded class is the root in hierarchy, their
+            # discriminator value is not explicitly stored.
+            child_cls.discriminator_mapping[child_cls.name].should be nil
+          end
+
+          it 'works' do
+            copy.class.should be original.class
+            copy.object_id.should_not == original.object_id
+          end
+        end
+
+        context 'embedded child is leaf of hierarchy' do
+          let(:child_cls) do
+            CopyableSpec::Youtuber
+          end
+
+          before do
+            # When embedded class is a leaf in hierarchy, their
+            # discriminator value is explicitly stored.
+            child_cls.discriminator_mapping[child_cls.name].should_not be nil
+          end
+
+          it 'works' do
+            copy.class.should be original.class
+            copy.object_id.should_not == original.object_id
+          end
+        end
+      end
     end
   end
 end

data/spec/mongoid/copyable_spec_models.rb

@@ -6,6 +6,7 @@ module CopyableSpec
     include Mongoid::Document
 
     embeds_many :locations
+    embeds_many :influencers
   end
 
   class Location
@@ -17,4 +18,17 @@ module CopyableSpec
   class Building
     include Mongoid::Document
   end
+
+  class Influencer
+    include Mongoid::Document
+
+    embeds_many :blurbs
+  end
+
+  class Youtuber < Influencer
+  end
+
+  class Blurb
+    include Mongoid::Document
+  end
 end

data/spec/mongoid/criteria/queryable/selectable_logical_spec.rb

@@ -1447,42 +1447,6 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
-
-    context 'when using multiple criteria and symbol operators' do
-      context 'when using fields that meaningfully evolve values' do
-
-        let(:query) do
-          Dictionary.any_of({a: 1}, :published.gt => Date.new(2020, 2, 3))
-        end
-
-        it 'generates the expected query' do
-          query.selector.should == {'$or' => [
-            {'a' => 1},
-            # Date instance is converted to a Time instance in local time,
-            # because we are querying on a Time field and dates are interpreted
-            # in local time when assigning to Time fields
-            {'published' => {'$gt' => Time.local(2020, 2, 3)}},
-          ]}
-        end
-      end
-
-      context 'when using fields that do not meaningfully evolve values' do
-
-        let(:query) do
-          Dictionary.any_of({a: 1}, :submitted_on.gt => Date.new(2020, 2, 3))
-        end
-
-        it 'generates the expected query' do
-          query.selector.should == {'$or' => [
-            {'a' => 1},
-            # Date instance is converted to a Time instance in UTC,
-            # because we are querying on a Date field and dates are interpreted
-            # in UTC when persisted as dates by Mongoid
-            {'submitted_on' => {'$gt' => Time.utc(2020, 2, 3)}},
-          ]}
-        end
-      end
-    end
   end
 
   describe "#not" do