mongoid 9.0.11 → 9.1.0

data/spec/mongoid/copyable_spec.rb

@@ -1,92 +1,85 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
-require_relative './copyable_spec_models'
+require_relative 'copyable_spec_models'
 
 describe Mongoid::Copyable do
-
-  [ :clone, :dup ].each do |method|
-
+  %i[clone dup].each do |method|
     describe "##{method}" do
-
       let(:person) do
         Person.new(
-          title: "Sir",
+          title: 'Sir',
           version: 4,
           created_at: Time.now,
           updated_at: Time.now,
-          desc: "description"
+          desc: 'description'
         ) do |p|
           p.owner_id = 5
         end
       end
 
       let!(:address) do
-        person.addresses.build(street: "Bond", name: "Bond")
+        person.addresses.build(street: 'Bond', name: 'Bond')
       end
 
       let!(:name) do
-        person.build_name(first_name: "Judy")
+        person.build_name(first_name: 'Judy')
       end
 
       let!(:posts) do
-        person.posts.build(title: "testing")
+        person.posts.build(title: 'testing')
       end
 
       let!(:game) do
-        person.build_game(name: "Tron")
+        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
-
+      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_one("$set" => { "id" => 1234 })
-        end
-
         let!(:cloned) do
           band.reload.send(method)
         end
 
-        it "does not set the id field as the _id" do
-          expect(cloned.id).to_not eq(1234)
+        before do
+          Band.collection.find(_id: band.id).update_one('$set' => { 'id' => 1234 })
         end
-      end
 
-      context "when a document has fields from a legacy schema" do
+        it 'does not set the id field as the _id' do
+          expect(cloned.id).not_to 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")
+            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)
+            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
+          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
+          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
+          it 'copies the known attributes' do
             expect(cloned.name).to eq('test')
           end
 
@@ -115,18 +108,14 @@ describe Mongoid::Copyable do
 
           include_examples 'behaves as expected'
         end
-
       end
 
-      context "when using store_as" do
-
-        context "and dynamic attributes are not set" do
-
+      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")
+            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)
@@ -135,10 +124,8 @@ describe Mongoid::Copyable do
           end
 
           context 'embeds_many' do
-
-
-            it "clones" do
-              t = StoreAsDupTest3.new(:name => "hi")
+            it 'clones' do
+              t = StoreAsDupTest3.new(name: 'hi')
               t.store_as_dup_test4s << StoreAsDupTest4.new
               t.save!
               copy = t.send(method)
@@ -164,13 +151,13 @@ describe Mongoid::Copyable do
         end
       end
 
-      context "when cloning a document with multiple languages field" do
+      context 'when cloning a document with multiple languages field' do
         with_default_i18n_configs
 
         before do
           I18n.locale = 'pt_BR'
-          person.desc = "descrição"
-          person.addresses.first.name = "descrição"
+          person.desc = 'descrição'
+          person.addresses.first.name = 'descrição'
           person.save!
         end
 
@@ -182,64 +169,56 @@ describe Mongoid::Copyable do
           from_db.send(method)
         end
 
-        it "sets the pt_BR version" do
+        it 'sets the pt_BR version' do
           I18n.locale = 'pt_BR'
-          expect(copy.desc).to eq("descrição")
+          expect(copy.desc).to eq('descrição')
         end
 
-        it "sets the english version" do
+        it 'sets the english version' do
           I18n.locale = :en
-          expect(copy.desc).to eq("description")
+          expect(copy.desc).to eq('description')
         end
 
-        it "sets to nil an nonexistent lang" do
+        it 'sets to nil an nonexistent lang' do
           I18n.locale = :fr
           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")
+          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")
+          expect(copy.addresses.first.name).to eq('Bond')
         end
       end
 
-      context "when cloning a document with polymorphic embedded documents with multiple language field" do
+      context 'when cloning a document with polymorphic embedded documents with multiple language field' do
         with_default_i18n_configs
 
-        let!(:shipment_address) do
-          person.addresses.build({ shipping_name: "Title" }, ShipmentAddress)
-        end
+        let(:shipment_address) { person.addresses.build({ shipping_name: 'Title' }, ShipmentAddress) }
+        let(:from_db) { Person.find(person.id) }
+        let(:copy) { from_db.send(method) }
 
         before do
+          shipment_address
+
           I18n.locale = 'pt_BR'
-          person.addresses.type(ShipmentAddress).each { |address| address.shipping_name = "Título" }
+          person.addresses.type(ShipmentAddress).each { |address| address.shipping_name = 'Título' }
           person.save!
         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")
+            expect(address.shipping_name).to eq('Título')
           end
         end
-
       end
 
-      context "when cloning a loaded document" do
-
+      context 'when cloning a loaded document' do
         before do
           person.save!
         end
@@ -252,23 +231,21 @@ describe Mongoid::Copyable do
           from_db.send(method)
         end
 
-        it "marks the fields as dirty" do
-          expect(copy.changes["age"]).to eq([ nil, 100 ])
+        it 'marks the fields as dirty' do
+          expect(copy.changes['age']).to eq([ nil, 100 ])
         end
 
-        it "flags the document as changed" do
+        it 'flags the document as changed' do
           expect(copy).to be_changed
         end
 
-        it "copies protected fields" do
+        it 'copies protected fields' do
           expect(copy.owner_id).to eq(5)
         end
       end
 
-      context "when the document is new" do
-
-        context "when there are changes" do
-
+      context 'when the document is new' do
+        context 'when there are changes' do
           let(:copy) do
             person.send(method)
           end
@@ -277,80 +254,79 @@ describe Mongoid::Copyable do
             person[:versions] = [ { number: 1 } ]
           end
 
-          it "returns a new document" do
-            expect(copy).to_not be_persisted
+          it 'returns a new document' do
+            expect(copy).not_to be_persisted
           end
 
-          it "has an id" do
-            expect(copy.id).to_not be_nil
+          it 'has an id' do
+            expect(copy.id).not_to be_nil
           end
 
-          it "flags the document as changed" do
+          it 'flags the document as changed' do
             expect(copy).to be_changed
           end
 
-          it "marks fields as dirty" do
-            expect(copy.changes["age"]).to eq([ nil, 100 ])
+          it 'marks fields as dirty' do
+            expect(copy.changes['age']).to eq([ nil, 100 ])
           end
 
-          it "has a different id from the original" do
-            expect(copy.id).to_not eq(person.id)
+          it 'has a different id from the original' do
+            expect(copy.id).not_to eq(person.id)
           end
 
-          it "returns a new instance" do
-            expect(copy).to_not be_eql(person)
+          it 'returns a new instance' do
+            expect(copy).not_to eql(person)
           end
 
-          it "copys embeds many documents" do
+          it 'copys embeds many documents' do
             expect(copy.addresses).to eq(person.addresses)
           end
 
-          it "copys deep embeds many documents" do
+          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
+          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
+          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)
+          it 'creates new embeds many instances' do
+            expect(copy.addresses).not_to equal(person.addresses)
           end
 
-          it "creates new deep embeds many instances" do
-            expect(copy.name.translations).to_not equal(person.name.translations)
+          it 'creates new deep embeds many instances' do
+            expect(copy.name.translations).not_to equal(person.name.translations)
           end
 
-          it "copys embeds one documents" do
+          it 'copys embeds one documents' do
             expect(copy.name).to eq(person.name)
           end
 
-          it "flags the embeds one documents as new" do
+          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)
+          it 'creates a new embeds one instance' do
+            expect(copy.name).not_to equal(person.name)
           end
 
-          it "does not copy referenced many documents" do
+          it 'does not copy referenced many documents' do
             expect(copy.posts).to be_empty
           end
 
-          it "does not copy references one documents" do
+          it 'does not copy references one documents' do
             expect(copy.game).to be_nil
           end
 
-          it "copies localized fields" do
-            expect(copy.desc).to eq("description")
+          it 'copies localized fields' do
+            expect(copy.desc).to eq('description')
           end
 
-          context "when saving the copy" do
-
+          context 'when saving the copy' do
             let(:reloaded) do
               copy.reload
             end
@@ -359,23 +335,24 @@ describe Mongoid::Copyable do
               copy.save!(validate: false)
             end
 
-            it "persists the attributes" do
-              expect(reloaded.title).to eq("Sir")
+            it 'persists the attributes' do
+              expect(reloaded.title).to eq('Sir')
             end
 
-            it "persists the embeds many relation" do
+            it 'persists the embeds many relation' do
               expect(reloaded.addresses).to eq(person.addresses)
             end
 
-            it "persists the embeds one relation" do
+            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
+        context 'when using a custom discriminator_key' do
           before do
-            Person.discriminator_key = "dkey"
+            Person.discriminator_key = 'dkey'
+            person[:versions] = [ { number: 1 } ]
           end
 
           after do
@@ -386,48 +363,43 @@ describe Mongoid::Copyable do
             person.send(method)
           end
 
-          before do
-            person[:versions] = [ { number: 1 } ]
-          end
-
-          it "copys embeds many documents" do
+          it 'copys embeds many documents' do
             expect(copy.addresses).to eq(person.addresses)
           end
 
-          it "copys deep embeds many documents" do
+          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
+          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
+          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)
+          it 'creates new embeds many instances' do
+            expect(copy.addresses).not_to equal(person.addresses)
           end
 
-          it "creates new deep embeds many instances" do
-            expect(copy.name.translations).to_not equal(person.name.translations)
+          it 'creates new deep embeds many instances' do
+            expect(copy.name.translations).not_to equal(person.name.translations)
           end
 
-          it "copys embeds one documents" do
+          it 'copys embeds one documents' do
             expect(copy.name).to eq(person.name)
           end
 
-          it "flags the embeds one documents as new" do
+          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)
+          it 'creates a new embeds one instance' do
+            expect(copy.name).not_to equal(person.name)
           end
 
-          context "when saving the copy" do
-
+          context 'when saving the copy' do
             let(:reloaded) do
               copy.reload
             end
@@ -436,29 +408,27 @@ describe Mongoid::Copyable do
               copy.save!(validate: false)
             end
 
-            it "persists the attributes" do
-              expect(reloaded.title).to eq("Sir")
+            it 'persists the attributes' do
+              expect(reloaded.title).to eq('Sir')
             end
 
-            it "persists the embeds many relation" do
+            it 'persists the embeds many relation' do
               expect(reloaded.addresses).to eq(person.addresses)
             end
 
-            it "persists the embeds one relation" do
+            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
-
+      context 'when the document is not new' do
         before do
           person.new_record = false
         end
 
-        context "when there are changes" do
-
+        context 'when there are changes' do
           let(:copy) do
             person.send(method)
           end
@@ -467,56 +437,55 @@ describe Mongoid::Copyable do
             person[:versions] = [ { number: 1 } ]
           end
 
-          it "flags the document as changed" do
+          it 'flags the document as changed' do
             expect(copy).to be_changed
           end
 
-          it "marks fields as dirty" do
-            expect(copy.changes["age"]).to eq([ nil, 100 ])
+          it 'marks fields as dirty' do
+            expect(copy.changes['age']).to eq([ nil, 100 ])
           end
 
-          it "returns a new document" do
-            expect(copy).to_not be_persisted
+          it 'returns a new document' do
+            expect(copy).not_to be_persisted
           end
 
-          it "has an id" do
-            expect(copy.id).to_not be_nil
+          it 'has an id' do
+            expect(copy.id).not_to be_nil
           end
 
-          it "has a different id from the original" do
-            expect(copy.id).to_not eq(person.id)
+          it 'has a different id from the original' do
+            expect(copy.id).not_to eq(person.id)
           end
 
-          it "returns a new instance" do
-            expect(copy).to_not be_eql(person)
+          it 'returns a new instance' do
+            expect(copy).not_to eql(person)
           end
 
-          it "copys embeds many documents" do
+          it 'copys embeds many documents' do
             expect(copy.addresses).to eq(person.addresses)
           end
 
-          it "creates new embeds many instances" do
-            expect(copy.addresses).to_not equal(person.addresses)
+          it 'creates new embeds many instances' do
+            expect(copy.addresses).not_to equal(person.addresses)
           end
 
-          it "copys embeds one documents" do
+          it 'copys embeds one documents' do
             expect(copy.name).to eq(person.name)
           end
 
-          it "creates a new embeds one instance" do
-            expect(copy.name).to_not equal(person.name)
+          it 'creates a new embeds one instance' do
+            expect(copy.name).not_to equal(person.name)
           end
 
-          it "does not copy referenced many documents" do
+          it 'does not copy referenced many documents' do
             expect(copy.posts).to be_empty
           end
 
-          it "does not copy references one documents" do
+          it 'does not copy references one documents' do
             expect(copy.game).to be_nil
           end
 
-          context "when saving the copy" do
-
+          context 'when saving the copy' do
             let(:reloaded) do
               copy.reload
             end
@@ -525,73 +494,71 @@ describe Mongoid::Copyable do
               copy.save!(validate: false)
             end
 
-            it "persists the attributes" do
-              expect(reloaded.title).to eq("Sir")
+            it 'persists the attributes' do
+              expect(reloaded.title).to eq('Sir')
             end
 
-            it "persists the embeds many relation" do
+            it 'persists the embeds many relation' do
               expect(reloaded.addresses).to eq(person.addresses)
             end
 
-            it "persists the embeds one relation" do
+            it 'persists the embeds one relation' do
               expect(reloaded.name).to eq(person.name)
             end
           end
         end
       end
 
-      context "when the document is frozen" do
-
+      context 'when the document is frozen' do
         let!(:copy) do
           person.freeze.send(method)
         end
 
-        it "returns a new document" do
-          expect(copy).to_not be_persisted
+        it 'returns a new document' do
+          expect(copy).not_to be_persisted
         end
 
-        it "has an id" do
-          expect(copy.id).to_not be_nil
+        it 'has an id' do
+          expect(copy.id).not_to be_nil
         end
 
-        it "has a different id from the original" do
-          expect(copy.id).to_not eq(person.id)
+        it 'has a different id from the original' do
+          expect(copy.id).not_to eq(person.id)
         end
 
-        it "returns a new instance" do
-          expect(copy).to_not be_eql(person)
+        it 'returns a new instance' do
+          expect(copy).not_to eql(person)
         end
 
-        it "copys embeds many documents" do
+        it 'copys embeds many documents' do
           expect(copy.addresses).to eq(person.addresses)
         end
 
-        it "creates new embeds many instances" do
-          expect(copy.addresses).to_not equal(person.addresses)
+        it 'creates new embeds many instances' do
+          expect(copy.addresses).not_to equal(person.addresses)
         end
 
-        it "copys embeds one documents" do
+        it 'copys embeds one documents' do
           expect(copy.name).to eq(person.name)
         end
 
-        it "creates a new embeds one instance" do
-          expect(copy.name).to_not equal(person.name)
+        it 'creates a new embeds one instance' do
+          expect(copy.name).not_to equal(person.name)
         end
 
-        it "does not copy referenced many documents" do
+        it 'does not copy referenced many documents' do
           expect(copy.posts).to be_empty
         end
 
-        it "does not copy references one documents" do
+        it 'does not copy references one documents' do
           expect(copy.game).to be_nil
         end
 
-        it "keeps the original attributes frozen" do
+        it 'keeps the original attributes frozen' do
           expect(person.attributes).to be_frozen
         end
 
-        context "when saving the copy" do
-
+        context 'when saving the copy' do
           let(:reloaded) do
             copy.reload
           end
@@ -600,54 +567,43 @@ describe Mongoid::Copyable do
             copy.save!(validate: false)
           end
 
-          it "persists the attributes" do
-            expect(reloaded.title).to eq("Sir")
+          it 'persists the attributes' do
+            expect(reloaded.title).to eq('Sir')
           end
 
-          it "persists the embeds many relation" do
+          it 'persists the embeds many relation' do
             expect(reloaded.addresses).to eq(person.addresses)
           end
 
-          it "persists the embeds one relation" do
+          it 'persists the embeds one relation' do
             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
-
+      context 'when cloning a document with an embedded child class and a custom discriminator value' do
         before do
-          ShipmentAddress.discriminator_value = "dvalue"
+          shipment_address
+          ShipmentAddress.discriminator_value = 'dvalue'
+          person.save!
         end
 
         after do
           ShipmentAddress.discriminator_value = nil
         end
 
-        let!(:shipment_address) do
-          person.addresses.build({}, ShipmentAddress)
-        end
+        let(:shipment_address) { person.addresses.build({}, ShipmentAddress) }
+        let(:from_db) { Person.find(person.id) }
+        let(:copy) { from_db.send(method) }
 
-        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
+        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])
+          CopyableSpec::A.new(influencers: [ child_cls.new ])
         end
 
         let(:copy) do
@@ -662,7 +618,7 @@ describe Mongoid::Copyable do
           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
+            child_cls.discriminator_mapping[child_cls.name].should be_nil
           end
 
           it 'works' do
@@ -679,7 +635,7 @@ describe Mongoid::Copyable do
           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
+            child_cls.discriminator_mapping[child_cls.name].should_not be_nil
           end
 
           it 'works' do
@@ -690,10 +646,8 @@ describe Mongoid::Copyable do
       end
     end
 
-    context "when fields are removed before cloning" do
-
-      context "when using embeds_one associations" do
-
+    context 'when fields are removed before cloning' do
+      context 'when using embeds_one associations' do
         before do
           class CloneParent
             include Mongoid::Document
@@ -722,7 +676,6 @@ describe Mongoid::Copyable do
             field :e, type: :string
             field :f, type: :string
           end
-
         end
 
         after do
@@ -731,15 +684,15 @@ describe Mongoid::Copyable do
           Object.send(:remove_const, :CloneGrandchild)
         end
 
-        context "when removing from the parent" do
-
+        context 'when removing from the parent' do
           before do
-            CloneParent.create(a: "1", b: "2")
+            CloneParent.create(a: '1', b: '2')
 
             Object.send(:remove_const, :CloneParent)
 
             class CloneParent
               include Mongoid::Document
+
               field :a, type: :string
             end
           end
@@ -753,22 +706,21 @@ describe Mongoid::Copyable do
             end.to raise_error(NoMethodError)
           end
 
-          it "contains the missing field in the attributes" do
-            expect(parent.attributes).to include({ "b" => "2" })
+          it 'contains the missing field in the attributes' do
+            expect(parent.attributes).to include({ 'b' => '2' })
           end
 
-          it "clones correctly" do
+          it 'clones correctly' do
             expect(clone).to be_a(CloneParent)
-            expect(clone.a).to eq("1")
-            expect(clone.attributes).to include({ "b" => "2" })
+            expect(clone.a).to eq('1')
+            expect(clone.attributes).to include({ 'b' => '2' })
           end
         end
 
-        context "when removing from the child" do
-
+        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 = CloneParent.new(a: '1', b: '2')
+            parent.clone_child = CloneChild.new(c: '3', d: '4')
             parent.save
 
             Object.send(:remove_const, :CloneParent)
@@ -776,6 +728,7 @@ describe Mongoid::Copyable do
 
             class CloneParent
               include Mongoid::Document
+
               embeds_one :clone_child
               field :a, type: :string
               field :b, type: :string
@@ -783,6 +736,7 @@ describe Mongoid::Copyable do
 
             class CloneChild
               include Mongoid::Document
+
               embedded_in :clone_parent
               field :c, type: :string
             end
@@ -797,29 +751,28 @@ describe Mongoid::Copyable do
             end.to raise_error(NoMethodError)
           end
 
-          it "contains the missing field in the attributes" do
-            expect(parent.clone_child.attributes).to include({ "d" => "4" })
+          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
+          it 'clones the parent correctly' do
             expect(clone).to be_a(CloneParent)
-            expect(clone.a).to eq("1")
-            expect(clone.b).to eq("2")
+            expect(clone.a).to eq('1')
+            expect(clone.b).to eq('2')
           end
 
-          it "clones the child correctly" do
+          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" })
+            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
-
+        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 = 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)
@@ -828,6 +781,7 @@ describe Mongoid::Copyable do
 
             class CloneParent
               include Mongoid::Document
+
               embeds_one :clone_child
               field :a, type: :string
               field :b, type: :string
@@ -835,6 +789,7 @@ describe Mongoid::Copyable do
 
             class CloneChild
               include Mongoid::Document
+
               embedded_in :clone_parent
               embeds_one :clone_grandchild
               field :c, type: :string
@@ -843,6 +798,7 @@ describe Mongoid::Copyable do
 
             class CloneGrandchild
               include Mongoid::Document
+
               embedded_in :clone_child
               field :e, type: :string
             end
@@ -857,32 +813,31 @@ describe Mongoid::Copyable do
             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" })
+          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
+          it 'clones the parent correctly' do
             expect(clone).to be_a(CloneParent)
-            expect(clone.a).to eq("1")
-            expect(clone.b).to eq("2")
+            expect(clone.a).to eq('1')
+            expect(clone.b).to eq('2')
           end
 
-          it "clones the child correctly" do
+          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")
+            expect(clone.clone_child.c).to eq('3')
+            expect(clone.clone_child.d).to eq('4')
           end
 
-          it "clones the child correctly" do
+          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" })
+            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
-
+      context 'when using embeds_many associations' do
         before do
           class CloneParent
             include Mongoid::Document
@@ -911,7 +866,6 @@ describe Mongoid::Copyable do
             field :e, type: :string
             field :f, type: :string
           end
-
         end
 
         after do
@@ -920,15 +874,15 @@ describe Mongoid::Copyable do
           Object.send(:remove_const, :CloneGrandchild)
         end
 
-        context "when removing from the parent" do
-
+        context 'when removing from the parent' do
           before do
-            CloneParent.create(a: "1", b: "2")
+            CloneParent.create(a: '1', b: '2')
 
             Object.send(:remove_const, :CloneParent)
 
             class CloneParent
               include Mongoid::Document
+
               field :a, type: :string
             end
           end
@@ -942,22 +896,21 @@ describe Mongoid::Copyable do
             end.to raise_error(NoMethodError)
           end
 
-          it "contains the missing field in the attributes" do
-            expect(parent.attributes).to include({ "b" => "2" })
+          it 'contains the missing field in the attributes' do
+            expect(parent.attributes).to include({ 'b' => '2' })
           end
 
-          it "clones correctly" do
+          it 'clones correctly' do
             expect(clone).to be_a(CloneParent)
-            expect(clone.a).to eq("1")
-            expect(clone.attributes).to include({ "b" => "2" })
+            expect(clone.a).to eq('1')
+            expect(clone.attributes).to include({ 'b' => '2' })
           end
         end
 
-        context "when removing from the child" do
-
+        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 = 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)
@@ -965,6 +918,7 @@ describe Mongoid::Copyable do
 
             class CloneParent
               include Mongoid::Document
+
               embeds_many :clone_children
               field :a, type: :string
               field :b, type: :string
@@ -972,6 +926,7 @@ describe Mongoid::Copyable do
 
             class CloneChild
               include Mongoid::Document
+
               embedded_in :clone_parent
               field :c, type: :string
             end
@@ -988,34 +943,33 @@ describe Mongoid::Copyable do
             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" })
+          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
+          it 'clones the parent correctly' do
             expect(clone).to be_a(CloneParent)
-            expect(clone.a).to eq("1")
-            expect(clone.b).to eq("2")
+            expect(clone.a).to eq('1')
+            expect(clone.b).to eq('2')
           end
 
-          it "clones the child correctly" do
+          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" })
+              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
-
+        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 = 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") ]
+              cc.clone_grandchildren = [ CloneGrandchild.new(e: '5', f: '6'), CloneGrandchild.new(e: '5', f: '6') ]
             end
             parent.save
 
@@ -1025,6 +979,7 @@ describe Mongoid::Copyable do
 
             class CloneParent
               include Mongoid::Document
+
               embeds_many :clone_children
               field :a, type: :string
               field :b, type: :string
@@ -1032,6 +987,7 @@ describe Mongoid::Copyable do
 
             class CloneChild
               include Mongoid::Document
+
               embedded_in :clone_parent
               embeds_many :clone_grandchildren
               field :c, type: :string
@@ -1040,6 +996,7 @@ describe Mongoid::Copyable do
 
             class CloneGrandchild
               include Mongoid::Document
+
               embedded_in :clone_child
               field :e, type: :string
             end
@@ -1058,44 +1015,43 @@ describe Mongoid::Copyable do
             end
           end
 
-          it "contains the missing field in the attributes" do
+          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" })
+                expect(cg.attributes).to include({ 'f' => '6' })
               end
             end
           end
 
-          it "clones the parent correctly" do
+          it 'clones the parent correctly' do
             expect(clone).to be_a(CloneParent)
-            expect(clone.a).to eq("1")
-            expect(clone.b).to eq("2")
+            expect(clone.a).to eq('1')
+            expect(clone.b).to eq('2')
           end
 
-          it "clones the child correctly" do
+          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" })
+              expect(clone_child.c).to eq('3')
+              expect(clone_child.attributes).to include({ 'd' => '4' })
             end
           end
 
-          it "clones the grandchild correctly" do
+          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" })
+                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
-
+      context 'when using embedded_in associations' do
         before do
           class CloneParent
             include Mongoid::Document
@@ -1121,12 +1077,10 @@ describe Mongoid::Copyable do
           Object.send(:remove_const, :CloneChild)
         end
 
-
-        context "when accessing the parent" do
-
+        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 = CloneParent.new(a: '1', b: '2')
+            parent.clone_child = CloneChild.new(c: '3', d: '4')
             parent.save
           end