mongoid 3.1.5 → 8.0.2

data/spec/mongoid/copyable_spec.rb

@@ -1,6 +1,9 @@
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
 require "spec_helper"
 
+require_relative './copyable_spec_models'
+
 describe Mongoid::Copyable do
 
   [ :clone, :dup ].each do |method|
@@ -20,7 +23,7 @@ describe Mongoid::Copyable do
       end
 
       let!(:address) do
-        person.addresses.build(street: "Bond")
+        person.addresses.build(street: "Bond", name: "Bond")
       end
 
       let!(:name) do
@@ -35,14 +38,18 @@ describe Mongoid::Copyable do
         person.build_game(name: "Tron")
       end
 
+      let!(:name_translations) do
+        person.name.translations.build(language: 'en')
+      end
+
       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
-          Band.collection.find(_id: band.id).update("$set" => { "id" => 1234 })
+          Band.collection.find(_id: band.id).update_one("$set" => { "id" => 1234 })
         end
 
         let!(:cloned) do
@@ -50,16 +57,120 @@ describe Mongoid::Copyable do
         end
 
         it "does not set the id field as the _id" do
-          cloned.id.should_not eq(1234)
+          expect(cloned.id).to_not eq(1234)
+        end
+      end
+
+      context "when a document has fields from a legacy schema" do
+
+        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 }
+            cls.collection.find(_id: instance.id).update_one("$set" => legacy_fields)
+          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 "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(Mongoid::Factory).to receive(:build).with(cls, 'name' => 'test').and_call_original
+            cloned
+          end
+        end
+
+        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
+
+        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
+
+        context "and dynamic attributes are not set" do
+
+          context 'embeds_one' do
+
+            it "clones" do
+              t = StoreAsDupTest1.new(:name => "hi")
+              t.build_store_as_dup_test2(:name => "there")
+              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)
+            end
+          end
+
+          context 'embeds_many' do
+
+
+            it "clones" do
+              t = StoreAsDupTest3.new(:name => "hi")
+              t.store_as_dup_test4s << StoreAsDupTest4.new
+              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
+              expect(copy.store_as_dup_test4s.first.object_id).not_to eq(t.store_as_dup_test4s.first.object_id)
+            end
+          end
+        end
+      end
+
+      context 'nested embeds_many' do
+        it 'works' do
+          a = CopyableSpec::A.new
+          a.locations << CopyableSpec::Location.new
+          a.locations.first.buildings << CopyableSpec::Building.new
+          a.save!
+
+          new_a = a.send(method)
+
+          expect(new_a.locations.length).to be 1
+          expect(new_a.locations.first.buildings.length).to be 1
         end
       end
 
       context "when cloning a document with multiple languages field" do
 
         before do
+          I18n.enforce_available_locales = false
           I18n.locale = 'pt_BR'
           person.desc = "descrição"
-          person.save
+          person.addresses.first.name = "descrição"
+          person.save!
         end
 
         after do
@@ -76,24 +187,68 @@ describe Mongoid::Copyable do
 
         it "sets the pt_BR version" do
           I18n.locale = 'pt_BR'
-          copy.desc.should eq("descrição")
+          expect(copy.desc).to eq("descrição")
         end
 
         it "sets the english version" do
           I18n.locale = :en
-          copy.desc.should eq("description")
+          expect(copy.desc).to eq("description")
         end
 
         it "sets to nil an nonexistent lang" do
           I18n.locale = :fr
-          copy.desc.should be_nil
+          expect(copy.desc).to be_nil
+        end
+
+        it 'sets embedded translations' do
+          I18n.locale = 'pt_BR'
+          expect(copy.addresses.first.name).to eq("descrição")
+        end
+
+        it 'sets embedded english version' do
+          I18n.locale = :en
+          expect(copy.addresses.first.name).to eq("Bond")
         end
       end
 
+      context "when cloning a document with polymorphic embedded documents with multiple language field" do
+
+        let!(:shipment_address) do
+          person.addresses.build({ shipping_name: "Title" }, ShipmentAddress)
+        end
+
+        before do
+          I18n.enforce_available_locales = false
+          I18n.locale = 'pt_BR'
+          person.addresses.type(ShipmentAddress).each { |address| address.shipping_name = "Título" }
+          person.save!
+        end
+
+        after do
+          I18n.locale = :en
+        end
+
+        let!(:from_db) do
+          Person.find(person.id)
+        end
+
+        let(:copy) do
+          from_db.send(method)
+        end
+
+        it 'sets embedded translations' do
+          I18n.locale = 'pt_BR'
+          copy.addresses.type(ShipmentAddress).each do |address|
+            expect(address.shipping_name).to eq("Título")
+          end
+        end
+
+      end
+
       context "when cloning a loaded document" do
 
         before do
-          person.save
+          person.save!
         end
 
         let!(:from_db) do
@@ -105,21 +260,21 @@ describe Mongoid::Copyable do
         end
 
         it "marks the fields as dirty" do
-          copy.changes["age"].should eq([ nil, 100 ])
+          expect(copy.changes["age"]).to eq([ nil, 100 ])
         end
 
         it "flags the document as changed" do
-          copy.should be_changed
+          expect(copy).to be_changed
         end
 
         it "copies protected fields" do
-          copy.owner_id.should eq(5)
+          expect(copy.owner_id).to eq(5)
         end
       end
 
       context "when the document is new" do
 
-        context "when versions exist" do
+        context "when there are changes" do
 
           let(:copy) do
             person.send(method)
@@ -130,71 +285,75 @@ describe Mongoid::Copyable do
           end
 
           it "returns a new document" do
-            copy.should_not be_persisted
+            expect(copy).to_not be_persisted
           end
 
           it "has an id" do
-            copy.id.should_not be_nil
+            expect(copy.id).to_not be_nil
           end
 
           it "flags the document as changed" do
-            copy.should be_changed
+            expect(copy).to be_changed
           end
 
           it "marks fields as dirty" do
-            copy.changes["age"].should eq([ nil, 100 ])
+            expect(copy.changes["age"]).to eq([ nil, 100 ])
           end
 
           it "has a different id from the original" do
-            copy.id.should_not eq(person.id)
+            expect(copy.id).to_not eq(person.id)
           end
 
-          it "does not copy the versions" do
-            copy[:versions].should be_nil
+          it "returns a new instance" do
+            expect(copy).to_not be_eql(person)
           end
 
-          it "resets the document version" do
-            copy.version.should eq(1)
+          it "copys embeds many documents" do
+            expect(copy.addresses).to eq(person.addresses)
           end
 
-          it "returns a new instance" do
-            copy.should_not be_eql(person)
+          it "copys deep embeds many documents" do
+            expect(copy.name.translations).to eq(person.name.translations)
           end
 
-          it "copys embeds many documents" do
-            copy.addresses.should eq(person.addresses)
+          it "sets the embedded many documents as new" do
+            expect(copy.addresses.first).to be_new_record
           end
 
-          it "sets the embedded many documents as new" do
-            copy.addresses.first.should be_new_record
+          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
-            copy.addresses.should_not equal(person.addresses)
+            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
-            copy.name.should eq(person.name)
+            expect(copy.name).to eq(person.name)
           end
 
           it "flags the embeds one documents as new" do
-            copy.name.should be_new_record
+            expect(copy.name).to be_new_record
           end
 
           it "creates a new embeds one instance" do
-            copy.name.should_not equal(person.name)
+            expect(copy.name).to_not equal(person.name)
           end
 
           it "does not copy referenced many documents" do
-            copy.posts.should be_empty
+            expect(copy.posts).to be_empty
           end
 
           it "does not copy references one documents" do
-            copy.game.should be_nil
+            expect(copy.game).to be_nil
           end
 
           it "copies localized fields" do
-            copy.desc.should eq("description")
+            expect(copy.desc).to eq("description")
           end
 
           context "when saving the copy" do
@@ -204,19 +363,96 @@ describe Mongoid::Copyable do
             end
 
             before do
-              copy.save(validate: false)
+              copy.save!(validate: false)
             end
 
             it "persists the attributes" do
-              reloaded.title.should eq("Sir")
+              expect(reloaded.title).to eq("Sir")
             end
 
             it "persists the embeds many relation" do
-              reloaded.addresses.should eq(person.addresses)
+              expect(reloaded.addresses).to eq(person.addresses)
             end
 
             it "persists the embeds one relation" do
-              reloaded.name.should eq(person.name)
+              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
+              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
@@ -228,7 +464,7 @@ describe Mongoid::Copyable do
           person.new_record = false
         end
 
-        context "when versions exist" do
+        context "when there are changes" do
 
           let(:copy) do
             person.send(method)
@@ -239,55 +475,51 @@ describe Mongoid::Copyable do
           end
 
           it "flags the document as changed" do
-            copy.should be_changed
+            expect(copy).to be_changed
           end
 
           it "marks fields as dirty" do
-            copy.changes["age"].should eq([ nil, 100 ])
+            expect(copy.changes["age"]).to eq([ nil, 100 ])
           end
 
           it "returns a new document" do
-            copy.should_not be_persisted
+            expect(copy).to_not be_persisted
           end
 
           it "has an id" do
-            copy.id.should_not be_nil
+            expect(copy.id).to_not be_nil
           end
 
           it "has a different id from the original" do
-            copy.id.should_not eq(person.id)
-          end
-
-          it "does not copy the versions" do
-            copy[:versions].should be_nil
+            expect(copy.id).to_not eq(person.id)
           end
 
           it "returns a new instance" do
-            copy.should_not be_eql(person)
+            expect(copy).to_not be_eql(person)
           end
 
           it "copys embeds many documents" do
-            copy.addresses.should eq(person.addresses)
+            expect(copy.addresses).to eq(person.addresses)
           end
 
           it "creates new embeds many instances" do
-            copy.addresses.should_not equal(person.addresses)
+            expect(copy.addresses).to_not equal(person.addresses)
           end
 
           it "copys embeds one documents" do
-            copy.name.should eq(person.name)
+            expect(copy.name).to eq(person.name)
           end
 
           it "creates a new embeds one instance" do
-            copy.name.should_not equal(person.name)
+            expect(copy.name).to_not equal(person.name)
           end
 
           it "does not copy referenced many documents" do
-            copy.posts.should be_empty
+            expect(copy.posts).to be_empty
           end
 
           it "does not copy references one documents" do
-            copy.game.should be_nil
+            expect(copy.game).to be_nil
           end
 
           context "when saving the copy" do
@@ -297,19 +529,19 @@ describe Mongoid::Copyable do
             end
 
             before do
-              copy.save(validate: false)
+              copy.save!(validate: false)
             end
 
             it "persists the attributes" do
-              reloaded.title.should eq("Sir")
+              expect(reloaded.title).to eq("Sir")
             end
 
             it "persists the embeds many relation" do
-              reloaded.addresses.should eq(person.addresses)
+              expect(reloaded.addresses).to eq(person.addresses)
             end
 
             it "persists the embeds one relation" do
-              reloaded.name.should eq(person.name)
+              expect(reloaded.name).to eq(person.name)
             end
           end
         end
@@ -322,47 +554,47 @@ describe Mongoid::Copyable do
         end
 
         it "returns a new document" do
-          copy.should_not be_persisted
+          expect(copy).to_not be_persisted
         end
 
         it "has an id" do
-          copy.id.should_not be_nil
+          expect(copy.id).to_not be_nil
         end
 
         it "has a different id from the original" do
-          copy.id.should_not eq(person.id)
+          expect(copy.id).to_not eq(person.id)
         end
 
         it "returns a new instance" do
-          copy.should_not be_eql(person)
+          expect(copy).to_not be_eql(person)
         end
 
         it "copys embeds many documents" do
-          copy.addresses.should eq(person.addresses)
+          expect(copy.addresses).to eq(person.addresses)
         end
 
         it "creates new embeds many instances" do
-          copy.addresses.should_not equal(person.addresses)
+          expect(copy.addresses).to_not equal(person.addresses)
         end
 
         it "copys embeds one documents" do
-          copy.name.should eq(person.name)
+          expect(copy.name).to eq(person.name)
         end
 
         it "creates a new embeds one instance" do
-          copy.name.should_not equal(person.name)
+          expect(copy.name).to_not equal(person.name)
         end
 
         it "does not copy referenced many documents" do
-          copy.posts.should be_empty
+          expect(copy.posts).to be_empty
         end
 
         it "does not copy references one documents" do
-          copy.game.should be_nil
+          expect(copy.game).to be_nil
         end
 
         it "keeps the original attributes frozen" do
-          person.attributes.should be_frozen
+          expect(person.attributes).to be_frozen
         end
 
         context "when saving the copy" do
@@ -372,19 +604,544 @@ describe Mongoid::Copyable do
           end
 
           before do
-            copy.save(validate: false)
+            copy.save!(validate: false)
           end
 
           it "persists the attributes" do
-            reloaded.title.should eq("Sir")
+            expect(reloaded.title).to eq("Sir")
           end
 
           it "persists the embeds many relation" do
-            reloaded.addresses.should eq(person.addresses)
+            expect(reloaded.addresses).to eq(person.addresses)
           end
 
           it "persists the embeds one relation" do
-            reloaded.name.should eq(person.name)
+            expect(reloaded.name).to eq(person.name)
+          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
+
+    context "when fields are removed before cloning" do
+
+      context "when using embeds_one associations" do
+
+        before do
+          class CloneParent
+            include Mongoid::Document
+
+            embeds_one :clone_child
+
+            field :a, type: :string
+            field :b, type: :string
+          end
+
+          class CloneChild
+            include Mongoid::Document
+
+            embedded_in :clone_parent
+            embeds_one :clone_grandchild
+
+            field :c, type: :string
+            field :d, type: :string
+          end
+
+          class CloneGrandchild
+            include Mongoid::Document
+
+            embedded_in :clone_child
+
+            field :e, type: :string
+            field :f, type: :string
+          end
+
+        end
+
+        after do
+          Object.send(:remove_const, :CloneParent)
+          Object.send(:remove_const, :CloneChild)
+          Object.send(:remove_const, :CloneGrandchild)
+        end
+
+        context "when removing from the parent" do
+
+          before do
+            CloneParent.create(a: "1", b: "2")
+
+            Object.send(:remove_const, :CloneParent)
+
+            class CloneParent
+              include Mongoid::Document
+              field :a, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            expect do
+              parent.b
+            end.to raise_error(NoMethodError)
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.attributes).to include({ "b" => "2" })
+          end
+
+          it "clones correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.attributes).to include({ "b" => "2" })
+          end
+        end
+
+        context "when removing from the child" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_child = CloneChild.new(c: "3", d: "4")
+            parent.save
+
+            Object.send(:remove_const, :CloneParent)
+            Object.send(:remove_const, :CloneChild)
+
+            class CloneParent
+              include Mongoid::Document
+              embeds_one :clone_child
+              field :a, type: :string
+              field :b, type: :string
+            end
+
+            class CloneChild
+              include Mongoid::Document
+              embedded_in :clone_parent
+              field :c, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            expect do
+              parent.clone_child.d
+            end.to raise_error(NoMethodError)
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.clone_child.attributes).to include({ "d" => "4" })
+          end
+
+          it "clones the parent correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.b).to eq("2")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_child).to be_a(CloneChild)
+            expect(clone.clone_child.c).to eq("3")
+            expect(clone.clone_child.attributes).to include({ "d" => "4" })
+          end
+        end
+
+        context "when removing from the grandchild" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_child = CloneChild.new(c: "3", d: "4")
+            parent.clone_child.clone_grandchild = CloneGrandchild.new(e: "5", f: "6")
+            parent.save
+
+            Object.send(:remove_const, :CloneParent)
+            Object.send(:remove_const, :CloneChild)
+            Object.send(:remove_const, :CloneGrandchild)
+
+            class CloneParent
+              include Mongoid::Document
+              embeds_one :clone_child
+              field :a, type: :string
+              field :b, type: :string
+            end
+
+            class CloneChild
+              include Mongoid::Document
+              embedded_in :clone_parent
+              embeds_one :clone_grandchild
+              field :c, type: :string
+              field :d, type: :string
+            end
+
+            class CloneGrandchild
+              include Mongoid::Document
+              embedded_in :clone_child
+              field :e, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            expect do
+              parent.clone_child.clone_grandchild.f
+            end.to raise_error(NoMethodError)
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.clone_child.clone_grandchild.attributes).to include({ "f" => "6" })
+          end
+
+          it "clones the parent correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.b).to eq("2")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_child).to be_a(CloneChild)
+            expect(clone.clone_child.c).to eq("3")
+            expect(clone.clone_child.d).to eq("4")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_child.clone_grandchild).to be_a(CloneGrandchild)
+            expect(clone.clone_child.clone_grandchild.e).to eq("5")
+            expect(clone.clone_child.clone_grandchild.attributes).to include({ "f" => "6" })
+          end
+        end
+      end
+
+      context "when using embeds_many associations" do
+
+        before do
+          class CloneParent
+            include Mongoid::Document
+
+            embeds_many :clone_children
+
+            field :a, type: :string
+            field :b, type: :string
+          end
+
+          class CloneChild
+            include Mongoid::Document
+
+            embedded_in :clone_parent
+            embeds_many :clone_grandchildren
+
+            field :c, type: :string
+            field :d, type: :string
+          end
+
+          class CloneGrandchild
+            include Mongoid::Document
+
+            embedded_in :clone_child
+
+            field :e, type: :string
+            field :f, type: :string
+          end
+
+        end
+
+        after do
+          Object.send(:remove_const, :CloneParent)
+          Object.send(:remove_const, :CloneChild)
+          Object.send(:remove_const, :CloneGrandchild)
+        end
+
+        context "when removing from the parent" do
+
+          before do
+            CloneParent.create(a: "1", b: "2")
+
+            Object.send(:remove_const, :CloneParent)
+
+            class CloneParent
+              include Mongoid::Document
+              field :a, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            expect do
+              parent.b
+            end.to raise_error(NoMethodError)
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.attributes).to include({ "b" => "2" })
+          end
+
+          it "clones correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.attributes).to include({ "b" => "2" })
+          end
+        end
+
+        context "when removing from the child" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_children = [ CloneChild.new(c: "3", d: "4"), CloneChild.new(c: "3", d: "4") ]
+            parent.save
+
+            Object.send(:remove_const, :CloneParent)
+            Object.send(:remove_const, :CloneChild)
+
+            class CloneParent
+              include Mongoid::Document
+              embeds_many :clone_children
+              field :a, type: :string
+              field :b, type: :string
+            end
+
+            class CloneChild
+              include Mongoid::Document
+              embedded_in :clone_parent
+              field :c, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            parent.clone_children.each do |clone_child|
+              expect do
+                clone_child.d
+              end.to raise_error(NoMethodError)
+            end
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.clone_children[0].attributes).to include({ "d" => "4" })
+            expect(parent.clone_children[1].attributes).to include({ "d" => "4" })
+          end
+
+          it "clones the parent correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.b).to eq("2")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_children.length).to eq(2)
+            clone.clone_children.each do |clone_child|
+              expect(clone_child).to be_a(CloneChild)
+              expect(clone_child.c).to eq("3")
+              expect(clone_child.attributes).to include({ "d" => "4" })
+            end
+          end
+        end
+
+        context "when removing from the grandchild" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_children = [ CloneChild.new(c: "3", d: "4"), CloneChild.new(c: "3", d: "4") ]
+            parent.clone_children.each do |cc|
+              cc.clone_grandchildren = [ CloneGrandchild.new(e: "5", f: "6"), CloneGrandchild.new(e: "5", f: "6") ]
+            end
+            parent.save
+
+            Object.send(:remove_const, :CloneParent)
+            Object.send(:remove_const, :CloneChild)
+            Object.send(:remove_const, :CloneGrandchild)
+
+            class CloneParent
+              include Mongoid::Document
+              embeds_many :clone_children
+              field :a, type: :string
+              field :b, type: :string
+            end
+
+            class CloneChild
+              include Mongoid::Document
+              embedded_in :clone_parent
+              embeds_many :clone_grandchildren
+              field :c, type: :string
+              field :d, type: :string
+            end
+
+            class CloneGrandchild
+              include Mongoid::Document
+              embedded_in :clone_child
+              field :e, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            parent.clone_children.each do |cc|
+              cc.clone_grandchildren.each do |cg|
+                expect do
+                  cg.f
+                end.to raise_error(NoMethodError)
+              end
+            end
+          end
+
+          it "contains the missing field in the attributes" do
+            parent.clone_children.each do |cc|
+              cc.clone_grandchildren.each do |cg|
+                expect(cg.attributes).to include({ "f" => "6" })
+              end
+            end
+          end
+
+          it "clones the parent correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.b).to eq("2")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_children.length).to eq(2)
+            clone.clone_children.each do |clone_child|
+              expect(clone_child).to be_a(CloneChild)
+              expect(clone_child.c).to eq("3")
+              expect(clone_child.attributes).to include({ "d" => "4" })
+            end
+          end
+
+          it "clones the grandchild correctly" do
+            parent.clone_children.each do |cc|
+              expect(cc.clone_grandchildren.length).to eq(2)
+              cc.clone_grandchildren.each do |cg|
+                expect(cg).to be_a(CloneGrandchild)
+                expect(cg.e).to eq("5")
+                expect(cg.attributes).to include({ "f" => "6" })
+              end
+            end
+          end
+        end
+      end
+
+      context "when using embedded_in associations" do
+
+        before do
+          class CloneParent
+            include Mongoid::Document
+
+            embeds_one :clone_child
+
+            field :a, type: :string
+            field :b, type: :string
+          end
+
+          class CloneChild
+            include Mongoid::Document
+
+            embedded_in :clone_parent
+
+            field :c, type: :string
+            field :d, type: :string
+          end
+        end
+
+        after do
+          Object.send(:remove_const, :CloneParent)
+          Object.send(:remove_const, :CloneChild)
+        end
+
+
+        context "when accessing the parent" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_child = CloneChild.new(c: "3", d: "4")
+            parent.save
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.clone_child.send(method) }
+
+          it "doesn't clone the parent" do
+            expect(clone.clone_parent).to be_nil
           end
         end
       end