mongoid 7.1.5 → 7.2.1

data/spec/mongoid/copyable_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
-# -*- coding: utf-8 -*-
 require "spec_helper"
 
 require_relative './copyable_spec_models'
@@ -65,30 +64,58 @@ describe Mongoid::Copyable do
 
       context "when a document has fields from a legacy schema" do
 
-        let!(:actor) do
-          Actor.create(name: "test")
-        end
+        shared_examples 'behaves as expected' do
+          let!(:instance) do
+            cls.create(name: "test")
+          end
 
-        before do
-          legacy_fields = { "this_is_not_a_field" => 1, "this_legacy_field_is_nil" => nil }
-          Actor.collection.find(_id: actor.id).update_one("$set" => legacy_fields)
-        end
+          before do
+            legacy_fields = { "this_is_not_a_field" => 1, "this_legacy_field_is_nil" => nil }
+            cls.collection.find(_id: instance.id).update_one("$set" => legacy_fields)
+          end
 
-        let(:cloned) do
-          actor.reload.send(method)
-        end
+          let(:cloned) do
+            instance.reload.send(method)
+          end
+
+          it "sets the legacy attribute" do
+            expect(cloned.attributes['this_is_not_a_field']).to eq(1)
+          end
 
-        it "sets the legacy attribute" do
-          expect(cloned.attributes['this_is_not_a_field']).to eq(1)
+          it "contains legacy attributes that are nil" do
+            expect(cloned.attributes.key?('this_legacy_field_is_nil')).to eq(true)
+          end
+
+          it "copies the known attributes" do
+            expect(cloned.name).to eq('test')
+          end
+
+          it 'calls constructor with explicitly declared attributes only' do
+            expect(cls).to receive(:new).with('name' => 'test').and_call_original
+            cloned
+          end
         end
 
-        it "contains legacy attributes that are nil" do
-          expect(cloned.attributes.key?('this_legacy_field_is_nil')).to eq(true)
+        context 'without Attributes::Dynamic' do
+          let(:cls) { CopyableSpec::Reg }
+
+          before do
+            cls.should_not include(Mongoid::Attributes::Dynamic)
+          end
+
+          include_examples 'behaves as expected'
         end
 
-        it "copies the known attributes" do
-          expect(cloned.name).to eq('test')
+        context 'with Attributes::Dynamic' do
+          let(:cls) { CopyableSpec::Dyn }
+
+          before do
+            cls.should include(Mongoid::Attributes::Dynamic)
+          end
+
+          include_examples 'behaves as expected'
         end
+
       end
 
       context "when using store_as" do
@@ -195,7 +222,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 +380,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 +621,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,31 @@ 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
+
+  # Do not include Attributes::Dynamic
+  class Reg
+    include Mongoid::Document
+
+    field :name, type: String
+  end
+
+  class Dyn
+    include Mongoid::Document
+    include Mongoid::Attributes::Dynamic
+
+    field :name, type: String
+  end
 end

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

@@ -1447,6 +1447,42 @@ 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

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

@@ -732,108 +732,89 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#geo_spacial" do
+  %i(geo_spatial geo_spacial).each do |meth|
+    describe "#geo_spacial" do
 
-    let(:query_method) { :geo_spacial }
+      let(:query_method) { meth }
 
-    it_behaves_like 'requires an argument'
-    it_behaves_like 'requires a non-nil argument'
+      it_behaves_like 'requires an argument'
+      it_behaves_like 'requires a non-nil argument'
 
-    context "when provided a criterion" do
+      context "when provided a criterion" do
 
-      context "when the geometry is a point intersection" do
+        context "when the geometry is a point intersection" do
 
-        let(:selection) do
-          query.geo_spacial(:location.intersects_point => [ 1, 10 ])
-        end
+          let(:selection) do
+            query.public_send(query_method, :location.intersects_point => [ 1, 10 ])
+          end
 
-        it "adds the $geoIntersects expression" do
-          expect(selection.selector).to eq({
-            "location" => {
-              "$geoIntersects" => {
-                "$geometry" => {
-                  "type" => "Point",
-                  "coordinates" => [ 1, 10 ]
+          it "adds the $geoIntersects expression" do
+            expect(selection.selector).to eq({
+              "location" => {
+                "$geoIntersects" => {
+                  "$geometry" => {
+                    "type" => "Point",
+                    "coordinates" => [ 1, 10 ]
+                  }
                 }
               }
-            }
-          })
-        end
+            })
+          end
 
-        it_behaves_like "returns a cloned query"
-      end
+          it_behaves_like "returns a cloned query"
+        end
 
-      context "when the geometry is a line intersection" do
+        context "when the geometry is a line intersection" do
 
-        let(:selection) do
-          query.geo_spacial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
-        end
+          let(:selection) do
+            query.public_send(query_method, :location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
+          end
 
-        it "adds the $geoIntersects expression" do
-          expect(selection.selector).to eq({
-            "location" => {
-              "$geoIntersects" => {
-                "$geometry" => {
-                  "type" => "LineString",
-                  "coordinates" => [[ 1, 10 ], [ 2, 10 ]]
+          it "adds the $geoIntersects expression" do
+            expect(selection.selector).to eq({
+              "location" => {
+                "$geoIntersects" => {
+                  "$geometry" => {
+                    "type" => "LineString",
+                    "coordinates" => [[ 1, 10 ], [ 2, 10 ]]
+                  }
                 }
               }
-            }
-          })
-        end
+            })
+          end
 
-        it_behaves_like "returns a cloned query"
-      end
+          it_behaves_like "returns a cloned query"
+        end
 
-      context "when the geometry is a polygon intersection" do
+        context "when the geometry is a polygon intersection" do
 
-        let(:selection) do
-          query.geo_spacial(
-            :location.intersects_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-          )
-        end
+          let(:selection) do
+            query.public_send(query_method,
+              :location.intersects_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+            )
+          end
 
-        it "adds the $geoIntersects expression" do
-          expect(selection.selector).to eq({
-            "location" => {
-              "$geoIntersects" => {
-                "$geometry" => {
-                  "type" => "Polygon",
-                  "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+          it "adds the $geoIntersects expression" do
+            expect(selection.selector).to eq({
+              "location" => {
+                "$geoIntersects" => {
+                  "$geometry" => {
+                    "type" => "Polygon",
+                    "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+                  }
                 }
               }
-            }
-          })
-        end
-
-        it_behaves_like "returns a cloned query"
-      end
-
-      context "when the geometry is within a polygon" do
+            })
+          end
 
-        let(:selection) do
-          query.geo_spacial(
-            :location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-          )
+          it_behaves_like "returns a cloned query"
         end
 
-        it "adds the $geoIntersects expression" do
-          expect(selection.selector).to eq({
-            "location" => {
-              "$geoWithin" => {
-                "$geometry" => {
-                  "type" => "Polygon",
-                  "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-                }
-              }
-            }
-          })
-        end
+        context "when the geometry is within a polygon" do
 
-        context "when used with the $box operator ($geoWithin query) " do
           let(:selection) do
-            query.geo_spacial(
-              :location.within_box => [[ 1, 10 ], [ 2, 10 ]]
+            query.public_send(query_method,
+              :location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
             )
           end
 
@@ -841,16 +822,37 @@ describe Mongoid::Criteria::Queryable::Selectable do
             expect(selection.selector).to eq({
               "location" => {
                 "$geoWithin" => {
-                  "$box" => [
-                    [ 1, 10 ], [ 2, 10 ]
-                  ]
+                  "$geometry" => {
+                    "type" => "Polygon",
+                    "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+                  }
                 }
               }
             })
           end
-        end
 
-        it_behaves_like "returns a cloned query"
+          context "when used with the $box operator ($geoWithin query) " do
+            let(:selection) do
+              query.public_send(query_method,
+                :location.within_box => [[ 1, 10 ], [ 2, 10 ]]
+              )
+            end
+
+            it "adds the $geoIntersects expression" do
+              expect(selection.selector).to eq({
+                "location" => {
+                  "$geoWithin" => {
+                    "$box" => [
+                      [ 1, 10 ], [ 2, 10 ]
+                    ]
+                  }
+                }
+              })
+            end
+          end
+
+          it_behaves_like "returns a cloned query"
+        end
       end
     end
   end