mongoid 9.0.11 → 9.1.0

data/spec/mongoid/attributes_spec.rb

@@ -1,87 +1,74 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
-require_relative './attributes/nested_spec_models'
+require 'spec_helper'
+require_relative 'attributes/nested_spec_models'
 
 describe Mongoid::Attributes do
-
   describe "\#{attribute}" do
-
-    context "when setting the value in the getter" do
-
+    context 'when setting the value in the getter' do
       let(:account) do
         Account.new
       end
 
-      it "does not cause an infinite loop" do
-        expect(account.overridden).to eq("not recommended")
+      it 'does not cause an infinite loop' do
+        expect(account.overridden).to eq('not recommended')
       end
     end
 
-    context "when the attribute was excluded in a criteria" do
-
+    context 'when the attribute was excluded in a criteria' do
       let!(:person) do
-        Person.create!(title: "sir")
+        Person.create!(title: 'sir')
       end
 
-      context "when the attribute is localized" do
-
+      context 'when the attribute is localized' do
         before do
-          person.update_attribute(:desc, "test")
+          person.update_attribute(:desc, 'test')
         end
 
-        context "when the context includes" do
-
-          context "when the attribute exists" do
-
+        context 'when the context includes' do
+          context 'when the attribute exists' do
             let(:from_db) do
               Person.only(:desc).first
             end
 
-            it "does not raise an error" do
-              expect(from_db.desc).to eq("test")
+            it 'does not raise an error' do
+              expect(from_db.desc).to eq('test')
             end
 
-            context "accessing via []" do
-
-              it "does not raise an error" do
-                expect(from_db["desc"]).to eq("test")
+            context 'accessing via []' do
+              it 'does not raise an error' do
+                expect(from_db['desc']).to eq('test')
               end
             end
 
-            context "when calling only on a sub-document" do
-
-              let(:title) {"Executive"}
-              let(:city) {"NYC"}
+            context 'when calling only on a sub-document' do
+              let(:title) { 'Executive' }
+              let(:city) { 'NYC' }
               let!(:agent) do
-                agent = Agent.new(:title => title)
-                agent.build_address(:city => city)
-                agent.save!()
+                agent = Agent.new(title: title)
+                agent.build_address(city: city)
+                agent.save!
                 agent
               end
               let(:from_db) do
-                Agent.only(:title, "address.city").first
+                Agent.only(:title, 'address.city').first
               end
 
-              context "when the field is in the only" do
-
-                it "does not raise an error" do
+              context 'when the field is in the only' do
+                it 'does not raise an error' do
                   expect(from_db.address.city).to eq(city)
                 end
               end
 
-              context "accessing via []" do
-
-                it "does not raise an error" do
-                  expect(from_db["address.city"]).to eq(city)
+              context 'accessing via []' do
+                it 'does not raise an error' do
+                  expect(from_db['address.city']).to eq(city)
                 end
               end
             end
           end
 
           context 'when the attribute is a hash field' do
-
             before do
               person.update_attribute(:map, map)
             end
@@ -94,19 +81,18 @@ describe Mongoid::Attributes do
               Person.only('map.dates.y.2016').first
             end
 
-            it "does not raise an error" do
+            it 'does not raise an error' do
               expect(from_db.map).to eq(map)
             end
 
             context 'when only one of the hash fields is projected' do
-
               let(:map) do
                 { 'dates' => { 'y' => { '2016' => 'Berlin', '2017' => 'Munich' } } }
               end
 
               let(:expected) do
                 { 'dates' => { 'y' => {
-                  '2016' => 'Berlin',
+                  '2016' => 'Berlin'
                 } } }
               end
 
@@ -116,19 +102,18 @@ describe Mongoid::Attributes do
             end
 
             context 'when several of the hash fields is projected' do
-
               let(:map) do
                 { 'dates' => { 'y' => {
                   '2016' => 'Berlin',
                   '2017' => 'Munich',
-                  '2018' => 'Krakow',
+                  '2018' => 'Krakow'
                 } } }
               end
 
               let(:expected) do
                 { 'dates' => { 'y' => {
                   '2016' => 'Berlin',
-                  '2018' => 'Krakow',
+                  '2018' => 'Krakow'
                 } } }
               end
 
@@ -143,62 +128,58 @@ describe Mongoid::Attributes do
           end
         end
 
-        context "when the context excludes" do
-
-          context "when the attribute exists" do
-
+        context 'when the context excludes' do
+          context 'when the attribute exists' do
             let(:from_db) do
               Person.without(:pets).first
             end
 
-            it "does not raise an error" do
-              expect(from_db.desc).to eq("test")
+            it 'does not raise an error' do
+              expect(from_db.desc).to eq('test')
             end
           end
         end
       end
 
-      context "when excluding with only" do
-
+      context 'when excluding with only' do
         let(:from_db) do
           Person.only(:_id).first
         end
 
-        it "raises an error" do
-          expect {
+        it 'raises an error' do
+          expect do
             from_db.title
-          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+          end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                             /Attempted to access attribute 'title' on Person which was not loaded/)
         end
 
-        context "accessing via []" do
-
-          it "raises an error" do
-            expect {
-              from_db["title"]
-            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+        context 'accessing via []' do
+          it 'raises an error' do
+            expect do
+              from_db['title']
+            end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                               /Attempted to access attribute 'title' on Person which was not loaded/)
           end
         end
       end
 
-      context "when excluding with without" do
-
+      context 'when excluding with without' do
         let(:from_db) do
           Person.without(:title).first
         end
 
-        it "raises an error" do
-          expect {
+        it 'raises an error' do
+          expect do
             from_db.title
-          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+          end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                             /Attempted to access attribute 'title' on Person which was not loaded/)
         end
       end
     end
   end
 
-  describe "#[]" do
-
+  describe '#[]' do
     context 'when the document has a custom attribute type' do
-
       let(:bar) do
         Bar.create!(lat_lng: LatLng.new(52.30, 13.25))
       end
@@ -208,139 +189,125 @@ describe Mongoid::Attributes do
       end
     end
 
-    context "when the document is a new record" do
-
+    context 'when the document is a new record' do
       let(:person) do
         Person.new
       end
 
-      context "when accessing a localized field" do
-
+      context 'when accessing a localized field' do
         before do
-          person.desc = "testing"
+          person.desc = 'testing'
         end
 
-        context "when passing just the name" do
-
-          it "returns the full value" do
-            expect(person[:desc]).to eq("testing")
+        context 'when passing just the name' do
+          it 'returns the full value' do
+            expect(person[:desc]).to eq('testing')
           end
         end
 
-        context "when passing the name with locale" do
-
-          it "returns the value for the locale" do
-            expect(person["desc.en"]).to eq("testing")
+        context 'when passing the name with locale' do
+          it 'returns the value for the locale' do
+            expect(person['desc.en']).to eq('testing')
           end
         end
       end
 
-      context "when attribute does not exist" do
-
-        it "returns the default value" do
+      context 'when attribute does not exist' do
+        it 'returns the default value' do
           expect(person[:age]).to eq(100)
         end
       end
 
-      context "when attribute is not accessible" do
-
+      context 'when attribute is not accessible' do
         before do
           person.owner_id = 5
         end
 
-        it "returns the value" do
+        it 'returns the value' do
           expect(person[:owner_id]).to eq(5)
         end
       end
     end
 
-    context "when the document is an existing record" do
-
+    context 'when the document is an existing record' do
       let!(:person) do
-        Person.create!(title: "sir")
+        Person.create!(title: 'sir')
       end
 
-      context "when the attribute was excluded in a criteria" do
-
-        context "when excluding with only" do
-
+      context 'when the attribute was excluded in a criteria' do
+        context 'when excluding with only' do
           let(:from_db) do
             Person.only(:_id).first
           end
 
-          it "raises an error" do
-            expect {
+          it 'raises an error' do
+            expect do
               from_db[:title]
-            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+            end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                               /Attempted to access attribute 'title' on Person which was not loaded/)
           end
         end
 
-        context "when excluding with without" do
-
+        context 'when excluding with without' do
           let(:from_db) do
             Person.without(:title).first
           end
 
-          it "raises an error" do
-            expect {
+          it 'raises an error' do
+            expect do
               from_db[:title]
-            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+            end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                               /Attempted to access attribute 'title' on Person which was not loaded/)
           end
         end
       end
 
-      context "when given nil" do
-
-        it "returns nil" do
-         expect(person[nil]).to be nil
+      context 'when given nil' do
+        it 'returns nil' do
+          expect(person[nil]).to be_nil
         end
-
       end
 
-      context "when given an empty string" do
-
-        it "returns nil" do
-         expect(person[""]).to be nil
+      context 'when given an empty string' do
+        it 'returns nil' do
+          expect(person['']).to be_nil
         end
-
       end
 
-      context "when the field was not explicitly defined" do
-
-        context "when excluding with only and the field was not excluded" do
-
+      context 'when the field was not explicitly defined' do
+        context 'when excluding with only and the field was not excluded' do
           let(:from_db) do
             Person.only(:_id).first
           end
 
-          it "raises an error" do
-            expect {
+          it 'raises an error' do
+            expect do
               from_db[:undefined_field]
-            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'undefined_field' on Person which was not loaded/)
+            end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                               /Attempted to access attribute 'undefined_field' on Person which was not loaded/)
           end
         end
 
-        context "when excluding with without and the field was excluded" do
-
+        context 'when excluding with without and the field was excluded' do
           let(:from_db) do
             Person.without(:title).first
           end
 
-          it "raises an error" do
-            expect {
+          it 'raises an error' do
+            expect do
               from_db[:title]
-            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+            end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                               /Attempted to access attribute 'title' on Person which was not loaded/)
           end
         end
 
-        context "when excluding with without and the field was not excluded" do
-
+        context 'when excluding with without and the field was not excluded' do
           let(:from_db) do
             Person.without(:title).first
           end
 
-          it "returns nil" do
-            from_db[:undefined_field].should be nil
+          it 'returns nil' do
+            from_db[:undefined_field].should be_nil
           end
         end
       end
@@ -356,7 +323,6 @@ describe Mongoid::Attributes do
           end
 
           context 'when retrieving a field of the association using the dot notation' do
-
             it 'retrieves the field' do
               expect(from_db['name.first_name']).to eq 'Jose'
             end
@@ -384,39 +350,38 @@ describe Mongoid::Attributes do
             it 'raises AttributeNotLoaded' do
               expect do
                 from_db['name.first_name']
-              end.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'name.first_name' on Person which was not loaded/)
+              end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                                 /Attempted to access attribute 'name.first_name' on Person which was not loaded/)
             end
           end
         end
       end
 
-      context "when the attribute does not exist" do
-
+      context 'when the attribute does not exist' do
         before do
           person.collection
-            .find({ _id: person.id })
-            .update_one({ "$unset" => { age: 1 }})
+                .find({ _id: person.id })
+                .update_one({ '$unset' => { age: 1 } })
         end
 
-        context "when found" do
-
+        context 'when found' do
           let(:found) do
             Person.find(person.id)
           end
 
-          it "returns the default value" do
+          it 'returns the default value' do
             expect(found[:age]).to eq(100)
           end
         end
 
-        context "when reloaded" do
+        context 'when reloaded' do
           config_override :raise_not_found_error, false
 
           before do
             person.reload
           end
 
-          it "returns the default value" do
+          it 'returns the default value' do
             expect(person[:age]).to eq(100)
           end
         end
@@ -424,10 +389,12 @@ describe Mongoid::Attributes do
     end
   end
 
-  describe "#[]=" do
+  describe '#[]=' do
+    let(:person) do
+      Person.new
+    end
 
     context 'when the document has a custom attribute type' do
-
       let(:bar) do
         Bar.new.tap do |b|
           b[:lat_lng] = LatLng.new(52.30, 13.25)
@@ -440,36 +407,30 @@ describe Mongoid::Attributes do
       end
     end
 
-    let(:person) do
-      Person.new
-    end
-
-    context "when setting the attribute to nil" do
-
+    context 'when setting the attribute to nil' do
       let!(:age) do
         person[:age] = nil
       end
 
-      it "does not use the default value" do
+      it 'does not use the default value' do
         expect(person.age).to be_nil
       end
 
-      it "returns the set value" do
+      it 'returns the set value' do
         expect(age).to be_nil
       end
     end
 
-    context "when field has a default value" do
-
+    context 'when field has a default value' do
       let!(:terms) do
         person[:terms] = true
       end
 
-      it "allows overwriting of the default value" do
+      it 'allows overwriting of the default value' do
         expect(person.terms).to be true
       end
 
-      it "returns the set value" do
+      it 'returns the set value' do
         expect(terms).to eq(true)
       end
     end
@@ -482,102 +443,96 @@ describe Mongoid::Attributes do
       end
 
       it 'writes the value into attributes' do
-        bar.attributes.should == {'_id' => bar.id, 'missing_field' => 42}
+        bar.attributes.should eq({ '_id' => bar.id, 'missing_field' => 42 })
       end
 
       it 'makes the attribute accessible via []' do
-        bar['missing_field'].should == 42
+        bar['missing_field'].should eq 42
       end
 
       context 'when writing fields on a document with projection' do
-
         let!(:person) do
-          Person.create!(title: "sir")
+          Person.create!(title: 'sir')
         end
 
-        context "when excluding with only and the field was not excluded" do
-
+        context 'when excluding with only and the field was not excluded' do
           let(:from_db) do
             Person.only(:_id).first
           end
 
-          it "raises an error" do
-            expect {
+          it 'raises an error' do
+            expect do
               from_db[:undefined_field] = 'x'
-            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'undefined_field' on Person which was not loaded/)
+            end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                               /Attempted to access attribute 'undefined_field' on Person which was not loaded/)
           end
         end
 
-        context "when excluding with without and the field was excluded" do
-
+        context 'when excluding with without and the field was excluded' do
           let(:from_db) do
             Person.without(:title).first
           end
 
-          it "raises an error" do
-            expect {
+          it 'raises an error' do
+            expect do
               from_db[:title] = 'x'
-            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+            end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                               /Attempted to access attribute 'title' on Person which was not loaded/)
           end
         end
 
-        context "when excluding with without and the field was not excluded" do
-
+        context 'when excluding with without and the field was not excluded' do
           let(:from_db) do
             Person.without(:title).first
           end
 
-          it "writes the value" do
+          it 'writes the value' do
             from_db[:undefined_field] = 'x'
-            from_db[:undefined_field].should == 'x'
+            from_db[:undefined_field].should eq 'x'
           end
         end
       end
     end
   end
 
-  describe "#_id" do
-
+  describe '#_id' do
     let(:person) do
       Person.new
     end
 
-    it "delegates to #id" do
+    it 'delegates to #id' do
       expect(person._id).to eq(person.id)
     end
 
-    context "when #id alias is overridden" do
-
+    context 'when #id alias is overridden' do
       let(:object) do
         IdKey.new(key: 'foo')
       end
 
-      it "delegates to another method" do
+      it 'delegates to another method' do
         expect(object.id).to eq(object.key)
       end
     end
   end
 
-  describe "#_id=" do
-
+  describe '#_id=' do
     after(:all) do
       Person.field(
         :_id,
         type: BSON::ObjectId,
         pre_processed: true,
-        default: ->{ BSON::ObjectId.new },
+        default: -> { BSON::ObjectId.new },
         overwrite: true
       )
     end
 
-    context "when using object ids" do
-
+    context 'when using object ids' do
       before(:all) do
         Person.field(
           :_id,
           type: BSON::ObjectId,
           pre_processed: true,
-          default: ->{ BSON::ObjectId.new },
+          default: -> { BSON::ObjectId.new },
           overwrite: true
         )
       end
@@ -590,61 +545,55 @@ describe Mongoid::Attributes do
         BSON::ObjectId.new
       end
 
-      context "when providing an object id" do
-
+      context 'when providing an object id' do
         before do
           person._id = bson_id
         end
 
-        it "sets the id as the object id" do
+        it 'sets the id as the object id' do
           expect(person.id).to eq(bson_id)
         end
       end
 
-      context "when providing a string" do
-
+      context 'when providing a string' do
         before do
           person._id = bson_id.to_s
         end
 
-        it "sets the id as the object id" do
+        it 'sets the id as the object id' do
           expect(person.id).to eq(bson_id)
         end
       end
 
-      context "when providing an integer" do
-
+      context 'when providing an integer' do
         before do
           person._id = 2
         end
 
-        it "sets the id as the supplied value to_s" do
+        it 'sets the id as the supplied value to_s' do
           expect(person.id).to eq(2)
         end
       end
 
-      context "when #id= alias is overridden" do
-
+      context 'when #id= alias is overridden' do
         let(:object) do
           IdKey.new(key: 'foo')
         end
 
-        it "delegates to another method" do
+        it 'delegates to another method' do
           object.id = 'bar'
           expect(object.id).to eq('bar')
         end
       end
-
     end
 
-    context "when using string ids" do
-
+    context 'when using string ids' do
       before(:all) do
         Person.field(
           :_id,
           type: String,
           pre_processed: true,
-          default: ->{ BSON::ObjectId.new.to_s },
+          default: -> { BSON::ObjectId.new.to_s },
           overwrite: true
         )
       end
@@ -657,42 +606,38 @@ describe Mongoid::Attributes do
         BSON::ObjectId.new
       end
 
-      context "when providing an object id" do
-
+      context 'when providing an object id' do
         before do
           person._id = bson_id
         end
 
-        it "sets the id as the string of the object id" do
+        it 'sets the id as the string of the object id' do
           expect(person.id).to eq(bson_id.to_s)
         end
       end
 
-      context "when providing a string" do
-
+      context 'when providing a string' do
         before do
           person._id = bson_id.to_s
         end
 
-        it "sets the id as the string" do
+        it 'sets the id as the string' do
           expect(person.id).to eq(bson_id.to_s)
         end
       end
 
-      context "when providing an integer" do
-
+      context 'when providing an integer' do
         before do
           person._id = 2
         end
 
-        it "sets the id as the supplied value to_s" do
-          expect(person.id).to eq("2")
+        it 'sets the id as the supplied value to_s' do
+          expect(person.id).to eq('2')
         end
       end
     end
 
-    context "when using integer ids" do
-
+    context 'when using integer ids' do
       before(:all) do
         Person.field(:_id, type: Integer, overwrite: true)
       end
@@ -701,62 +646,57 @@ describe Mongoid::Attributes do
         Person.new
       end
 
-      context "when providing a string" do
-
+      context 'when providing a string' do
         before do
           person._id = 1.to_s
         end
 
-        it "sets the id as the integer" do
+        it 'sets the id as the integer' do
           expect(person.id).to eq(1)
         end
       end
 
-      context "when providing an integer" do
-
+      context 'when providing an integer' do
         before do
           person._id = 2
         end
 
-        it "sets the id as the supplied value" do
+        it 'sets the id as the supplied value' do
           expect(person.id).to eq(2)
         end
       end
     end
   end
 
-  describe "#method_missing" do
-
+  describe '#method_missing' do
     let(:attributes) do
-      { testing: "Testing" }
+      { testing: 'Testing' }
     end
 
     let(:person) do
       Person.new(attributes)
     end
 
-    context "when an attribute exists" do
-
-      it "allows the getter" do
-        expect(person.testing).to eq("Testing")
+    context 'when an attribute exists' do
+      it 'allows the getter' do
+        expect(person.testing).to eq('Testing')
       end
 
-      it "allows the setter" do
-        person.testing = "Test"
-        expect(person.testing).to eq("Test")
+      it 'allows the setter' do
+        person.testing = 'Test'
+        expect(person.testing).to eq('Test')
       end
 
-      it "allows the getter before_type_cast" do
-        expect(person.testing_before_type_cast).to eq("Testing")
+      it 'allows the getter before_type_cast' do
+        expect(person.testing_before_type_cast).to eq('Testing')
       end
 
-      it "returns true for respond_to?" do
+      it 'returns true for respond_to?' do
         expect(person.respond_to?(:testing)).to be true
       end
     end
 
-    context "when the provided value needs mongoization" do
-
+    context 'when the provided value needs mongoization' do
       let(:new_years) do
         DateTime.new(2013, 1, 1, 0, 0, 0)
       end
@@ -765,77 +705,70 @@ describe Mongoid::Attributes do
         person[:new_years] = new_years
       end
 
-      it "mongoizes the dynamic field" do
+      it 'mongoizes the dynamic field' do
         expect(person.new_years).to be_a(Time)
       end
 
-      it "keeps the same value" do
+      it 'keeps the same value' do
         expect(person.new_years).to eq(new_years)
       end
     end
   end
 
-  describe "#process" do
-
-    context "when attributes dont have fields defined" do
-
+  describe '#process' do
+    context 'when attributes dont have fields defined' do
       let(:attributes) do
         {
-          nofieldstring: "Testing",
+          nofieldstring: 'Testing',
           nofieldint: 5,
           employer: Employer.new
         }
       end
 
-      context "when allowing dynamic fields" do
-
+      context 'when allowing dynamic fields' do
         let!(:person) do
           Person.new(attributes)
         end
 
-        context "when attribute is a string" do
-
-          it "adds the string to the attributes" do
-            expect(person.attributes["nofieldstring"]).to eq("Testing")
+        context 'when attribute is a string' do
+          it 'adds the string to the attributes' do
+            expect(person.attributes['nofieldstring']).to eq('Testing')
           end
         end
 
-        context "when attribute is not a string" do
-
-          it "adds a cast value to the attributes" do
-            expect(person.attributes["nofieldint"]).to eq(5)
+        context 'when attribute is not a string' do
+          it 'adds a cast value to the attributes' do
+            expect(person.attributes['nofieldint']).to eq(5)
           end
         end
       end
 
-      context "when not allowing dynamic fields" do
-
-        it "raises an unknown attribute error on instantiation" do
-          expect {
-            Account.new({ anothernew: "Test" })
-          }.to raise_error(Mongoid::Errors::UnknownAttribute)
+      context 'when not allowing dynamic fields' do
+        it 'raises an unknown attribute error on instantiation' do
+          expect do
+            Account.new({ anothernew: 'Test' })
+          end.to raise_error(Mongoid::Errors::UnknownAttribute)
         end
       end
     end
 
-    context "when supplied hash has string values" do
-
+    context 'when supplied hash has string values' do
       let(:bson_id) do
         BSON::ObjectId.new
       end
 
       let!(:attributes) do
         {
-          title: "value",
-          age: "30",
-          terms: "true",
-          score: "",
+          title: 'value',
+          age: '30',
+          terms: 'true',
+          score: '',
           name: {
-            _id: "2", first_name: "Test", last_name: "User"
+            _id: '2', first_name: 'Test', last_name: 'User'
           },
           addresses: [
-            { _id: "3", street: "First Street" },
-            { _id: "4", street: "Second Street" }
+            { _id: '3', street: 'First Street' },
+            { _id: '4', street: 'Second Street' }
           ]
         }
       end
@@ -844,25 +777,23 @@ describe Mongoid::Attributes do
         Person.new(attributes)
       end
 
-      it "casts integers" do
+      it 'casts integers' do
         expect(person[:age]).to eq(30)
       end
 
-      it "casts booleans" do
+      it 'casts booleans' do
         expect(person[:terms]).to be true
       end
 
-      it "sets empty strings to nil" do
+      it 'sets empty strings to nil' do
         expect(person[:score]).to be_nil
       end
     end
 
-    context "when associations provided in the attributes" do
-
-      context "when association is a has_one" do
-
+    context 'when associations provided in the attributes' do
+      context 'when association is a has_one' do
         let(:name) do
-          Name.new(first_name: "Testy")
+          Name.new(first_name: 'Testy')
         end
 
         let(:attributes) do
@@ -873,13 +804,12 @@ describe Mongoid::Attributes do
           Person.new(attributes)
         end
 
-        it "sets the associations" do
+        it 'sets the associations' do
           expect(person.name).to eq(name)
         end
       end
 
-      context "when association is a references_one" do
-
+      context 'when association is a references_one' do
         let(:game) do
           Game.new(score: 100)
         end
@@ -892,52 +822,49 @@ describe Mongoid::Attributes do
           Person.new(attributes)
         end
 
-        it "sets the parent association" do
+        it 'sets the parent association' do
           expect(person.game).to eq(game)
         end
 
-        it "sets the inverse association" do
+        it 'sets the inverse association' do
           expect(game.person).to eq(person)
         end
       end
 
-      context "when association is a embedded_in" do
-
+      context 'when association is a embedded_in' do
         let(:person) do
           Person.new
         end
 
         let(:name) do
-          Name.new(first_name: "Tyler", person: person)
+          Name.new(first_name: 'Tyler', person: person)
         end
 
-        it "sets the association" do
+        it 'sets the association' do
           expect(name.person).to eq(person)
         end
       end
     end
 
-    context "when non-associations provided in the attributes" do
-
+    context 'when non-associations provided in the attributes' do
       let(:employer) do
         Employer.new
       end
 
       let(:attributes) do
-        { employer_id: employer.id, title: "Sir" }
+        { employer_id: employer.id, title: 'Sir' }
       end
 
       let(:person) do
         Person.new(attributes)
       end
 
-      it "calls the setter for the association" do
-        expect(person.employer_id).to eq("1")
+      it 'calls the setter for the association' do
+        expect(person.employer_id).to eq('1')
       end
     end
 
-    context "when an empty array is provided in the attributes" do
-
+    context 'when an empty array is provided in the attributes' do
       let(:attributes) do
         { aliases: [] }
       end
@@ -946,13 +873,12 @@ describe Mongoid::Attributes do
         Person.new(attributes)
       end
 
-      it "sets the empty array" do
+      it 'sets the empty array' do
         expect(person.aliases).to be_empty
       end
     end
 
-    context "when an empty hash is provided in the attributes" do
-
+    context 'when an empty hash is provided in the attributes' do
       let(:attributes) do
         { map: {} }
       end
@@ -961,48 +887,44 @@ describe Mongoid::Attributes do
         Person.new(attributes)
       end
 
-      it "sets the empty hash" do
+      it 'sets the empty hash' do
         expect(person.map).to eq({})
       end
     end
 
-    context "when providing tainted parameters" do
-
+    context 'when providing tainted parameters' do
       let(:params) do
-        ActionController::Parameters.new(title: "sir")
+        ActionController::Parameters.new(title: 'sir')
       end
 
-      it "raises an error" do
-        expect {
+      it 'raises an error' do
+        expect do
           Person.new(params)
-        }.to raise_error(ActiveModel::ForbiddenAttributesError)
+        end.to raise_error(ActiveModel::ForbiddenAttributesError)
       end
     end
   end
 
-  context "updating when attributes already exist" do
-
+  context 'updating when attributes already exist' do
     let(:person) do
-      Person.new(title: "Sir")
+      Person.new(title: 'Sir')
     end
 
     let(:attributes) do
-      { dob: "2000-01-01" }
+      { dob: '2000-01-01' }
     end
 
     before do
       person.process_attributes(attributes)
     end
 
-    it "only overwrites supplied attributes" do
-      expect(person.title).to eq("Sir")
+    it 'only overwrites supplied attributes' do
+      expect(person.title).to eq('Sir')
     end
   end
 
-  describe "#read_attribute" do
-
+  describe '#read_attribute' do
     context 'when the document has a custom attribute type' do
-
       let(:bar) do
         Bar.create!(lat_lng: LatLng.new(52.30, 13.25))
       end
@@ -1012,204 +934,185 @@ describe Mongoid::Attributes do
       end
     end
 
-    context "when the document is a new record" do
-
+    context 'when the document is a new record' do
       let(:person) do
         Person.new
       end
 
-      context "when attribute does not exist" do
-
-        it "returns the default value" do
+      context 'when attribute does not exist' do
+        it 'returns the default value' do
           expect(person.age).to eq(100)
           expect(person.pets).to be false
         end
-
       end
 
-      context "when attribute is not accessible" do
-
+      context 'when attribute is not accessible' do
         before do
           person.owner_id = 5
         end
 
-        it "returns the value" do
+        it 'returns the value' do
           expect(person.read_attribute(:owner_id)).to eq(5)
         end
       end
     end
 
-    context "when the document is an existing record" do
-
+    context 'when the document is an existing record' do
       let(:person) do
         Person.create!
       end
 
-      context "when the attribute does not exist" do
+      context 'when the attribute does not exist' do
         config_override :raise_not_found_error, false
 
         before do
           person.collection
-            .find({ _id: person.id })
-            .update_one({ "$unset" => { age: 1 }})
+                .find({ _id: person.id })
+                .update_one({ '$unset' => { age: 1 } })
           person.reload
         end
 
-        it "returns the default value" do
+        it 'returns the default value' do
           expect(person.age).to eq(100)
         end
       end
     end
 
-    context "when attribute has an aliased name" do
-
+    context 'when attribute has an aliased name' do
       let(:person) do
         Person.new
       end
 
-      before(:each) do
-        person.write_attribute(:t, "aliased field to test")
+      before do
+        person.write_attribute(:t, 'aliased field to test')
       end
 
-      it "returns the value of the aliased field" do
-        expect(person.read_attribute(:test)).to eq("aliased field to test")
+      it 'returns the value of the aliased field' do
+        expect(person.read_attribute(:test)).to eq('aliased field to test')
       end
     end
   end
 
-  describe "#read_attribute_before_type_cast" do
-
+  describe '#read_attribute_before_type_cast' do
     let(:person) do
       Person.create!
     end
 
-    context "when the attribute has not yet been assigned" do
-
-      it "returns the default value" do
+    context 'when the attribute has not yet been assigned' do
+      it 'returns the default value' do
         expect(person.age_before_type_cast).to eq(100)
       end
     end
 
-    context "after the attribute has been assigned" do
-
-      it "returns the default value" do
-        person.age = "42"
-        expect(person.age_before_type_cast).to eq("42")
+    context 'after the attribute has been assigned' do
+      it 'returns the default value' do
+        person.age = '42'
+        expect(person.age_before_type_cast).to eq('42')
       end
     end
 
     context 'when reading fields on a document with projection' do
-
       let!(:person) do
-        Person.create!(title: "sir")
+        Person.create!(title: 'sir')
       end
 
-      context "when excluding with only and the field was not excluded" do
-
+      context 'when excluding with only and the field was not excluded' do
         let(:from_db) do
           Person.only(:_id).first
         end
 
-        it "raises an error" do
-          expect {
+        it 'raises an error' do
+          expect do
             from_db.read_attribute(:undefined_field)
-          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'undefined_field' on Person which was not loaded/)
+          end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                             /Attempted to access attribute 'undefined_field' on Person which was not loaded/)
         end
       end
 
-      context "when excluding with without and the field was excluded" do
-
+      context 'when excluding with without and the field was excluded' do
         let(:from_db) do
           Person.without(:title).first
         end
 
-        it "raises an error" do
-          expect {
+        it 'raises an error' do
+          expect do
             from_db.read_attribute(:title)
-          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+          end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                             /Attempted to access attribute 'title' on Person which was not loaded/)
         end
       end
 
-      context "when excluding with without and the field was not excluded" do
-
+      context 'when excluding with without and the field was not excluded' do
         let(:from_db) do
           Person.without(:title).first
         end
 
-        it "returns nil" do
-          from_db.read_attribute(:undefined_field).should be nil
+        it 'returns nil' do
+          from_db.read_attribute(:undefined_field).should be_nil
         end
       end
     end
   end
 
-  describe "#attribute_present?" do
-
-    context "when document is a new record" do
-
+  describe '#attribute_present?' do
+    context 'when document is a new record' do
       let(:person) do
         Person.new
       end
 
-      context "when attribute does not exist" do
-
-        it "returns false" do
+      context 'when attribute does not exist' do
+        it 'returns false' do
           expect(person.attribute_present?(:owner_id)).to be false
         end
       end
 
-      context "when attribute does exist" do
+      context 'when attribute does exist' do
         before do
           person.owner_id = 5
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person.attribute_present?(:owner_id)).to be true
         end
       end
     end
 
-    context "when the document is an existing record" do
-
+    context 'when the document is an existing record' do
       let(:person) do
         Person.create!
       end
 
-      context "when the attribute does not exist" do
+      context 'when the attribute does not exist' do
         config_override :raise_not_found_error, false
 
         before do
           person.collection
-            .find({ _id: person.id })
-            .update_one({ "$unset" => { age: 1 }})
+                .find({ _id: person.id })
+                .update_one({ '$unset' => { age: 1 } })
           person.reload
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person.attribute_present?(:age)).to be true
         end
       end
     end
 
-    context "when the value is boolean" do
-
+    context 'when the value is boolean' do
       let(:person) do
         Person.new
       end
 
-      context "when attribute does not exist" do
-
-        context "when the value is true" do
-
-          it "return true"  do
+      context 'when attribute does not exist' do
+        context 'when the value is true' do
+          it 'return true' do
             person.terms = false
             expect(person.attribute_present?(:terms)).to be true
           end
         end
 
-        context "when the value is false" do
-
-          it "return true"  do
+        context 'when the value is false' do
+          it 'return true' do
             person.terms = false
             expect(person.attribute_present?(:terms)).to be true
           end
@@ -1217,153 +1120,137 @@ describe Mongoid::Attributes do
       end
     end
 
-    context "when the value is blank string" do
-
+    context 'when the value is blank string' do
       let(:person) do
         Person.new(title: '')
       end
 
-      it "return false" do
+      it 'return false' do
         expect(person.attribute_present?(:title)).to be false
       end
     end
 
-    context "when the attribute is not on only list" do
-
+    context 'when the attribute is not on only list' do
       before { Person.create! }
+
       let(:person) do
         Person.only(:id).first
       end
 
-      it "return false" do
+      it 'return false' do
         expect(person.attribute_present?(:foobar)).to be false
       end
     end
   end
 
-  describe "#has_attribute?" do
-
+  describe '#has_attribute?' do
     let(:person) do
-      Person.new(title: "sir")
+      Person.new(title: 'sir')
     end
 
-    context "when the key is in the attributes" do
-
-      context "when provided a symbol" do
-
-        it "returns true" do
+    context 'when the key is in the attributes' do
+      context 'when provided a symbol' do
+        it 'returns true' do
           expect(person.has_attribute?(:title)).to be true
         end
       end
 
-      context "when provided a string" do
-
-        it "returns true" do
-          expect(person.has_attribute?("title")).to be true
+      context 'when provided a string' do
+        it 'returns true' do
+          expect(person.has_attribute?('title')).to be true
         end
       end
     end
 
-    context "when the key is not in the attributes" do
-
-      it "returns false" do
+    context 'when the key is not in the attributes' do
+      it 'returns false' do
         expect(person.has_attribute?(:employer_id)).to be false
       end
     end
   end
 
   describe '#has_attribute_before_type_cast?' do
-
     let(:person) do
       Person.new
     end
 
-    context "before the attribute has been assigned" do
-
-      it "returns true" do
+    context 'before the attribute has been assigned' do
+      it 'returns true' do
         expect(person.has_attribute_before_type_cast?(:age)).to be true
       end
     end
 
-    context "after the attribute has been assigned" do
-
-      it "returns true" do
+    context 'after the attribute has been assigned' do
+      it 'returns true' do
         person.age = '42'
         expect(person.has_attribute_before_type_cast?(:age)).to be true
       end
     end
   end
 
-  describe "#remove_attribute" do
-
-    context "when the attribute exists" do
-
+  describe '#remove_attribute' do
+    context 'when the attribute exists' do
       let(:person) do
-        Person.create!(title: "Sir")
+        Person.create!(title: 'Sir')
       end
 
       before do
         person.remove_attribute(:title)
       end
 
-      it "removes the attribute" do
+      it 'removes the attribute' do
         expect(person.title).to be_nil
       end
 
-      it "removes the key from the attributes hash" do
+      it 'removes the key from the attributes hash' do
         expect(person.has_attribute?(:title)).to be false
       end
 
-      context "when saving after the removal" do
-
+      context 'when saving after the removal' do
         before do
           person.save!
         end
 
-        it "persists the removal" do
+        it 'persists the removal' do
           expect(person.reload.has_attribute?(:title)).to be false
         end
       end
     end
 
-    context "when the attribute exists in embedded document" do
-
-     let(:pet) do
-       Animal.new(name: "Cat")
-     end
-
-     let(:person) do
-       Person.new(pet: pet)
-     end
-
-     before do
-       person.save!
-       person.pet.remove_attribute(:name)
-     end
+    context 'when the attribute exists in embedded document' do
+      let(:pet) do
+        Animal.new(name: 'Cat')
+      end
 
-     it "removes the attribute" do
-       expect(person.pet.name).to be_nil
-     end
+      let(:person) do
+        Person.new(pet: pet)
+      end
 
-     it "removes the key from the attributes hash" do
-       expect(person.pet.has_attribute?(:name)).to be false
-     end
+      before do
+        person.save!
+        person.pet.remove_attribute(:name)
+      end
 
-     context "when saving after the removal" do
+      it 'removes the attribute' do
+        expect(person.pet.name).to be_nil
+      end
 
-       before do
-         person.save!
-       end
+      it 'removes the key from the attributes hash' do
+        expect(person.pet.has_attribute?(:name)).to be false
+      end
 
-       it "persists the removal" do
-         expect(person.reload.pet.has_attribute?(:name)).to be false
-       end
-     end
+      context 'when saving after the removal' do
+        before do
+          person.save!
+        end
 
+        it 'persists the removal' do
+          expect(person.reload.pet.has_attribute?(:name)).to be false
+        end
+      end
     end
 
-    context "when the attribute does not exist" do
-
+    context 'when the attribute does not exist' do
       let(:person) do
         Person.new
       end
@@ -1372,30 +1259,27 @@ describe Mongoid::Attributes do
         person.remove_attribute(:title)
       end
 
-      it "does not fail" do
+      it 'does not fail' do
         expect(person.title).to be_nil
       end
     end
 
-    context "when the document is new" do
-
+    context 'when the document is new' do
       let(:person) do
-        Person.new(title: "sir")
+        Person.new(title: 'sir')
       end
 
       before do
         person.remove_attribute(:title)
       end
 
-      it "does not add a delayed unset operation" do
+      it 'does not add a delayed unset operation' do
         expect(person.delayed_atomic_unsets).to be_empty
       end
     end
 
-    context "when the attribute is aliased" do
-
+    context 'when the attribute is aliased' do
       context 'when the database name is used' do
-
         let(:person) do
           Person.create!(at: Time.now)
         end
@@ -1404,28 +1288,26 @@ describe Mongoid::Attributes do
           person.remove_attribute(:at)
         end
 
-        it "removes the attribute" do
+        it 'removes the attribute' do
           expect(person.at).to be_nil
         end
 
-        it "removes the key from the attributes hash" do
+        it 'removes the key from the attributes hash' do
           expect(person.has_attribute?(:at)).to be false
         end
 
-        context "when saving after the removal" do
-
+        context 'when saving after the removal' do
           before do
             person.save!
           end
 
-          it "persists the removal" do
+          it 'persists the removal' do
             expect(person.reload.has_attribute?(:at)).to be false
           end
         end
       end
 
       context 'when the alias is used' do
-
         let(:person) do
           Person.create!(aliased_timestamp: Time.now)
         end
@@ -1434,21 +1316,20 @@ describe Mongoid::Attributes do
           person.remove_attribute(:aliased_timestamp)
         end
 
-        it "removes the attribute" do
+        it 'removes the attribute' do
           expect(person.aliased_timestamp).to be_nil
         end
 
-        it "removes the key from the attributes hash" do
+        it 'removes the key from the attributes hash' do
           expect(person.has_attribute?(:aliased_timestamp)).to be false
         end
 
-        context "when saving after the removal" do
-
+        context 'when saving after the removal' do
           before do
             person.save!
           end
 
-          it "persists the removal" do
+          it 'persists the removal' do
             expect(person.reload.has_attribute?(:aliased_timestamp)).to be false
           end
         end
@@ -1456,116 +1337,100 @@ describe Mongoid::Attributes do
     end
   end
 
-  describe "#respond_to?" do
-
-    context "when allowing dynamic fields" do
-
+  describe '#respond_to?' do
+    context 'when allowing dynamic fields' do
       let(:person) do
         Person.new
       end
 
-      context "when asking for the getter" do
-
-        context "when the attribute exists" do
-
+      context 'when asking for the getter' do
+        context 'when the attribute exists' do
           before do
-            person[:attr] = "test"
+            person[:attr] = 'test'
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(person).to respond_to(:attr)
           end
         end
 
-        context "when the attribute does not exist" do
-
-          it "returns false" do
-            expect(person).to_not respond_to(:attr)
+        context 'when the attribute does not exist' do
+          it 'returns false' do
+            expect(person).not_to respond_to(:attr)
           end
         end
       end
 
-      context "when asking for the setter" do
-
-        context "when the attribute exists" do
-
+      context 'when asking for the setter' do
+        context 'when the attribute exists' do
           before do
-            person[:attr] = "test"
+            person[:attr] = 'test'
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(person).to respond_to(:attr=)
           end
         end
 
-        context "when the attribute does not exist" do
-
-          it "returns false" do
-            expect(person).to_not respond_to(:attr=)
+        context 'when the attribute does not exist' do
+          it 'returns false' do
+            expect(person).not_to respond_to(:attr=)
           end
         end
       end
     end
 
-    context "when not allowing dynamic fields" do
-
+    context 'when not allowing dynamic fields' do
       let(:bar) do
         Bar.new
       end
 
-      context "when asking for the getter" do
-
-        it "returns false" do
-          expect(bar).to_not respond_to(:attr)
+      context 'when asking for the getter' do
+        it 'returns false' do
+          expect(bar).not_to respond_to(:attr)
         end
       end
 
-      context "when asking for the setter" do
-
-        it "returns false" do
-          expect(bar).to_not respond_to(:attr=)
+      context 'when asking for the setter' do
+        it 'returns false' do
+          expect(bar).not_to respond_to(:attr=)
         end
       end
     end
   end
 
-  describe "#write_attribute" do
-
-    context "when attribute does not exist" do
-
+  describe '#write_attribute' do
+    context 'when attribute does not exist' do
       let(:person) do
         Person.new
       end
 
-      it "returns the default value" do
+      it 'returns the default value' do
         expect(person.age).to eq(100)
       end
     end
 
-    context "when setting an attribute that needs type casting" do
-
+    context 'when setting an attribute that needs type casting' do
       let(:person) do
-        Person.new(age: "42")
+        Person.new(age: '42')
       end
 
-      it "should store the attribute before type cast" do
-        expect(person.age_before_type_cast).to eq("42")
+      it 'stores the attribute before type cast' do
+        expect(person.age_before_type_cast).to eq('42')
       end
     end
 
-    context "when setting the attribute to nil" do
-
+    context 'when setting the attribute to nil' do
       let(:person) do
         Person.new(age: nil)
       end
 
-      it "does not use the default value" do
+      it 'does not use the default value' do
         expect(person.age).to be_nil
       end
     end
 
-    context "when field has a default value" do
-
+    context 'when field has a default value' do
       let(:person) do
         Person.new
       end
@@ -1574,121 +1439,118 @@ describe Mongoid::Attributes do
         person.terms = true
       end
 
-      it "allows overwriting of the default value" do
+      it 'allows overwriting of the default value' do
         expect(person.terms).to be true
       end
     end
 
-    context "when attribute has an aliased name" do
-
+    context 'when attribute has an aliased name' do
       let(:person) do
         Person.new
       end
 
-      before(:each) do
-        person.write_attribute(:test, "aliased field to test")
+      before do
+        person.write_attribute(:test, 'aliased field to test')
       end
 
-      it "allows the field name to be updated" do
-        expect(person.t).to eq("aliased field to test")
+      it 'allows the field name to be updated' do
+        expect(person.t).to eq('aliased field to test')
       end
     end
 
-    context "when attribute is a Hash" do
-      let(:person) { Person.new map: { somekey: "somevalue" } }
+    context 'when attribute is a Hash' do
+      let(:person) { Person.new map: { somekey: 'somevalue' } }
 
-      it "writes nil when trying to set a value of invalid type - array" do
+      it 'writes nil when trying to set a value of invalid type - array' do
         person.map = []
         expect(person.map).to be_nil
       end
 
-      it "writes nil when trying to set a value of invalid type - boolean" do
+      it 'writes nil when trying to set a value of invalid type - boolean' do
         person.map = false
         expect(person.map).to be_nil
       end
 
-      it "can set a Hash value with stringified keys" do
-        expect(person.map).to eq( { "somekey" => "somevalue" } )
+      it 'can set a Hash value with stringified keys' do
+        expect(person.map).to eq({ 'somekey' => 'somevalue' })
       end
     end
 
-    context "when attribute is an Array" do
+    context 'when attribute is an Array' do
       let(:person) { Person.new aliases: [ :alias_1 ] }
 
-      it "can set an Array Value" do
+      it 'can set an Array Value' do
         expect(person.aliases).to eq([ :alias_1 ])
       end
 
-      it "writes nil when trying to set a value of invalid type - hash" do
+      it 'writes nil when trying to set a value of invalid type - hash' do
         person.aliases = {}
         expect(person.aliases).to be_nil
       end
 
-      it "writes nil when trying to set a value of invalid type - boolean" do
+      it 'writes nil when trying to set a value of invalid type - boolean' do
         person.aliases = false
         expect(person.aliases).to be_nil
       end
     end
 
-    context "when attribute is localized and #attributes is a BSON::Document" do
+    context 'when attribute is localized and #attributes is a BSON::Document' do
       let(:dictionary) { Dictionary.new }
 
       before do
         allow(dictionary).to receive(:attributes).and_return(BSON::Document.new)
       end
 
-      it "sets the value for the current locale" do
+      it 'sets the value for the current locale' do
         dictionary.write_attribute(:description, 'foo')
         expect(dictionary.description).to eq('foo')
       end
     end
 
     context 'when writing fields on a document with projection' do
-
       let!(:person) do
-        Person.create!(title: "sir")
+        Person.create!(title: 'sir')
       end
 
-      context "when excluding with only and the field was not excluded" do
-
+      context 'when excluding with only and the field was not excluded' do
         let(:from_db) do
           Person.only(:_id).first
         end
 
-        it "raises an error" do
-          expect {
+        it 'raises an error' do
+          expect do
             from_db.write_attribute(:undefined_field, 'x')
-          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'undefined_field' on Person which was not loaded/)
+          end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                             /Attempted to access attribute 'undefined_field' on Person which was not loaded/)
         end
       end
 
-      context "when excluding with without and the field was excluded" do
-
+      context 'when excluding with without and the field was excluded' do
         let(:from_db) do
           Person.without(:title).first
         end
 
-        it "raises an error" do
-          expect {
+        it 'raises an error' do
+          expect do
             from_db.write_attribute(:title, 'x')
-          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+          end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                             /Attempted to access attribute 'title' on Person which was not loaded/)
         end
       end
 
-      context "when excluding with without and the field was not excluded" do
-
+      context 'when excluding with without and the field was not excluded' do
         let(:from_db) do
           Person.without(:title).first
         end
 
-        it "writes the value" do
+        it 'writes the value' do
           from_db.write_attribute(:undefined_field, 'x')
-          from_db.read_attribute(:undefined_field).should == 'x'
+          from_db.read_attribute(:undefined_field).should eq 'x'
         end
       end
     end
 
-    context "when comparing the object_ids of the written value" do
+    context 'when comparing the object_ids of the written value' do
       before do
         Person.create!
       end
@@ -1697,34 +1559,32 @@ describe Mongoid::Attributes do
         Person.first
       end
 
-      context "when the field is not resizable" do
+      context 'when the field is not resizable' do
         let(:test) do
-          person.write_attribute(:test, "aliased field to test")
+          person.write_attribute(:test, 'aliased field to test')
         end
 
-        it "has the same object_id as the attributes hash value" do
+        it 'has the same object_id as the attributes hash value' do
           expect(test.object_id).to eq(person.test.object_id)
         end
       end
 
-      context "when the field is resizable" do
-
+      context 'when the field is resizable' do
         let(:arrays) do
           person.write_attribute(:arrays, [])
         end
 
-        it "has the same object_id as the attributes hash value" do
+        it 'has the same object_id as the attributes hash value' do
           expect(arrays.object_id).to eq(person.arrays.object_id)
         end
       end
 
-      context "when the field is a HABTM foreign key array" do
-
+      context 'when the field is a HABTM foreign key array' do
         let(:preference_ids) do
           person.write_attribute(:preference_ids, [])
         end
 
-        it "has the same object_id as the attributes hash value" do
+        it 'has the same object_id as the attributes hash value' do
           expect(preference_ids.object_id).to eq(person.preference_ids.object_id)
         end
       end
@@ -1734,54 +1594,49 @@ describe Mongoid::Attributes do
       config_override :map_big_decimal_to_decimal128, true
 
       context 'when writing an identical number' do
-        let(:band) { Band.create!(name: 'Nirvana', sales: 123456.78).reload }
+        let(:band) { Band.create!(name: 'Nirvana', sales: 123_456.78).reload }
 
         it 'does not mark the document as changed' do
-          band.sales = 123456.78
+          band.sales = 123_456.78
           expect(band.changed?).to be false
         end
       end
     end
   end
 
-  describe "#typed_value_for" do
-
+  describe '#typed_value_for' do
     let(:person) do
       Person.new
     end
 
-    context "when the key has been specified as a field" do
-
-      it "retuns the typed value" do
-        person.send(:typed_value_for, "age", "51")
+    context 'when the key has been specified as a field' do
+      it 'returns the typed value' do
+        person.send(:typed_value_for, 'age', '51')
       end
     end
 
-    context "when the key has not been specified as a field" do
-
+    context 'when the key has not been specified as a field' do
       before do
         allow(person).to receive(:fields).and_return({})
       end
 
-      it "returns the value" do
-        person.send(:typed_value_for, "age", expect("51")).to eq("51")
+      it 'returns the value' do
+        person.send(:typed_value_for, 'age', expect('51')).to eq('51')
       end
     end
   end
 
-  describe "#apply_default_attributes" do
-
+  describe '#apply_default_attributes' do
     let(:person) do
       Person.new
     end
 
-    it "typecasts proc values" do
+    it 'typecasts proc values' do
       expect(person.age).to eq(100)
     end
   end
 
-  describe "#typed_attributes"  do
-
+  describe '#typed_attributes' do
     let(:date_time) do
       DateTime.current
     end
@@ -1791,64 +1646,57 @@ describe Mongoid::Attributes do
     end
 
     it 'returns typecasted attributes' do
-      expect(user.typed_attributes).to include("last_login" => date_time)
+      expect(user.typed_attributes).to include('last_login' => date_time)
     end
   end
 
-  [:attributes=, :write_attributes].each do |method|
-
+  %i[attributes= write_attributes].each do |method|
     describe "##{method}" do
-
-      context "when nested" do
-
+      context 'when nested' do
         let(:person) do
           Person.new
         end
 
         before do
-          person.send(method, { videos: [{title: "Fight Club"}] })
+          person.send(method, { videos: [ { title: 'Fight Club' } ] })
         end
 
-        it "sets nested documents" do
-          expect(person.videos.first.title).to eq("Fight Club")
+        it 'sets nested documents' do
+          expect(person.videos.first.title).to eq('Fight Club')
         end
       end
 
-      context "typecasting" do
-
+      context 'typecasting' do
         let(:person) do
           Person.new
         end
 
         let(:attributes) do
-          { age: "50" }
+          { age: '50' }
         end
 
-        context "when passing a hash" do
-
+        context 'when passing a hash' do
           before do
             person.send(method, attributes)
           end
 
-          it "properly casts values" do
+          it 'properly casts values' do
             expect(person.age).to eq(50)
           end
         end
 
-        context "when passing nil" do
-
+        context 'when passing nil' do
           before do
             person.send(method, nil)
           end
 
-          it "does not set anything" do
+          it 'does not set anything' do
             expect(person.age).to eq(100)
           end
         end
       end
 
-      context "copying from instance" do
-
+      context 'copying from instance' do
         let(:person) do
           Person.new
         end
@@ -1865,25 +1713,23 @@ describe Mongoid::Attributes do
           person.send(method, instance.attributes)
         end
 
-        it "properly copies values" do
+        it 'properly copies values' do
           expect(person.age).to eq(50)
         end
 
-        it "properly copies ranges" do
+        it 'properly copies ranges' do
           expect(person.range).to eq(1..100)
         end
       end
 
-      context "on a parent document" do
-
-        context "when the parent has a has many through a has one" do
-
+      context 'on a parent document' do
+        context 'when the parent has a has many through a has one' do
           let(:owner) do
-            PetOwner.new(title: "Mr")
+            PetOwner.new(title: 'Mr')
           end
 
           let(:pet) do
-            Pet.new(name: "Fido")
+            Pet.new(name: 'Fido')
           end
 
           let(:vet_visit) do
@@ -1893,23 +1739,22 @@ describe Mongoid::Attributes do
           before do
             owner.pet = pet
             pet.vet_visits = [ vet_visit ]
-            owner.send(method, { pet: { name: "Bingo" } })
+            owner.send(method, { pet: { name: 'Bingo' } })
           end
 
-          it "does not overwrite child attributes if not in the hash" do
-            expect(owner.pet.name).to eq("Bingo")
+          it 'does not overwrite child attributes if not in the hash' do
+            expect(owner.pet.name).to eq('Bingo')
             expect(owner.pet.vet_visits.size).to eq(1)
           end
         end
 
-        context "when parent destroy all child on setter" do
-
+        context 'when parent destroy all child on setter' do
           let(:owner) do
-            PetOwner.create!(title: "Mr")
+            PetOwner.create!(title: 'Mr')
           end
 
           let(:pet) do
-            Pet.create!(name: "Kika", pet_owner: owner)
+            Pet.create!(name: 'Kika', pet_owner: owner)
           end
 
           let!(:vet_visit) do
@@ -1921,17 +1766,16 @@ describe Mongoid::Attributes do
             pet.save!
           end
 
-          it "has 3 new entries" do
+          it 'has 3 new entries' do
             expect(pet.vet_visits.count).to eq 3
           end
 
-          it "persists the changes" do
+          it 'persists the changes' do
             expect(pet.reload.vet_visits.count).to eq 3
           end
         end
 
-        context "when the parent has an empty embeds_many" do
-
+        context 'when the parent has an empty embeds_many' do
           let(:person) do
             Person.new
           end
@@ -1940,54 +1784,51 @@ describe Mongoid::Attributes do
             { services: [] }
           end
 
-          it "does not raise an error" do
+          it 'does not raise an error' do
             person.send(method, attributes)
           end
         end
       end
 
-      context "on a child document" do
-
-        context "when child is part of a has one" do
-
+      context 'on a child document' do
+        context 'when child is part of a has one' do
           let(:person) do
-            Person.new(title: "Sir", age: 30)
+            Person.new(title: 'Sir', age: 30)
           end
 
           let(:name) do
-            Name.new(first_name: "Test", last_name: "User")
+            Name.new(first_name: 'Test', last_name: 'User')
           end
 
           before do
             person.name = name
-            name.send(method, first_name: "Test2", last_name: "User2")
+            name.send(method, first_name: 'Test2', last_name: 'User2')
           end
 
-          it "sets the child attributes on the parent" do
+          it 'sets the child attributes on the parent' do
             expect(name.attributes).to eq(
-              { "_id" => "Test-User", "first_name" => "Test2", "last_name" => "User2" }
+              { '_id' => 'Test-User', 'first_name' => 'Test2', 'last_name' => 'User2' }
             )
           end
         end
 
-        context "when child is part of a has many" do
-
+        context 'when child is part of a has many' do
           let(:person) do
-            Person.new(title: "Sir")
+            Person.new(title: 'Sir')
           end
 
           let(:address) do
-            Address.new(street: "Test")
+            Address.new(street: 'Test')
           end
 
           before do
             person.addresses << address
-            address.send(method, "street" => "Test2")
+            address.send(method, 'street' => 'Test2')
           end
 
-          it "updates the child attributes on the parent" do
+          it 'updates the child attributes on the parent' do
             expect(address.attributes).to eq(
-              { "_id" => "test", "street" => "Test2" }
+              { '_id' => 'test', 'street' => 'Test2' }
             )
           end
         end
@@ -2050,134 +1891,125 @@ describe Mongoid::Attributes do
     end
   end
 
-  describe "#alias_attribute" do
-
+  describe '#alias_attribute' do
     let(:product) do
       Product.new
     end
 
-    context "when checking against the alias" do
-
+    context 'when checking against the alias' do
       before do
         product.cost = 500
       end
 
-      it "adds the alias for criteria" do
-        expect(Product.where(cost: 500).selector).to eq("price" => 500)
+      it 'adds the alias for criteria' do
+        expect(Product.where(cost: 500).selector).to eq('price' => 500)
       end
 
-      it "aliases the getter" do
+      it 'aliases the getter' do
         expect(product.cost).to eq(500)
       end
 
-      it "aliases the existence check" do
+      it 'aliases the existence check' do
         expect(product.cost?).to be true
       end
 
-      it "aliases *_changed?" do
+      it 'aliases *_changed?' do
         expect(product.cost_changed?).to be true
       end
 
-      it "aliases *_change" do
+      it 'aliases *_change' do
         expect(product.cost_change).to eq([ nil, 500 ])
       end
 
-      it "aliases *_will_change!" do
+      it 'aliases *_will_change!' do
         expect(product).to respond_to(:cost_will_change!)
       end
 
-      it "aliases *_was" do
+      it 'aliases *_was' do
         expect(product.cost_was).to be_nil
       end
 
-      it "aliases reset_*!" do
+      it 'aliases reset_*!' do
         product.reset_cost!
         expect(product.cost).to be_nil
       end
 
-      it "aliases *_before_type_cast" do
-        product.cost = "42"
-        expect(product.cost_before_type_cast).to eq("42")
+      it 'aliases *_before_type_cast' do
+        product.cost = '42'
+        expect(product.cost_before_type_cast).to eq('42')
       end
     end
 
-    context "when checking against the original" do
-
+    context 'when checking against the original' do
       before do
         product.price = 500
       end
 
-      it "aliases the getter" do
+      it 'aliases the getter' do
         expect(product.price).to eq(500)
       end
 
-      it "aliases the existence check" do
+      it 'aliases the existence check' do
         expect(product.price?).to be true
       end
 
-      it "aliases *_changed?" do
+      it 'aliases *_changed?' do
         expect(product.price_changed?).to be true
       end
 
-      it "aliases *_change" do
+      it 'aliases *_change' do
         expect(product.price_change).to eq([ nil, 500 ])
       end
 
-      it "aliases *_will_change!" do
+      it 'aliases *_will_change!' do
         expect(product).to respond_to(:price_will_change!)
       end
 
-      it "aliases *_was" do
+      it 'aliases *_was' do
         expect(product.price_was).to be_nil
       end
 
-      it "aliases reset_*!" do
+      it 'aliases reset_*!' do
         product.reset_price!
         expect(product.price).to be_nil
       end
     end
   end
 
-  context "when persisting nil attributes" do
-
+  context 'when persisting nil attributes' do
     let!(:person) do
       Person.create!(score: nil)
     end
 
-    it "has an entry in the attributes" do
-      expect(person.reload.attributes).to have_key("score")
+    it 'has an entry in the attributes' do
+      expect(person.reload.attributes).to have_key('score')
     end
   end
 
-  context "with a default last_drink_taken_at" do
-
+  context 'with a default last_drink_taken_at' do
     let(:person) do
       Person.new
     end
 
-    it "saves the default" do
-      expect { person.save! }.to_not raise_error
-      expect(person.last_drink_taken_at).to eq(1.day.ago.in_time_zone("Alaska").to_date)
+    it 'saves the default' do
+      expect { person.save! }.not_to raise_error
+      expect(person.last_drink_taken_at).to eq(1.day.ago.in_time_zone('Alaska').to_date)
     end
   end
 
-  context "when default values are defined" do
-
-    context "when no value exists in the database" do
-
+  context 'when default values are defined' do
+    context 'when no value exists in the database' do
       let(:person) do
         Person.create!
       end
 
-      it "applies the default value" do
-        expect(person.last_drink_taken_at).to eq(1.day.ago.in_time_zone("Alaska").to_date)
+      it 'applies the default value' do
+        expect(person.last_drink_taken_at).to eq(1.day.ago.in_time_zone('Alaska').to_date)
       end
     end
 
-    context "when a value exists in the database" do
-
-      context "when the value is not nil" do
-
+    context 'when a value exists in the database' do
+      context 'when the value is not nil' do
         let!(:person) do
           Person.create!(age: 50)
         end
@@ -2186,13 +2018,12 @@ describe Mongoid::Attributes do
           Person.find(person.id)
         end
 
-        it "does not set the default" do
+        it 'does not set the default' do
           expect(from_db.age).to eq(50)
         end
       end
 
-      context "when the value is explicitly nil" do
-
+      context 'when the value is explicitly nil' do
         let!(:person) do
           Person.create!(age: nil)
         end
@@ -2201,22 +2032,21 @@ describe Mongoid::Attributes do
           Person.find(person.id)
         end
 
-        it "does not set the default" do
+        it 'does not set the default' do
           expect(from_db.age).to be_nil
         end
       end
 
-      context "when the default is a proc" do
-
+      context 'when the default is a proc' do
         let!(:account) do
-          Account.create!(name: "savings", balance: 100)
+          Account.create!(name: 'savings', balance: 100)
         end
 
         let(:from_db) do
           Account.find(account.id)
         end
 
-        it "applies the defaults after all attributes are set" do
+        it 'applies the defaults after all attributes are set' do
           expect(from_db).to be_balanced
         end
       end
@@ -2224,7 +2054,6 @@ describe Mongoid::Attributes do
   end
 
   context 'when calling the attribute check method' do
-
     context 'when the attribute is blank' do
       let(:person) do
         Person.create!(title: '')
@@ -2241,14 +2070,12 @@ describe Mongoid::Attributes do
       end
 
       context 'after initialization when the field is nil' do
-
         it 'returns false' do
           expect(person.desc?).to be(false)
         end
       end
 
       context 'when setting the field to nil' do
-
         it 'applies the localization when checking the attribute' do
           person.desc = nil
           expect(person.desc?).to be(false)
@@ -2256,7 +2083,6 @@ describe Mongoid::Attributes do
       end
 
       context 'when the field is a boolean' do
-
         before do
           person.desc = false
         end
@@ -2282,136 +2108,140 @@ describe Mongoid::Attributes do
     end
   end
 
-  context "when an attribute is removed then set" do
-    let(:cat) { Cat.create!(name: "Neil") }
+  context 'when an attribute is removed then set' do
+    let(:cat) { Cat.create!(name: 'Neil') }
 
     before do
-      cat.remove_attribute("name")
-      cat.name = "Nissim"
+      cat.remove_attribute('name')
+      cat.name = 'Nissim'
       cat.save!
       cat.reload
     end
 
-    it "correctly sets the attribute" do
-      expect(cat.name).to eq("Nissim")
+    it 'correctly sets the attribute' do
+      expect(cat.name).to eq('Nissim')
     end
   end
 
-  describe "attributes after setting an association without reloading" do
-
-    context "on embeds_many" do
-
-      context "when not setting anything" do
+  describe 'attributes after setting an association without reloading' do
+    context 'on embeds_many' do
+      context 'when not setting anything' do
         let(:doc) { NestedBook.create! }
 
         it "doesn't add attributes" do
-          expect(doc.attributes).to_not have_key("pages")
+          expect(doc.attributes).not_to have_key('pages')
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when using nested attributes" do
+      context 'when using nested attributes' do
         let(:doc) { NestedBook.create! }
 
         before do
           doc.update_attributes({ pages_attributes: [ {} ] })
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"]).to eq([{ "_id" => doc.pages.first.id }])
+        it 'updates the attributes' do
+          expect(doc.attributes['pages']).to eq([ { '_id' => doc.pages.first.id } ])
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when doing assignments" do
+      context 'when doing assignments' do
         let(:doc) { NestedBook.create! }
+
         before do
-          doc.pages = [NestedPage.new]
+          doc.pages = [ NestedPage.new ]
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"]).to eq([{ "_id" => doc.pages.first.id }])
+        it 'updates the attributes' do
+          expect(doc.attributes['pages']).to eq([ { '_id' => doc.pages.first.id } ])
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when replacing assignments" do
+      context 'when replacing assignments' do
         let(:doc) { NestedBook.create! }
+
         before do
-          doc.pages = [NestedPage.new(number: 1)]
-          doc.pages = [NestedPage.new(number: 2)]
+          doc.pages = [ NestedPage.new(number: 1) ]
+          doc.pages = [ NestedPage.new(number: 2) ]
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"]).to eq([{ "_id" => doc.pages.first.id, "number" => 2 }])
+        it 'updates the attributes' do
+          expect(doc.attributes['pages']).to eq([ { '_id' => doc.pages.first.id, 'number' => 2 } ])
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when setting to nil" do
+      context 'when setting to nil' do
         let(:doc) { NestedBook.create! }
+
         before do
-          doc.pages = [NestedPage.new(number: 1)]
+          doc.pages = [ NestedPage.new(number: 1) ]
           doc.pages = nil
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes).to_not have_key("pages")
+        it 'updates the attributes' do
+          expect(doc.attributes).not_to have_key('pages')
         end
 
-        it "has the same attributes after reloading" do
-          expect({ "pages" => [] }.merge(doc.attributes)).to eq(doc.reload.attributes)
+        it 'has the same attributes after reloading' do
+          expect({ 'pages' => [] }.merge(doc.attributes)).to eq(doc.reload.attributes)
         end
       end
 
-      context "when setting to nil and back" do
+      context 'when setting to nil and back' do
         let(:doc) { NestedBook.create! }
         let(:page) { NestedPage.new }
+
         before do
-          doc.pages = [page]
+          doc.pages = [ page ]
           doc.pages = nil
-          doc.pages = [page]
+          doc.pages = [ page ]
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"]).to eq([{ "_id" => doc.pages.first.id }])
+        it 'updates the attributes' do
+          expect(doc.attributes['pages']).to eq([ { '_id' => doc.pages.first.id } ])
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when pushing" do
+      context 'when pushing' do
         let(:doc) { NestedBook.create! }
+
         before do
           doc.pages << NestedPage.new
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"]).to eq([{ "_id" => doc.pages.first.id }])
+        it 'updates the attributes' do
+          expect(doc.attributes['pages']).to eq([ { '_id' => doc.pages.first.id } ])
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      [:shift, :pop].each do |meth|
+      %i[shift pop].each do |meth|
         context "when performing #{meth}" do
           let(:doc) { NestedBook.create! }
+
           before do
             doc.pages << NestedPage.new
             doc.pages << NestedPage.new
@@ -2420,52 +2250,55 @@ describe Mongoid::Attributes do
             doc.pages.send(meth, 2)
           end
 
-          it "updates the attributes" do
-            expect(doc.attributes["pages"]).to eq([{ "_id" => doc.pages.first.id }])
+          it 'updates the attributes' do
+            expect(doc.attributes['pages']).to eq([ { '_id' => doc.pages.first.id } ])
           end
 
-          it "has the same attributes after reloading" do
+          it 'has the same attributes after reloading' do
             expect(doc.attributes).to eq(doc.reload.attributes)
           end
         end
       end
 
-      context "when concatting" do
+      context 'when concatting' do
         let(:doc) { NestedBook.create! }
+
         before do
           doc.pages << NestedPage.new
-          doc.pages.concat([NestedPage.new, NestedPage.new])
+          doc.pages.concat([ NestedPage.new, NestedPage.new ])
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"].count).to eq 3
+        it 'updates the attributes' do
+          expect(doc.attributes['pages'].count).to eq 3
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      [:build, :create].each do |meth|
+      %i[build create].each do |meth|
         context "when preforming #{meth}" do
           let(:doc) { NestedBook.create! }
+
           before do
             doc.pages.send(meth)
           end
 
-          it "updates the attributes" do
-            expect(doc.attributes["pages"]).to eq([{ "_id" => doc.pages.first.id }])
+          it 'updates the attributes' do
+            expect(doc.attributes['pages']).to eq([ { '_id' => doc.pages.first.id } ])
           end
 
-          it "has the same attributes after reloading" do
+          it 'has the same attributes after reloading' do
             doc.pages.first.save
             expect(doc.attributes).to eq(doc.reload.attributes)
           end
         end
       end
 
-      context "when clearing" do
+      context 'when clearing' do
         let(:doc) { NestedBook.create! }
+
         before do
           doc.pages << NestedPage.new
           doc.pages << NestedPage.new
@@ -2474,18 +2307,19 @@ describe Mongoid::Attributes do
           doc.pages.clear
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes).to_not have_key("pages")
+        it 'updates the attributes' do
+          expect(doc.attributes).not_to have_key('pages')
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      [:delete_all, :destroy_all, :remove_all].each do |meth|
+      %i[delete_all destroy_all remove_all].each do |meth|
         context "when performing: #{meth}" do
           let(:doc) { NestedBook.create! }
+
           before do
             doc.pages << NestedPage.new
             doc.pages << NestedPage.new
@@ -2494,19 +2328,20 @@ describe Mongoid::Attributes do
             doc.pages.send(meth)
           end
 
-          it "updates the attributes" do
-            expect(doc.attributes).to_not have_key("pages")
+          it 'updates the attributes' do
+            expect(doc.attributes).not_to have_key('pages')
           end
 
-          it "has the same attributes after reloading" do
-            expect({ "pages" => [] }.merge(doc.attributes)).to eq(doc.reload.attributes)
+          it 'has the same attributes after reloading' do
+            expect({ 'pages' => [] }.merge(doc.attributes)).to eq(doc.reload.attributes)
           end
         end
       end
 
-      context "when deleting" do
+      context 'when deleting' do
         let(:doc) { NestedBook.create! }
         let(:page) { NestedPage.new }
+
         before do
           doc.pages << page
           doc.pages << NestedPage.new
@@ -2515,18 +2350,19 @@ describe Mongoid::Attributes do
           doc.pages.delete(page)
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"].count).to eq 2
+        it 'updates the attributes' do
+          expect(doc.attributes['pages'].count).to eq 2
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when doing _remove" do
+      context 'when doing _remove' do
         let(:doc) { NestedBook.create! }
         let(:page) { NestedPage.new }
+
         before do
           doc.pages << page
           doc.pages << NestedPage.new
@@ -2535,180 +2371,187 @@ describe Mongoid::Attributes do
           doc.pages._remove(page)
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"].count).to eq 2
+        it 'updates the attributes' do
+          expect(doc.attributes['pages'].count).to eq 2
         end
       end
 
-      context "when assigning an array of hashes" do
+      context 'when assigning an array of hashes' do
         let(:doc) { NestedBook.create! }
+
         before do
-          doc.pages = [{}]
+          doc.pages = [ {} ]
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"]).to eq([{ "_id" => doc.pages.first.id }])
+        it 'updates the attributes' do
+          expect(doc.attributes['pages']).to eq([ { '_id' => doc.pages.first.id } ])
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when assigning twice" do
+      context 'when assigning twice' do
         let(:doc) { NestedBook.create! }
+
         before do
-          doc.pages = [{ number: 1 }]
-          doc.pages = [{}]
+          doc.pages = [ { number: 1 } ]
+          doc.pages = [ {} ]
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["pages"]).to eq([{ "_id" => doc.pages.first.id }])
+        it 'updates the attributes' do
+          expect(doc.attributes['pages']).to eq([ { '_id' => doc.pages.first.id } ])
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
     end
 
-    context "on embeds_one" do
+    context 'on embeds_one' do
+      let(:attrs) { { 'title' => 'Title' } }
 
-      let(:attrs) { { "title" => "Title" } }
-
-      context "when using nested attributes" do
+      context 'when using nested attributes' do
         let(:doc) { NestedBook.create! }
 
         before do
           doc.update_attributes({ cover_attributes: attrs })
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["cover"]).to eq(attrs.merge("_id" => doc.cover.id))
+        it 'updates the attributes' do
+          expect(doc.attributes['cover']).to eq(attrs.merge('_id' => doc.cover.id))
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when doing assignments" do
+      context 'when doing assignments' do
         let(:doc) { NestedBook.create! }
+
         before do
           doc.cover = NestedCover.new(attrs)
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["cover"]).to eq(attrs.merge("_id" => doc.cover.id))
+        it 'updates the attributes' do
+          expect(doc.attributes['cover']).to eq(attrs.merge('_id' => doc.cover.id))
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when replacing assignments" do
+      context 'when replacing assignments' do
         let(:doc) { NestedBook.create! }
+
         before do
-          doc.cover = NestedCover.new("title" => "Title1")
+          doc.cover = NestedCover.new('title' => 'Title1')
           doc.cover = NestedCover.new(attrs)
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["cover"]).to eq(attrs.merge("_id" => doc.cover.id))
+        it 'updates the attributes' do
+          expect(doc.attributes['cover']).to eq(attrs.merge('_id' => doc.cover.id))
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when setting to nil" do
+      context 'when setting to nil' do
         let(:doc) { NestedBook.create! }
+
         before do
           doc.cover = NestedCover.new(attrs)
           doc.cover = nil
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes.key?("cover")).to be false
+        it 'updates the attributes' do
+          expect(doc.attributes.key?('cover')).to be false
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when setting to nil and back" do
+      context 'when setting to nil and back' do
         let(:doc) { NestedBook.create! }
+
         before do
           doc.cover = NestedCover.new(attrs)
           doc.cover = nil
           doc.cover = NestedCover.new(attrs)
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["cover"]).to eq(attrs.merge("_id" => doc.cover.id))
+        it 'updates the attributes' do
+          expect(doc.attributes['cover']).to eq(attrs.merge('_id' => doc.cover.id))
         end
 
-
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      [:build, :create].each do |meth|
+      %i[build create].each do |meth|
         context "when preforming #{meth}" do
           let(:doc) { NestedBook.create! }
+
           before do
             doc.send("#{meth}_cover", attrs)
           end
 
-          it "updates the attributes" do
-            expect(doc.attributes["cover"]).to eq(attrs.merge("_id" => doc.cover.id))
+          it 'updates the attributes' do
+            expect(doc.attributes['cover']).to eq(attrs.merge('_id' => doc.cover.id))
           end
 
-          it "has the same attributes after reloading" do
+          it 'has the same attributes after reloading' do
             doc.cover.save
             expect(doc.attributes).to eq(doc.reload.attributes)
           end
         end
       end
 
-      context "when assigning a hash" do
+      context 'when assigning a hash' do
         let(:doc) { NestedBook.create! }
+
         before do
           doc.cover = attrs
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["cover"]).to eq(attrs.merge("_id" => doc.cover.id))
+        it 'updates the attributes' do
+          expect(doc.attributes['cover']).to eq(attrs.merge('_id' => doc.cover.id))
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
 
-      context "when assigning twice" do
+      context 'when assigning twice' do
         let(:doc) { NestedBook.create! }
+
         before do
-          doc.cover = { "title" => "1984" }
+          doc.cover = { 'title' => '1984' }
           doc.cover = attrs
         end
 
-        it "updates the attributes" do
-          expect(doc.attributes["cover"]).to eq(attrs.merge("_id" => doc.cover.id))
+        it 'updates the attributes' do
+          expect(doc.attributes['cover']).to eq(attrs.merge('_id' => doc.cover.id))
         end
 
-        it "has the same attributes after reloading" do
+        it 'has the same attributes after reloading' do
           expect(doc.attributes).to eq(doc.reload.attributes)
         end
       end
     end
   end
 
-  context "when modifiying a hash referenced with the [] notation" do
+  context 'when modifying a hash referenced with the [] notation' do
     let(:church) { Church.create!(location: { x: 1 }) }
 
     before do
@@ -2717,28 +2560,28 @@ describe Mongoid::Attributes do
       church.reload
     end
 
-    it "persists the updated hash" do
-      church.location.should == { "x" => 1, "y" => 2 }
+    it 'persists the updated hash' do
+      church.location.should eq({ 'x' => 1, 'y' => 2 })
     end
   end
 
-  context "when accessing an embedded document with the attribute accessor" do
+  context 'when accessing an embedded document with the attribute accessor' do
     let(:band) { Band.create! }
 
     before do
       Band.where(id: band.id).update_all({
-        :$push => {records: { _id: BSON::ObjectId.new }}
-      })
+                                           :$push => { records: { _id: BSON::ObjectId.new } }
+                                         })
     end
 
-    it "does not throw a conflicting update error" do
+    it 'does not throw a conflicting update error' do
       b1 = Band.find(band.id)
       b1[:records].is_a?(Array).should be true
       expect { b1.save! }.not_to raise_error
     end
   end
 
-  context "when modifying a set referenced with the [] notation" do
+  context 'when modifying a set referenced with the [] notation' do
     let(:catalog) { Catalog.create!(set_field: [ 1 ].to_set) }
 
     before do
@@ -2747,9 +2590,9 @@ describe Mongoid::Attributes do
       catalog.reload
     end
 
-    it "persists the updated hash" do
-      pending "MONGOID-2951"
-      catalog.set_field.should == Set.new([ 1, 2 ])
+    it 'persists the updated hash' do
+      pending 'MONGOID-2951'
+      catalog.set_field.should eq Set.new([ 1, 2 ])
     end
   end