mongoid 3.1.6 → 4.0.2

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

@@ -4,7 +4,6 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
   before(:all) do
     Mongoid.raise_not_found_error = true
-    Person.autosaved_relations.delete_one(:preferences)
     Person.autosave(Person.relations["preferences"].merge!(autosave: true))
     Person.synced(Person.relations["preferences"])
   end
@@ -35,7 +34,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "persists the child document" do
-            preference.should be_persisted
+            expect(preference).to be_persisted
           end
         end
 
@@ -46,7 +45,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "does not persist the child document" do
-            preference.should_receive(:save).never
+            expect(preference).to receive(:save).never
             article.preferences.send(method, preference)
           end
         end
@@ -67,7 +66,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns an array of loaded documents" do
-          result.should eq([ preference ])
+          expect(result).to eq([ preference ])
         end
       end
 
@@ -86,7 +85,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns an array of loaded documents" do
-          result.should eq([ preference ])
+          expect(result).to eq([ preference ])
         end
       end
 
@@ -107,11 +106,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "appends the document to the relation" do
-            person.houses.should eq([ house ])
+            expect(person.houses).to eq([ house ])
           end
 
           it "sets the foreign key on the relation" do
-            person.house_ids.should eq([ house.id ])
+            expect(person.house_ids).to eq([ house.id ])
           end
         end
 
@@ -128,27 +127,27 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "adds the documents to the relation" do
-            person.preferences.should eq([ preference ])
+            expect(person.preferences).to eq([ preference ])
           end
 
           it "sets the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id ])
+            expect(person.preference_ids).to eq([ preference.id ])
           end
 
           it "sets the foreign key on the inverse relation" do
-            preference.person_ids.should eq([ person.id ])
+            expect(preference.person_ids).to eq([ person.id ])
           end
 
           it "saves the target" do
-            preference.should be_persisted
+            expect(preference).to be_persisted
           end
 
           it "adds the correct number of documents" do
-            person.preferences.size.should eq(1)
+            expect(person.preferences.size).to eq(1)
           end
 
           it "persists the link" do
-            person.reload.preferences.should eq([ preference ])
+            expect(person.reload.preferences).to eq([ preference ])
           end
         end
 
@@ -169,23 +168,23 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "adds the documents to the relation" do
-              person.preferences.should eq([ preference ])
+              expect(person.preferences).to eq([ preference ])
             end
 
             it "sets the foreign key on the relation" do
-              person.preference_ids.should eq([ preference.id ])
+              expect(person.preference_ids).to eq([ preference.id ])
             end
 
             it "sets the foreign key on the inverse relation" do
-              preference.person_ids.should eq([ person.id ])
+              expect(preference.person_ids).to eq([ person.id ])
             end
 
             it "does not save the target" do
-              preference.should be_new_record
+              expect(preference).to be_new_record
             end
 
             it "adds the correct number of documents" do
-              person.preferences.size.should eq(1)
+              expect(person.preferences.size).to eq(1)
             end
 
             context "when appending a second time" do
@@ -195,11 +194,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
               end
 
               it "does not allow the document to be added again" do
-                person.preferences.should eq([ preference ])
+                expect(person.preferences).to eq([ preference ])
               end
 
               it "does not allow duplicate ids" do
-                person.preference_ids.should eq([ preference.id ])
+                expect(person.preference_ids).to eq([ preference.id ])
               end
             end
           end
@@ -220,27 +219,27 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "adds the documents to the relation" do
-              person.preferences.should eq([ preference ])
+              expect(person.preferences).to eq([ preference ])
             end
 
             it "sets the foreign key on the relation" do
-              person.preference_ids.should eq([ preference.id ])
+              expect(person.preference_ids).to eq([ preference.id ])
             end
 
             it "sets the foreign key on the inverse relation" do
-              preference.person_ids.should eq([ person.id ])
+              expect(preference.person_ids).to eq([ person.id ])
             end
 
             it "saves the target" do
-              preference.should be_persisted
+              expect(preference).to be_persisted
             end
 
             it "adds the correct number of documents" do
-              person.preferences.size.should eq(1)
+              expect(person.preferences.size).to eq(1)
             end
 
             it "persists the link" do
-              person.reload.preferences.should eq([ preference ])
+              expect(person.reload.preferences).to eq([ preference ])
             end
           end
 
@@ -263,23 +262,23 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "adds the documents to the relation" do
-              person.preferences.should eq([ preference ])
+              expect(person.preferences).to eq([ preference ])
             end
 
             it "sets the foreign key on the relation" do
-              person.preference_ids.should eq([ preference.id ])
+              expect(person.preference_ids).to eq([ preference.id ])
             end
 
             it "sets the foreign key on the inverse relation" do
-              preference.reload.person_ids.should eq([ person.id ])
+              expect(preference.reload.person_ids).to eq([ person.id ])
             end
 
             it "adds the correct number of documents" do
-              person.preferences.size.should eq(1)
+              expect(person.preferences.size).to eq(1)
             end
 
             it "persists the link" do
-              person.reload.preferences.should eq([ preference ])
+              expect(person.reload.preferences).to eq([ preference ])
             end
           end
         end
@@ -299,31 +298,31 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "adds the documents to the relation" do
-            person.preferences.should eq([ preference ])
+            expect(person.preferences).to eq([ preference ])
           end
 
           it "sets the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id ])
+            expect(person.preference_ids).to eq([ preference.id ])
           end
 
           it "sets the foreign key on the inverse relation" do
-            preference.person_ids.should eq([ person.id ])
+            expect(preference.person_ids).to eq([ person.id ])
           end
 
           it "sets the base on the inverse relation" do
-            preference.people.should eq([ person ])
+            expect(preference.people).to eq([ person ])
           end
 
           it "sets the same instance on the inverse relation" do
-            preference.people.first.should eql(person)
+            expect(preference.people.first).to eql(person)
           end
 
           it "saves the target" do
-            preference.should_not be_new_record
+            expect(preference).to_not be_new_record
           end
 
           it "adds the document to the target" do
-            person.preferences.count.should eq(1)
+            expect(person.preferences.count).to eq(1)
           end
 
           context "when documents already exist on the relation" do
@@ -337,31 +336,31 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "adds the documents to the relation" do
-              person.preferences.should eq([ preference, preference_two ])
+              expect(person.preferences).to eq([ preference, preference_two ])
             end
 
             it "sets the foreign key on the relation" do
-              person.preference_ids.should eq([ preference.id, preference_two.id ])
+              expect(person.preference_ids).to eq([ preference.id, preference_two.id ])
             end
 
             it "sets the foreign key on the inverse relation" do
-              preference_two.person_ids.should eq([ person.id ])
+              expect(preference_two.person_ids).to eq([ person.id ])
             end
 
             it "sets the base on the inverse relation" do
-              preference_two.people.should eq([ person ])
+              expect(preference_two.people).to eq([ person ])
             end
 
             it "sets the same instance on the inverse relation" do
-              preference_two.people.first.should eql(person)
+              expect(preference_two.people.first).to eql(person)
             end
 
             it "saves the target" do
-              preference.should_not be_new_record
+              expect(preference).to_not be_new_record
             end
 
             it "adds the document to the target" do
-              person.preferences.count.should eq(2)
+              expect(person.preferences.count).to eq(2)
             end
           end
         end
@@ -381,21 +380,21 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "sets the front side of the relation" do
-            person.administrated_events.should eq([ event ])
+            expect(person.administrated_events).to eq([ event ])
           end
 
           it "sets the inverse side of the relation" do
-            event.administrators(true).should eq([ person ])
+            expect(event.administrators(true)).to eq([ person ])
           end
 
           context "when reloading" do
 
             it "sets the front side of the relation" do
-              person.reload.administrated_events.should eq([ event ])
+              expect(person.reload.administrated_events).to eq([ event ])
             end
 
             it "sets the inverse side of the relation" do
-              event.reload.administrators.should eq([ person ])
+              expect(event.reload.administrators).to eq([ person ])
             end
           end
 
@@ -410,11 +409,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "sets the front side of the relation" do
-              loaded_person.administrated_events.should eq([ event ])
+              expect(loaded_person.administrated_events).to eq([ event ])
             end
 
             it "sets the inverse side of the relation" do
-              loaded_event.administrators.should eq([ person ])
+              expect(loaded_event.administrators).to eq([ person ])
             end
           end
         end
@@ -438,7 +437,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "creates a single artwork object" do
-            Artwork.count.should eq(1)
+            expect(Artwork.count).to eq(1)
           end
         end
 
@@ -457,21 +456,21 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "sets the front side of the relation" do
-            tag_one.related.should eq([ tag_two ])
+            expect(tag_one.related).to eq([ tag_two ])
           end
 
           it "sets the inverse side of the relation" do
-            tag_two.related(true).should eq([ tag_one ])
+            expect(tag_two.related(true)).to eq([ tag_one ])
           end
 
           context "when reloading" do
 
             it "sets the front side of the relation" do
-              tag_one.reload.related.should eq([ tag_two ])
+              expect(tag_one.reload.related).to eq([ tag_two ])
             end
 
             it "sets the inverse side of the relation" do
-              tag_two.reload.related.should eq([ tag_one ])
+              expect(tag_two.reload.related).to eq([ tag_one ])
             end
           end
 
@@ -486,11 +485,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "sets the front side of the relation" do
-              loaded_tag_one.related.should eq([ tag_two ])
+              expect(loaded_tag_one.related).to eq([ tag_two ])
             end
 
             it "sets the inverse side of the relation" do
-              loaded_tag_two.related.should eq([ tag_one ])
+              expect(loaded_tag_two.related).to eq([ tag_one ])
             end
           end
         end
@@ -510,20 +509,20 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
           it "executes the callback" do
             post.tags.send(method, tag)
-            post.before_add_called.should be_true
+            expect(post.before_add_called).to be true
           end
 
           context "when errors are raised" do
 
             before do
-              post.should_receive(:before_add_tag).and_raise
+              expect(post).to receive(:before_add_tag).and_raise
             end
 
             it "does not add the document to the relation" do
               expect {
                 post.tags.send(method, tag)
               }.to raise_error
-              post.tags.should be_empty
+              expect(post.tags).to be_empty
             end
           end
         end
@@ -532,20 +531,20 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
           it "executes the callback" do
             post.tags.send(method, tag)
-            post.after_add_called.should be_true
+            expect(post.after_add_called).to be true
           end
 
           context "when errors are raised" do
 
             before do
-              post.should_receive(:after_add_tag).and_raise
+              expect(post).to receive(:after_add_tag).and_raise
             end
 
             it "adds the document to the relation" do
               expect {
                 post.tags.send(method, tag)
               }.to raise_error
-              post.tags.should eq([ tag ])
+              expect(post.tags).to eq([ tag ])
             end
           end
         end
@@ -572,11 +571,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       context "when the document is new" do
 
         it "does not add the duplicates" do
-          person.preferences.should eq([ preference ])
+          expect(person.preferences).to eq([ preference ])
         end
 
         it "does not create duplicate keys" do
-          person.preference_ids.should eq([ preference.id ])
+          expect(person.preference_ids).to eq([ preference.id ])
         end
       end
 
@@ -587,19 +586,29 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "does not add the duplicates" do
-          person.preferences.should eq([ preference ])
+          expect(person.preferences).to eq([ preference ])
         end
 
         it "does not create duplicate keys" do
-          person.preference_ids.should eq([ preference.id ])
+          expect(person.preference_ids).to eq([ preference.id ])
         end
 
         it "does not add duplicates on the inverse" do
-          preference.people.should eq([ person ])
+          expect(preference.people).to eq([ person ])
         end
 
         it "does not add duplicate inverse keys" do
-          preference.person_ids.should eq([ person.id ])
+          expect(preference.person_ids).to eq([ person.id ])
+        end
+
+        context "when reloading document from db" do
+
+          let(:from_db) { Preference.last }
+
+          it "does not create duplicate keys" do
+            person.preferences = [ from_db ]
+            expect(from_db.person_ids).to eq([ person.id ])
+          end
         end
       end
     end
@@ -621,19 +630,19 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "sets the relation" do
-          person.preferences.should eq([ preference ])
+          expect(person.preferences).to eq([ preference ])
         end
 
         it "sets the foreign key on the relation" do
-          person.preference_ids.should eq([ preference.id ])
+          expect(person.preference_ids).to eq([ preference.id ])
         end
 
         it "sets the foreign key on the inverse relation" do
-          preference.person_ids.should eq([ person.id ])
+          expect(preference.person_ids).to eq([ person.id ])
         end
 
         it "does not save the target" do
-          preference.should be_new_record
+          expect(preference).to be_new_record
         end
       end
 
@@ -652,15 +661,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "sets the relation" do
-          person.preferences.should eq([ preference ])
+          expect(person.preferences).to eq([ preference ])
         end
 
         it "sets the foreign key on the relation" do
-          person.preference_ids.should eq([ preference.id ])
+          expect(person.preference_ids).to eq([ preference.id ])
         end
 
         it "sets the foreign key on the inverse relation" do
-          preference.person_ids.should eq([ person.id ])
+          expect(preference.person_ids).to eq([ person.id ])
         end
 
         context "and the parent is persisted" do
@@ -671,19 +680,19 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "maintains the relation" do
-            person.preferences.should eq([ preference ])
+            expect(person.preferences).to eq([ preference ])
           end
 
           it "maintains the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id ])
+            expect(person.preference_ids).to eq([ preference.id ])
           end
 
           it "maintains the foreign key on the inverse relation" do
-            preference.person_ids.should eq([ person.id ])
+            expect(preference.person_ids).to eq([ person.id ])
           end
 
           it "maintains the base on the inverse relation" do
-            preference.people.first.should eq(person)
+            expect(preference.people.first).to eq(person)
           end
         end
       end
@@ -703,23 +712,23 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "sets the relation" do
-          person.preferences.should eq([ preference ])
+          expect(person.preferences).to eq([ preference ])
         end
 
         it "sets the foreign key on the relation" do
-          person.preference_ids.should eq([ preference.id ])
+          expect(person.preference_ids).to eq([ preference.id ])
         end
 
         it "sets the foreign key on the inverse relation" do
-          preference.person_ids.should eq([ person.id ])
+          expect(preference.person_ids).to eq([ person.id ])
         end
 
         it "sets the base on the inverse relation" do
-          preference.people.first.should eq(person)
+          expect(preference.people.first).to eq(person)
         end
 
         it "saves the target" do
-          preference.should be_persisted
+          expect(preference).to be_persisted
         end
 
         it "persists the relation" do
@@ -737,19 +746,19 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "sets the relation" do
-            person.preferences.should eq([ another_preference ])
+            expect(person.preferences).to eq([ another_preference ])
           end
 
           it "saves the target" do
-            another_preference.should be_persisted
+            expect(another_preference).to be_persisted
           end
 
           it "does not leave foreign keys of the previous relation" do
-            person.preference_ids.should eq([ another_preference.id ])
+            expect(person.preference_ids).to eq([ another_preference.id ])
           end
 
           it "clears its own key on the foreign relation" do
-            preference.person_ids.should be_empty
+            expect(preference.person_ids).to be_empty
           end
 
           context "and then overwriting it again with the same value" do
@@ -759,7 +768,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "persists the relation between another_preference and person" do
-              another_preference.reload.people.should eq([ person ])
+              expect(another_preference.reload.people).to eq([ person ])
             end
 
           end
@@ -772,15 +781,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "persists the relation between person and another_preference" do
-              person.preferences.should eq([ another_preference ])
+              expect(person.preferences).to eq([ another_preference ])
             end
 
             it "persists the relation between another_prefrence and person" do
-              another_preference.people.should eq([ person ])
+              expect(another_preference.people).to eq([ person ])
             end
 
             it "no longer has any relation between preference and person" do
-              preference.people.should be_empty
+              expect(preference.people).to be_empty
             end
           end
 
@@ -793,15 +802,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "persists the relation between person and another_preference" do
-              person.preferences.should eq([ another_preference ])
+              expect(person.preferences).to eq([ another_preference ])
             end
 
             it "persists the relation between another_prefrence and person" do
-              another_preference.people.should eq([ person ])
+              expect(another_preference.people).to eq([ person ])
             end
 
             it "no longer has any relation between preference and person" do
-              preference.people.should be_empty
+              expect(preference.people).to be_empty
             end
           end
         end
@@ -831,11 +840,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "clears the relation" do
-            person.houses.should be_empty
+            expect(person.houses).to be_empty
           end
 
           it "clears the foreign keys" do
-            person.house_ids.should be_empty
+            expect(person.house_ids).to be_empty
           end
         end
 
@@ -855,19 +864,19 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "sets the relation to an empty array" do
-            person.preferences.should be_empty
+            expect(person.preferences).to be_empty
           end
 
           it "removed the inverse relation" do
-            preference.people.should be_empty
+            expect(preference.people).to be_empty
           end
 
           it "removes the foreign key values" do
-            person.preference_ids.should be_empty
+            expect(person.preference_ids).to be_empty
           end
 
           it "removes the inverse foreign key values" do
-            preference.person_ids.should be_empty
+            expect(preference.person_ids).to be_empty
           end
         end
 
@@ -889,23 +898,23 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "sets the relation to an empty array" do
-              person.preferences.should be_empty
+              expect(person.preferences).to be_empty
             end
 
             it "removed the inverse relation" do
-              preference.people.should be_empty
+              expect(preference.people).to be_empty
             end
 
             it "removes the foreign key values" do
-              person.preference_ids.should be_empty
+              expect(person.preference_ids).to be_empty
             end
 
             it "removes the inverse foreign key values" do
-              preference.person_ids.should be_empty
+              expect(preference.person_ids).to be_empty
             end
 
             it "does not delete the target from the database" do
-              preference.should_not be_destroyed
+              expect(preference).to_not be_destroyed
             end
           end
 
@@ -930,11 +939,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "sets the relation to an empty array" do
-              from_db.preferences.should be_empty
+              expect(from_db.preferences).to be_empty
             end
 
             it "removes the foreign key values" do
-              from_db.preference_ids.should be_empty
+              expect(from_db.preference_ids).to be_empty
             end
           end
         end
@@ -946,28 +955,6 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
     describe "##{method}" do
 
-      context "when providing scoped mass assignment" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:house) do
-          person.houses.send(
-            method,
-            { name: "Dream", model: "Home" }, as: :admin
-          )
-        end
-
-        it "sets the attributes for the provided role" do
-          house.name.should eq("Dream")
-        end
-
-        it "does not set the attributes for other roles" do
-          house.model.should be_nil
-        end
-      end
-
       context "when the relation is not polymorphic" do
 
         context "when the parent is a new record" do
@@ -981,27 +968,27 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "adds the document to the relation" do
-            person.preferences.should eq([ preference ])
+            expect(person.preferences).to eq([ preference ])
           end
 
           it "sets the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id ])
+            expect(person.preference_ids).to eq([ preference.id ])
           end
 
           it "sets the inverse foreign key on the relation" do
-            preference.person_ids.should eq([ person.id ])
+            expect(preference.person_ids).to eq([ person.id ])
           end
 
           it "sets the attributes" do
-            preference.name.should eq("settings")
+            expect(preference.name).to eq("settings")
           end
 
           it "does not save the target" do
-            preference.should be_new_record
+            expect(preference).to be_new_record
           end
 
           it "adds the correct number of documents" do
-            person.preferences.size.should eq(1)
+            expect(person.preferences.size).to eq(1)
           end
         end
 
@@ -1016,31 +1003,31 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "adds the document to the relation" do
-            person.preferences.should eq([ preference ])
+            expect(person.preferences).to eq([ preference ])
           end
 
           it "sets the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id ])
+            expect(person.preference_ids).to eq([ preference.id ])
           end
 
           it "sets the inverse foreign key on the relation" do
-            preference.person_ids.should eq([ person.id ])
+            expect(preference.person_ids).to eq([ person.id ])
           end
 
           it "sets the base on the inverse relation" do
-            preference.people.should eq([ person ])
+            expect(preference.people).to eq([ person ])
           end
 
           it "sets the attributes" do
-            preference.name.should eq("settings")
+            expect(preference.name).to eq("settings")
           end
 
           it "does not save the target" do
-            preference.should be_new_record
+            expect(preference).to be_new_record
           end
 
           it "adds the correct number of documents" do
-            person.preferences.size.should eq(1)
+            expect(person.preferences.size).to eq(1)
           end
 
           context "when saving the target" do
@@ -1050,7 +1037,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "persists the parent keys" do
-              person.reload.preference_ids.should eq([ preference.id ])
+              expect(person.reload.preference_ids).to eq([ preference.id ])
             end
           end
         end
@@ -1065,16 +1052,17 @@ describe Mongoid::Relations::Referenced::ManyToMany 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
 
@@ -1099,31 +1087,31 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "clears out the relation" do
-            person.preferences.should be_empty
+            expect(person.preferences).to be_empty
           end
 
           it "removes the parent from the inverse relation" do
-            preference.people.should_not include(person)
+            expect(preference.people).to_not include(person)
           end
 
           it "removes the foreign keys" do
-            person.preference_ids.should be_empty
+            expect(person.preference_ids).to be_empty
           end
 
           it "removes the parent key from the inverse" do
-            preference.person_ids.should_not include(person.id)
+            expect(preference.person_ids).to_not include(person.id)
           end
 
           it "does not delete the documents" do
-            preference.should_not be_destroyed
+            expect(preference).to_not be_destroyed
           end
 
           it "persists the nullification" do
-            person.reload.preferences.should be_empty
+            expect(person.reload.preferences).to be_empty
           end
 
           it "returns the relation" do
-            relation.should be_empty
+            expect(relation).to be_empty
           end
         end
 
@@ -1138,7 +1126,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "clears out the relation" do
-            person.preferences.should be_empty
+            expect(person.preferences).to be_empty
           end
         end
       end
@@ -1158,7 +1146,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "clears out the relation" do
-          person.preferences.should be_empty
+          expect(person.preferences).to be_empty
         end
       end
     end
@@ -1186,25 +1174,25 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "executes the callback" do
-            post.before_remove_called.should be_true
+            expect(post.before_remove_called).to be true
           end
 
           it "removes the document from the relation" do
-            post.tags.should be_empty
+            expect(post.tags).to be_empty
           end
         end
 
         context "when errors are raised" do
 
           before do
-            post.should_receive(:before_remove_tag).and_raise
+            expect(post).to receive(:before_remove_tag).and_raise
           end
 
           it "does not remove the document from the relation" do
             expect {
               post.tags.clear
             }.to raise_error
-            post.tags.should eq([ tag ])
+            expect(post.tags).to eq([ tag ])
           end
         end
       end
@@ -1218,25 +1206,25 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "executes the callback" do
-            post.after_remove_called.should be_true
+            expect(post.after_remove_called).to be true
           end
 
           it "removes the document from the relation" do
-            post.tags.should be_empty
+            expect(post.tags).to be_empty
           end
         end
 
         context "when errors are raised" do
 
           before do
-            post.should_receive(:after_remove_tag).and_raise
+            expect(post).to receive(:after_remove_tag).and_raise
           end
 
           it "removes the document from the relation" do
             expect {
               post.tags.clear
             }.to raise_error
-            post.tags.should be_empty
+            expect(post.tags).to be_empty
           end
         end
       end
@@ -1260,7 +1248,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "returns an array of loaded documents" do
-        result.should eq([ preference ])
+        expect(result).to eq([ preference ])
       end
     end
 
@@ -1279,7 +1267,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "returns an array of loaded documents" do
-        result.should eq([ preference ])
+        expect(result).to eq([ preference ])
       end
     end
 
@@ -1300,11 +1288,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "appends the document to the relation" do
-          person.houses.should eq([ house ])
+          expect(person.houses).to eq([ house ])
         end
 
         it "sets the foreign key on the relation" do
-          person.house_ids.should eq([ house.id ])
+          expect(person.house_ids).to eq([ house.id ])
         end
       end
 
@@ -1321,27 +1309,27 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "adds the documents to the relation" do
-          person.preferences.should eq([ preference ])
+          expect(person.preferences).to eq([ preference ])
         end
 
         it "sets the foreign key on the relation" do
-          person.preference_ids.should eq([ preference.id ])
+          expect(person.preference_ids).to eq([ preference.id ])
         end
 
         it "sets the foreign key on the inverse relation" do
-          preference.person_ids.should eq([ person.id ])
+          expect(preference.person_ids).to eq([ person.id ])
         end
 
         it "saves the target" do
-          preference.should be_persisted
+          expect(preference).to be_persisted
         end
 
         it "adds the correct number of documents" do
-          person.preferences.size.should eq(1)
+          expect(person.preferences.size).to eq(1)
         end
 
         it "persists the link" do
-          person.reload.preferences.should eq([ preference ])
+          expect(person.reload.preferences).to eq([ preference ])
         end
       end
 
@@ -1362,23 +1350,23 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "adds the documents to the relation" do
-            person.preferences.should eq([ preference ])
+            expect(person.preferences).to eq([ preference ])
           end
 
           it "sets the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id ])
+            expect(person.preference_ids).to eq([ preference.id ])
           end
 
           it "sets the foreign key on the inverse relation" do
-            preference.person_ids.should eq([ person.id ])
+            expect(preference.person_ids).to eq([ person.id ])
           end
 
           it "does not save the target" do
-            preference.should be_new_record
+            expect(preference).to be_new_record
           end
 
           it "adds the correct number of documents" do
-            person.preferences.size.should eq(1)
+            expect(person.preferences.size).to eq(1)
           end
 
           context "when appending a second time" do
@@ -1388,11 +1376,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "does not allow the document to be added again" do
-              person.preferences.should eq([ preference ])
+              expect(person.preferences).to eq([ preference ])
             end
 
             it "does not allow duplicate ids" do
-              person.preference_ids.should eq([ preference.id ])
+              expect(person.preference_ids).to eq([ preference.id ])
             end
           end
         end
@@ -1413,27 +1401,27 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "adds the documents to the relation" do
-            person.preferences.should eq([ preference ])
+            expect(person.preferences).to eq([ preference ])
           end
 
           it "sets the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id ])
+            expect(person.preference_ids).to eq([ preference.id ])
           end
 
           it "sets the foreign key on the inverse relation" do
-            preference.person_ids.should eq([ person.id ])
+            expect(preference.person_ids).to eq([ person.id ])
           end
 
           it "saves the target" do
-            preference.should be_persisted
+            expect(preference).to be_persisted
           end
 
           it "adds the correct number of documents" do
-            person.preferences.size.should eq(1)
+            expect(person.preferences.size).to eq(1)
           end
 
           it "persists the link" do
-            person.reload.preferences.should eq([ preference ])
+            expect(person.reload.preferences).to eq([ preference ])
           end
         end
 
@@ -1456,23 +1444,23 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "adds the documents to the relation" do
-            person.preferences.should eq([ preference ])
+            expect(person.preferences).to eq([ preference ])
           end
 
           it "sets the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id ])
+            expect(person.preference_ids).to eq([ preference.id ])
           end
 
           it "sets the foreign key on the inverse relation" do
-            preference.reload.person_ids.should eq([ person.id ])
+            expect(preference.reload.person_ids).to eq([ person.id ])
           end
 
           it "adds the correct number of documents" do
-            person.preferences.size.should eq(1)
+            expect(person.preferences.size).to eq(1)
           end
 
           it "persists the link" do
-            person.reload.preferences.should eq([ preference ])
+            expect(person.reload.preferences).to eq([ preference ])
           end
         end
       end
@@ -1492,31 +1480,31 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "adds the documents to the relation" do
-          person.preferences.should eq([ preference ])
+          expect(person.preferences).to eq([ preference ])
         end
 
         it "sets the foreign key on the relation" do
-          person.preference_ids.should eq([ preference.id ])
+          expect(person.preference_ids).to eq([ preference.id ])
         end
 
         it "sets the foreign key on the inverse relation" do
-          preference.person_ids.should eq([ person.id ])
+          expect(preference.person_ids).to eq([ person.id ])
         end
 
         it "sets the base on the inverse relation" do
-          preference.people.should eq([ person ])
+          expect(preference.people).to eq([ person ])
         end
 
         it "sets the same instance on the inverse relation" do
-          preference.people.first.should eql(person)
+          expect(preference.people.first).to eql(person)
         end
 
         it "saves the target" do
-          preference.should_not be_new_record
+          expect(preference).to_not be_new_record
         end
 
         it "adds the document to the target" do
-          person.preferences.count.should eq(1)
+          expect(person.preferences.count).to eq(1)
         end
 
         context "when documents already exist on the relation" do
@@ -1530,31 +1518,31 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "adds the documents to the relation" do
-            person.preferences.should eq([ preference, preference_two ])
+            expect(person.preferences).to eq([ preference, preference_two ])
           end
 
           it "sets the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id, preference_two.id ])
+            expect(person.preference_ids).to eq([ preference.id, preference_two.id ])
           end
 
           it "sets the foreign key on the inverse relation" do
-            preference_two.person_ids.should eq([ person.id ])
+            expect(preference_two.person_ids).to eq([ person.id ])
           end
 
           it "sets the base on the inverse relation" do
-            preference_two.people.should eq([ person ])
+            expect(preference_two.people).to eq([ person ])
           end
 
           it "sets the same instance on the inverse relation" do
-            preference_two.people.first.should eql(person)
+            expect(preference_two.people.first).to eql(person)
           end
 
           it "saves the target" do
-            preference.should_not be_new_record
+            expect(preference).to_not be_new_record
           end
 
           it "adds the document to the target" do
-            person.preferences.count.should eq(2)
+            expect(person.preferences.count).to eq(2)
           end
         end
       end
@@ -1574,21 +1562,21 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "sets the front side of the relation" do
-          person.administrated_events.should eq([ event ])
+          expect(person.administrated_events).to eq([ event ])
         end
 
         it "sets the inverse side of the relation" do
-          event.administrators(true).should eq([ person ])
+          expect(event.administrators(true)).to eq([ person ])
         end
 
         context "when reloading" do
 
           it "sets the front side of the relation" do
-            person.reload.administrated_events.should eq([ event ])
+            expect(person.reload.administrated_events).to eq([ event ])
           end
 
           it "sets the inverse side of the relation" do
-            event.reload.administrators.should eq([ person ])
+            expect(event.reload.administrators).to eq([ person ])
           end
         end
 
@@ -1603,11 +1591,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "sets the front side of the relation" do
-            loaded_person.administrated_events.should eq([ event ])
+            expect(loaded_person.administrated_events).to eq([ event ])
           end
 
           it "sets the inverse side of the relation" do
-            loaded_event.administrators.should eq([ person ])
+            expect(loaded_event.administrators).to eq([ person ])
           end
         end
       end
@@ -1631,7 +1619,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "creates a single artwork object" do
-          Artwork.count.should eq(1)
+          expect(Artwork.count).to eq(1)
         end
       end
 
@@ -1650,21 +1638,21 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "sets the front side of the relation" do
-          tag_one.related.should eq([ tag_two ])
+          expect(tag_one.related).to eq([ tag_two ])
         end
 
         it "sets the inverse side of the relation" do
-          tag_two.related(true).should eq([ tag_one ])
+          expect(tag_two.related(true)).to eq([ tag_one ])
         end
 
         context "when reloading" do
 
           it "sets the front side of the relation" do
-            tag_one.reload.related.should eq([ tag_two ])
+            expect(tag_one.reload.related).to eq([ tag_two ])
           end
 
           it "sets the inverse side of the relation" do
-            tag_two.reload.related.should eq([ tag_one ])
+            expect(tag_two.reload.related).to eq([ tag_one ])
           end
         end
 
@@ -1679,11 +1667,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "sets the front side of the relation" do
-            loaded_tag_one.related.should eq([ tag_two ])
+            expect(loaded_tag_one.related).to eq([ tag_two ])
           end
 
           it "sets the inverse side of the relation" do
-            loaded_tag_two.related.should eq([ tag_one ])
+            expect(loaded_tag_two.related).to eq([ tag_one ])
           end
         end
       end
@@ -1710,7 +1698,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
         it "returns zero" do
           sandwich.destroy
-          sandwich.meats.count.should eq(0)
+          expect(sandwich.meats.count).to eq(0)
         end
       end
     end
@@ -1722,7 +1710,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "returns the number of persisted documents" do
-        person.preferences.count.should eq(1)
+        expect(person.preferences.count).to eq(1)
       end
     end
 
@@ -1738,7 +1726,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "returns the number of persisted documents" do
-        person.preferences.count.should eq(2)
+        expect(person.preferences.count).to eq(2)
       end
     end
 
@@ -1749,7 +1737,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "returns 0" do
-        person.preferences.count.should eq(0)
+        expect(person.preferences.count).to eq(0)
       end
     end
 
@@ -1762,7 +1750,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns the count from the db" do
-          person.reload.preferences.count.should eq(1)
+          expect(person.reload.preferences.count).to eq(1)
         end
       end
 
@@ -1773,7 +1761,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns the count from the db" do
-          person.preferences.count.should eq(0)
+          expect(person.preferences.count).to eq(0)
         end
       end
     end
@@ -1787,7 +1775,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns the number of persisted documents" do
-          person.houses.count.should eq(1)
+          expect(person.houses.count).to eq(1)
         end
       end
 
@@ -1798,7 +1786,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns 0" do
-          person.preferences.count.should eq(0)
+          expect(person.preferences.count).to eq(0)
         end
       end
     end
@@ -1808,28 +1796,6 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
     describe "##{method}" do
 
-      context "when providing scoped mass assignment" do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:house) do
-          person.houses.send(
-            method,
-            { name: "Dream", model: "Home" }, as: :admin
-          )
-        end
-
-        it "sets the attributes for the provided role" do
-          house.name.should eq("Dream")
-        end
-
-        it "does not set the attributes for other roles" do
-          house.model.should be_nil
-        end
-      end
-
       context "when the relation is not polymorphic" do
 
         context "when using string keys" do
@@ -1843,7 +1809,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "does not convert the string key to an object id" do
-            agent.account_ids.should eq([ "testing-again" ])
+            expect(agent.account_ids).to eq([ "testing-again" ])
           end
         end
 
@@ -1871,39 +1837,39 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "sets the foreign key on the relation" do
-            person.preference_ids.should eq([ preference.id ])
+            expect(person.preference_ids).to eq([ preference.id ])
           end
 
           it "sets the foreign key on the inverse relation" do
-            preference.person_ids.should eq([ person.id ])
+            expect(preference.person_ids).to eq([ person.id ])
           end
 
           it "adds the document" do
-            person.preferences.should eq([ preference ])
+            expect(person.preferences).to eq([ preference ])
           end
 
           it "sets the base on the inverse relation" do
-            preference.people.should eq([ person ])
+            expect(preference.people).to eq([ person ])
           end
 
           it "sets the attributes" do
-            preference.name.should eq("Testing")
+            expect(preference.name).to eq("Testing")
           end
 
           it "saves the target" do
-            preference.should be_persisted
+            expect(preference).to be_persisted
           end
 
           it "adds the document to the target" do
-            person.preferences.count.should eq(1)
+            expect(person.preferences.count).to eq(1)
           end
 
           it "does not duplicate documents" do
-            person.reload.preferences.count.should eq(1)
+            expect(person.reload.preferences.count).to eq(1)
           end
 
           it "does not duplicate ids" do
-            person.reload.preference_ids.count.should eq(1)
+            expect(person.reload.preference_ids.count).to eq(1)
           end
         end
       end
@@ -1954,23 +1920,23 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "removes the document from the relation" do
-        person.preferences.should eq([ preference_two ])
+        expect(person.preferences).to eq([ preference_two ])
       end
 
       it "returns the document" do
-        deleted.should eq(preference_one)
+        expect(deleted).to eq(preference_one)
       end
 
       it "removes the document key from the foreign key" do
-        person.preference_ids.should eq([ preference_two.id ])
+        expect(person.preference_ids).to eq([ preference_two.id ])
       end
 
       it "removes the inverse reference" do
-        deleted.reload.people.should be_empty
+        expect(deleted.reload.people).to be_empty
       end
 
       it "removes the base id from the inverse keys" do
-        deleted.reload.person_ids.should be_empty
+        expect(deleted.reload.person_ids).to be_empty
       end
 
       context "and person and preferences are reloaded" do
@@ -1982,11 +1948,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "nullifies the deleted preference" do
-          person.preferences.should eq([ preference_two ])
+          expect(person.preferences).to eq([ preference_two ])
         end
 
         it "retains the ids for one preference" do
-          person.preference_ids.should eq([ preference_two.id ])
+          expect(person.preference_ids).to eq([ preference_two.id ])
         end
       end
     end
@@ -1998,15 +1964,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "returns nil" do
-        deleted.should be_nil
+        expect(deleted).to be_nil
       end
 
       it "does not modify the relation" do
-        person.preferences.should eq([ preference_one, preference_two ])
+        expect(person.preferences).to eq([ preference_one, preference_two ])
       end
 
       it "does not modify the keys" do
-        person.preference_ids.should eq([ preference_one.id, preference_two.id ])
+        expect(person.preference_ids).to eq([ preference_one.id, preference_two.id ])
       end
     end
 
@@ -2023,7 +1989,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "deletes the document" do
-          event.delete.should be_true
+          expect(event.delete).to be true
         end
       end
     end
@@ -2049,19 +2015,19 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "deletes the document from the relation" do
-          tag_one.related.should be_empty
+          expect(tag_one.related).to be_empty
         end
 
         it "deletes the foreign key from the relation" do
-          tag_one.related_ids.should be_empty
+          expect(tag_one.related_ids).to be_empty
         end
 
         it "removes the reference from the inverse" do
-          deleted.related.should be_empty
+          expect(deleted.related).to be_empty
         end
 
         it "removes the foreign keys from the inverse" do
-          deleted.related_ids.should be_empty
+          expect(deleted.related_ids).to be_empty
         end
       end
 
@@ -2078,19 +2044,19 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "deletes the document from the relation" do
-            reloaded.related.should be_empty
+            expect(reloaded.related).to be_empty
           end
 
           it "deletes the foreign key from the relation" do
-            reloaded.related_ids.should be_empty
+            expect(reloaded.related_ids).to be_empty
           end
 
           it "removes the reference from the inverse" do
-            deleted.related.should be_empty
+            expect(deleted.related).to be_empty
           end
 
           it "removes the foreign keys from the inverse" do
-            deleted.related_ids.should be_empty
+            expect(deleted.related_ids).to be_empty
           end
         end
 
@@ -2105,15 +2071,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "deletes the document from the relation" do
-            reloaded.related.should be_empty
+            expect(reloaded.related).to be_empty
           end
 
           it "deletes the foreign key from the relation" do
-            reloaded.related_ids.should be_empty
+            expect(reloaded.related_ids).to be_empty
           end
 
           it "removes the foreign keys from the inverse" do
-            deleted.related_ids.should be_empty
+            expect(deleted.related_ids).to be_empty
           end
         end
       end
@@ -2142,25 +2108,25 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "executes the callback" do
-            post.before_remove_called.should be_true
+            expect(post.before_remove_called).to be true
           end
 
           it "removes the document from the relation" do
-            post.tags.should be_empty
+            expect(post.tags).to be_empty
           end
         end
 
         context "when errors are raised" do
 
           before do
-            post.should_receive(:before_remove_tag).and_raise
+            expect(post).to receive(:before_remove_tag).and_raise
           end
 
           it "does not remove the document from the relation" do
             expect {
               post.tags.delete tag
             }.to raise_error
-            post.tags.should eq([ tag ])
+            expect(post.tags).to eq([ tag ])
           end
         end
       end
@@ -2174,25 +2140,25 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "executes the callback" do
-            post.after_remove_called.should be_true
+            expect(post.after_remove_called).to be true
           end
 
           it "removes the document from the relation" do
-            post.tags.should be_empty
+            expect(post.tags).to be_empty
           end
         end
 
         context "when errors are raised" do
 
           before do
-            post.should_receive(:after_remove_tag).and_raise
+            expect(post).to receive(:after_remove_tag).and_raise
           end
 
           it "removes the document from the relation" do
             expect {
               post.tags.delete(tag)
             }.to raise_error
-            post.tags.should be_empty
+            expect(post.tags).to be_empty
           end
         end
       end
@@ -2227,19 +2193,19 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "removes the correct preferences" do
-            person.preferences.count.should eq(1)
+            expect(person.preferences.count).to eq(1)
           end
 
           it "deletes the documents from the database" do
-            Preference.where(name: "Testing").count.should eq(0)
+            expect(Preference.where(name: "Testing").count).to eq(0)
           end
 
           it "returns the number of documents deleted" do
-            deleted.should eq(1)
+            expect(deleted).to eq(1)
           end
 
           it "removes the ids from the foreign key" do
-            person.preference_ids.should eq([ preference_two.id ])
+            expect(person.preference_ids).to eq([ preference_two.id ])
           end
         end
 
@@ -2257,67 +2223,25 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "removes the correct preferences" do
-            person.preferences.count.should eq(0)
+            expect(person.preferences.count).to eq(0)
           end
 
           it "deletes the documents from the database" do
-            Preference.count.should eq(0)
+            expect(Preference.count).to eq(0)
           end
 
           it "returns the number of documents deleted" do
-            deleted.should eq(2)
+            expect(deleted).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
-
-      let!(:person) do
-        Person.create
-      end
-
-      let!(:preference) do
-        person.preferences.create(name: "testing")
-      end
-
-      let(:metadata) do
-        Person.relations["preferences"]
-      end
-
-      let(:ids) do
-        [ preference.id ]
-      end
-
-      let!(:eager) do
-        described_class.eager_load(metadata, ids)
-      end
-
-      let(:map) do
-        Mongoid::IdentityMap.get(Preference, ids)
-      end
-
-      it "puts the documents in the identity map" do
-        map.should eq([ preference ])
-      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
 
@@ -2334,7 +2258,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "returns true" do
-        person.preferences.exists?.should be_true
+        expect(person.preferences.exists?).to be true
       end
     end
 
@@ -2345,7 +2269,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "returns false" do
-        person.preferences.exists?.should be_false
+        expect(person.preferences.exists?).to be false
       end
     end
   end
@@ -2383,7 +2307,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "returns the matching document" do
-            preference.should eq(preference_one)
+            expect(preference).to eq(preference_one)
           end
         end
 
@@ -2410,7 +2334,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
             it "raises an error" do
               expect {
-                person.preferences.find(Moped::BSON::ObjectId.new)
+                person.preferences.find(BSON::ObjectId.new)
               }.to raise_error(Mongoid::Errors::DocumentNotFound)
             end
           end
@@ -2418,7 +2342,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           context "when config set not to raise error" do
 
             let(:preference) do
-              person.preferences.find(Moped::BSON::ObjectId.new)
+              person.preferences.find(BSON::ObjectId.new)
             end
 
             before do
@@ -2430,7 +2354,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "returns nil" do
-              preference.should be_nil
+              expect(preference).to be_nil
             end
           end
         end
@@ -2445,7 +2369,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "returns the matching documents" do
-            preferences.should eq([ preference_one, preference_two ])
+            expect(preferences).to eq([ preference_one, preference_two ])
           end
         end
 
@@ -2474,7 +2398,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
             it "raises an error" do
               expect {
-                person.preferences.find([ Moped::BSON::ObjectId.new ])
+                person.preferences.find([ BSON::ObjectId.new ])
               }.to raise_error(Mongoid::Errors::DocumentNotFound)
             end
           end
@@ -2482,7 +2406,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           context "when config set not to raise error" do
 
             let(:preferences) do
-              person.preferences.find([ Moped::BSON::ObjectId.new ])
+              person.preferences.find([ BSON::ObjectId.new ])
             end
 
             before do
@@ -2494,7 +2418,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
             end
 
             it "returns an empty array" do
-              preferences.should be_empty
+              expect(preferences).to be_empty
             end
           end
         end
@@ -2521,7 +2445,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns the document" do
-          found.should eq(preference)
+          expect(found).to eq(preference)
         end
       end
 
@@ -2532,11 +2456,60 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "sets the new document attributes" do
-          found.name.should eq("Test")
+          expect(found.name).to eq("Test")
+        end
+
+        it "returns a newly persisted document" do
+          expect(found).to be_persisted
+        end
+      end
+    end
+  end
+
+  describe "#find_or_create_by!" do
+
+    context "when the relation is not polymorphic" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let!(:preference) do
+        person.preferences.create(name: "Testing")
+      end
+
+      context "when the document exists" do
+
+        let(:found) do
+          person.preferences.find_or_create_by!(name: "Testing")
+        end
+
+        it "returns the document" do
+          expect(found).to eq(preference)
+        end
+      end
+
+      context "when the document does not exist" do
+
+        let(:found) do
+          person.preferences.find_or_create_by!(name: "Test")
+        end
+
+        it "sets the new document attributes" do
+          expect(found.name).to eq("Test")
         end
 
         it "returns a newly persisted document" do
-          found.should be_persisted
+          expect(found).to be_persisted
+        end
+
+        context "when validation fails" do
+
+          it "raises an error" do
+            expect {
+              person.preferences.find_or_create_by!(name: "A")
+            }.to raise_error(Mongoid::Errors::Validations)
+          end
         end
       end
     end
@@ -2561,7 +2534,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns the document" do
-          found.should eq(preference)
+          expect(found).to eq(preference)
         end
       end
 
@@ -2572,11 +2545,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "sets the new document attributes" do
-          found.name.should eq("Test")
+          expect(found.name).to eq("Test")
         end
 
         it "returns a non persisted document" do
-          found.should_not be_persisted
+          expect(found).to_not be_persisted
         end
       end
     end
@@ -2585,14 +2558,14 @@ describe Mongoid::Relations::Referenced::ManyToMany do
   describe ".foreign_key_suffix" do
 
     it "returns _ids" do
-      described_class.foreign_key_suffix.should eq("_ids")
+      expect(described_class.foreign_key_suffix).to eq("_ids")
     end
   end
 
   describe ".macro" do
 
     it "returns has_and_belongs_to_many" do
-      described_class.macro.should eq(:has_and_belongs_to_many)
+      expect(described_class.macro).to eq(:has_and_belongs_to_many)
     end
   end
 
@@ -2621,7 +2594,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
 
     it "returns the document with the max value of the supplied field" do
-      max.should eq(preference_two)
+      expect(max).to eq(preference_two)
     end
   end
 
@@ -2648,7 +2621,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
 
     it "returns the document with the max value of the supplied field" do
-      max.should eq(preference_two)
+      expect(max).to eq(preference_two)
     end
   end
 
@@ -2677,7 +2650,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "applies the criteria to the documents" do
-        preferences.should eq([ preference_one ])
+        expect(preferences).to eq([ preference_one ])
       end
     end
 
@@ -2688,7 +2661,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "does not return unrelated documents" do
-        preferences.should be_empty
+        expect(preferences).to be_empty
       end
     end
 
@@ -2699,7 +2672,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "applies the criteria to the documents" do
-        preferences.should eq([ preference_one ])
+        expect(preferences).to eq([ preference_one ])
       end
     end
 
@@ -2710,7 +2683,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "applies the criteria to the documents" do
-        preferences.should eq([ preference_one ])
+        expect(preferences).to eq([ preference_one ])
       end
     end
 
@@ -2718,9 +2691,13 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
       describe "#distinct" do
 
+        let(:values) do
+          person.preferences.distinct(:name)
+        end
+
         it "returns the distinct values for the fields" do
-          person.preferences.distinct(:name).should =~
-            [ "First",  "Second"]
+          expect(values).to include("First")
+          expect(values).to include("Second")
         end
 
         context "when the inverse relation is not defined" do
@@ -2730,7 +2707,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
           end
 
           it "returns the distinct values for the fields" do
-            person.houses.distinct(:name).should eq([ house.name ])
+            expect(person.houses.distinct(:name)).to eq([ house.name ])
           end
         end
       end
@@ -2762,7 +2739,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
 
     it "returns the min value of the supplied field" do
-      min.should eq(preference_one)
+      expect(min).to eq(preference_one)
     end
   end
 
@@ -2789,14 +2766,14 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
 
     it "returns the min value of the supplied field" do
-      min.should eq(preference_one)
+      expect(min).to eq(preference_one)
     end
   end
 
   describe "#nil?" do
 
     it "returns false" do
-      Person.new.preferences.should_not be_nil
+      expect(Person.new.preferences).to_not be_nil
     end
   end
 
@@ -2820,30 +2797,30 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
     it "removes the foreign key from the base document" do
       [ preference_one, preference_two ].each do |preference|
-        person.preference_ids.should_not include(preference.id)
+        expect(person.preference_ids).to_not include(preference.id)
       end
     end
 
     it "removes the foreign key from the target documents" do
       [ preference_one, preference_two ].each do |preference|
-        preference.person_ids.should_not include(person.id)
+        expect(preference.person_ids).to_not include(person.id)
       end
     end
 
     it "removes the reference from the base document" do
       [ preference_one, preference_two ].each do |preference|
-        person.preferences.should_not include(preference)
+        expect(person.preferences).to_not include(preference)
       end
     end
 
     it "removes the reference from the target documents" do
       [ preference_one, preference_two ].each do |preference|
-        preference.people.should_not include(person)
+        expect(preference.people).to_not include(person)
       end
     end
 
     it "saves the documents" do
-      preference_one.reload.people.should_not include(person)
+      expect(preference_one.reload.people).to_not include(person)
     end
   end
 
@@ -2862,7 +2839,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       context "when checking #{method}" do
 
         it "returns true" do
-          preferences.respond_to?(method).should be_true
+          expect(preferences.respond_to?(method)).to be true
         end
       end
     end
@@ -2872,7 +2849,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       context "when checking #{method}" do
 
         it "returns true" do
-          preferences.respond_to?(method).should be_true
+          expect(preferences.respond_to?(method)).to be true
         end
       end
     end
@@ -2882,7 +2859,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       context "when checking #{method}" do
 
         it "returns true" do
-          preferences.respond_to?(method).should be_true
+          expect(preferences.respond_to?(method)).to be true
         end
       end
     end
@@ -2891,7 +2868,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
   describe ".stores_foreign_key?" do
 
     it "returns true" do
-      described_class.stores_foreign_key?.should be_true
+      expect(described_class.stores_foreign_key?).to be true
     end
   end
 
@@ -2906,11 +2883,11 @@ describe Mongoid::Relations::Referenced::ManyToMany 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({ "$and" => [{ "_id" => { "$in" => [] }}]})
+      expect(scoped.selector).to eq({ "$and" => [{ "_id" => { "$in" => [] }}]})
     end
   end
 
@@ -2929,7 +2906,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns the number of documents" do
-          person.preferences.send(method).should eq(1)
+          expect(person.preferences.send(method)).to eq(1)
         end
       end
 
@@ -2941,7 +2918,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "returns the total number of documents" do
-          person.preferences.send(method).should eq(2)
+          expect(person.preferences.send(method)).to eq(2)
         end
       end
     end
@@ -2968,7 +2945,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "returns only the associated documents" do
-        unscoped.should eq([ preference_one ])
+        expect(unscoped).to eq([ preference_one ])
       end
     end
 
@@ -2991,11 +2968,11 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "only returns associated documents" do
-        unscoped.should eq([ house_one ])
+        expect(unscoped).to eq([ house_one ])
       end
 
       it "removes the default scoping options" do
-        unscoped.options.should eq({})
+        expect(unscoped.options).to eq({})
       end
     end
   end
@@ -3003,7 +2980,7 @@ describe Mongoid::Relations::Referenced::ManyToMany 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,
@@ -3023,7 +3000,7 @@ describe Mongoid::Relations::Referenced::ManyToMany 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
 
@@ -3055,7 +3032,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     context "when reloading" do
 
       it "properly sets the references" do
-        person.houses(true).should eq([ girlfriend_house ])
+        expect(person.houses(true)).to eq([ girlfriend_house ])
       end
     end
   end
@@ -3077,15 +3054,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "sets the businesses" do
-        user.businesses.should eq([ business ])
+        expect(user.businesses).to eq([ business ])
       end
 
       it "sets the inverse users" do
-        user.businesses.first.owners.first.should eq(user)
+        expect(user.businesses.first.owners.first).to eq(user)
       end
 
       it "sets the inverse businesses" do
-        business.owners.should eq([ user ])
+        expect(business.owners).to eq([ user ])
       end
     end
 
@@ -3104,15 +3081,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "sets the businesses" do
-        user.businesses.should eq([ business ])
+        expect(user.businesses).to eq([ business ])
       end
 
       it "sets the inverse users" do
-        user.businesses.first.owners.first.should eq(user)
+        expect(user.businesses.first.owners.first).to eq(user)
       end
 
       it "sets the inverse businesses" do
-        business.owners.should eq([ user ])
+        expect(business.owners).to eq([ user ])
       end
 
       context "when reloading" do
@@ -3123,15 +3100,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "persists the businesses" do
-          user.businesses.should eq([ business ])
+          expect(user.businesses).to eq([ business ])
         end
 
         it "persists the inverse users" do
-          user.businesses.first.owners.first.should eq(user)
+          expect(user.businesses.first.owners.first).to eq(user)
         end
 
         it "persists the inverse businesses" do
-          business.owners.should eq([ user ])
+          expect(business.owners).to eq([ user ])
         end
       end
     end
@@ -3151,15 +3128,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "sets the businesses" do
-        user.businesses.should eq([ business ])
+        expect(user.businesses).to eq([ business ])
       end
 
       it "sets the inverse users" do
-        user.businesses.first.owners.first.should eq(user)
+        expect(user.businesses.first.owners.first).to eq(user)
       end
 
       it "sets the inverse businesses" do
-        business.owners.should eq([ user ])
+        expect(business.owners).to eq([ user ])
       end
 
       context "when reloading" do
@@ -3170,15 +3147,15 @@ describe Mongoid::Relations::Referenced::ManyToMany do
         end
 
         it "persists the businesses" do
-          user.businesses.should eq([ business ])
+          expect(user.businesses).to eq([ business ])
         end
 
         it "persists the inverse users" do
-          user.businesses.first.owners.first.should eq(user)
+          expect(user.businesses.first.owners.first).to eq(user)
         end
 
         it "persists the inverse businesses" do
-          business.owners.should eq([ user ])
+          expect(business.owners).to eq([ user ])
         end
       end
     end
@@ -3197,13 +3174,13 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     before do
       2.times do
         person.preferences.each do |preference|
-          preference.person_ids.should eq([ person.id ])
+          expect(preference.person_ids).to eq([ person.id ])
         end
       end
     end
 
     it "does not duplicate foreign keys" do
-      person.preference_ids.should eq([ preference.id ])
+      expect(person.preference_ids).to eq([ preference.id ])
     end
   end
 
@@ -3231,13 +3208,13 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
 
     it "orders the documents" do
-      person.ordered_preferences(true).should eq(
+      expect(person.ordered_preferences(true)).to eq(
         [preference_two, preference_three, preference_one]
       )
     end
 
     it "chains default criteria with additional" do
-      person.ordered_preferences.order_by(:name.desc).to_a.should eq(
+      expect(person.ordered_preferences.order_by(:name.desc).to_a).to eq(
         [preference_three, preference_two, preference_one]
       )
     end
@@ -3261,17 +3238,17 @@ describe Mongoid::Relations::Referenced::ManyToMany do
     end
 
     it "sets the relation to an empty array" do
-      person.preferences.should be_empty
+      expect(person.preferences).to be_empty
     end
 
     it "removes the foreign key values" do
-      person.preference_ids.should be_empty
+      expect(person.preference_ids).to be_empty
     end
 
     it "does not delete the target from the database" do
       expect {
         preference.reload
-      }.not_to raise_error(Mongoid::Errors::DocumentNotFound)
+      }.not_to raise_error
     end
   end
 
@@ -3305,7 +3282,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "reloads the document from the database" do
-        reloaded.first.name.should eq("reloaded")
+        expect(reloaded.first.name).to eq("reloaded")
       end
     end
 
@@ -3320,7 +3297,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "reloads the new document from the database" do
-        reloaded.should eq([ preference_one, preference_two ])
+        expect(reloaded).to eq([ preference_one, preference_two ])
       end
     end
   end
@@ -3342,19 +3319,19 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "persists the first preference" do
-        preference_one.should_not be_nil
+        expect(preference_one).to_not be_nil
       end
 
       it "sets the first inverse" do
-        preference_one.people.should eq([ person ])
+        expect(preference_one.people).to eq([ person ])
       end
 
       it "persists the second preference" do
-        preference_two.should_not be_nil
+        expect(preference_two).to_not be_nil
       end
 
       it "sets the second inverse keys" do
-        preference_two.people.should eq([ person ])
+        expect(preference_two.people).to eq([ person ])
       end
     end
   end
@@ -3390,7 +3367,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "persists the change in id order" do
-        reloaded.preference_ids.should eq(
+        expect(reloaded.preference_ids).to eq(
           [ preference_two.id, preference_one.id ]
         )
       end
@@ -3413,7 +3390,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "also persists the change in id order" do
-        reloaded.preference_ids.should eq(
+        expect(reloaded.preference_ids).to eq(
           [ preference_two.id, preference_one.id, preference_three.id ]
         )
       end
@@ -3439,7 +3416,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "also persists the change in id order" do
-        reloaded.preference_ids.should eq(
+        expect(reloaded.preference_ids).to eq(
           [ preference_three.id, preference_two.id ]
         )
       end
@@ -3471,7 +3448,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "adds both documents" do
-        result.should eq([ preference_one, preference_two ])
+        expect(result).to eq([ preference_one, preference_two ])
       end
     end
   end
@@ -3497,7 +3474,7 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
 
       it "sets the new documents on the relation" do
-        person.preferences.should eq([ pref_two ])
+        expect(person.preferences).to eq([ pref_two ])
       end
     end
   end