mongoid 7.0.10 → 7.4.0

data/spec/mongoid/contextual/none_spec.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Contextual::None do
 
-  describe "#==" do
+  before do
+    Band.create!(name: "Depeche Mode")
+  end
 
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
+  let(:context) do
+    described_class.new(Band.where(name: "Depeche Mode"))
+  end
 
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
+  describe "#==" do
 
     context "when the other is a none" do
-
       let(:other) do
         described_class.new(Band.where(name: "Depeche Mode"))
       end
@@ -24,7 +25,6 @@ describe Mongoid::Contextual::None do
     end
 
     context "when the other is not a none" do
-
       let(:other) do
         Mongoid::Contextual::Memory.new(Band.where(name: "Depeche Mode"))
       end
@@ -36,120 +36,48 @@ describe Mongoid::Contextual::None do
   end
 
   describe "#each" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "iterates over no documents" do
       expect(context.each.entries).to be_empty
     end
   end
 
   describe "#exists?" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns false" do
       expect(context).to_not be_exists
     end
   end
 
   describe "#distinct" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns an empty array" do
       expect(context.distinct(:id)).to eq([])
     end
   end
 
   describe "#pluck" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns an empty array" do
       expect(context.pluck(:id)).to eq([])
     end
   end
 
   describe "#first" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns nil" do
       expect(context.first).to be_nil
     end
   end
 
   describe "#last" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns nil" do
       expect(context.last).to be_nil
     end
   end
 
   describe "#length" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns zero" do
       expect(context.length).to eq(0)
     end
   end
 
   describe "#size" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns zero" do
       expect(context.size).to eq(0)
     end

data/spec/mongoid/copyable_spec.rb

@@ -1,4 +1,5 @@
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
 require "spec_helper"
 
 require_relative './copyable_spec_models'
@@ -44,7 +45,7 @@ describe Mongoid::Copyable do
       context "when the document has an id field in the database" do
 
         let!(:band) do
-          Band.create(name: "Tool")
+          Band.create!(name: "Tool")
         end
 
         before do
@@ -62,30 +63,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)
+          it "sets the legacy attribute" do
+            expect(cloned.attributes['this_is_not_a_field']).to eq(1)
+          end
+
+          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
@@ -97,7 +126,7 @@ describe Mongoid::Copyable do
             it "clones" do
               t = StoreAsDupTest1.new(:name => "hi")
               t.build_store_as_dup_test2(:name => "there")
-              t.save
+              t.save!
               copy = t.send(method)
               expect(copy.object_id).not_to eq(t.object_id)
               expect(copy.store_as_dup_test2.name).to eq(t.store_as_dup_test2.name)
@@ -110,7 +139,7 @@ describe Mongoid::Copyable do
             it "clones" do
               t = StoreAsDupTest3.new(:name => "hi")
               t.store_as_dup_test4s << StoreAsDupTest4.new
-              t.save
+              t.save!
               copy = t.send(method)
               expect(copy.object_id).not_to eq(t.object_id)
               expect(copy.store_as_dup_test4s).not_to be_empty
@@ -141,7 +170,7 @@ describe Mongoid::Copyable do
           I18n.locale = 'pt_BR'
           person.desc = "descrição"
           person.addresses.first.name = "descrição"
-          person.save
+          person.save!
         end
 
         after do
@@ -192,7 +221,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
@@ -219,7 +248,7 @@ describe Mongoid::Copyable do
       context "when cloning a loaded document" do
 
         before do
-          person.save
+          person.save!
         end
 
         let!(:from_db) do
@@ -334,7 +363,84 @@ describe Mongoid::Copyable do
             end
 
             before do
-              copy.save(validate: false)
+              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
+
+        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
@@ -423,7 +529,7 @@ describe Mongoid::Copyable do
             end
 
             before do
-              copy.save(validate: false)
+              copy.save!(validate: false)
             end
 
             it "persists the attributes" do
@@ -498,7 +604,7 @@ describe Mongoid::Copyable do
           end
 
           before do
-            copy.save(validate: false)
+            copy.save!(validate: false)
           end
 
           it "persists the attributes" do
@@ -514,6 +620,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

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 module CopyableSpec
   class A
     include Mongoid::Document
 
     embeds_many :locations
+    embeds_many :influencers
   end
 
   class Location
@@ -14,4 +17,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