mongoid 3.1.5 → 8.0.2

data/spec/mongoid/attributes_spec.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "spec_helper"
+require_relative './attributes/nested_spec_models'
 
 describe Mongoid::Attributes do
 
@@ -11,13 +14,199 @@ describe Mongoid::Attributes do
       end
 
       it "does not cause an infinite loop" do
-        account.overridden.should eq("not recommended")
+        expect(account.overridden).to eq("not recommended")
+      end
+    end
+
+    context "when the attribute was excluded in a criteria" do
+
+      let!(:person) do
+        Person.create!(title: "sir")
+      end
+
+      context "when the attribute is localized" do
+
+        before do
+          person.update_attribute(:desc, "test")
+        end
+
+        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")
+            end
+
+            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"}
+              let!(:agent) do
+                agent = Agent.new(:title => title)
+                agent.build_address(:city => city)
+                agent.save!()
+                agent
+              end
+              let(:from_db) do
+                Agent.only(:title, "address.city").first
+              end
+
+              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)
+                end
+              end
+            end
+          end
+
+          context 'when the attribute is a hash field' do
+
+            before do
+              person.update_attribute(:map, map)
+            end
+
+            let(:map) do
+              { 'dates' => { 'y' => { '2016' => 'Berlin' } } }
+            end
+
+            let(:from_db) do
+              Person.only('map.dates.y.2016').first
+            end
+
+            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
+
+        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")
+            end
+          end
+        end
+      end
+
+      context "when excluding with only" do
+
+        let(:from_db) do
+          Person.only(:_id).first
+        end
+
+        it "raises an error" do
+          expect {
+            from_db.title
+          }.to raise_error(ActiveModel::MissingAttributeError)
+        end
+
+        context "accessing via []" do
+
+          it "raises an error" do
+            expect {
+              from_db["title"]
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
+        end
+      end
+
+      context "when excluding with without" do
+
+        let(:from_db) do
+          Person.without(:title).first
+        end
+
+        it "raises an error" do
+          expect {
+            from_db.title
+          }.to raise_error(ActiveModel::MissingAttributeError)
+        end
       end
     end
   end
 
   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
+
+      it 'returns the demongoized version of the attribute' do
+        expect(bar.reload[:lat_lng]).to be_a(LatLng)
+      end
+    end
+
     context "when the document is a new record" do
 
       let(:person) do
@@ -33,14 +222,14 @@ describe Mongoid::Attributes do
         context "when passing just the name" do
 
           it "returns the full value" do
-            person[:desc].should eq("en" => "testing")
+            expect(person[:desc]).to eq("testing")
           end
         end
 
         context "when passing the name with locale" do
 
           it "returns the value for the locale" do
-            person["desc.en"].should eq("testing")
+            expect(person["desc.en"]).to eq("testing")
           end
         end
       end
@@ -48,7 +237,7 @@ describe Mongoid::Attributes do
       context "when attribute does not exist" do
 
         it "returns the default value" do
-          person[:age].should eq(100)
+          expect(person[:age]).to eq(100)
         end
       end
 
@@ -59,7 +248,7 @@ describe Mongoid::Attributes do
         end
 
         it "returns the value" do
-          person[:owner_id].should eq(5)
+          expect(person[:owner_id]).to eq(5)
         end
       end
     end
@@ -67,315 +256,265 @@ 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 does not exist" do
-
-        before do
-          person.collection
-            .find({ _id: person.id })
-            .update({ "$unset" => { age: 1 }})
-        end
+      context "when the attribute was excluded in a criteria" do
 
-        context "when found" do
+        context "when excluding with only" do
 
-          let(:found) do
-            Person.find(person.id)
+          let(:from_db) do
+            Person.only(:_id).first
           end
 
-          it "returns the default value" do
-            found[:age].should eq(100)
+          it "raises an error" do
+            expect {
+              from_db[:title]
+            }.to raise_error(ActiveModel::MissingAttributeError)
           end
         end
 
-        context "when reloaded" do
+        context "when excluding with without" do
 
-          before do
-            Mongoid.raise_not_found_error = false
-            person.reload
-            Mongoid.raise_not_found_error = true
+          let(:from_db) do
+            Person.without(:title).first
           end
 
-          it "returns the default value" do
-            person[:age].should eq(100)
+          it "raises an error" do
+            expect {
+              from_db[:title]
+            }.to raise_error(ActiveModel::MissingAttributeError)
           end
         end
       end
-    end
-  end
-
-  describe "#[]=" do
-
-    let(:person) do
-      Person.new
-    end
-
-    context "when setting the attribute to nil" do
-
-      before do
-        person[:age] = nil
-      end
-
-      it "does not use the default value" do
-        person.age.should be_nil
-      end
-    end
-
-    context "when field has a default value" do
-
-      before do
-        person[:terms] = true
-      end
-
-      it "allows overwriting of the default value" do
-        person.terms.should be_true
-      end
-    end
-  end
 
-  describe ".attr_accessible" do
+      context "when the field was not explicitly defined" do
 
-    context "when the field is not _id" do
+        context "when excluding with only and the field was not excluded" do
 
-      let(:account) do
-        Account.new(number: 999999)
-      end
+          let(:from_db) do
+            Person.only(:_id).first
+          end
 
-      it "prevents setting via mass assignment" do
-        account.number.should be_nil
-      end
-    end
+          it "raises an error" do
+            expect {
+              from_db[:undefined_field]
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
+        end
 
-    context "when the field is _id" do
+        context "when excluding with without and the field was excluded" do
 
-      let(:account) do
-        Account.new(_id: "ABBA")
-      end
+          let(:from_db) do
+            Person.without(:title).first
+          end
 
-      it "prevents setting via mass assignment" do
-        account._id.should_not eq("ABBA")
-      end
-    end
+          it "raises an error" do
+            expect {
+              from_db[:title]
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
+        end
 
-    context "when using instantiate" do
+        context "when excluding with without and the field was not excluded" do
 
-      let(:account) do
-        Account.instantiate("_id" => "1", "balance" => "ABBA")
-      end
+          let(:from_db) do
+            Person.without(:title).first
+          end
 
-      it "ignores any protected attribute" do
-        account.balance.should eq("ABBA")
+          it "returns nil" do
+            from_db[:undefined_field].should be nil
+          end
+        end
       end
-    end
 
-    context "when using override" do
-
-      let(:account) do
-        Account.new
-      end
+      context 'when projecting with #only' do
+        let!(:person) do
+          Person.create!(title: 'sir', name: { first_name: 'Jose', language: { name: 'es' } })
+        end
 
-      it "ignores any protected attribute" do
-        account.write_attributes({balance: "ABBA"}, false)
-        account.balance.should eq("ABBA")
-      end
-    end
+        context 'when projecting an embedded association' do
+          let(:from_db) do
+            Person.only(:name).first
+          end
 
-    context "when mass assignment role is indicated" do
+          context 'when retrieving a field of the association using the dot notation' do
 
-      context "when attributes assigned from default role" do
+            it 'retrieves the field' do
+              expect(from_db['name.first_name']).to eq 'Jose'
+            end
+          end
 
-        let(:article) do
-          Article.new(
-            title: "Some Title",
-            is_rss: true,
-            user_login: "SomeLogin"
-          )
+          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
 
-        it "sets the title field for default role" do
-          article.title.should eq("Some Title")
-        end
+        context 'when projecting a sub-association of an embedded association' do
+          let(:from_db) do
+            Person.only('name.language').first
+          end
 
-        it "sets the user login field for the default role" do
-          article.user_login.should eq("SomeLogin")
-        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
 
-        it "sets the rss field for the default role" do
-          article.is_rss.should be_false
+          context 'when retrieving a non-projected field' do
+            it 'raises MissingAttributeError' do
+              expect do
+                from_db['name.first_name']
+              end.to raise_error(ActiveModel::MissingAttributeError)
+            end
+          end
         end
       end
 
-      context "when attributes assigned from parser role" do
-
-        let(:article) do
-          Article.new({
-            title: "Some Title",
-            is_rss: true,
-            user_login: "SomeLogin"
-            }, as: :parser
-          )
-        end
-
-        it "sets the title field" do
-          article.title.should eq("Some Title")
-        end
+      context "when the attribute does not exist" do
 
-        it "sets the rss field" do
-          article.is_rss.should be_true
+        before do
+          person.collection
+            .find({ _id: person.id })
+            .update_one({ "$unset" => { age: 1 }})
         end
 
-        it "does not set the user login field" do
-          article.user_login.should be_nil
-        end
-      end
+        context "when found" do
 
-      context "when attributes assigned without protection" do
+          let(:found) do
+            Person.find(person.id)
+          end
 
-        let(:article) do
-          Article.new(
-            { title: "Some Title",
-              is_rss: true,
-              user_login: "SomeLogin"
-            }, without_protection: true
-          )
+          it "returns the default value" do
+            expect(found[:age]).to eq(100)
+          end
         end
 
-        it "sets the title field" do
-          article.title.should eq("Some Title")
-        end
+        context "when reloaded" do
 
-        it "sets the user login field" do
-          article.user_login.should eq("SomeLogin")
-        end
+          before do
+            Mongoid.raise_not_found_error = false
+            person.reload
+            Mongoid.raise_not_found_error = true
+          end
 
-        it "sets the rss field" do
-          article.is_rss.should be_true
+          it "returns the default value" do
+            expect(person[:age]).to eq(100)
+          end
         end
       end
     end
   end
 
-  describe ".attr_protected" do
+  describe "#[]=" do
 
-    context "when the field is not _id" do
+    context 'when the document has a custom attribute type' do
 
-      let(:person) do
-        Person.new(security_code: "ABBA")
+      let(:bar) do
+        Bar.new.tap do |b|
+          b[:lat_lng] = LatLng.new(52.30, 13.25)
+          b.save!
+        end
       end
 
-      it "prevents setting via mass assignment" do
-        person.security_code.should be_nil
+      it 'sets the demongoized version of the attribute' do
+        expect(bar.reload.lat_lng).to be_a(LatLng)
       end
     end
 
-    context "when the field is _id" do
+    let(:person) do
+      Person.new
+    end
 
-      let(:game) do
-        Game.new(_id: "ABBA")
-      end
+    context "when setting the attribute to nil" do
 
-      it "prevents setting via mass assignment" do
-        game._id.should_not eq("ABBA")
+      let!(:age) do
+        person[:age] = nil
       end
-    end
 
-    context "when using instantiate" do
-
-      let(:person) do
-        Person.instantiate("_id" => "1", "security_code" => "ABBA")
+      it "does not use the default value" do
+        expect(person.age).to be_nil
       end
 
-      it "ignores any protected attribute" do
-        person.security_code.should eq("ABBA")
+      it "returns the set value" do
+        expect(age).to be_nil
       end
     end
 
-    context "when using override" do
+    context "when field has a default value" do
 
-      let(:person) do
-        Person.new
+      let!(:terms) do
+        person[:terms] = true
       end
 
-      it "ignores any protected attribute" do
-        person.write_attributes({security_code: "ABBA"}, false)
-        person.security_code.should eq("ABBA")
+      it "allows overwriting of the default value" do
+        expect(person.terms).to be true
       end
-    end
-
-    context "when mass assignment role is indicated" do
 
-      let(:item) do
-        Item.new
+      it "returns the set value" do
+        expect(terms).to eq(true)
       end
+    end
 
-      context "when attributes assigned from default role" do
-
-        before do
-          item.assign_attributes(
-            title: "Some Title",
-            is_rss: true,
-            user_login: "SomeLogin"
-          )
-        end
+    context 'when the field is not explicitly defined' do
+      let(:bar) { Bar.new }
 
-        it "sets the field for the default role" do
-          item.is_rss.should be_true
-        end
+      before do
+        bar['missing_field'] = 42
+      end
 
-        it "does not set the field for non default role title" do
-          item.title.should be_nil
-        end
+      it 'writes the value into attributes' do
+        bar.attributes.should == {'_id' => bar.id, 'missing_field' => 42}
+      end
 
-        it "does not set the field for non default role user login" do
-          item.user_login.should be_nil
-        end
+      it 'makes the attribute accessible via []' do
+        bar['missing_field'].should == 42
       end
 
-      context "when attributes assigned from parser role" do
+      context 'when writing fields on a document with projection' do
 
-        before do
-          item.assign_attributes(
-            { title: "Some Title",
-              is_rss: true,
-              user_login: "SomeLogin" }, as: :parser
-          )
+        let!(:person) do
+          Person.create!(title: "sir")
         end
 
-        it "sets the user login field for parser role" do
-          item.user_login.should eq("SomeLogin")
-        end
+        context "when excluding with only and the field was not excluded" do
 
-        it "sets the is rss field for parse role" do
-          item.is_rss.should be_false
-        end
+          let(:from_db) do
+            Person.only(:_id).first
+          end
 
-        it "does not set the title field" do
-          item.title.should be_nil
+          it "raises an error" do
+            expect {
+              from_db[:undefined_field] = 'x'
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
         end
-      end
 
-      context "when attributes assigned without protection" do
+        context "when excluding with without and the field was excluded" do
 
-        before do
-          item.assign_attributes(
-            { title: "Some Title",
-              is_rss: true,
-              user_login: "SomeLogin"
-            }, without_protection: true
-          )
-        end
+          let(:from_db) do
+            Person.without(:title).first
+          end
 
-        it "sets the title attribute" do
-          item.title.should eq("Some Title")
+          it "raises an error" do
+            expect {
+              from_db[:title] = 'x'
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
         end
 
-        it "sets the user login attribute" do
-          item.user_login.should eq("SomeLogin")
-        end
+        context "when excluding with without and the field was not excluded" do
 
-        it "sets the rss attribute" do
-          item.is_rss.should be_true
+          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
@@ -388,7 +527,18 @@ describe Mongoid::Attributes do
     end
 
     it "delegates to #id" do
-      person._id.should eq(person.id)
+      expect(person._id).to eq(person.id)
+    end
+
+    context "when #id alias is overridden" do
+
+      let(:object) do
+        IdKey.new(key: 'foo')
+      end
+
+      it "delegates to another method" do
+        expect(object.id).to eq(object.key)
+      end
     end
   end
 
@@ -397,9 +547,10 @@ describe Mongoid::Attributes do
     after(:all) do
       Person.field(
         :_id,
-        type: Moped::BSON::ObjectId,
+        type: BSON::ObjectId,
         pre_processed: true,
-        default: ->{ Moped::BSON::ObjectId.new }
+        default: ->{ BSON::ObjectId.new },
+        overwrite: true
       )
     end
 
@@ -408,9 +559,10 @@ describe Mongoid::Attributes do
       before(:all) do
         Person.field(
           :_id,
-          type: Moped::BSON::ObjectId,
+          type: BSON::ObjectId,
           pre_processed: true,
-          default: ->{ Moped::BSON::ObjectId.new }
+          default: ->{ BSON::ObjectId.new },
+          overwrite: true
         )
       end
 
@@ -419,7 +571,7 @@ describe Mongoid::Attributes do
       end
 
       let(:bson_id) do
-        Moped::BSON::ObjectId.new
+        BSON::ObjectId.new
       end
 
       context "when providing an object id" do
@@ -429,7 +581,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets the id as the object id" do
-          person.id.should eq(bson_id)
+          expect(person.id).to eq(bson_id)
         end
       end
 
@@ -440,7 +592,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets the id as the object id" do
-          person.id.should eq(bson_id)
+          expect(person.id).to eq(bson_id)
         end
       end
 
@@ -451,9 +603,22 @@ describe Mongoid::Attributes do
         end
 
         it "sets the id as the supplied value to_s" do
-          person.id.should eq(2)
+          expect(person.id).to eq(2)
+        end
+      end
+
+      context "when #id= alias is overridden" do
+
+        let(:object) do
+          IdKey.new(key: 'foo')
+        end
+
+        it "delegates to another method" do
+          object.id = 'bar'
+          expect(object.id).to eq('bar')
         end
       end
+
     end
 
     context "when using string ids" do
@@ -463,7 +628,8 @@ describe Mongoid::Attributes do
           :_id,
           type: String,
           pre_processed: true,
-          default: ->{ Moped::BSON::ObjectId.new.to_s }
+          default: ->{ BSON::ObjectId.new.to_s },
+          overwrite: true
         )
       end
 
@@ -472,7 +638,7 @@ describe Mongoid::Attributes do
       end
 
       let(:bson_id) do
-        Moped::BSON::ObjectId.new
+        BSON::ObjectId.new
       end
 
       context "when providing an object id" do
@@ -482,7 +648,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets the id as the string of the object id" do
-          person.id.should eq(bson_id.to_s)
+          expect(person.id).to eq(bson_id.to_s)
         end
       end
 
@@ -493,7 +659,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets the id as the string" do
-          person.id.should eq(bson_id.to_s)
+          expect(person.id).to eq(bson_id.to_s)
         end
       end
 
@@ -504,7 +670,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets the id as the supplied value to_s" do
-          person.id.should eq("2")
+          expect(person.id).to eq("2")
         end
       end
     end
@@ -512,7 +678,7 @@ describe Mongoid::Attributes do
     context "when using integer ids" do
 
       before(:all) do
-        Person.field(:_id, type: Integer)
+        Person.field(:_id, type: Integer, overwrite: true)
       end
 
       let(:person) do
@@ -526,7 +692,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets the id as the integer" do
-          person.id.should eq(1)
+          expect(person.id).to eq(1)
         end
       end
 
@@ -537,7 +703,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets the id as the supplied value" do
-          person.id.should eq(2)
+          expect(person.id).to eq(2)
         end
       end
     end
@@ -553,27 +719,23 @@ describe Mongoid::Attributes do
       Person.new(attributes)
     end
 
-    before do
-      Mongoid.configure.allow_dynamic_fields = true
-    end
-
     context "when an attribute exists" do
 
       it "allows the getter" do
-        person.testing.should eq("Testing")
+        expect(person.testing).to eq("Testing")
       end
 
       it "allows the setter" do
         person.testing = "Test"
-        person.testing.should eq("Test")
+        expect(person.testing).to eq("Test")
       end
 
       it "allows the getter before_type_cast" do
-        person.testing_before_type_cast.should eq("Testing")
+        expect(person.testing_before_type_cast).to eq("Testing")
       end
 
       it "returns true for respond_to?" do
-        person.respond_to?(:testing).should be_true
+        expect(person.respond_to?(:testing)).to be true
       end
     end
 
@@ -588,28 +750,17 @@ describe Mongoid::Attributes do
       end
 
       it "mongoizes the dynamic field" do
-        person.new_years.should be_a(Time)
+        expect(person.new_years).to be_a(Time)
       end
 
       it "keeps the same value" do
-        person.new_years.should eq(new_years)
+        expect(person.new_years).to eq(new_years)
       end
     end
   end
 
   describe "#process" do
 
-    context "when passing non accessible fields" do
-
-      let(:person) do
-        Person.new(owner_id: 6)
-      end
-
-      it "does not set the value" do
-        person.owner_id.should be_nil
-      end
-    end
-
     context "when attributes dont have fields defined" do
 
       let(:attributes) do
@@ -626,43 +777,26 @@ describe Mongoid::Attributes do
           Person.new(attributes)
         end
 
-        before do
-          Mongoid.configure.allow_dynamic_fields = true
-        end
-
         context "when attribute is a string" do
 
           it "adds the string to the attributes" do
-            person.attributes["nofieldstring"].should eq("Testing")
+            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
-            person.attributes["nofieldint"].should eq(5)
+            expect(person.attributes["nofieldint"]).to eq(5)
           end
         end
       end
 
       context "when not allowing dynamic fields" do
 
-        let!(:attributes) do
-          { nofieldstring: "Testing" }
-        end
-
-        before do
-          Mongoid.configure.allow_dynamic_fields = false
-          Person.fields.delete(:nofieldstring)
-        end
-
-        after do
-          Mongoid.configure.allow_dynamic_fields = true
-        end
-
-        it "raises an unknown attribute error" do
+        it "raises an unknown attribute error on instantiation" do
           expect {
-            Person.new({ anothernew: "Test" })
+            Account.new({ anothernew: "Test" })
           }.to raise_error(Mongoid::Errors::UnknownAttribute)
         end
       end
@@ -671,7 +805,7 @@ describe Mongoid::Attributes do
     context "when supplied hash has string values" do
 
       let(:bson_id) do
-        Moped::BSON::ObjectId.new
+        BSON::ObjectId.new
       end
 
       let!(:attributes) do
@@ -695,15 +829,15 @@ describe Mongoid::Attributes do
       end
 
       it "casts integers" do
-        person[:age].should eq(30)
+        expect(person[:age]).to eq(30)
       end
 
       it "casts booleans" do
-        person[:terms].should be_true
+        expect(person[:terms]).to be true
       end
 
       it "sets empty strings to nil" do
-        person[:score].should be_nil
+        expect(person[:score]).to be_nil
       end
     end
 
@@ -724,7 +858,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets the associations" do
-          person.name.should eq(name)
+          expect(person.name).to eq(name)
         end
       end
 
@@ -743,11 +877,11 @@ describe Mongoid::Attributes do
         end
 
         it "sets the parent association" do
-          person.game.should eq(game)
+          expect(person.game).to eq(game)
         end
 
         it "sets the inverse association" do
-          game.person.should eq(person)
+          expect(game.person).to eq(person)
         end
       end
 
@@ -762,7 +896,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets the association" do
-          name.person.should eq(person)
+          expect(name.person).to eq(person)
         end
       end
     end
@@ -782,7 +916,7 @@ describe Mongoid::Attributes do
       end
 
       it "calls the setter for the association" do
-        person.employer_id.should eq("1")
+        expect(person.employer_id).to eq("1")
       end
     end
 
@@ -797,7 +931,7 @@ describe Mongoid::Attributes do
       end
 
       it "sets the empty array" do
-        person.aliases.should be_empty
+        expect(person.aliases).to be_empty
       end
     end
 
@@ -812,7 +946,20 @@ describe Mongoid::Attributes do
       end
 
       it "sets the empty hash" do
-        person.map.should eq({})
+        expect(person.map).to eq({})
+      end
+    end
+
+    context "when providing tainted parameters" do
+
+      let(:params) do
+        ActionController::Parameters.new(title: "sir")
+      end
+
+      it "raises an error" do
+        expect {
+          Person.new(params)
+        }.to raise_error(ActiveModel::ForbiddenAttributesError)
       end
     end
   end
@@ -832,12 +979,23 @@ describe Mongoid::Attributes do
     end
 
     it "only overwrites supplied attributes" do
-      person.title.should eq("Sir")
+      expect(person.title).to eq("Sir")
     end
   end
 
   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
+
+      it 'returns the demongoized version of the attribute' do
+        expect(bar.reload.read_attribute(:lat_lng)).to be_a(LatLng)
+      end
+    end
+
     context "when the document is a new record" do
 
       let(:person) do
@@ -847,8 +1005,8 @@ describe Mongoid::Attributes do
       context "when attribute does not exist" do
 
         it "returns the default value" do
-          person.age.should eq(100)
-          person.pets.should be_false
+          expect(person.age).to eq(100)
+          expect(person.pets).to be false
         end
 
       end
@@ -860,7 +1018,7 @@ describe Mongoid::Attributes do
         end
 
         it "returns the value" do
-          person.read_attribute(:owner_id).should eq(5)
+          expect(person.read_attribute(:owner_id)).to eq(5)
         end
       end
     end
@@ -868,7 +1026,7 @@ 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
@@ -876,40 +1034,99 @@ describe Mongoid::Attributes do
         before do
           person.collection
             .find({ _id: person.id })
-            .update({ "$unset" => { age: 1 }})
+            .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
-          person.age.should eq(100)
+          expect(person.age).to eq(100)
         end
       end
     end
+
+    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")
+      end
+
+      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
+
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     context "when the attribute has not yet been assigned" do
 
       it "returns the default value" do
-        person.age_before_type_cast.should eq(100)
+        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 = "old"
-        person.age_before_type_cast.should eq("old")
+        person.age = "42"
+        expect(person.age_before_type_cast).to eq("42")
       end
     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(ActiveModel::MissingAttributeError)
+        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(ActiveModel::MissingAttributeError)
+        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
 
   describe "#attribute_present?" do
 
@@ -922,7 +1139,7 @@ describe Mongoid::Attributes do
       context "when attribute does not exist" do
 
         it "returns false" do
-          person.attribute_present?(:owner_id).should be_false
+          expect(person.attribute_present?(:owner_id)).to be false
         end
       end
 
@@ -932,7 +1149,7 @@ describe Mongoid::Attributes do
         end
 
         it "returns true" do
-          person.attribute_present?(:owner_id).should be_true
+          expect(person.attribute_present?(:owner_id)).to be true
         end
       end
     end
@@ -940,7 +1157,7 @@ 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
@@ -948,14 +1165,14 @@ describe Mongoid::Attributes do
         before do
           person.collection
             .find({ _id: person.id })
-            .update({ "$unset" => { age: 1 }})
+            .update_one({ "$unset" => { age: 1 }})
           Mongoid.raise_not_found_error = false
           person.reload
           Mongoid.raise_not_found_error = true
         end
 
         it "returns true" do
-          person.attribute_present?(:age).should be_true
+          expect(person.attribute_present?(:age)).to be true
         end
       end
     end
@@ -972,7 +1189,7 @@ describe Mongoid::Attributes do
 
           it "return true"  do
             person.terms = false
-            person.attribute_present?(:terms).should be_true
+            expect(person.attribute_present?(:terms)).to be true
           end
         end
 
@@ -980,7 +1197,7 @@ describe Mongoid::Attributes do
 
           it "return true"  do
             person.terms = false
-            person.attribute_present?(:terms).should be_true
+            expect(person.attribute_present?(:terms)).to be true
           end
         end
       end
@@ -993,7 +1210,19 @@ describe Mongoid::Attributes do
       end
 
       it "return false" do
-        person.attribute_present?(:title).should be_false
+        expect(person.attribute_present?(:title)).to be false
+      end
+    end
+
+    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
+        expect(person.attribute_present?(:foobar)).to be false
       end
     end
   end
@@ -1009,14 +1238,14 @@ describe Mongoid::Attributes do
       context "when provided a symbol" do
 
         it "returns true" do
-          person.has_attribute?(:title).should be_true
+          expect(person.has_attribute?(:title)).to be true
         end
       end
 
       context "when provided a string" do
 
         it "returns true" do
-          person.has_attribute?("title").should be_true
+          expect(person.has_attribute?("title")).to be true
         end
       end
     end
@@ -1024,7 +1253,7 @@ describe Mongoid::Attributes do
     context "when the key is not in the attributes" do
 
       it "returns false" do
-        person.has_attribute?(:employer_id).should be_false
+        expect(person.has_attribute?(:employer_id)).to be false
       end
     end
   end
@@ -1037,16 +1266,16 @@ describe Mongoid::Attributes do
 
     context "before the attribute has been assigned" do
 
-      it "returns false" do
-        person.has_attribute_before_type_cast?(:age).should 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.has_attribute_before_type_cast?(:age).should be_true
+        person.age = '42'
+        expect(person.has_attribute_before_type_cast?(:age)).to be true
       end
     end
   end
@@ -1056,7 +1285,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
@@ -1064,21 +1293,21 @@ describe Mongoid::Attributes do
       end
 
       it "removes the attribute" do
-        person.title.should be_nil
+        expect(person.title).to be_nil
       end
 
       it "removes the key from the attributes hash" do
-        person.has_attribute?(:title).should be_false
+        expect(person.has_attribute?(:title)).to be false
       end
 
       context "when saving after the removal" do
 
         before do
-          person.save
+          person.save!
         end
 
         it "persists the removal" do
-          person.reload.has_attribute?(:title).should be_false
+          expect(person.reload.has_attribute?(:title)).to be false
         end
       end
     end
@@ -1094,26 +1323,26 @@ describe Mongoid::Attributes do
      end
 
      before do
-       person.save
+       person.save!
        person.pet.remove_attribute(:name)
      end
 
      it "removes the attribute" do
-       person.pet.name.should be_nil
+       expect(person.pet.name).to be_nil
      end
 
      it "removes the key from the attributes hash" do
-       person.pet.has_attribute?(:name).should be_false
+       expect(person.pet.has_attribute?(:name)).to be false
      end
 
      context "when saving after the removal" do
 
        before do
-         person.save
+         person.save!
        end
 
        it "persists the removal" do
-         person.reload.pet.has_attribute?(:name).should be_false
+         expect(person.reload.pet.has_attribute?(:name)).to be false
        end
      end
 
@@ -1130,7 +1359,7 @@ describe Mongoid::Attributes do
       end
 
       it "does not fail" do
-        person.title.should be_nil
+        expect(person.title).to be_nil
       end
     end
 
@@ -1145,7 +1374,70 @@ describe Mongoid::Attributes do
       end
 
       it "does not add a delayed unset operation" do
-        person.delayed_atomic_unsets.should be_empty
+        expect(person.delayed_atomic_unsets).to be_empty
+      end
+    end
+
+    context "when the attribute is aliased" do
+
+      context 'when the database name is used' do
+
+        let(:person) do
+          Person.create!(at: Time.now)
+        end
+
+        before do
+          person.remove_attribute(:at)
+        end
+
+        it "removes the attribute" do
+          expect(person.at).to be_nil
+        end
+
+        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
+
+          before do
+            person.save!
+          end
+
+          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
+
+        before do
+          person.remove_attribute(:aliased_timestamp)
+        end
+
+        it "removes the attribute" do
+          expect(person.aliased_timestamp).to be_nil
+        end
+
+        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
+
+          before do
+            person.save!
+          end
+
+          it "persists the removal" do
+            expect(person.reload.has_attribute?(:aliased_timestamp)).to be false
+          end
+        end
       end
     end
   end
@@ -1158,10 +1450,6 @@ describe Mongoid::Attributes do
         Person.new
       end
 
-      before(:all) do
-        Mongoid.allow_dynamic_fields = true
-      end
-
       context "when asking for the getter" do
 
         context "when the attribute exists" do
@@ -1171,14 +1459,14 @@ describe Mongoid::Attributes do
           end
 
           it "returns true" do
-            person.should respond_to(:attr)
+            expect(person).to respond_to(:attr)
           end
         end
 
         context "when the attribute does not exist" do
 
           it "returns false" do
-            person.should_not respond_to(:attr)
+            expect(person).to_not respond_to(:attr)
           end
         end
       end
@@ -1192,14 +1480,14 @@ describe Mongoid::Attributes do
           end
 
           it "returns true" do
-            person.should respond_to(:attr=)
+            expect(person).to respond_to(:attr=)
           end
         end
 
         context "when the attribute does not exist" do
 
           it "returns false" do
-            person.should_not respond_to(:attr=)
+            expect(person).to_not respond_to(:attr=)
           end
         end
       end
@@ -1207,29 +1495,21 @@ describe Mongoid::Attributes do
 
     context "when not allowing dynamic fields" do
 
-      let(:person) do
-        Person.new
-      end
-
-      before(:all) do
-        Mongoid.allow_dynamic_fields = false
-      end
-
-      after(:all) do
-        Mongoid.allow_dynamic_fields = true
+      let(:bar) do
+        Bar.new
       end
 
       context "when asking for the getter" do
 
         it "returns false" do
-          person.should_not respond_to(:attr)
+          expect(bar).to_not respond_to(:attr)
         end
       end
 
       context "when asking for the setter" do
 
         it "returns false" do
-          person.should_not respond_to(:attr=)
+          expect(bar).to_not respond_to(:attr=)
         end
       end
     end
@@ -1244,17 +1524,18 @@ describe Mongoid::Attributes do
       end
 
       it "returns the default value" do
-        person.age.should eq(100)
+        expect(person.age).to eq(100)
       end
     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
-        person.age_before_type_cast.should eq("old")
+        expect(person.age_before_type_cast).to eq("42")
       end
     end
 
@@ -1265,7 +1546,7 @@ describe Mongoid::Attributes do
       end
 
       it "does not use the default value" do
-        person.age.should be_nil
+        expect(person.age).to be_nil
       end
     end
 
@@ -1280,7 +1561,7 @@ describe Mongoid::Attributes do
       end
 
       it "allows overwriting of the default value" do
-        person.terms.should be_true
+        expect(person.terms).to be true
       end
     end
 
@@ -1294,8 +1575,146 @@ describe Mongoid::Attributes do
         person.write_attribute(:test, "aliased field to test")
       end
 
-      it "allows the field name to be udpated" do
-        person.t.should 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" } }
+
+      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
+        person.map = false
+        expect(person.map).to be_nil
+      end
+
+      it "can set a Hash value" do
+        expect(person.map).to eq( { somekey: "somevalue" } )
+      end
+    end
+
+    context "when attribute is an Array" do
+      let(:person) { Person.new aliases: [ :alias_1 ] }
+
+      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
+        person.aliases = {}
+        expect(person.aliases).to be_nil
+      end
+
+      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
+      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
+        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")
+      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(ActiveModel::MissingAttributeError)
+        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(ActiveModel::MissingAttributeError)
+        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
+      config_override :legacy_attributes, false
+
+      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
@@ -1316,11 +1735,11 @@ describe Mongoid::Attributes do
     context "when the key has not been specified as a field" do
 
       before do
-        person.stub(:fields).and_return({})
+        allow(person).to receive(:fields).and_return({})
       end
 
       it "returns the value" do
-        person.send(:typed_value_for, "age", "51").should eq("51")
+        person.send(:typed_value_for, "age", expect("51")).to eq("51")
       end
     end
   end
@@ -1332,7 +1751,22 @@ describe Mongoid::Attributes do
     end
 
     it "typecasts proc values" do
-      person.age.should eq(100)
+      expect(person.age).to eq(100)
+    end
+  end
+
+  describe "#typed_attributes"  do
+
+    let(:date_time) do
+      DateTime.current
+    end
+
+    let(:user) do
+      User.new(last_login: date_time)
+    end
+
+    it 'returns typecasted attributes' do
+      expect(user.typed_attributes).to include("last_login" => date_time)
     end
   end
 
@@ -1351,7 +1785,7 @@ describe Mongoid::Attributes do
         end
 
         it "sets nested documents" do
-          person.videos.first.title.should eq("Fight Club")
+          expect(person.videos.first.title).to eq("Fight Club")
         end
       end
 
@@ -1372,7 +1806,7 @@ describe Mongoid::Attributes do
           end
 
           it "properly casts values" do
-            person.age.should eq(50)
+            expect(person.age).to eq(50)
           end
         end
 
@@ -1383,11 +1817,38 @@ describe Mongoid::Attributes do
           end
 
           it "does not set anything" do
-            person.age.should eq(100)
+            expect(person.age).to eq(100)
           end
         end
       end
 
+      context "copying from instance" do
+
+        let(:person) do
+          Person.new
+        end
+
+        let(:instance) do
+          Person.new(attributes)
+        end
+
+        let(:attributes) do
+          { age: 50, range: 1..100 }
+        end
+
+        before do
+          person.send(method, instance.attributes)
+        end
+
+        it "properly copies values" do
+          expect(person.age).to eq(50)
+        end
+
+        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
@@ -1411,8 +1872,8 @@ describe Mongoid::Attributes do
           end
 
           it "does not overwrite child attributes if not in the hash" do
-            owner.pet.name.should eq("Bingo")
-            owner.pet.vet_visits.size.should eq(1)
+            expect(owner.pet.name).to eq("Bingo")
+            expect(owner.pet.vet_visits.size).to eq(1)
           end
         end
 
@@ -1436,11 +1897,11 @@ describe Mongoid::Attributes do
           end
 
           it "has 3 new entries" do
-            pet.vet_visits.count.should eq(3)
+            expect(pet.vet_visits.count).to eq 3
           end
 
           it "persists the changes" do
-            pet.reload.vet_visits.count.should eq(3)
+            expect(pet.reload.vet_visits.count).to eq 3
           end
         end
 
@@ -1478,7 +1939,7 @@ describe Mongoid::Attributes do
           end
 
           it "sets the child attributes on the parent" do
-            name.attributes.should eq(
+            expect(name.attributes).to eq(
               { "_id" => "Test-User", "first_name" => "Test2", "last_name" => "User2" }
             )
           end
@@ -1500,7 +1961,7 @@ describe Mongoid::Attributes do
           end
 
           it "updates the child attributes on the parent" do
-            address.attributes.should eq(
+            expect(address.attributes).to eq(
               { "_id" => "test", "street" => "Test2" }
             )
           end
@@ -1509,6 +1970,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
@@ -1521,38 +2037,42 @@ describe Mongoid::Attributes do
         product.cost = 500
       end
 
+      it "adds the alias for criteria" do
+        expect(Product.where(cost: 500).selector).to eq("price" => 500)
+      end
+
       it "aliases the getter" do
-        product.cost.should eq(500)
+        expect(product.cost).to eq(500)
       end
 
-      it "aliases the existance check" do
-        product.cost?.should be_true
+      it "aliases the existence check" do
+        expect(product.cost?).to be true
       end
 
       it "aliases *_changed?" do
-        product.cost_changed?.should be_true
+        expect(product.cost_changed?).to be true
       end
 
       it "aliases *_change" do
-        product.cost_change.should eq([ nil, 500 ])
+        expect(product.cost_change).to eq([ nil, 500 ])
       end
 
       it "aliases *_will_change!" do
-        product.should respond_to(:cost_will_change!)
+        expect(product).to respond_to(:cost_will_change!)
       end
 
       it "aliases *_was" do
-        product.cost_was.should be_nil
+        expect(product.cost_was).to be_nil
       end
 
       it "aliases reset_*!" do
         product.reset_cost!
-        product.cost.should be_nil
+        expect(product.cost).to be_nil
       end
 
       it "aliases *_before_type_cast" do
-        product.cost = "expensive"
-        product.cost_before_type_cast.should eq("expensive")
+        product.cost = "42"
+        expect(product.cost_before_type_cast).to eq("42")
       end
     end
 
@@ -1563,32 +2083,32 @@ describe Mongoid::Attributes do
       end
 
       it "aliases the getter" do
-        product.price.should eq(500)
+        expect(product.price).to eq(500)
       end
 
-      it "aliases the existance check" do
-        product.price?.should be_true
+      it "aliases the existence check" do
+        expect(product.price?).to be true
       end
 
       it "aliases *_changed?" do
-        product.price_changed?.should be_true
+        expect(product.price_changed?).to be true
       end
 
       it "aliases *_change" do
-        product.price_change.should eq([ nil, 500 ])
+        expect(product.price_change).to eq([ nil, 500 ])
       end
 
       it "aliases *_will_change!" do
-        product.should respond_to(:price_will_change!)
+        expect(product).to respond_to(:price_will_change!)
       end
 
       it "aliases *_was" do
-        product.price_was.should be_nil
+        expect(product.price_was).to be_nil
       end
 
       it "aliases reset_*!" do
         product.reset_price!
-        product.price.should be_nil
+        expect(product.price).to be_nil
       end
     end
   end
@@ -1596,11 +2116,11 @@ 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
-      person.reload.attributes.should have_key("score")
+      expect(person.reload.attributes).to have_key("score")
     end
   end
 
@@ -1611,8 +2131,8 @@ describe Mongoid::Attributes do
     end
 
     it "saves the default" do
-      expect { person.save }.to_not raise_error
-      person.last_drink_taken_at.should eq(1.day.ago.in_time_zone("Alaska").to_date)
+      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
 
@@ -1621,11 +2141,11 @@ 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
-        person.last_drink_taken_at.should eq(1.day.ago.in_time_zone("Alaska").to_date)
+        expect(person.last_drink_taken_at).to eq(1.day.ago.in_time_zone("Alaska").to_date)
       end
     end
 
@@ -1634,7 +2154,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
@@ -1642,14 +2162,14 @@ describe Mongoid::Attributes do
         end
 
         it "does not set the default" do
-          from_db.age.should eq(50)
+          expect(from_db.age).to eq(50)
         end
       end
 
       context "when the value is explicitly nil" do
 
         let!(:person) do
-          Person.create(age: nil)
+          Person.create!(age: nil)
         end
 
         let(:from_db) do
@@ -1657,14 +2177,14 @@ describe Mongoid::Attributes do
         end
 
         it "does not set the default" do
-          from_db.age.should be_nil
+          expect(from_db.age).to be_nil
         end
       end
 
       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
@@ -1672,34 +2192,523 @@ describe Mongoid::Attributes do
         end
 
         it "applies the defaults after all attributes are set" do
-          from_db.should be_balanced
+          expect(from_db).to be_balanced
+        end
+      end
+    end
+  end
+
+  context 'when calling the attribute check method' do
+
+    context 'when the attribute is blank' do
+      let(:person) do
+        Person.create!(title: '')
+      end
+
+      it 'returns false' do
+        expect(person.title?).to be(false)
+      end
+    end
+
+    context 'when the attribute is localized' do
+      let(:person) do
+        Person.create!
+      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)
+        end
+      end
+
+      context 'when the field is a boolean' do
+
+        before do
+          person.desc = false
+        end
+
+        it 'applies the localization when checking the attribute' do
+          expect(person.desc?).to be(false)
         end
       end
     end
+
+    context 'when the attribute is not localized' do
+      let(:person) do
+        Person.create!(username: 'localized')
+      end
+
+      before do
+        person.username = nil
+      end
+
+      it 'does not apply localization when checking the attribute' do
+        expect(person.username?).to be(false)
+      end
+    end
   end
 
-  context "when dynamic fields are not allowed" do
+  context "when an attribute is removed then set" do
+    let(:cat) { Cat.create!(name: "Neil") }
 
     before do
-      Mongoid.configure.allow_dynamic_fields = false
+      cat.remove_attribute("name")
+      cat.name = "Nissim"
+      cat.save!
+      cat.reload
     end
 
-    after do
-      Mongoid.configure.allow_dynamic_fields = true
+    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 delete_one" do
+        let(:doc) { NestedBook.create! }
+        let(:page) { NestedPage.new }
+        before do
+          doc.pages << page
+          doc.pages << NestedPage.new
+          doc.pages << NestedPage.new
+
+          doc.pages.send(:delete_one, 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 "when an embedded document has been persisted" do
+    context "on embeds_one" do
 
-      context "when the field is no longer recognized" do
+      let(:attrs) { { "title" => "Title" } }
+
+      context "when using nested attributes" do
+        let(:doc) { NestedBook.create! }
 
         before do
-          Person.collection.insert 'pet' => { 'unrecognized_field' => true }
+          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 "allows access to the legacy data" do
-          Person.first.pet.read_attribute(:unrecognized_field).should be_true
+        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
 end