mongoid 3.1.6 → 4.0.0

data/spec/mongoid/relations/referenced/many_spec.rb

@@ -56,27 +56,27 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "sets the foreign key on the relation" do
-              post.person_id.should eq(person.id)
+              expect(post.person_id).to eq(person.id)
             end
 
             it "sets the base on the inverse relation" do
-              post.person.should eq(person)
+              expect(post.person).to eq(person)
             end
 
             it "sets the same instance on the inverse relation" do
-              post.person.should eql(person)
+              expect(post.person).to eql(person)
             end
 
             it "does not save the target" do
-              post.should be_new_record
+              expect(post).to be_new_record
             end
 
             it "adds the document to the target" do
-              person.posts.size.should eq(1)
+              expect(person.posts.size).to eq(1)
             end
 
             it "returns the relation" do
-              added.should eq(person.posts)
+              expect(added).to eq(person.posts)
             end
           end
 
@@ -91,23 +91,23 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "sets the foreign key on the relation" do
-              post.person_id.should eq(person.id)
+              expect(post.person_id).to eq(person.id)
             end
 
             it "sets the base on the inverse relation" do
-              post.person.should eq(person)
+              expect(post.person).to eq(person)
             end
 
             it "sets the same instance on the inverse relation" do
-              post.person.should eql(person)
+              expect(post.person).to eql(person)
             end
 
             it "does not save the parent" do
-              person.should be_new_record
+              expect(person).to be_new_record
             end
 
             it "adds the document to the target" do
-              person.posts.size.should eq(1)
+              expect(person.posts.size).to eq(1)
             end
 
             context "when subsequently saving the parent" do
@@ -118,7 +118,7 @@ describe Mongoid::Relations::Referenced::Many do
               end
 
               it "returns the correct count of the relation" do
-                person.posts.count.should eq(1)
+                expect(person.posts.count).to eq(1)
               end
             end
           end
@@ -137,23 +137,23 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "adds the documents to the relation" do
-            person.posts.should eq([ post ])
+            expect(person.posts).to eq([ post ])
           end
 
           it "sets the foreign key on the inverse relation" do
-            post.person_id.should eq(person.id)
+            expect(post.person_id).to eq(person.id)
           end
 
           it "saves the target" do
-            post.should be_persisted
+            expect(post).to be_persisted
           end
 
           it "adds the correct number of documents" do
-            person.posts.size.should eq(1)
+            expect(person.posts.size).to eq(1)
           end
 
           it "persists the link" do
-            person.reload.posts.should eq([ post ])
+            expect(person.reload.posts).to eq([ post ])
           end
         end
 
@@ -172,27 +172,43 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the foreign key on the relation" do
-            post.person_id.should eq(person.id)
+            expect(post.person_id).to eq(person.id)
           end
 
           it "sets the base on the inverse relation" do
-            post.person.should eq(person)
+            expect(post.person).to eq(person)
           end
 
           it "sets the same instance on the inverse relation" do
-            post.person.should eql(person)
+            expect(post.person).to eql(person)
           end
 
           it "saves the target" do
-            post.should be_persisted
+            expect(post).to be_persisted
           end
 
           it "adds the document to the target" do
-            person.posts.count.should eq(1)
+            expect(person.posts.count).to eq(1)
           end
 
           it "increments the counter cache" do
-            person.reload.posts_count.should eq(1)
+            expect(person[:posts_count]).to eq(1)
+            expect(person.posts_count).to eq(1)
+          end
+
+          it "doesnt change the list of changes" do
+            expect(person.changed).to eq([])
+          end
+
+          context "when saving another post" do
+
+            before do
+              person.posts.send(method, Post.new)
+            end
+
+            it "increments the counter cache" do
+              expect(person.posts_count).to eq(2)
+            end
           end
 
           context "when documents already exist on the relation" do
@@ -206,41 +222,41 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "sets the foreign key on the relation" do
-              post_two.person_id.should eq(person.id)
+              expect(post_two.person_id).to eq(person.id)
             end
 
             it "sets the base on the inverse relation" do
-              post_two.person.should eq(person)
+              expect(post_two.person).to eq(person)
             end
 
             it "sets the same instance on the inverse relation" do
-              post_two.person.should eql(person)
+              expect(post_two.person).to eql(person)
             end
 
             it "saves the target" do
-              post_two.should be_persisted
+              expect(post_two).to be_persisted
             end
 
             it "adds the document to the target" do
-              person.posts.count.should eq(2)
+              expect(person.posts.count).to eq(2)
             end
 
             it "increments the counter cache" do
-              person.reload.posts_count.should eq(2)
+              expect(person.reload.posts_count).to eq(2)
             end
 
             it "contains the initial document in the target" do
-              person.posts.should include(post)
+              expect(person.posts).to include(post)
             end
 
             it "contains the added document in the target" do
-              person.posts.should include(post_two)
+              expect(person.posts).to include(post_two)
             end
           end
         end
       end
 
-      context "when.with(safe: true).adding to the relation" do
+      context "when.adding to the relation" do
 
         let(:person) do
           Person.create
@@ -253,11 +269,11 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           before do
-            person.posts.with(safe: true).send(method, post)
+            person.posts.send(method, post)
           end
 
           it "adds the document to the relation" do
-            person.posts.should eq([ post ])
+            expect(person.posts).to eq([ post ])
           end
         end
 
@@ -275,7 +291,7 @@ describe Mongoid::Relations::Referenced::Many do
 
           it "raises an error" do
             expect {
-              person.posts.with(safe: true).send(method, post)
+              person.posts.send(method, post)
             }.to raise_error(Moped::Errors::OperationFailure)
           end
         end
@@ -298,23 +314,19 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the foreign key on the relation" do
-            rating.ratable_id.should eq(movie.id)
-          end
-
-          it "does not set the inverse field on the relation" do
-            rating.ratable_field.should be_nil
+            expect(rating.ratable_id).to eq(movie.id)
           end
 
           it "sets the base on the inverse relation" do
-            rating.ratable.should eq(movie)
+            expect(rating.ratable).to eq(movie)
           end
 
           it "does not save the target" do
-            rating.should be_new_record
+            expect(rating).to be_new_record
           end
 
           it "adds the document to the target" do
-            movie.ratings.size.should eq(1)
+            expect(movie.ratings.size).to eq(1)
           end
         end
 
@@ -333,23 +345,19 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the foreign key on the relation" do
-            rating.ratable_id.should eq(movie.id)
-          end
-
-          it "does not set the inverse field on the relation" do
-            rating.ratable_field.should be_nil
+            expect(rating.ratable_id).to eq(movie.id)
           end
 
           it "sets the base on the inverse relation" do
-            rating.ratable.should eq(movie)
+            expect(rating.ratable).to eq(movie)
           end
 
           it "saves the target" do
-            rating.should be_persisted
+            expect(rating).to be_persisted
           end
 
           it "adds the document to the target" do
-            movie.ratings.count.should eq(1)
+            expect(movie.ratings.count).to eq(1)
           end
         end
       end
@@ -375,19 +383,19 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the target of the relation" do
-          person.posts.target.should eq([ post ])
+          expect(person.posts.target).to eq([ post ])
         end
 
         it "sets the foreign key on the relation" do
-          post.person_id.should eq(person.id)
+          expect(post.person_id).to eq(person.id)
         end
 
         it "sets the base on the inverse relation" do
-          post.person.should eq(person)
+          expect(post.person).to eq(person)
         end
 
         it "does not save the target" do
-          post.should_not be_persisted
+          expect(post).to_not be_persisted
         end
       end
 
@@ -406,19 +414,19 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the target of the relation" do
-          person.posts.target.should eq([ post ])
+          expect(person.posts.target).to eq([ post ])
         end
 
         it "sets the foreign key of the relation" do
-          post.person_id.should eq(person.id)
+          expect(post.person_id).to eq(person.id)
         end
 
         it "sets the base on the inverse relation" do
-          post.person.should eq(person)
+          expect(post.person).to eq(person)
         end
 
         it "saves the target" do
-          post.should be_persisted
+          expect(post).to be_persisted
         end
 
         context "when replacing the relation with the same documents" do
@@ -430,11 +438,11 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "keeps the relation intact" do
-              person.posts.should eq([ post ])
+              expect(person.posts).to eq([ post ])
             end
 
             it "does not delete the relation" do
-              person.reload.posts.should eq([ post ])
+              expect(person.reload.posts).to eq([ post ])
             end
           end
 
@@ -449,11 +457,11 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "keeps the relation intact" do
-              from_db.posts.should eq([ post ])
+              expect(from_db.posts).to eq([ post ])
             end
 
             it "does not delete the relation" do
-              from_db.reload.posts.should eq([ post ])
+              expect(from_db.reload.posts).to eq([ post ])
             end
           end
         end
@@ -471,19 +479,19 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "keeps the relation intact" do
-              person.posts.size.should eq(2)
+              expect(person.posts.size).to eq(2)
             end
 
             it "keeps the first post" do
-              person.posts.should include(post)
+              expect(person.posts).to include(post)
             end
 
             it "keeps the second post" do
-              person.posts.should include(new_post)
+              expect(person.posts).to include(new_post)
             end
 
             it "does not delete the relation" do
-              person.reload.posts.should eq([ post, new_post ])
+              expect(person.reload.posts).to eq([ post, new_post ])
             end
           end
 
@@ -498,11 +506,11 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "keeps the relation intact" do
-              from_db.posts.should eq([ post, new_post ])
+              expect(from_db.posts).to eq([ post, new_post ])
             end
 
             it "does not delete the relation" do
-              from_db.reload.posts.should eq([ post, new_post ])
+              expect(from_db.reload.posts).to eq([ post, new_post ])
             end
           end
         end
@@ -520,11 +528,11 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "keeps the relation intact" do
-              person.posts.should eq([ new_post ])
+              expect(person.posts).to eq([ new_post ])
             end
 
             it "does not delete the relation" do
-              person.reload.posts.should eq([ new_post ])
+              expect(person.reload.posts).to eq([ new_post ])
             end
           end
 
@@ -539,11 +547,11 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "keeps the relation intact" do
-              from_db.posts.should eq([ new_post ])
+              expect(from_db.posts).to eq([ new_post ])
             end
 
             it "does not delete the relation" do
-              from_db.reload.posts.should eq([ new_post ])
+              expect(from_db.reload.posts).to eq([ new_post ])
             end
           end
         end
@@ -567,19 +575,19 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the target of the relation" do
-          movie.ratings.target.should eq([ rating ])
+          expect(movie.ratings.target).to eq([ rating ])
         end
 
         it "sets the foreign key on the relation" do
-          rating.ratable_id.should eq(movie.id)
+          expect(rating.ratable_id).to eq(movie.id)
         end
 
         it "sets the base on the inverse relation" do
-          rating.ratable.should eq(movie)
+          expect(rating.ratable).to eq(movie)
         end
 
         it "does not save the target" do
-          rating.should_not be_persisted
+          expect(rating).to_not be_persisted
         end
       end
 
@@ -598,19 +606,19 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the target of the relation" do
-          movie.ratings.target.should eq([ rating ])
+          expect(movie.ratings.target).to eq([ rating ])
         end
 
         it "sets the foreign key of the relation" do
-          rating.ratable_id.should eq(movie.id)
+          expect(rating.ratable_id).to eq(movie.id)
         end
 
         it "sets the base on the inverse relation" do
-          rating.ratable.should eq(movie)
+          expect(rating.ratable).to eq(movie)
         end
 
         it "saves the target" do
-          rating.should be_persisted
+          expect(rating).to be_persisted
         end
       end
     end
@@ -635,11 +643,11 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "removes all the children" do
-          person.posts.should be_empty
+          expect(person.posts).to be_empty
         end
 
         it "persists the changes" do
-          person.posts(true).should be_empty
+          expect(person.posts(true)).to be_empty
         end
       end
     end
@@ -665,15 +673,15 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the relation to an empty array" do
-          person.posts.should be_empty
+          expect(person.posts).to be_empty
         end
 
         it "removed the inverse relation" do
-          post.person.should be_nil
+          expect(post.person).to be_nil
         end
 
         it "removes the foreign key value" do
-          post.person_id.should be_nil
+          expect(post.person_id).to be_nil
         end
       end
 
@@ -695,19 +703,19 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the relation to empty" do
-            person.posts.should be_empty
+            expect(person.posts).to be_empty
           end
 
           it "removed the inverse relation" do
-            post.person.should be_nil
+            expect(post.person).to be_nil
           end
 
           it "removes the foreign key value" do
-            post.person_id.should be_nil
+            expect(post.person_id).to be_nil
           end
 
           it "deletes the target from the database" do
-            post.should be_destroyed
+            expect(post).to be_destroyed
           end
         end
 
@@ -723,19 +731,19 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the relation to empty" do
-            person.drugs.should be_empty
+            expect(person.drugs).to be_empty
           end
 
           it "removed the inverse relation" do
-            drug.person.should be_nil
+            expect(drug.person).to be_nil
           end
 
           it "removes the foreign key value" do
-            drug.person_id.should be_nil
+            expect(drug.person_id).to be_nil
           end
 
           it "nullifies the relation" do
-            drug.should_not be_destroyed
+            expect(drug).to_not be_destroyed
           end
         end
       end
@@ -759,15 +767,15 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the relation to an empty array" do
-          movie.ratings.should be_empty
+          expect(movie.ratings).to be_empty
         end
 
         it "removed the inverse relation" do
-          rating.ratable.should be_nil
+          expect(rating.ratable).to be_nil
         end
 
         it "removes the foreign key value" do
-          rating.ratable_id.should be_nil
+          expect(rating.ratable_id).to be_nil
         end
       end
 
@@ -787,21 +795,21 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the relation to empty" do
-          movie.ratings.should be_empty
+          expect(movie.ratings).to be_empty
         end
 
         it "removed the inverse relation" do
-          rating.ratable.should be_nil
+          expect(rating.ratable).to be_nil
         end
 
         it "removes the foreign key value" do
-          rating.ratable_id.should be_nil
+          expect(rating.ratable_id).to be_nil
         end
 
         context "when dependent is nullify" do
 
           it "does not delete the target from the database" do
-            rating.should_not be_destroyed
+            expect(rating).to_not be_destroyed
           end
         end
       end
@@ -827,7 +835,7 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "calls setter with documents find by given ids" do
-      person.posts.should eq([ post_one, post_two ])
+      expect(person.posts).to eq([ post_one, post_two ])
     end
   end
 
@@ -842,7 +850,7 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "returns ids of documents that are in the relation" do
-      person.post_ids.should eq(posts.map(&:id))
+      expect(person.post_ids).to eq(posts.map(&:id))
     end
   end
 
@@ -850,28 +858,6 @@ describe Mongoid::Relations::Referenced::Many do
 
     describe "##{method}" do
 
-      context "when providing scoped mass assignment" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:drug) do
-          person.drugs.send(
-            method,
-            { name: "Oxycontin", generic: false }, as: :admin
-          )
-        end
-
-        it "sets the attributes for the provided role" do
-          drug.name.should eq("Oxycontin")
-        end
-
-        it "does not set the attributes for other roles" do
-          drug.generic.should be_nil
-        end
-      end
-
       context "when the relation is not polymorphic" do
 
         context "when the parent is a new record" do
@@ -885,31 +871,31 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the foreign key on the relation" do
-            post.person_id.should eq(person.id)
+            expect(post.person_id).to eq(person.id)
           end
 
           it "sets the base on the inverse relation" do
-            post.person.should eq(person)
+            expect(post.person).to eq(person)
           end
 
           it "sets the attributes" do
-            post.title.should eq("$$$")
+            expect(post.title).to eq("$$$")
           end
 
           it "sets the post processed defaults" do
-            post.person_title.should eq(person.title)
+            expect(post.person_title).to eq(person.title)
           end
 
           it "does not save the target" do
-            post.should be_new_record
+            expect(post).to be_new_record
           end
 
           it "adds the document to the target" do
-            person.posts.size.should eq(1)
+            expect(person.posts.size).to eq(1)
           end
 
           it "does not perform validation" do
-            post.errors.should be_empty
+            expect(post.errors).to be_empty
           end
         end
 
@@ -924,23 +910,23 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the foreign key on the relation" do
-            post.person_id.should eq(person.id)
+            expect(post.person_id).to eq(person.id)
           end
 
           it "sets the base on the inverse relation" do
-            post.person.should eq(person)
+            expect(post.person).to eq(person)
           end
 
           it "sets the attributes" do
-            post.text.should eq("Testing")
+            expect(post.text).to eq("Testing")
           end
 
           it "does not save the target" do
-            post.should be_new_record
+            expect(post).to be_new_record
           end
 
           it "adds the document to the target" do
-            person.posts.size.should eq(1)
+            expect(person.posts.size).to eq(1)
           end
         end
       end
@@ -977,27 +963,27 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the foreign key on the relation" do
-            rating.ratable_id.should eq(movie.id)
+            expect(rating.ratable_id).to eq(movie.id)
           end
 
           it "sets the base on the inverse relation" do
-            rating.ratable.should eq(movie)
+            expect(rating.ratable).to eq(movie)
           end
 
           it "sets the attributes" do
-            rating.value.should eq(3)
+            expect(rating.value).to eq(3)
           end
 
           it "does not save the target" do
-            rating.should be_new_record
+            expect(rating).to be_new_record
           end
 
           it "adds the document to the target" do
-            movie.ratings.size.should eq(1)
+            expect(movie.ratings.size).to eq(1)
           end
 
           it "does not perform validation" do
-            rating.errors.should be_empty
+            expect(rating.errors).to be_empty
           end
         end
 
@@ -1012,23 +998,23 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the foreign key on the relation" do
-            rating.ratable_id.should eq(movie.id)
+            expect(rating.ratable_id).to eq(movie.id)
           end
 
           it "sets the base on the inverse relation" do
-            rating.ratable.should eq(movie)
+            expect(rating.ratable).to eq(movie)
           end
 
           it "sets the attributes" do
-            rating.value.should eq(4)
+            expect(rating.value).to eq(4)
           end
 
           it "does not save the target" do
-            rating.should be_new_record
+            expect(rating).to be_new_record
           end
 
           it "adds the document to the target" do
-            movie.ratings.size.should eq(1)
+            expect(movie.ratings.size).to eq(1)
           end
         end
       end
@@ -1042,16 +1028,17 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     let(:document) do
-      stub
+      double
     end
 
     let(:metadata) do
-      stub(extension?: false)
+      double(extension?: false)
     end
 
     it "returns the embedded in builder" do
-      described_class.builder(nil, metadata, document).should
-        be_a_kind_of(builder_klass)
+      expect(
+        described_class.builder(nil, metadata, document)
+      ).to be_a_kind_of(builder_klass)
     end
   end
 
@@ -1076,19 +1063,19 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "clears out the relation" do
-            person.posts.should be_empty
+            expect(person.posts).to be_empty
           end
 
           it "marks the documents as deleted" do
-            post.should be_destroyed
+            expect(post).to be_destroyed
           end
 
           it "deletes the documents from the db" do
-            person.reload.posts.should be_empty
+            expect(person.reload.posts).to be_empty
           end
 
           it "returns the relation" do
-            relation.should be_empty
+            expect(relation).to be_empty
           end
         end
 
@@ -1103,7 +1090,7 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "clears out the relation" do
-            person.posts.should be_empty
+            expect(person.posts).to be_empty
           end
         end
       end
@@ -1123,7 +1110,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "clears out the relation" do
-          person.posts.should be_empty
+          expect(person.posts).to be_empty
         end
       end
     end
@@ -1147,19 +1134,19 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "clears out the relation" do
-            movie.ratings.should be_empty
+            expect(movie.ratings).to be_empty
           end
 
           it "handles the proper dependent strategy" do
-            rating.should_not be_destroyed
+            expect(rating).to_not be_destroyed
           end
 
           it "deletes the documents from the db" do
-            movie.reload.ratings.should be_empty
+            expect(movie.reload.ratings).to be_empty
           end
 
           it "returns the relation" do
-            relation.should be_empty
+            expect(relation).to be_empty
           end
         end
 
@@ -1174,7 +1161,7 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "clears out the relation" do
-            movie.ratings.should be_empty
+            expect(movie.ratings).to be_empty
           end
         end
       end
@@ -1194,7 +1181,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "clears out the relation" do
-          movie.ratings.should be_empty
+          expect(movie.ratings).to be_empty
         end
       end
     end
@@ -1219,23 +1206,23 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the foreign key on the relation" do
-          post.person_id.should eq(person.id)
+          expect(post.person_id).to eq(person.id)
         end
 
         it "sets the base on the inverse relation" do
-          post.person.should eq(person)
+          expect(post.person).to eq(person)
         end
 
         it "sets the same instance on the inverse relation" do
-          post.person.should eql(person)
+          expect(post.person).to eql(person)
         end
 
         it "does not save the target" do
-          post.should be_new_record
+          expect(post).to be_new_record
         end
 
         it "adds the document to the target" do
-          person.posts.size.should eq(1)
+          expect(person.posts.size).to eq(1)
         end
       end
 
@@ -1252,23 +1239,23 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "adds the documents to the relation" do
-          person.posts.should eq([ post ])
+          expect(person.posts).to eq([ post ])
         end
 
         it "sets the foreign key on the inverse relation" do
-          post.person_id.should eq(person.id)
+          expect(post.person_id).to eq(person.id)
         end
 
         it "saves the target" do
-          post.should be_persisted
+          expect(post).to be_persisted
         end
 
         it "adds the correct number of documents" do
-          person.posts.size.should eq(1)
+          expect(person.posts.size).to eq(1)
         end
 
         it "persists the link" do
-          person.reload.posts.should eq([ post ])
+          expect(person.reload.posts).to eq([ post ])
         end
       end
 
@@ -1291,23 +1278,23 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the foreign key on the relation" do
-          post.person_id.should eq(person.id)
+          expect(post.person_id).to eq(person.id)
         end
 
         it "sets the base on the inverse relation" do
-          post.person.should eq(person)
+          expect(post.person).to eq(person)
         end
 
         it "sets the same instance on the inverse relation" do
-          post.person.should eql(person)
+          expect(post.person).to eql(person)
         end
 
         it "saves the target" do
-          post.should be_persisted
+          expect(post).to be_persisted
         end
 
         it "adds the document to the target" do
-          person.posts.count.should eq(2)
+          expect(person.posts.count).to eq(2)
         end
 
         context "when documents already exist on the relation" do
@@ -1321,31 +1308,31 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the foreign key on the relation" do
-            post_two.person_id.should eq(person.id)
+            expect(post_two.person_id).to eq(person.id)
           end
 
           it "sets the base on the inverse relation" do
-            post_two.person.should eq(person)
+            expect(post_two.person).to eq(person)
           end
 
           it "sets the same instance on the inverse relation" do
-            post_two.person.should eql(person)
+            expect(post_two.person).to eql(person)
           end
 
           it "saves the target" do
-            post_two.should be_persisted
+            expect(post_two).to be_persisted
           end
 
           it "adds the document to the target" do
-            person.posts.count.should eq(3)
+            expect(person.posts.count).to eq(3)
           end
 
           it "contains the initial document in the target" do
-            person.posts.should include(post)
+            expect(person.posts).to include(post)
           end
 
           it "contains the added document in the target" do
-            person.posts.should include(post_two)
+            expect(person.posts).to include(post_two)
           end
         end
       end
@@ -1369,19 +1356,19 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "sets the foreign key on the relation" do
-        rating.ratable_id.should eq(movie.id)
+        expect(rating.ratable_id).to eq(movie.id)
       end
 
       it "sets the base on the inverse relation" do
-        rating.ratable.should eq(movie)
+        expect(rating.ratable).to eq(movie)
       end
 
       it "does not save the target" do
-        rating.should be_new_record
+        expect(rating).to be_new_record
       end
 
       it "adds the document to the target" do
-        movie.ratings.size.should eq(1)
+        expect(movie.ratings.size).to eq(1)
       end
     end
 
@@ -1400,19 +1387,19 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "sets the foreign key on the relation" do
-        rating.ratable_id.should eq(movie.id)
+        expect(rating.ratable_id).to eq(movie.id)
       end
 
       it "sets the base on the inverse relation" do
-        rating.ratable.should eq(movie)
+        expect(rating.ratable).to eq(movie)
       end
 
       it "saves the target" do
-        rating.should be_persisted
+        expect(rating).to be_persisted
       end
 
       it "adds the document to the target" do
-        movie.ratings.count.should eq(1)
+        expect(movie.ratings.count).to eq(1)
       end
     end
   end
@@ -1430,7 +1417,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "returns the number of persisted documents" do
-        movie.ratings.count.should eq(1)
+        expect(movie.ratings.count).to eq(1)
       end
     end
 
@@ -1441,7 +1428,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "returns 0" do
-        movie.ratings.count.should eq(0)
+        expect(movie.ratings.count).to eq(0)
       end
     end
 
@@ -1454,7 +1441,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "returns the count from the db" do
-          movie.ratings.count.should eq(1)
+          expect(movie.ratings.count).to eq(1)
         end
       end
 
@@ -1465,7 +1452,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "returns the count from the db" do
-          movie.ratings.count.should eq(0)
+          expect(movie.ratings.count).to eq(0)
         end
       end
     end
@@ -1473,24 +1460,30 @@ describe Mongoid::Relations::Referenced::Many do
 
   describe "#create" do
 
-    context "when providing scoped mass assignment" do
+    context "when providing multiple attributes" do
 
       let(:person) do
         Person.create
       end
 
-      let(:drug) do
-        person.drugs.create(
-          { name: "Oxycontin", generic: false }, as: :admin
-        )
+      let!(:posts) do
+        person.posts.create([{ text: "Test1" }, { text: "Test2" }])
+      end
+
+      it "creates multiple documents" do
+        expect(posts.size).to eq(2)
+      end
+
+      it "sets the first attributes" do
+        expect(posts.first.text).to eq("Test1")
       end
 
-      it "sets the attributes for the provided role" do
-        drug.name.should eq("Oxycontin")
+      it "sets the second attributes" do
+        expect(posts.last.text).to eq("Test2")
       end
 
-      it "does not set the attributes for other roles" do
-        drug.generic.should be_nil
+      it "persists the children" do
+        expect(person.posts.count).to eq(2)
       end
     end
 
@@ -1511,7 +1504,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
       end
 
-      context "when.with(safe: true).creating the document" do
+      context "when.creating the document" do
 
         context "when the operation is successful" do
 
@@ -1520,11 +1513,11 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           let!(:post) do
-            person.posts.with(safe: true).create(text: "Testing")
+            person.posts.create(text: "Testing")
           end
 
           it "creates the document" do
-            person.posts.should eq([ post ])
+            expect(person.posts).to eq([ post ])
           end
         end
 
@@ -1540,7 +1533,7 @@ describe Mongoid::Relations::Referenced::Many do
 
           it "raises an error" do
             expect {
-              person.posts.with(safe: true).create do |doc|
+              person.posts.create do |doc|
                 doc._id = existing.id
               end
             }.to raise_error(Moped::Errors::OperationFailure)
@@ -1561,27 +1554,54 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the foreign key on the relation" do
-          post.person_id.should eq(person.id)
+          expect(post.person_id).to eq(person.id)
         end
 
         it "sets the base on the inverse relation" do
-          post.person.should eq(person)
+          expect(post.person).to eq(person)
         end
 
         it "sets the attributes" do
-          post.text.should eq("Testing")
+          expect(post.text).to eq("Testing")
         end
 
         it "saves the target" do
-          post.should_not be_a_new_record
+          expect(post).to_not be_a_new_record
         end
 
         it "calls the passed block" do
-          post.content.should eq("The Content")
+          expect(post.content).to eq("The Content")
         end
 
         it "adds the document to the target" do
-          person.posts.count.should eq(1)
+          expect(person.posts.count).to eq(1)
+        end
+      end
+
+      context "when passing a new object" do
+
+        let!(:odd) do
+          Odd.create(name: 'one')
+        end
+
+        let!(:even) do
+          odd.evens.create(name: 'two', odds: [Odd.new(name: 'three')])
+        end
+
+        it "only push one even to the list" do
+          expect(odd.evens.count).to eq(1)
+        end
+
+        it "saves the reference back" do
+          expect(odd.evens.first.odds.count).to eq(1)
+        end
+
+        it "only saves one even" do
+          expect(Even.count).to eq(1)
+        end
+
+        it "saves the first odd and the second" do
+          expect(Odd.count).to eq(2)
         end
       end
     end
@@ -1614,23 +1634,23 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the foreign key on the relation" do
-          rating.ratable_id.should eq(movie.id)
+          expect(rating.ratable_id).to eq(movie.id)
         end
 
         it "sets the base on the inverse relation" do
-          rating.ratable.should eq(movie)
+          expect(rating.ratable).to eq(movie)
         end
 
         it "sets the attributes" do
-          rating.value.should eq(3)
+          expect(rating.value).to eq(3)
         end
 
         it "saves the target" do
-          rating.should_not be_new_record
+          expect(rating).to_not be_new_record
         end
 
         it "adds the document to the target" do
-          movie.ratings.count.should eq(1)
+          expect(movie.ratings.count).to eq(1)
         end
       end
     end
@@ -1646,31 +1666,37 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it 'saves pk value on fk field' do
-        drug.person_id.should eq('arthurnn')
+        expect(drug.person_id).to eq('arthurnn')
       end
     end
   end
 
   describe "#create!" do
 
-    context "when providing mass scoping options" do
+    context "when providing multiple attributes" do
 
       let(:person) do
         Person.create
       end
 
-      let(:drug) do
-        person.drugs.create!(
-          { name: "Oxycontin", generic: false }, as: :admin
-        )
+      let!(:posts) do
+        person.posts.create!([{ text: "Test1" }, { text: "Test2" }])
       end
 
-      it "sets the attributes for the provided role" do
-        drug.name.should eq("Oxycontin")
+      it "creates multiple documents" do
+        expect(posts.size).to eq(2)
       end
 
-      it "does not set the attributes for other roles" do
-        drug.generic.should be_nil
+      it "sets the first attributes" do
+        expect(posts.first.text).to eq("Test1")
+      end
+
+      it "sets the second attributes" do
+        expect(posts.last.text).to eq("Test2")
+      end
+
+      it "persists the children" do
+        expect(person.posts.count).to eq(2)
       end
     end
 
@@ -1702,23 +1728,23 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the foreign key on the relation" do
-          post.person_id.should eq(person.id)
+          expect(post.person_id).to eq(person.id)
         end
 
         it "sets the base on the inverse relation" do
-          post.person.should eq(person)
+          expect(post.person).to eq(person)
         end
 
         it "sets the attributes" do
-          post.title.should eq("Testing")
+          expect(post.title).to eq("Testing")
         end
 
         it "saves the target" do
-          post.should_not be_a_new_record
+          expect(post).to_not be_a_new_record
         end
 
         it "adds the document to the target" do
-          person.posts.count.should eq(1)
+          expect(person.posts.count).to eq(1)
         end
 
         context "when validation fails" do
@@ -1760,23 +1786,23 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the foreign key on the relation" do
-          rating.ratable_id.should eq(movie.id)
+          expect(rating.ratable_id).to eq(movie.id)
         end
 
         it "sets the base on the inverse relation" do
-          rating.ratable.should eq(movie)
+          expect(rating.ratable).to eq(movie)
         end
 
         it "sets the attributes" do
-          rating.value.should eq(4)
+          expect(rating.value).to eq(4)
         end
 
         it "saves the target" do
-          rating.should_not be_new_record
+          expect(rating).to_not be_new_record
         end
 
         it "adds the document to the target" do
-          movie.ratings.count.should eq(1)
+          expect(movie.ratings.count).to eq(1)
         end
 
         context "when validation fails" do
@@ -1794,7 +1820,7 @@ describe Mongoid::Relations::Referenced::Many do
   describe ".criteria" do
 
     let(:id) do
-      Moped::BSON::ObjectId.new
+      BSON::ObjectId.new
     end
 
     context "when the relation is polymorphic" do
@@ -1808,11 +1834,10 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "includes the type in the criteria" do
-        criteria.selector.should eq(
+        expect(criteria.selector).to eq(
           {
             "ratable_id"    => id,
-            "ratable_type"  => "Movie",
-            "ratable_field" => { "$in" => [ :ratings, nil ] }
+            "ratable_type"  => "Movie"
           }
         )
       end
@@ -1829,7 +1854,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "does not include the type in the criteria" do
-        criteria.selector.should eq({ "person_id" => id })
+        expect(criteria.selector).to eq({ "person_id" => id })
       end
     end
   end
@@ -1863,7 +1888,7 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "does not cascade" do
-            deleted.changes.keys.should eq([ "person_id" ])
+            expect(deleted.changes.keys).to eq([ "person_id" ])
           end
         end
 
@@ -1878,15 +1903,15 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "returns the document" do
-            deleted.should eq(drug)
+            expect(deleted).to eq(drug)
           end
 
           it "deletes the foreign key" do
-            drug.person_id.should be_nil
+            expect(drug.person_id).to be_nil
           end
 
           it "removes the document from the relation" do
-            person.drugs.should_not include(drug)
+            expect(person.drugs).to_not include(drug)
           end
         end
 
@@ -1901,15 +1926,15 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "returns the document" do
-            deleted.should eq(drug)
+            expect(deleted).to eq(drug)
           end
 
           it "deletes the foreign key" do
-            drug.person_id.should be_nil
+            expect(drug.person_id).to be_nil
           end
 
           it "removes the document from the relation" do
-            person.drugs.should_not include(drug)
+            expect(person.drugs).to_not include(drug)
           end
         end
       end
@@ -1927,15 +1952,15 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "returns the document" do
-            deleted.should eq(post)
+            expect(deleted).to eq(post)
           end
 
           it "deletes the document" do
-            post.should be_destroyed
+            expect(post).to be_destroyed
           end
 
           it "removes the document from the relation" do
-            person.posts.should_not include(post)
+            expect(person.posts).to_not include(post)
           end
         end
 
@@ -1950,15 +1975,15 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "returns the document" do
-            deleted.should eq(post)
+            expect(deleted).to eq(post)
           end
 
           it "deletes the document" do
-            post.should be_destroyed
+            expect(post).to be_destroyed
           end
 
           it "removes the document from the relation" do
-            person.posts.should_not include(post)
+            expect(person.posts).to_not include(post)
           end
         end
       end
@@ -1975,11 +2000,11 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "returns nil" do
-        deleted.should be_nil
+        expect(deleted).to be_nil
       end
 
       it "does not delete the document" do
-        post.should be_persisted
+        expect(post).to be_persisted
       end
     end
   end
@@ -2002,18 +2027,18 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "removes the correct posts" do
-            person.posts.send(method, conditions: { title: "Testing" })
-            person.posts.count.should eq(1)
-            person.reload.posts_count.should eq(1) if method == :destroy_all
+            person.posts.send(method, { title: "Testing" })
+            expect(person.posts.count).to eq(1)
+            expect(person.reload.posts_count).to eq(1) if method == :destroy_all
           end
 
           it "deletes the documents from the database" do
-            person.posts.send(method, conditions: {title: "Testing" })
-            Post.where(title: "Testing").count.should eq(0)
+            person.posts.send(method, { title: "Testing" })
+            expect(Post.where(title: "Testing").count).to eq(0)
           end
 
           it "returns the number of documents deleted" do
-            person.posts.send(method, conditions: { title: "Testing" }).should eq(1)
+            expect(person.posts.send(method, { title: "Testing" })).to eq(1)
           end
         end
 
@@ -2030,16 +2055,16 @@ describe Mongoid::Relations::Referenced::Many do
 
           it "removes the correct posts" do
             person.posts.send(method)
-            person.posts.count.should eq(0)
+            expect(person.posts.count).to eq(0)
           end
 
           it "deletes the documents from the database" do
             person.posts.send(method)
-            Post.where(title: "Testing").count.should eq(0)
+            expect(Post.where(title: "Testing").count).to eq(0)
           end
 
           it "returns the number of documents deleted" do
-            person.posts.send(method).should eq(2)
+            expect(person.posts.send(method)).to eq(2)
           end
         end
       end
@@ -2058,17 +2083,17 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "removes the correct ratings" do
-            movie.ratings.send(method, conditions: { value: 1 })
-            movie.ratings.count.should eq(1)
+            movie.ratings.send(method, { value: 1 })
+            expect(movie.ratings.count).to eq(1)
           end
 
           it "deletes the documents from the database" do
-            movie.ratings.send(method, conditions: { value: 1 })
-            Rating.where(value: 1).count.should eq(0)
+            movie.ratings.send(method, { value: 1 })
+            expect(Rating.where(value: 1).count).to eq(0)
           end
 
           it "returns the number of documents deleted" do
-            movie.ratings.send(method, conditions: { value: 1 }).should eq(1)
+            expect(movie.ratings.send(method, { value: 1 })).to eq(1)
           end
         end
 
@@ -2085,164 +2110,26 @@ describe Mongoid::Relations::Referenced::Many do
 
           it "removes the correct ratings" do
             movie.ratings.send(method)
-            movie.ratings.count.should eq(0)
+            expect(movie.ratings.count).to eq(0)
           end
 
           it "deletes the documents from the database" do
             movie.ratings.send(method)
-            Rating.where(value: 1).count.should eq(0)
+            expect(Rating.where(value: 1).count).to eq(0)
           end
 
           it "returns the number of documents deleted" do
-            movie.ratings.send(method).should eq(2)
+            expect(movie.ratings.send(method)).to eq(2)
           end
         end
       end
     end
   end
 
-  describe ".eager_load" do
-
-    before do
-      Mongoid.identity_map_enabled = true
-    end
-
-    after do
-      Mongoid.identity_map_enabled = false
-    end
-
-    context "when the relation is not polymorphic" do
-
-      context "when the eager load has returned documents" do
-
-        let!(:person) do
-          Person.create
-        end
-
-        let!(:post) do
-          person.posts.create(title: "testing")
-        end
-
-        let(:metadata) do
-          Person.relations["posts"]
-        end
-
-        let!(:eager) do
-          described_class.eager_load(metadata, Person.all.map(&:_id))
-        end
-
-        let(:map) do
-          Mongoid::IdentityMap.get(Post, {"person_id" => person.id})
-        end
-
-        it "puts the documents in the identity map" do
-          map.should eq({ post.id => post })
-        end
-      end
-
-      context "when the eager load has not returned documents" do
-
-        let!(:person) do
-          Person.create
-        end
-
-        let(:metadata) do
-          Person.relations["posts"]
-        end
-
-        let!(:eager) do
-          described_class.eager_load(metadata, Person.all.map(&:_id))
-        end
-
-        let(:map) do
-          Mongoid::IdentityMap.get(Post, {"person_id" => person.id})
-        end
-
-        it "puts an empty array in the identity map" do
-          map.should be_empty
-        end
-      end
-
-      context "when the eager load has not returned documents for some" do
-
-        let!(:person_one) do
-          Person.create
-        end
-
-        let!(:person_two) do
-          Person.create
-        end
-
-        let!(:post) do
-          person_one.posts.create(title: "testing")
-        end
-
-        let(:metadata) do
-          Person.relations["posts"]
-        end
-
-        let!(:eager) do
-          described_class.eager_load(metadata, Person.all.map(&:_id))
-        end
-
-        let(:map_one) do
-          Mongoid::IdentityMap.get(Post, {"person_id" => person_one.id})
-        end
-
-        let(:map_two) do
-          Mongoid::IdentityMap.get(Post, {"person_id" => person_two.id})
-        end
-
-        it "puts the found documents in the identity map" do
-          map_one.should eq({ post.id => post })
-        end
-
-        it "puts an empty array for parents with no docs" do
-          map_two.should be_empty
-        end
-      end
-    end
-
-    context "when the relation is polymorphic" do
-
-      let!(:movie) do
-        Movie.create(name: "Bladerunner")
-      end
-
-      let!(:book) do
-        Book.create(name: "Game of Thrones")
-      end
-
-      let!(:movie_rating) do
-        movie.ratings.create(value: 10)
-      end
-
-      let!(:book_rating) do
-        book.create_rating(value: 10)
-      end
-
-      let(:metadata) do
-        Movie.relations["ratings"]
-      end
-
-      let!(:eager) do
-        described_class.eager_load(metadata, Movie.all.map(&:_id))
-      end
-
-      let(:map) do
-        Mongoid::IdentityMap.get(Rating, {"ratable_id" => movie.id})
-      end
-
-      it "puts the documents in the identity map" do
-        map.should eq({ movie_rating.id => movie_rating })
-      end
-    end
-  end
-
   describe ".embedded?" do
 
     it "returns false" do
-      described_class.should_not be_embedded
+      expect(described_class).to_not be_embedded
     end
   end
 
@@ -2259,7 +2146,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "returns true" do
-        person.posts.exists?.should be_true
+        expect(person.posts.exists?).to be true
       end
     end
 
@@ -2270,7 +2157,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "returns false" do
-        person.posts.exists?.should be_false
+        expect(person.posts.exists?).to be false
       end
     end
   end
@@ -2279,14 +2166,6 @@ describe Mongoid::Relations::Referenced::Many do
 
     context "when the identity map is enabled" do
 
-      before do
-        Mongoid.identity_map_enabled = true
-      end
-
-      after do
-        Mongoid.identity_map_enabled = false
-      end
-
       context "when the document is in the map" do
 
         let(:person) do
@@ -2335,7 +2214,7 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "returns the matching document" do
-            post.should eq(post_one)
+            expect(post).to eq(post_one)
           end
         end
 
@@ -2362,7 +2241,7 @@ describe Mongoid::Relations::Referenced::Many do
 
             it "raises an error" do
               expect {
-                person.posts.find(Moped::BSON::ObjectId.new)
+                person.posts.find(BSON::ObjectId.new)
               }.to raise_error(Mongoid::Errors::DocumentNotFound)
             end
           end
@@ -2370,7 +2249,7 @@ describe Mongoid::Relations::Referenced::Many do
           context "when config set not to raise error" do
 
             let(:post) do
-              person.posts.find(Moped::BSON::ObjectId.new)
+              person.posts.find(BSON::ObjectId.new)
             end
 
             before do
@@ -2382,7 +2261,7 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "returns nil" do
-              post.should be_nil
+              expect(post).to be_nil
             end
           end
         end
@@ -2397,7 +2276,7 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "returns the matching documents" do
-            posts.should eq([ post_one, post_two ])
+            expect(posts).to eq([ post_one, post_two ])
           end
         end
 
@@ -2411,7 +2290,7 @@ describe Mongoid::Relations::Referenced::Many do
 
             it "raises an error" do
               expect {
-                person.posts.find([ Moped::BSON::ObjectId.new ])
+                person.posts.find([ BSON::ObjectId.new ])
               }.to raise_error(Mongoid::Errors::DocumentNotFound)
             end
           end
@@ -2419,7 +2298,7 @@ describe Mongoid::Relations::Referenced::Many do
           context "when config set not to raise error" do
 
             let(:posts) do
-              person.posts.find([ Moped::BSON::ObjectId.new ])
+              person.posts.find([ BSON::ObjectId.new ])
             end
 
             before do
@@ -2431,7 +2310,7 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "returns an empty array" do
-              posts.should be_empty
+              expect(posts).to be_empty
             end
           end
         end
@@ -2461,7 +2340,7 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "returns the matching document" do
-            rating.should eq(rating_one)
+            expect(rating).to eq(rating_one)
           end
         end
 
@@ -2475,7 +2354,7 @@ describe Mongoid::Relations::Referenced::Many do
 
             it "raises an error" do
               expect {
-                movie.ratings.find(Moped::BSON::ObjectId.new)
+                movie.ratings.find(BSON::ObjectId.new)
               }.to raise_error(Mongoid::Errors::DocumentNotFound)
             end
           end
@@ -2483,7 +2362,7 @@ describe Mongoid::Relations::Referenced::Many do
           context "when config set not to raise error" do
 
             let(:rating) do
-              movie.ratings.find(Moped::BSON::ObjectId.new)
+              movie.ratings.find(BSON::ObjectId.new)
             end
 
             before do
@@ -2495,7 +2374,7 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "returns nil" do
-              rating.should be_nil
+              expect(rating).to be_nil
             end
           end
         end
@@ -2509,8 +2388,16 @@ describe Mongoid::Relations::Referenced::Many do
             movie.ratings.find([ rating_one.id, rating_two.id ])
           end
 
-          it "returns the matching documents" do
-            ratings.should eq([ rating_one, rating_two ])
+          it "returns the first matching document" do
+            expect(ratings).to include(rating_one)
+          end
+
+          it "returns the second matching document" do
+            expect(ratings).to include(rating_two)
+          end
+
+          it "returns the correct number of documents" do
+            expect(ratings.size).to eq(2)
           end
         end
 
@@ -2524,7 +2411,7 @@ describe Mongoid::Relations::Referenced::Many do
 
             it "raises an error" do
               expect {
-                movie.ratings.find([ Moped::BSON::ObjectId.new ])
+                movie.ratings.find([ BSON::ObjectId.new ])
               }.to raise_error(Mongoid::Errors::DocumentNotFound)
             end
           end
@@ -2532,7 +2419,7 @@ describe Mongoid::Relations::Referenced::Many do
           context "when config set not to raise error" do
 
             let(:ratings) do
-              movie.ratings.find([ Moped::BSON::ObjectId.new ])
+              movie.ratings.find([ BSON::ObjectId.new ])
             end
 
             before do
@@ -2544,7 +2431,7 @@ describe Mongoid::Relations::Referenced::Many do
             end
 
             it "returns an empty array" do
-              ratings.should be_empty
+              expect(ratings).to be_empty
             end
           end
         end
@@ -2571,11 +2458,11 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "returns the document" do
-          found.should eq(post)
+          expect(found).to eq(post)
         end
 
         it "keeps the document in the relation" do
-          found.person.should eq(person)
+          expect(found.person).to eq(person)
         end
       end
 
@@ -2590,19 +2477,19 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the new document attributes" do
-            found.title.should eq("Test")
+            expect(found.title).to eq("Test")
           end
 
           it "returns a newly persisted document" do
-            found.should be_persisted
+            expect(found).to be_persisted
           end
 
           it "calls the passed block" do
-            found.content.should eq("The Content")
+            expect(found.content).to eq("The Content")
           end
 
           it "keeps the document in the relation" do
-            found.person.should eq(person)
+            expect(found.person).to eq(person)
           end
         end
 
@@ -2613,15 +2500,15 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "sets the new document attributes" do
-            found.title.should eq("Test")
+            expect(found.title).to eq("Test")
           end
 
           it "returns a newly persisted document" do
-            found.should be_persisted
+            expect(found).to be_persisted
           end
 
           it "keeps the document in the relation" do
-            found.person.should eq(person)
+            expect(found.person).to eq(person)
           end
         end
       end
@@ -2644,11 +2531,11 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "returns the document" do
-          found.should eq(rating)
+          expect(found).to eq(rating)
         end
 
         it "keeps the document in the relation" do
-          found.ratable.should eq(movie)
+          expect(found.ratable).to eq(movie)
         end
       end
 
@@ -2659,15 +2546,15 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the new document attributes" do
-          found.value.should eq(3)
+          expect(found.value).to eq(3)
         end
 
         it "returns a newly persisted document" do
-          found.should be_persisted
+          expect(found).to be_persisted
         end
 
         it "keeps the document in the relation" do
-          found.ratable.should eq(movie)
+          expect(found.ratable).to eq(movie)
         end
       end
     end
@@ -2692,7 +2579,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "returns the document" do
-          found.should eq(post)
+          expect(found).to eq(post)
         end
       end
 
@@ -2705,15 +2592,15 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the new document attributes" do
-          found.title.should eq("Test")
+          expect(found.title).to eq("Test")
         end
 
         it "returns a non persisted document" do
-          found.should_not be_persisted
+          expect(found).to_not be_persisted
         end
 
         it "calls the passed block" do
-          found.content.should eq("The Content")
+          expect(found.content).to eq("The Content")
         end
       end
     end
@@ -2735,7 +2622,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "returns the document" do
-          found.should eq(rating)
+          expect(found).to eq(rating)
         end
       end
 
@@ -2746,11 +2633,11 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "sets the new document attributes" do
-          found.value.should eq(3)
+          expect(found.value).to eq(3)
         end
 
         it "returns a non persisted document" do
-          found.should_not be_persisted
+          expect(found).to_not be_persisted
         end
       end
     end
@@ -2759,7 +2646,7 @@ describe Mongoid::Relations::Referenced::Many do
   describe ".foreign_key_suffix" do
 
     it "returns _id" do
-      described_class.foreign_key_suffix.should eq("_id")
+      expect(described_class.foreign_key_suffix).to eq("_id")
     end
   end
 
@@ -2785,7 +2672,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "does not raise an error" do
-        post.roles.should be_empty
+        expect(post.roles).to be_empty
       end
     end
   end
@@ -2793,7 +2680,7 @@ describe Mongoid::Relations::Referenced::Many do
   describe ".macro" do
 
     it "returns has_many" do
-      described_class.macro.should eq(:has_many)
+      expect(described_class.macro).to eq(:has_many)
     end
   end
 
@@ -2822,7 +2709,7 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "returns the document with the max value of the supplied field" do
-      max.should eq(post_two)
+      expect(max).to eq(post_two)
     end
   end
 
@@ -2849,7 +2736,7 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "returns the document with the max value of the supplied field" do
-      max.should eq(post_two)
+      expect(max).to eq(post_two)
     end
   end
 
@@ -2874,7 +2761,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "applies the criteria to the documents" do
-        posts.should eq([ post_one ])
+        expect(posts).to eq([ post_one ])
       end
     end
 
@@ -2885,7 +2772,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "applies the criteria to the documents" do
-        posts.should eq([ post_one ])
+        expect(posts).to eq([ post_one ])
       end
     end
 
@@ -2896,7 +2783,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "applies the criteria to the documents" do
-        posts.should eq([ post_one ])
+        expect(posts).to eq([ post_one ])
       end
     end
 
@@ -2904,8 +2791,13 @@ describe Mongoid::Relations::Referenced::Many do
 
       describe "#distinct" do
 
+        let(:values) do
+          person.posts.distinct(:title)
+        end
+
         it "returns the distinct values for the fields" do
-          person.posts.distinct(:title).should =~ [ "First",  "Second"]
+          expect(values).to include("First")
+          expect(values).to include("Second")
         end
       end
     end
@@ -2936,7 +2828,7 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "returns the min value of the supplied field" do
-      min.should eq(post_one)
+      expect(min).to eq(post_one)
     end
   end
 
@@ -2963,7 +2855,7 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "returns the min value of the supplied field" do
-      min.should eq(post_one)
+      expect(min).to eq(post_one)
     end
   end
 
@@ -2992,16 +2884,16 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "loads the targets before nullifying" do
-        from_db.posts.should be_empty
+        expect(from_db.posts).to be_empty
       end
 
       it "persists the base nullifications" do
-        Person.first.posts.should be_empty
+        expect(Person.first.posts).to be_empty
       end
 
       it "persists the inverse nullifications" do
         Post.all.each do |post|
-          post.person.should be_nil
+          expect(post.person).to be_nil
         end
       end
     end
@@ -3026,18 +2918,18 @@ describe Mongoid::Relations::Referenced::Many do
 
       it "removes all the foreign keys from the target" do
         [ post_one, post_two ].each do |post|
-          post.person_id.should be_nil
+          expect(post.person_id).to be_nil
         end
       end
 
       it "removes all the references from the target" do
         [ post_one, post_two ].each do |post|
-          post.person.should be_nil
+          expect(post.person).to be_nil
         end
       end
 
       it "saves the documents" do
-        post_one.reload.person.should be_nil
+        expect(post_one.reload.person).to be_nil
       end
 
       context "when adding a nullified document back to the relation" do
@@ -3047,7 +2939,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "persists the relation" do
-          person.posts(true).should eq([ post_one ])
+          expect(person.posts(true)).to eq([ post_one ])
         end
       end
     end
@@ -3072,13 +2964,13 @@ describe Mongoid::Relations::Referenced::Many do
 
       it "removes all the foreign keys from the target" do
         [ rating_one, rating_two ].each do |rating|
-          rating.ratable_id.should be_nil
+          expect(rating.ratable_id).to be_nil
         end
       end
 
       it "removes all the references from the target" do
         [ rating_one, rating_two ].each do |rating|
-          rating.ratable.should be_nil
+          expect(rating.ratable).to be_nil
         end
       end
     end
@@ -3099,7 +2991,7 @@ describe Mongoid::Relations::Referenced::Many do
       context "when checking #{method}" do
 
         it "returns true" do
-          posts.respond_to?(method).should be_true
+          expect(posts.respond_to?(method)).to be true
         end
       end
     end
@@ -3109,7 +3001,7 @@ describe Mongoid::Relations::Referenced::Many do
       context "when checking #{method}" do
 
         it "returns true" do
-          posts.respond_to?(method).should be_true
+          expect(posts.respond_to?(method)).to be true
         end
       end
     end
@@ -3119,7 +3011,7 @@ describe Mongoid::Relations::Referenced::Many do
       context "when checking #{method}" do
 
         it "returns true" do
-          posts.respond_to?(method).should be_true
+          expect(posts.respond_to?(method)).to be true
         end
       end
     end
@@ -3128,7 +3020,7 @@ describe Mongoid::Relations::Referenced::Many do
   describe ".stores_foreign_key?" do
 
     it "returns false" do
-      described_class.stores_foreign_key?.should be_false
+      expect(described_class.stores_foreign_key?).to be false
     end
   end
 
@@ -3143,11 +3035,11 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "returns the relation criteria" do
-      scoped.should be_a(Mongoid::Criteria)
+      expect(scoped).to be_a(Mongoid::Criteria)
     end
 
     it "returns with an empty selector" do
-      scoped.selector.should eq({ "person_id" => person.id })
+      expect(scoped.selector).to eq({ "person_id" => person.id })
     end
   end
 
@@ -3166,7 +3058,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "returns 1" do
-          movie.ratings.send(method).should eq(1)
+          expect(movie.ratings.send(method)).to eq(1)
         end
       end
 
@@ -3178,7 +3070,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "returns the total number of documents" do
-          movie.ratings.send(method).should eq(2)
+          expect(movie.ratings.send(method)).to eq(2)
         end
       end
     end
@@ -3205,7 +3097,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "returns only the associated documents" do
-        unscoped.should eq([ post_one ])
+        expect(unscoped).to eq([ post_one ])
       end
     end
 
@@ -3228,11 +3120,11 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "only returns associated documents" do
-        unscoped.should eq([ acolyte_one ])
+        expect(unscoped).to eq([ acolyte_one ])
       end
 
       it "removes the default scoping options" do
-        unscoped.options.should eq({})
+        expect(unscoped.options).to eq({})
       end
     end
   end
@@ -3240,7 +3132,7 @@ describe Mongoid::Relations::Referenced::Many do
   describe ".valid_options" do
 
     it "returns the valid options" do
-      described_class.valid_options.should eq(
+      expect(described_class.valid_options).to eq(
         [
           :after_add,
           :after_remove,
@@ -3260,7 +3152,7 @@ describe Mongoid::Relations::Referenced::Many do
   describe ".validation_default" do
 
     it "returns true" do
-      described_class.validation_default.should be_true
+      expect(described_class.validation_default).to be true
     end
   end
 
@@ -3288,13 +3180,13 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "order documents" do
-      person.ordered_posts(true).should eq(
+      expect(person.ordered_posts(true)).to eq(
         [post_two, post_three, post_one]
       )
     end
 
     it "chaining order criterias" do
-      person.ordered_posts.order_by(:title.desc).to_a.should eq(
+      expect(person.ordered_posts.order_by(:title.desc).to_a).to eq(
         [post_three, post_two, post_one]
       )
     end
@@ -3330,7 +3222,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "reloads the document from the database" do
-        reloaded.first.title.should eq("reloaded")
+        expect(reloaded.first.title).to eq("reloaded")
       end
     end
 
@@ -3345,11 +3237,11 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "reloads the first document from the database" do
-        reloaded.should include(post_one)
+        expect(reloaded).to include(post_one)
       end
 
       it "reloads the new document from the database" do
-        reloaded.should include(post_two)
+        expect(reloaded).to include(post_two)
       end
     end
   end
@@ -3363,7 +3255,7 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "allows creation of the document" do
-      jar.id.should eq(1)
+      expect(jar.id).to eq(1)
     end
   end
 
@@ -3392,7 +3284,7 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "adds both documents" do
-        result.should eq([ post_one, post_two ])
+        expect(result).to eq([ post_one, post_two ])
       end
     end
   end
@@ -3414,29 +3306,29 @@ describe Mongoid::Relations::Referenced::Many do
       end
 
       it "it executes method callbacks" do
-        artist.before_add_referenced_called.should be_true
+        expect(artist.before_add_referenced_called).to be true
       end
 
       it "it executes proc callbacks" do
-        album.before_add_called.should be_true
+        expect(album.before_add_called).to be true
       end
 
       it "adds the document to the relation" do
-        artist.albums.should eq([ album ])
+        expect(artist.albums).to eq([ album ])
       end
     end
 
     context "when execution raises errors" do
 
       before do
-        artist.should_receive(:before_add_album).and_raise
+        expect(artist).to receive(:before_add_album).and_raise
       end
 
       it "does not add the document to the relation" do
         expect {
           artist.albums << album
         }.to raise_error
-        artist.albums.should be_empty
+        expect(artist.albums).to be_empty
       end
     end
   end
@@ -3453,20 +3345,20 @@ describe Mongoid::Relations::Referenced::Many do
 
     it "executes the callback" do
       artist.albums << album
-      artist.after_add_referenced_called.should be_true
+      expect(artist.after_add_referenced_called).to be true
     end
 
     context "when execution raises errors" do
 
       before do
-        artist.should_receive(:after_add_album).and_raise
+        expect(artist).to receive(:after_add_album).and_raise
       end
 
       it "adds the document to the relation" do
         expect {
           artist.albums << album
         }.to raise_error
-        artist.albums.should eq([ album ])
+        expect(artist.albums).to eq([ album ])
       end
     end
   end
@@ -3494,11 +3386,11 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "executes the callback" do
-          artist.before_remove_referenced_called.should be_true
+          expect(artist.before_remove_referenced_called).to be true
         end
 
         it "removes the document from the relation" do
-          artist.albums.should be_empty
+          expect(artist.albums).to be_empty
         end
       end
 
@@ -3509,18 +3401,18 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "executes the callback" do
-          artist.before_remove_referenced_called.should be_true
+          expect(artist.before_remove_referenced_called).to be true
         end
 
         it "clears the relation" do
-          artist.albums.should be_empty
+          expect(artist.albums).to be_empty
         end
       end
 
       context "when execution raises errors" do
 
         before do
-          artist.should_receive(:before_remove_album).and_raise
+          expect(artist).to receive(:before_remove_album).and_raise
         end
 
         describe "#delete" do
@@ -3532,7 +3424,7 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "does not remove the document from the relation" do
-            artist.albums.should eq([ album ])
+            expect(artist.albums).to eq([ album ])
           end
         end
 
@@ -3545,7 +3437,7 @@ describe Mongoid::Relations::Referenced::Many do
           end
 
           it "does not clear the relation" do
-            artist.albums.should eq([ album ])
+            expect(artist.albums).to eq([ album ])
           end
         end
       end
@@ -3575,7 +3467,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "executes the callback" do
-          artist.after_remove_referenced_called.should be_true
+          expect(artist.after_remove_referenced_called).to be true
         end
       end
 
@@ -3587,7 +3479,7 @@ describe Mongoid::Relations::Referenced::Many do
 
         it "executes the callback" do
           artist.albums.clear
-          artist.after_remove_referenced_called.should be_true
+          expect(artist.after_remove_referenced_called).to be true
         end
       end
     end
@@ -3595,7 +3487,7 @@ describe Mongoid::Relations::Referenced::Many do
     context "when errors are raised" do
 
       before do
-        artist.should_receive(:after_remove_album).and_raise
+        expect(artist).to receive(:after_remove_album).and_raise
       end
 
       describe "#delete" do
@@ -3607,7 +3499,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "removes the documents from the relation" do
-          artist.albums.should be_empty
+          expect(artist.albums).to be_empty
         end
       end
 
@@ -3620,7 +3512,7 @@ describe Mongoid::Relations::Referenced::Many do
         end
 
         it "removes the documents from the relation" do
-          artist.albums.should be_empty
+          expect(artist.albums).to be_empty
         end
       end
     end
@@ -3645,7 +3537,22 @@ describe Mongoid::Relations::Referenced::Many do
     end
 
     it "does not drop the ordering" do
-      criteria.should eq([ post_two, post_one ])
+      expect(criteria).to eq([ post_two, post_one ])
+    end
+  end
+
+  context "when accessing a scope named open" do
+
+    let(:person) do
+      Person.create
+    end
+
+    let!(:post) do
+      person.posts.create(title: "open")
+    end
+
+    it "returns the appropriate documents" do
+      expect(person.posts.open).to eq([ post ])
     end
   end
 end