mongoid 3.1.6 → 4.0.2

data/spec/mongoid/attributes/readonly_spec.rb

@@ -15,7 +15,7 @@ describe Mongoid::Attributes::Readonly do
       end
 
       it "adds the field to readonly attributes" do
-        Person.readonly_attributes.to_a.should eq([ "title" ])
+        expect(Person.readonly_attributes.to_a).to eq([ "title" ])
       end
     end
 
@@ -26,7 +26,7 @@ describe Mongoid::Attributes::Readonly do
       end
 
       it "adds the fields to readonly attributes" do
-        Person.readonly_attributes.to_a.should eq([ "title", "terms" ])
+        expect(Person.readonly_attributes.to_a).to eq([ "title", "terms" ])
       end
     end
 
@@ -41,30 +41,30 @@ describe Mongoid::Attributes::Readonly do
       end
 
       it "sets the first readonly value" do
-        person.title.should eq("sir")
+        expect(person.title).to eq("sir")
       end
 
       it "sets subsequent readonly values" do
-        person.terms.should be_true
+        expect(person.terms).to be true
       end
 
       it "persists the first readonly value" do
-        person.reload.title.should eq("sir")
+        expect(person.reload.title).to eq("sir")
       end
 
       it "persists subsequent readonly values" do
-        person.reload.terms.should be_true
+        expect(person.reload.terms).to be true
       end
     end
 
     context "when updating an existing readonly field" do
 
       before do
-        Person.attr_readonly :title, :terms
+        Person.attr_readonly :title, :terms, :score
       end
 
       let(:person) do
-        Person.create(title: "sir", terms: true)
+        Person.create(title: "sir", terms: true, score: 1)
       end
 
       context "when updating via the setter" do
@@ -75,11 +75,51 @@ describe Mongoid::Attributes::Readonly do
         end
 
         it "does not update the field" do
-          person.title.should eq("sir")
+          expect(person.title).to eq("sir")
         end
 
         it "does not persist the changes" do
-          person.reload.title.should eq("sir")
+          expect(person.reload.title).to eq("sir")
+        end
+      end
+
+      context "when updating via inc" do
+
+        context 'with single field operation' do
+          it "raises an error " do
+            expect {
+              person.inc(score: 1)
+            }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          end
+        end
+
+        context 'with multiple fields operation' do
+          it "raises an error " do
+            expect {
+              person.inc(score: 1, age: 1)
+            }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          end
+        end
+      end
+
+      context "when updating via bit" do
+
+        context 'with single field operation' do
+          it "raises an error " do
+            expect {
+              person.bit(score: { or: 13 })
+            }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          end
+        end
+
+        context 'with multiple fields operation' do
+          it "raises an error " do
+            expect {
+              person.bit(
+                age: { and: 13 }, score: { or: 13 }, inte: { and: 13, or: 10 }
+              )
+            }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+          end
         end
       end
 
@@ -91,11 +131,11 @@ describe Mongoid::Attributes::Readonly do
         end
 
         it "does not update the field" do
-          person.title.should eq("sir")
+          expect(person.title).to eq("sir")
         end
 
         it "does not persist the changes" do
-          person.reload.title.should eq("sir")
+          expect(person.reload.title).to eq("sir")
         end
       end
 
@@ -107,11 +147,11 @@ describe Mongoid::Attributes::Readonly do
         end
 
         it "does not update the field" do
-          person.title.should eq("sir")
+          expect(person.title).to eq("sir")
         end
 
         it "does not persist the changes" do
-          person.reload.title.should eq("sir")
+          expect(person.reload.title).to eq("sir")
         end
       end
 
@@ -123,11 +163,11 @@ describe Mongoid::Attributes::Readonly do
         end
 
         it "does not update the field" do
-          person.title.should eq("sir")
+          expect(person.title).to eq("sir")
         end
 
         it "does not persist the changes" do
-          person.reload.title.should eq("sir")
+          expect(person.reload.title).to eq("sir")
         end
       end
 
@@ -139,11 +179,11 @@ describe Mongoid::Attributes::Readonly do
         end
 
         it "does not update the field" do
-          person.title.should eq("sir")
+          expect(person.title).to eq("sir")
         end
 
         it "does not persist the changes" do
-          person.reload.title.should eq("sir")
+          expect(person.reload.title).to eq("sir")
         end
       end
 

data/spec/mongoid/attributes_spec.rb

@@ -11,7 +11,75 @@ 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
+          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
+      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
@@ -33,14 +101,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("en" => "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 +116,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 +127,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
@@ -70,6 +138,35 @@ describe Mongoid::Attributes do
         Person.create(title: "sir")
       end
 
+      context "when the attribute was excluded in a criteria" do
+
+        context "when excluding with only" do
+
+          let(:from_db) do
+            Person.only(:_id).first
+          end
+
+          it "raises an error" do
+            expect {
+              from_db[:title]
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          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
+
       context "when the attribute does not exist" do
 
         before do
@@ -85,7 +182,7 @@ describe Mongoid::Attributes do
           end
 
           it "returns the default value" do
-            found[:age].should eq(100)
+            expect(found[:age]).to eq(100)
           end
         end
 
@@ -98,7 +195,7 @@ describe Mongoid::Attributes do
           end
 
           it "returns the default value" do
-            person[:age].should eq(100)
+            expect(person[:age]).to eq(100)
           end
         end
       end
@@ -113,293 +210,66 @@ describe Mongoid::Attributes do
 
     context "when setting the attribute to nil" do
 
-      before do
+      let!(:age) do
         person[:age] = nil
       end
 
       it "does not use the default value" do
-        person.age.should be_nil
+        expect(person.age).to be_nil
+      end
+
+      it "returns the set value" do
+        expect(age).to be_nil
       end
     end
 
     context "when field has a default value" do
 
-      before do
+      let!(:terms) 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 is not _id" do
-
-      let(:account) do
-        Account.new(number: 999999)
+        expect(person.terms).to be true
       end
 
-      it "prevents setting via mass assignment" do
-        account.number.should be_nil
-      end
-    end
-
-    context "when the field is _id" do
-
-      let(:account) do
-        Account.new(_id: "ABBA")
-      end
-
-      it "prevents setting via mass assignment" do
-        account._id.should_not eq("ABBA")
-      end
-    end
-
-    context "when using instantiate" do
-
-      let(:account) do
-        Account.instantiate("_id" => "1", "balance" => "ABBA")
-      end
-
-      it "ignores any protected attribute" do
-        account.balance.should eq("ABBA")
-      end
-    end
-
-    context "when using override" do
-
-      let(:account) do
-        Account.new
-      end
-
-      it "ignores any protected attribute" do
-        account.write_attributes({balance: "ABBA"}, false)
-        account.balance.should eq("ABBA")
-      end
-    end
-
-    context "when mass assignment role is indicated" do
-
-      context "when attributes assigned from default role" do
-
-        let(:article) do
-          Article.new(
-            title: "Some Title",
-            is_rss: true,
-            user_login: "SomeLogin"
-          )
-        end
-
-        it "sets the title field for default role" do
-          article.title.should eq("Some Title")
-        end
-
-        it "sets the user login field for the default role" do
-          article.user_login.should eq("SomeLogin")
-        end
-
-        it "sets the rss field for the default role" do
-          article.is_rss.should be_false
-        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
-
-        it "sets the rss field" do
-          article.is_rss.should be_true
-        end
-
-        it "does not set the user login field" do
-          article.user_login.should be_nil
-        end
-      end
-
-      context "when attributes assigned without protection" do
-
-        let(:article) do
-          Article.new(
-            { title: "Some Title",
-              is_rss: true,
-              user_login: "SomeLogin"
-            }, without_protection: true
-          )
-        end
-
-        it "sets the title field" do
-          article.title.should eq("Some Title")
-        end
-
-        it "sets the user login field" do
-          article.user_login.should eq("SomeLogin")
-        end
-
-        it "sets the rss field" do
-          article.is_rss.should be_true
-        end
+      it "returns the set value" do
+        expect(terms).to eq(true)
       end
     end
   end
 
-  describe ".attr_protected" do
-
-    context "when the field is not _id" do
-
-      let(:person) do
-        Person.new(security_code: "ABBA")
-      end
-
-      it "prevents setting via mass assignment" do
-        person.security_code.should be_nil
-      end
-    end
-
-    context "when the field is _id" do
-
-      let(:game) do
-        Game.new(_id: "ABBA")
-      end
+  describe "#_id" do
 
-      it "prevents setting via mass assignment" do
-        game._id.should_not eq("ABBA")
-      end
+    let(:person) do
+      Person.new
     end
 
-    context "when using instantiate" do
-
-      let(:person) do
-        Person.instantiate("_id" => "1", "security_code" => "ABBA")
-      end
-
-      it "ignores any protected attribute" do
-        person.security_code.should eq("ABBA")
-      end
+    it "delegates to #id" do
+      expect(person._id).to eq(person.id)
     end
 
-    context "when using override" do
+    context "when #id alias is overridden" do
 
-      let(:person) do
-        Person.new
+      let(:object) do
+        IdKey.new(key: 'foo')
       end
 
-      it "ignores any protected attribute" do
-        person.write_attributes({security_code: "ABBA"}, false)
-        person.security_code.should eq("ABBA")
-      end
-    end
-
-    context "when mass assignment role is indicated" do
-
-      let(:item) do
-        Item.new
-      end
-
-      context "when attributes assigned from default role" do
-
-        before do
-          item.assign_attributes(
-            title: "Some Title",
-            is_rss: true,
-            user_login: "SomeLogin"
-          )
-        end
-
-        it "sets the field for the default role" do
-          item.is_rss.should be_true
-        end
-
-        it "does not set the field for non default role title" do
-          item.title.should be_nil
-        end
-
-        it "does not set the field for non default role user login" do
-          item.user_login.should be_nil
-        end
-      end
-
-      context "when attributes assigned from parser role" do
-
-        before do
-          item.assign_attributes(
-            { title: "Some Title",
-              is_rss: true,
-              user_login: "SomeLogin" }, as: :parser
-          )
-        end
-
-        it "sets the user login field for parser role" do
-          item.user_login.should eq("SomeLogin")
-        end
-
-        it "sets the is rss field for parse role" do
-          item.is_rss.should be_false
-        end
-
-        it "does not set the title field" do
-          item.title.should be_nil
-        end
-      end
-
-      context "when attributes assigned without protection" do
-
-        before do
-          item.assign_attributes(
-            { title: "Some Title",
-              is_rss: true,
-              user_login: "SomeLogin"
-            }, without_protection: true
-          )
-        end
-
-        it "sets the title attribute" do
-          item.title.should eq("Some Title")
-        end
-
-        it "sets the user login attribute" do
-          item.user_login.should eq("SomeLogin")
-        end
-
-        it "sets the rss attribute" do
-          item.is_rss.should be_true
-        end
+      it "delegates to another method" do
+        expect(object.id).to eq(object.key)
       end
     end
   end
 
-  describe "#_id" do
-
-    let(:person) do
-      Person.new
-    end
-
-    it "delegates to #id" do
-      person._id.should eq(person.id)
-    end
-  end
-
   describe "#_id=" 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 +278,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 +290,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 +300,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 +311,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 +322,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 +347,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 +357,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 +367,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 +378,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 +389,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 +397,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 +411,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 +422,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 +438,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 +469,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 +496,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 +524,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 +548,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 +577,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 +596,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 +615,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 +635,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 +650,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 +665,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,7 +698,7 @@ describe Mongoid::Attributes do
     end
 
     it "only overwrites supplied attributes" do
-      person.title.should eq("Sir")
+      expect(person.title).to eq("Sir")
     end
   end
 
@@ -847,8 +713,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 +726,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
@@ -883,13 +749,29 @@ describe Mongoid::Attributes do
         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
     end
@@ -897,7 +779,7 @@ describe Mongoid::Attributes do
     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
 
@@ -905,12 +787,11 @@ describe Mongoid::Attributes do
 
       it "returns the default value" do
         person.age = "old"
-        person.age_before_type_cast.should eq("old")
+        expect(person.age_before_type_cast).to eq("old")
       end
     end
   end
 
-
   describe "#attribute_present?" do
 
     context "when document is a new record" do
@@ -922,7 +803,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 +813,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
@@ -955,7 +836,7 @@ describe Mongoid::Attributes do
         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 +853,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 +861,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 +874,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 +902,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 +917,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
@@ -1038,7 +931,7 @@ 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
+        expect(person.has_attribute_before_type_cast?(:age)).to be false
       end
     end
 
@@ -1046,7 +939,7 @@ describe Mongoid::Attributes do
 
       it "returns true" do
         person.age = 'old'
-        person.has_attribute_before_type_cast?(:age).should be_true
+        expect(person.has_attribute_before_type_cast?(:age)).to be true
       end
     end
   end
@@ -1064,11 +957,11 @@ 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
@@ -1078,7 +971,7 @@ describe Mongoid::Attributes do
         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
@@ -1099,11 +992,11 @@ describe Mongoid::Attributes do
      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
@@ -1113,7 +1006,7 @@ describe Mongoid::Attributes do
        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 +1023,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 +1038,7 @@ 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
   end
@@ -1158,10 +1051,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 +1060,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 +1081,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 +1096,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,7 +1125,7 @@ describe Mongoid::Attributes do
       end
 
       it "returns the default value" do
-        person.age.should eq(100)
+        expect(person.age).to eq(100)
       end
     end
 
@@ -1254,7 +1135,7 @@ describe Mongoid::Attributes do
       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("old")
       end
     end
 
@@ -1265,7 +1146,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 +1161,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
 
@@ -1295,7 +1176,35 @@ describe Mongoid::Attributes do
       end
 
       it "allows the field name to be udpated" do
-        person.t.should eq("aliased field to test")
+        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 "raises an error when try to set an invalid value" do
+        expect {
+          person.map = []
+        }.to raise_error(Mongoid::Errors::InvalidValue)
+      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 "raises an error when try to set an invalid value" do
+        expect {
+          person.aliases = {}
+        }.to raise_error(Mongoid::Errors::InvalidValue)
       end
     end
   end
@@ -1316,11 +1225,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 +1241,7 @@ describe Mongoid::Attributes do
     end
 
     it "typecasts proc values" do
-      person.age.should eq(100)
+      expect(person.age).to eq(100)
     end
   end
 
@@ -1351,7 +1260,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 +1281,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 +1292,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 +1347,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 +1372,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 +1414,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 +1436,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
@@ -1521,38 +1457,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
+        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")
+        expect(product.cost_before_type_cast).to eq("expensive")
       end
     end
 
@@ -1563,32 +1503,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
+        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
@@ -1600,7 +1540,7 @@ describe Mongoid::Attributes do
     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
 
@@ -1612,7 +1552,7 @@ describe Mongoid::Attributes do
 
     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.last_drink_taken_at).to eq(1.day.ago.in_time_zone("Alaska").to_date)
     end
   end
 
@@ -1625,7 +1565,7 @@ describe Mongoid::Attributes do
       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
 
@@ -1642,7 +1582,7 @@ 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
 
@@ -1657,7 +1597,7 @@ 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
 
@@ -1672,32 +1612,7 @@ describe Mongoid::Attributes do
         end
 
         it "applies the defaults after all attributes are set" do
-          from_db.should be_balanced
-        end
-      end
-    end
-  end
-
-  context "when dynamic fields are not allowed" do
-
-    before do
-      Mongoid.configure.allow_dynamic_fields = false
-    end
-
-    after do
-      Mongoid.configure.allow_dynamic_fields = true
-    end
-
-    context "when an embedded document has been persisted" do
-
-      context "when the field is no longer recognized" do
-
-        before do
-          Person.collection.insert 'pet' => { 'unrecognized_field' => true }
-        end
-
-        it "allows access to the legacy data" do
-          Person.first.pet.read_attribute(:unrecognized_field).should be_true
+          expect(from_db).to be_balanced
         end
       end
     end