mongoid 7.2.1 → 9.0.0

data/spec/mongoid/attributes_spec.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
+require_relative './attributes/nested_spec_models'
 
 describe Mongoid::Attributes do
 
@@ -21,7 +22,7 @@ describe Mongoid::Attributes 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
@@ -56,7 +57,7 @@ describe Mongoid::Attributes do
               let!(:agent) do
                 agent = Agent.new(:title => title)
                 agent.build_address(:city => city)
-                agent.save()
+                agent.save!()
                 agent
               end
               let(:from_db) do
@@ -96,6 +97,49 @@ describe Mongoid::Attributes 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',
+                } } }
+              end
+
+              it 'retrieves only the projected fields' do
+                expect(from_db.map).to eq(expected)
+              end
+            end
+
+            context 'when several of the hash fields is projected' do
+
+              let(:map) do
+                { 'dates' => { 'y' => {
+                  '2016' => 'Berlin',
+                  '2017' => 'Munich',
+                  '2018' => 'Krakow',
+                } } }
+              end
+
+              let(:expected) do
+                { 'dates' => { 'y' => {
+                  '2016' => 'Berlin',
+                  '2018' => 'Krakow',
+                } } }
+              end
+
+              let(:from_db) do
+                Person.only('map.dates.y.2016', 'map.dates.y.2018').first
+              end
+
+              it 'retrieves only the projected fields' do
+                expect(from_db.map).to eq(expected)
+              end
+            end
           end
         end
 
@@ -123,7 +167,7 @@ describe Mongoid::Attributes do
         it "raises an error" do
           expect {
             from_db.title
-          }.to raise_error(ActiveModel::MissingAttributeError)
+          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
         end
 
         context "accessing via []" do
@@ -131,7 +175,7 @@ describe Mongoid::Attributes do
           it "raises an error" do
             expect {
               from_db["title"]
-            }.to raise_error(ActiveModel::MissingAttributeError)
+            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
           end
         end
       end
@@ -145,7 +189,7 @@ describe Mongoid::Attributes do
         it "raises an error" do
           expect {
             from_db.title
-          }.to raise_error(ActiveModel::MissingAttributeError)
+          }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
         end
       end
     end
@@ -156,7 +200,7 @@ describe Mongoid::Attributes do
     context 'when the document has a custom attribute type' do
 
       let(:bar) do
-        Bar.create(lat_lng: LatLng.new(52.30, 13.25))
+        Bar.create!(lat_lng: LatLng.new(52.30, 13.25))
       end
 
       it 'returns the demongoized version of the attribute' do
@@ -213,7 +257,7 @@ describe Mongoid::Attributes 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
@@ -227,7 +271,7 @@ describe Mongoid::Attributes do
           it "raises an error" do
             expect {
               from_db[:title]
-            }.to raise_error(ActiveModel::MissingAttributeError)
+            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
           end
         end
 
@@ -240,7 +284,92 @@ describe Mongoid::Attributes do
           it "raises an error" do
             expect {
               from_db[:title]
-            }.to raise_error(ActiveModel::MissingAttributeError)
+            }.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
+          end
+        end
+      end
+
+      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 {
+              from_db[:undefined_field]
+            }.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
+
+          let(:from_db) do
+            Person.without(:title).first
+          end
+
+          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/)
+          end
+        end
+
+        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
+          end
+        end
+      end
+
+      context 'when projecting with #only' do
+        let!(:person) do
+          Person.create!(title: 'sir', name: { first_name: 'Jose', language: { name: 'es' } })
+        end
+
+        context 'when projecting an embedded association' do
+          let(:from_db) do
+            Person.only(:name).first
+          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
+          end
+
+          context 'when retrieving a field of a nested association using the dot notation' do
+            it 'retrieves the field' do
+              expect(from_db['name.language.name']).to eq 'es'
+            end
+          end
+        end
+
+        context 'when projecting a sub-association of an embedded association' do
+          let(:from_db) do
+            Person.only('name.language').first
+          end
+
+          context 'when retrieving a field under the projected sub-association' do
+            it 'retrieves the field' do
+              expect(from_db['name.language.name']).to eq 'es'
+            end
+          end
+
+          context 'when retrieving a non-projected field' 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
           end
         end
       end
@@ -265,11 +394,10 @@ describe Mongoid::Attributes do
         end
 
         context "when reloaded" do
+          config_override :raise_not_found_error, false
 
           before do
-            Mongoid.raise_not_found_error = false
             person.reload
-            Mongoid.raise_not_found_error = true
           end
 
           it "returns the default value" do
@@ -287,7 +415,7 @@ describe Mongoid::Attributes do
       let(:bar) do
         Bar.new.tap do |b|
           b[:lat_lng] = LatLng.new(52.30, 13.25)
-          b.save
+          b.save!
         end
       end
 
@@ -329,6 +457,67 @@ describe Mongoid::Attributes do
         expect(terms).to eq(true)
       end
     end
+
+    context 'when the field is not explicitly defined' do
+      let(:bar) { Bar.new }
+
+      before do
+        bar['missing_field'] = 42
+      end
+
+      it 'writes the value into attributes' do
+        bar.attributes.should == {'_id' => bar.id, 'missing_field' => 42}
+      end
+
+      it 'makes the attribute accessible via []' do
+        bar['missing_field'].should == 42
+      end
+
+      context 'when writing fields on a document with projection' do
+
+        let!(:person) do
+          Person.create!(title: "sir")
+        end
+
+        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 {
+              from_db[:undefined_field] = 'x'
+            }.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
+
+          let(:from_db) do
+            Person.without(:title).first
+          end
+
+          it "raises an error" do
+            expect {
+              from_db[:title] = 'x'
+            }.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
+
+          let(:from_db) do
+            Person.without(:title).first
+          end
+
+          it "writes the value" do
+            from_db[:undefined_field] = 'x'
+            from_db[:undefined_field].should == 'x'
+          end
+        end
+      end
+    end
   end
 
   describe "#_id" do
@@ -799,7 +988,7 @@ describe Mongoid::Attributes do
     context 'when the document has a custom attribute type' do
 
       let(:bar) do
-        Bar.create(lat_lng: LatLng.new(52.30, 13.25))
+        Bar.create!(lat_lng: LatLng.new(52.30, 13.25))
       end
 
       it 'returns the demongoized version of the attribute' do
@@ -837,18 +1026,17 @@ describe Mongoid::Attributes do
     context "when the document is an existing record" do
 
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       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 }})
-          Mongoid.raise_not_found_error = false
           person.reload
-          Mongoid.raise_not_found_error = true
         end
 
         it "returns the default value" do
@@ -876,7 +1064,7 @@ describe Mongoid::Attributes do
   describe "#read_attribute_before_type_cast" do
 
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     context "when the attribute has not yet been assigned" do
@@ -889,8 +1077,52 @@ describe Mongoid::Attributes do
     context "after the attribute has been assigned" do
 
       it "returns the default value" do
-        person.age = "old"
-        expect(person.age_before_type_cast).to eq("old")
+        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")
+      end
+
+      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 {
+            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
+      end
+
+      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 {
+            from_db.read_attribute(:title)
+          }.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
+
+        let(:from_db) do
+          Person.without(:title).first
+        end
+
+        it "returns nil" do
+          from_db.read_attribute(:undefined_field).should be nil
+        end
       end
     end
   end
@@ -924,18 +1156,17 @@ describe Mongoid::Attributes do
     context "when the document is an existing record" do
 
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       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 }})
-          Mongoid.raise_not_found_error = false
           person.reload
-          Mongoid.raise_not_found_error = true
         end
 
         it "returns true" do
@@ -983,7 +1214,7 @@ describe Mongoid::Attributes do
 
     context "when the attribute is not on only list" do
 
-      before { Person.create }
+      before { Person.create! }
       let(:person) do
         Person.only(:id).first
       end
@@ -1033,15 +1264,15 @@ describe Mongoid::Attributes do
 
     context "before the attribute has been assigned" do
 
-      it "returns false" do
-        expect(person.has_attribute_before_type_cast?(:age)).to be false
+      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
-        person.age = 'old'
+        person.age = '42'
         expect(person.has_attribute_before_type_cast?(:age)).to be true
       end
     end
@@ -1052,7 +1283,7 @@ describe Mongoid::Attributes do
     context "when the attribute exists" do
 
       let(:person) do
-        Person.create(title: "Sir")
+        Person.create!(title: "Sir")
       end
 
       before do
@@ -1070,7 +1301,7 @@ describe Mongoid::Attributes do
       context "when saving after the removal" do
 
         before do
-          person.save
+          person.save!
         end
 
         it "persists the removal" do
@@ -1090,7 +1321,7 @@ describe Mongoid::Attributes do
      end
 
      before do
-       person.save
+       person.save!
        person.pet.remove_attribute(:name)
      end
 
@@ -1105,7 +1336,7 @@ describe Mongoid::Attributes do
      context "when saving after the removal" do
 
        before do
-         person.save
+         person.save!
        end
 
        it "persists the removal" do
@@ -1150,7 +1381,7 @@ describe Mongoid::Attributes do
       context 'when the database name is used' do
 
         let(:person) do
-          Person.create(at: Time.now)
+          Person.create!(at: Time.now)
         end
 
         before do
@@ -1168,7 +1399,7 @@ describe Mongoid::Attributes do
         context "when saving after the removal" do
 
           before do
-            person.save
+            person.save!
           end
 
           it "persists the removal" do
@@ -1180,7 +1411,7 @@ describe Mongoid::Attributes do
       context 'when the alias is used' do
 
         let(:person) do
-          Person.create(aliased_timestamp: Time.now)
+          Person.create!(aliased_timestamp: Time.now)
         end
 
         before do
@@ -1198,7 +1429,7 @@ describe Mongoid::Attributes do
         context "when saving after the removal" do
 
           before do
-            person.save
+            person.save!
           end
 
           it "persists the removal" do
@@ -1296,12 +1527,13 @@ describe Mongoid::Attributes do
     end
 
     context "when setting an attribute that needs type casting" do
+
       let(:person) do
-        Person.new(age: "old")
+        Person.new(age: "42")
       end
 
       it "should store the attribute before type cast" do
-        expect(person.age_before_type_cast).to eq("old")
+        expect(person.age_before_type_cast).to eq("42")
       end
     end
 
@@ -1341,7 +1573,7 @@ describe Mongoid::Attributes do
         person.write_attribute(:test, "aliased field to test")
       end
 
-      it "allows the field name to be udpated" do
+      it "allows the field name to be updated" do
         expect(person.t).to eq("aliased field to test")
       end
     end
@@ -1349,20 +1581,18 @@ describe Mongoid::Attributes do
     context "when attribute is a Hash" do
       let(:person) { Person.new map: { somekey: "somevalue" } }
 
-      it "raises an error when trying to set a value of invalid type - array" do
-        expect do
-          person.map = []
-        end.to raise_error(Mongoid::Errors::InvalidValue, /Value of type Array cannot be written to a field of type Hash/)
+      it "writes nil when trying to set a value of invalid type - array" do
+        person.map = []
+        expect(person.map).to be_nil
       end
 
-      it "raises an error when trying to set a value of invalid type - boolean" do
-        expect do
-          person.map = false
-        end.to raise_error(Mongoid::Errors::InvalidValue, /Value of type FalseClass cannot be written to a field of type Hash/)
+      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" 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
 
@@ -1373,16 +1603,14 @@ describe Mongoid::Attributes do
         expect(person.aliases).to eq([ :alias_1 ])
       end
 
-      it "raises an error when trying to set a value of invalid type - hash" do
-        expect do
-          person.aliases = {}
-        end.to raise_error(Mongoid::Errors::InvalidValue, /Value of type Hash cannot be written to a field of type Array/)
+      it "writes nil when trying to set a value of invalid type - hash" do
+        person.aliases = {}
+        expect(person.aliases).to be_nil
       end
 
-      it "raises an error when trying to set a value of invalid type - boolean" do
-        expect do
-          person.aliases = false
-        end.to raise_error(Mongoid::Errors::InvalidValue, /Value of type FalseClass cannot be written to a field of type Array/)
+      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
 
@@ -1398,6 +1626,93 @@ describe Mongoid::Attributes do
         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")
+      end
+
+      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 {
+            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
+      end
+
+      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 {
+            from_db.write_attribute(:title, 'x')
+          }.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
+
+        let(:from_db) do
+          Person.without(:title).first
+        end
+
+        it "writes the value" do
+          from_db.write_attribute(:undefined_field, 'x')
+          from_db.read_attribute(:undefined_field).should == 'x'
+        end
+      end
+    end
+
+    context "when comparing the object_ids of the written value" do
+      before do
+        Person.create!
+      end
+
+      let(:person) do
+        Person.first
+      end
+
+      context "when the field is not resizable" do
+        let(:test) do
+          person.write_attribute(:test, "aliased field to test")
+        end
+
+        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
+
+        let(:arrays) do
+          person.write_attribute(:arrays, [])
+        end
+
+        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
+
+        let(:preference_ids) do
+          person.write_attribute(:preference_ids, [])
+        end
+
+        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
+    end
   end
 
   describe "#typed_value_for" do
@@ -1578,11 +1893,11 @@ describe Mongoid::Attributes do
           end
 
           it "has 3 new entries" do
-            expect(pet.vet_visits.count).to eq(3)
+            expect(pet.vet_visits.count).to eq 3
           end
 
           it "persists the changes" do
-            expect(pet.reload.vet_visits.count).to eq(3)
+            expect(pet.reload.vet_visits.count).to eq 3
           end
         end
 
@@ -1651,6 +1966,61 @@ describe Mongoid::Attributes do
     end
   end
 
+  describe '#unalias_attribute' do
+    let(:shirt) { Shirt.new }
+    let(:id) { '1234' }
+
+    context 'when creating object' do
+      let(:shirt) { Shirt.new(id: id) }
+
+      it 'id and _id are not the same' do
+        expect(shirt.id).to eq(id)
+        expect(shirt._id).not_to eq(id)
+      end
+    end
+
+    context 'update' do
+      before do
+        shirt.update(id: id)
+      end
+
+      it 'updates id but not_id' do
+        expect(shirt.id).to eq(id)
+        expect(shirt._id).not_to eq(id)
+      end
+    end
+
+    context 'id=' do
+      before do
+        shirt.id = id
+      end
+
+      it 'sets id and not _id' do
+        expect(shirt.id).to eq(id)
+        expect(shirt._id).not_to eq(id)
+      end
+    end
+
+    context 'id?' do
+      context 'with null id' do
+        it 'returns false' do
+          expect(shirt.id?).to be false
+          expect(shirt._id?).to be true
+        end
+      end
+
+      context 'with id' do
+        before do
+          shirt.id = id
+        end
+
+        it 'returns true' do
+          expect(shirt.id?).to be true
+        end
+      end
+    end
+  end
+
   describe "#alias_attribute" do
 
     let(:product) do
@@ -1697,8 +2067,8 @@ describe Mongoid::Attributes do
       end
 
       it "aliases *_before_type_cast" do
-        product.cost = "expensive"
-        expect(product.cost_before_type_cast).to eq("expensive")
+        product.cost = "42"
+        expect(product.cost_before_type_cast).to eq("42")
       end
     end
 
@@ -1742,7 +2112,7 @@ describe Mongoid::Attributes do
   context "when persisting nil attributes" do
 
     let!(:person) do
-      Person.create(score: nil)
+      Person.create!(score: nil)
     end
 
     it "has an entry in the attributes" do
@@ -1757,7 +2127,7 @@ describe Mongoid::Attributes do
     end
 
     it "saves the default" do
-      expect { person.save }.to_not raise_error
+      expect { person.save! }.to_not raise_error
       expect(person.last_drink_taken_at).to eq(1.day.ago.in_time_zone("Alaska").to_date)
     end
   end
@@ -1767,7 +2137,7 @@ describe Mongoid::Attributes do
     context "when no value exists in the database" do
 
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       it "applies the default value" do
@@ -1780,7 +2150,7 @@ describe Mongoid::Attributes do
       context "when the value is not nil" do
 
         let!(:person) do
-          Person.create(age: 50)
+          Person.create!(age: 50)
         end
 
         let(:from_db) do
@@ -1795,7 +2165,7 @@ describe Mongoid::Attributes do
       context "when the value is explicitly nil" do
 
         let!(:person) do
-          Person.create(age: nil)
+          Person.create!(age: nil)
         end
 
         let(:from_db) do
@@ -1810,7 +2180,7 @@ describe Mongoid::Attributes 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
@@ -1828,7 +2198,7 @@ describe Mongoid::Attributes do
 
     context 'when the attribute is blank' do
       let(:person) do
-        Person.create(title: '')
+        Person.create!(title: '')
       end
 
       it 'returns false' do
@@ -1838,7 +2208,7 @@ describe Mongoid::Attributes do
 
     context 'when the attribute is localized' do
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       context 'after initialization when the field is nil' do
@@ -1870,7 +2240,7 @@ describe Mongoid::Attributes do
 
     context 'when the attribute is not localized' do
       let(:person) do
-        Person.create(username: 'localized')
+        Person.create!(username: 'localized')
       end
 
       before do
@@ -1882,4 +2252,486 @@ describe Mongoid::Attributes do
       end
     end
   end
+
+  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.save!
+      cat.reload
+    end
+
+    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
+        let(:doc) { NestedBook.create! }
+
+        it "doesn't add attributes" do
+          expect(doc.attributes).to_not have_key("pages")
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      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 }])
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      context "when doing assignments" 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 }])
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      context "when replacing assignments" do
+        let(:doc) { NestedBook.create! }
+        before do
+          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 }])
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      context "when setting to nil" do
+        let(:doc) { NestedBook.create! }
+        before do
+          doc.pages = [NestedPage.new(number: 1)]
+          doc.pages = nil
+        end
+
+        it "updates the attributes" do
+          expect(doc.attributes).to_not have_key("pages")
+        end
+
+        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
+        let(:doc) { NestedBook.create! }
+        let(:page) { NestedPage.new }
+        before do
+          doc.pages = [page]
+          doc.pages = nil
+          doc.pages = [page]
+        end
+
+        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
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      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 }])
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      [:shift, :pop].each do |meth|
+        context "when performing #{meth}" do
+          let(:doc) { NestedBook.create! }
+          before do
+            doc.pages << NestedPage.new
+            doc.pages << NestedPage.new
+            doc.pages << NestedPage.new
+
+            doc.pages.send(meth, 2)
+          end
+
+          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
+            expect(doc.attributes).to eq(doc.reload.attributes)
+          end
+        end
+      end
+
+      context "when concatting" do
+        let(:doc) { NestedBook.create! }
+        before do
+          doc.pages << NestedPage.new
+          doc.pages.concat([NestedPage.new, NestedPage.new])
+        end
+
+        it "updates the attributes" do
+          expect(doc.attributes["pages"].count).to eq 3
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      [: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 }])
+          end
+
+          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
+        let(:doc) { NestedBook.create! }
+        before do
+          doc.pages << NestedPage.new
+          doc.pages << NestedPage.new
+          doc.pages << NestedPage.new
+
+          doc.pages.clear
+        end
+
+        it "updates the attributes" do
+          expect(doc.attributes).to_not have_key("pages")
+        end
+
+        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|
+        context "when performing: #{meth}" do
+          let(:doc) { NestedBook.create! }
+          before do
+            doc.pages << NestedPage.new
+            doc.pages << NestedPage.new
+            doc.pages << NestedPage.new
+
+            doc.pages.send(meth)
+          end
+
+          it "updates the attributes" do
+            expect(doc.attributes).to_not have_key("pages")
+          end
+
+          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
+        let(:doc) { NestedBook.create! }
+        let(:page) { NestedPage.new }
+        before do
+          doc.pages << page
+          doc.pages << NestedPage.new
+          doc.pages << NestedPage.new
+
+          doc.pages.delete(page)
+        end
+
+        it "updates the attributes" do
+          expect(doc.attributes["pages"].count).to eq 2
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      context "when doing _remove" do
+        let(:doc) { NestedBook.create! }
+        let(:page) { NestedPage.new }
+        before do
+          doc.pages << page
+          doc.pages << NestedPage.new
+          doc.pages << NestedPage.new
+
+          doc.pages._remove(page)
+        end
+
+        it "updates the attributes" do
+          expect(doc.attributes["pages"].count).to eq 2
+        end
+      end
+
+      context "when assigning an array of hashes" do
+        let(:doc) { NestedBook.create! }
+        before do
+          doc.pages = [{}]
+        end
+
+        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
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      context "when assigning twice" do
+        let(:doc) { NestedBook.create! }
+        before do
+          doc.pages = [{ number: 1 }]
+          doc.pages = [{}]
+        end
+
+        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
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+    end
+
+    context "on embeds_one" do
+
+      let(:attrs) { { "title" => "Title" } }
+
+      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))
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      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))
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      context "when replacing assignments" do
+        let(:doc) { NestedBook.create! }
+        before do
+          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))
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      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
+        end
+
+        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
+        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))
+        end
+
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      [: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))
+          end
+
+          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
+        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))
+        end
+
+        it "has the same attributes after reloading" do
+          expect(doc.attributes).to eq(doc.reload.attributes)
+        end
+      end
+
+      context "when assigning twice" do
+        let(:doc) { NestedBook.create! }
+        before do
+          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))
+        end
+
+        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
+    let(:church) { Church.create!(location: { x: 1 }) }
+
+    before do
+      church[:location].merge!(y: 2)
+      church.save!
+      church.reload
+    end
+
+    it "persists the updated hash" do
+      church.location.should == { "x" => 1, "y" => 2 }
+    end
+  end
+
+  context "when modifiying a set referenced with the [] notation" do
+    let(:catalog) { Catalog.create!(set_field: [ 1 ].to_set) }
+
+    before do
+      catalog[:set_field] << 2
+      catalog.save!
+      catalog.reload
+    end
+
+    it "persists the updated hash" do
+      pending "MONGOID-2951"
+      catalog.set_field.should == Set.new([ 1, 2 ])
+    end
+  end
+
+  context 'when an embedded field has a capitalized store_as name' do
+    let(:person) { Person.new(Purse: { brand: 'Gucci' }) }
+
+    it 'sets the value' do
+      expect(person.purse.brand).to eq('Gucci')
+    end
+
+    it 'saves successfully' do
+      expect(person.save!).to eq(true)
+    end
+
+    context 'when persisted' do
+      before do
+        person.save!
+        person.reload
+      end
+
+      it 'persists the value' do
+        expect(person.reload.purse.brand).to eq('Gucci')
+      end
+
+      it 'uses the correct key in the database' do
+        expect(person.collection.find(_id: person.id).first['Purse']['_id']).to eq(person.purse.id)
+      end
+    end
+  end
 end