mongoid 3.1.6 → 4.0.2

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

@@ -21,35 +21,35 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "appends to the target" do
-          person.addresses.should eq([ address ])
+          expect(person.addresses).to eq([ address ])
         end
 
         it "sets the base on the inverse relation" do
-          address.addressable.should eq(person)
+          expect(address.addressable).to eq(person)
         end
 
         it "sets the same instance on the inverse relation" do
-          address.addressable.should eql(person)
+          expect(address.addressable).to eql(person)
         end
 
         it "does not save the new document" do
-          address.should_not be_persisted
+          expect(address).to_not be_persisted
         end
 
         it "sets the parent on the child" do
-          address._parent.should eq(person)
+          expect(address._parent).to eq(person)
         end
 
         it "sets the metadata on the child" do
-          address.metadata.should_not be_nil
+          expect(address.__metadata).to_not be_nil
         end
 
         it "sets the index on the child" do
-          address._index.should eq(0)
+          expect(address._index).to eq(0)
         end
 
         it "returns the relation" do
-          added.should eq(person.addresses)
+          expect(added).to eq(person.addresses)
         end
 
         context "with a limiting default scope" do
@@ -65,11 +65,11 @@ describe Mongoid::Relations::Embedded::Many do
             end
 
             it "appends to the target" do
-              person.appointments.target.should eq([ active ])
+              expect(person.appointments.target).to eq([ active ])
             end
 
             it "appends to the _unscoped" do
-              person.appointments.send(:_unscoped).should eq([ active ])
+              expect(person.appointments.send(:_unscoped)).to eq([ active ])
             end
           end
 
@@ -84,11 +84,11 @@ describe Mongoid::Relations::Embedded::Many do
             end
 
             it "doesn't append to the target" do
-              person.appointments.target.should_not eq([ inactive ])
+              expect(person.appointments.target).to_not eq([ inactive ])
             end
 
             it "appends to the _unscoped" do
-              person.appointments.send(:_unscoped).should eq([ inactive ])
+              expect(person.appointments.send(:_unscoped)).to eq([ inactive ])
             end
           end
         end
@@ -109,7 +109,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "saves the new document" do
-          address.should be_persisted
+          expect(address).to be_persisted
         end
       end
 
@@ -132,15 +132,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "saves the first document" do
-          address_one.should be_persisted
+          expect(address_one).to be_persisted
         end
 
         it "saves the second document" do
-          address_two.should be_persisted
+          expect(address_two).to be_persisted
         end
 
         it "returns the relation" do
-          added.should eq(person.addresses)
+          expect(added).to eq(person.addresses)
         end
       end
 
@@ -161,31 +161,31 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "appends to the target" do
-            parent_role.child_roles.should eq([ child_role ])
+            expect(parent_role.child_roles).to eq([ child_role ])
           end
 
           it "sets the base on the inverse relation" do
-            child_role.parent_role.should eq(parent_role)
+            expect(child_role.parent_role).to eq(parent_role)
           end
 
           it "sets the same instance on the inverse relation" do
-            child_role.parent_role.should eql(parent_role)
+            expect(child_role.parent_role).to eql(parent_role)
           end
 
           it "does not save the new document" do
-            child_role.should_not be_persisted
+            expect(child_role).to_not be_persisted
           end
 
           it "sets the parent on the child" do
-            child_role._parent.should eq(parent_role)
+            expect(child_role._parent).to eq(parent_role)
           end
 
           it "sets the metadata on the child" do
-            child_role.metadata.should_not be_nil
+            expect(child_role.__metadata).to_not be_nil
           end
 
           it "sets the index on the child" do
-            child_role._index.should eq(0)
+            expect(child_role._index).to eq(0)
           end
         end
 
@@ -204,7 +204,38 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "saves the new document" do
-            child_role.should be_persisted
+            expect(child_role).to be_persisted
+          end
+        end
+      end
+
+      context "when the child has one sided many to many relation" do
+        let(:person) do
+          Person.create
+        end
+
+        let(:message) do
+          Message.new
+        end
+
+        context "assign parent first" do
+          before do
+            message.person = person
+            message.receviers.send(method, person)
+          end
+
+          it "appends to the relation array" do
+            expect(message.receviers).to include(person)
+          end
+        end
+
+        context "not assign parent" do
+          before do
+            message.receviers.send(method, person)
+          end
+
+          it "appends to the relation array" do
+            expect(message.receviers).to include(person)
           end
         end
       end
@@ -228,35 +259,35 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "sets the target of the relation" do
-        person.addresses.should eq([ address ])
+        expect(person.addresses).to eq([ address ])
       end
 
       it "sets the _unscoped of the relation" do
-        person.addresses.send(:_unscoped).should eq([ address ])
+        expect(person.addresses.send(:_unscoped)).to eq([ address ])
       end
 
       it "sets the base on the inverse relation" do
-        address.addressable.should eq(person)
+        expect(address.addressable).to eq(person)
       end
 
       it "sets the same instance on the inverse relation" do
-        address.addressable.should eql(person)
+        expect(address.addressable).to eql(person)
       end
 
       it "does not save the target" do
-        address.should_not be_persisted
+        expect(address).to_not be_persisted
       end
 
       it "sets the parent on the child" do
-        address._parent.should eq(person)
+        expect(address._parent).to eq(person)
       end
 
       it "sets the metadata on the child" do
-        address.metadata.should_not be_nil
+        expect(address.__metadata).to_not be_nil
       end
 
       it "sets the index on the child" do
-        address._index.should eq(0)
+        expect(address._index).to eq(0)
       end
     end
 
@@ -277,7 +308,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "saves the target" do
-          address.should be_persisted
+          expect(address).to be_persisted
         end
       end
 
@@ -300,7 +331,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "overwrites the existing addresses" do
-          person.reload.addresses.should eq([ new_address ])
+          expect(person.reload.addresses).to eq([ new_address ])
         end
       end
 
@@ -311,11 +342,11 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the relation" do
-          person.addresses.should eq([ address ])
+          expect(person.addresses).to eq([ address ])
         end
 
         it "does not save the target" do
-          address.should_not be_persisted
+          expect(address).to_not be_persisted
         end
 
         context "when setting the relation multiple times" do
@@ -330,11 +361,11 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "sets the new documents" do
-            person.addresses.should eq([ address_two ])
+            expect(person.addresses).to eq([ address_two ])
           end
 
           it "persits only the new documents" do
-            person.reload.addresses.should eq([ address_two ])
+            expect(person.reload.addresses).to eq([ address_two ])
           end
         end
       end
@@ -364,11 +395,11 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "sets the documents" do
-            doctor.addresses.should eq([ address_one ])
+            expect(doctor.addresses).to eq([ address_one ])
           end
 
           it "persists the document" do
-            doctor.reload.addresses.should eq([ address_one ])
+            expect(doctor.reload.addresses).to eq([ address_one ])
           end
 
           context "when setting the relation multiple times" do
@@ -383,11 +414,11 @@ describe Mongoid::Relations::Embedded::Many do
             end
 
             it "sets the new documents" do
-              doctor.addresses.should eq([ address_two ])
+              expect(doctor.addresses).to eq([ address_two ])
             end
 
             it "persits only the new documents" do
-              doctor.reload.addresses.should eq([ address_two ])
+              expect(doctor.reload.addresses).to eq([ address_two ])
             end
           end
         end
@@ -412,7 +443,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "deletes the old documents" do
-        person.reload.addresses.should eq([ address ])
+        expect(person.reload.addresses).to eq([ address ])
       end
     end
 
@@ -434,7 +465,6 @@ describe Mongoid::Relations::Embedded::Many do
             field :old_state, type: String
             field :new_state, type: String
             field :when_changed, type: DateTime
-            attr_protected :_id
             embedded_in :tracking_id, class_name: "MyCompany::Model::TrackingId"
           end
         end
@@ -453,15 +483,15 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "allows creation of the embedded document" do
-        tracking_id.validation_history.size.should eq(1)
+        expect(tracking_id.validation_history.size).to eq(1)
       end
 
       it "saves the relation" do
-        history.should be_persisted
+        expect(history).to be_persisted
       end
 
       it "remains on reload" do
-        tracking_id.reload.validation_history.size.should eq(1)
+        expect(tracking_id.reload.validation_history.size).to eq(1)
       end
     end
 
@@ -480,7 +510,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "requires an inflection to determine the class" do
-        slave.reload.address_numbers.size.should eq(1)
+        expect(slave.reload.address_numbers.size).to eq(1)
       end
     end
 
@@ -510,11 +540,11 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the new attributes" do
-          person.addresses.first.city.should eq("Berlin")
+          expect(person.addresses.first.city).to eq("Berlin")
         end
 
         it "persists the changes" do
-          person.reload.addresses.first.city.should eq("Berlin")
+          expect(person.reload.addresses.first.city).to eq("Berlin")
         end
       end
     end
@@ -546,23 +576,23 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the new attributes on the address" do
-          person.addresses.first.city.should eq("Berlin")
+          expect(person.addresses.first.city).to eq("Berlin")
         end
 
         it "sets the new attributes on the location" do
-          person.addresses.first.locations.first.name.should eq("Home")
+          expect(person.addresses.first.locations.first.name).to eq("Home")
         end
 
         it "persists the changes to the address" do
-          person.reload.addresses.first.city.should eq("Berlin")
+          expect(person.reload.addresses.first.city).to eq("Berlin")
         end
 
         it "persists the changes to the location" do
-          person.reload.addresses.first.locations.first.name.should eq("Home")
+          expect(person.reload.addresses.first.locations.first.name).to eq("Home")
         end
 
         it "does not persist the locations collection to the person document" do
-          person.reload[:locations].should be_nil
+          expect(person.reload[:locations]).to be_nil
         end
       end
     end
@@ -584,31 +614,31 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the target of the relation" do
-          parent_role.child_roles.should eq([ child_role ])
+          expect(parent_role.child_roles).to eq([ child_role ])
         end
 
         it "sets the base on the inverse relation" do
-          child_role.parent_role.should eq(parent_role)
+          expect(child_role.parent_role).to eq(parent_role)
         end
 
         it "sets the same instance on the inverse relation" do
-          child_role.parent_role.should eql(parent_role)
+          expect(child_role.parent_role).to eql(parent_role)
         end
 
         it "does not save the target" do
-          child_role.should_not be_persisted
+          expect(child_role).to_not be_persisted
         end
 
         it "sets the parent on the child" do
-          child_role._parent.should eq(parent_role)
+          expect(child_role._parent).to eq(parent_role)
         end
 
         it "sets the metadata on the child" do
-          child_role.metadata.should_not be_nil
+          expect(child_role.__metadata).to_not be_nil
         end
 
         it "sets the index on the child" do
-          child_role._index.should eq(0)
+          expect(child_role._index).to eq(0)
         end
       end
 
@@ -627,7 +657,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "saves the target" do
-          child_role.should be_persisted
+          expect(child_role).to be_persisted
         end
       end
     end
@@ -653,15 +683,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the relation to empty" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
 
         it "sets the unscoped to empty" do
-          person.addresses.send(:_unscoped).should be_empty
+          expect(person.addresses.send(:_unscoped)).to be_empty
         end
 
         it "removes the inverse relation" do
-          address.addressable.should be_nil
+          expect(address.addressable).to be_nil
         end
       end
 
@@ -676,7 +706,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the relation to empty" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
       end
 
@@ -698,19 +728,19 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "sets the relation to empty" do
-            person.addresses.should be_empty
+            expect(person.addresses).to be_empty
           end
 
           it "sets the relation to empty in the database" do
-            person.reload.addresses.should be_empty
+            expect(person.reload.addresses).to be_empty
           end
 
           it "removed the inverse relation" do
-            address.addressable.should be_nil
+            expect(address.addressable).to be_nil
           end
 
           it "deletes the child document" do
-            address.should be_destroyed
+            expect(address).to be_destroyed
           end
         end
 
@@ -722,11 +752,11 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "sets the relation to empty" do
-            person.addresses.should be_empty
+            expect(person.addresses).to be_empty
           end
 
           it "deletes the child document" do
-            address.should be_destroyed
+            expect(address).to be_destroyed
           end
 
           context "when saving the parent" do
@@ -737,7 +767,7 @@ describe Mongoid::Relations::Embedded::Many do
             end
 
             it "persists the deletion" do
-              person.addresses.should be_empty
+              expect(person.addresses).to be_empty
             end
           end
         end
@@ -763,11 +793,11 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the relation to empty" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
 
         it "sets the relation to empty in the database" do
-          reloaded.addresses.should be_empty
+          expect(reloaded.addresses).to be_empty
         end
       end
     end
@@ -790,11 +820,11 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the relation to empty" do
-          parent_role.child_roles.should be_empty
+          expect(parent_role.child_roles).to be_empty
         end
 
         it "removes the inverse relation" do
-          child_role.parent_role.should be_nil
+          expect(child_role.parent_role).to be_nil
         end
       end
 
@@ -809,7 +839,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the relation to empty" do
-          parent_role.child_roles.should be_empty
+          expect(parent_role.child_roles).to be_empty
         end
       end
 
@@ -829,15 +859,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets the relation to empty" do
-          parent_role.child_roles.should be_empty
+          expect(parent_role.child_roles).to be_empty
         end
 
         it "removed the inverse relation" do
-          child_role.parent_role.should be_nil
+          expect(child_role.parent_role).to be_nil
         end
 
         it "deletes the child document" do
-          child_role.should be_destroyed
+          expect(child_role).to be_destroyed
         end
       end
     end
@@ -860,7 +890,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "returns the documents as an array of hashes" do
-        document.should eq([ address.as_document ])
+        expect(document).to eq([ address.as_document ])
       end
     end
 
@@ -885,7 +915,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "returns the unscoped documents as an array of hashes" do
-          document.should eq([ headache.as_document, cough.as_document ])
+          expect(document).to eq([ headache.as_document, cough.as_document ])
         end
       end
 
@@ -908,7 +938,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "returns the unscoped documents as an array of hashes" do
-          document.should eq([ active.as_document, inactive.as_document ])
+          expect(document).to eq([ active.as_document, inactive.as_document ])
         end
       end
     end
@@ -918,28 +948,6 @@ describe Mongoid::Relations::Embedded::Many do
 
     describe "#build" do
 
-      context "when providing scoped mass assignment" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:video) do
-          person.videos.send(
-            method,
-            { title: "Inception", year: 1999 }, as: :admin
-          )
-        end
-
-        it "sets the attributes for the provided role" do
-          video.title.should eq("Inception")
-        end
-
-        it "does not set the attributes for other roles" do
-          video.year.should be_nil
-        end
-      end
-
       context "when the relation is not cyclic" do
 
         let(:person) do
@@ -953,39 +961,39 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "appends to the target" do
-          person.addresses.should eq([ address ])
+          expect(person.addresses).to eq([ address ])
         end
 
         it "appends to the unscoped" do
-          person.addresses.send(:_unscoped).should eq([ address ])
+          expect(person.addresses.send(:_unscoped)).to eq([ address ])
         end
 
         it "sets the base on the inverse relation" do
-          address.addressable.should eq(person)
+          expect(address.addressable).to eq(person)
         end
 
         it "does not save the new document" do
-          address.should_not be_persisted
+          expect(address).to_not be_persisted
         end
 
         it "sets the parent on the child" do
-          address._parent.should eq(person)
+          expect(address._parent).to eq(person)
         end
 
         it "sets the metadata on the child" do
-          address.metadata.should_not be_nil
+          expect(address.__metadata).to_not be_nil
         end
 
         it "sets the index on the child" do
-          address._index.should eq(0)
+          expect(address._index).to eq(0)
         end
 
         it "writes to the attributes" do
-          address.street.should eq("Bond")
+          expect(address.street).to eq("Bond")
         end
 
         it "calls the passed block" do
-          address.state.should eq("CA")
+          expect(address.state).to eq("CA")
         end
       end
 
@@ -1000,31 +1008,31 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "appends to the target" do
-          parent_role.child_roles.should eq([ child_role ])
+          expect(parent_role.child_roles).to eq([ child_role ])
         end
 
         it "sets the base on the inverse relation" do
-          child_role.parent_role.should eq(parent_role)
+          expect(child_role.parent_role).to eq(parent_role)
         end
 
         it "does not save the new document" do
-          child_role.should_not be_persisted
+          expect(child_role).to_not be_persisted
         end
 
         it "sets the parent on the child" do
-          child_role._parent.should eq(parent_role)
+          expect(child_role._parent).to eq(parent_role)
         end
 
         it "sets the metadata on the child" do
-          child_role.metadata.should_not be_nil
+          expect(child_role.__metadata).to_not be_nil
         end
 
         it "sets the index on the child" do
-          child_role._index.should eq(0)
+          expect(child_role._index).to eq(0)
         end
 
         it "writes to the attributes" do
-          child_role.name.should eq("CTO")
+          expect(child_role.name).to eq("CTO")
         end
       end
 
@@ -1053,7 +1061,7 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "persists the deeply embedded document" do
-            location.name.should eq("Home")
+            expect(location.name).to eq("Home")
           end
         end
       end
@@ -1083,8 +1091,9 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "returns the many builder" do
-      described_class.builder(base, metadata, document).should
-        be_a(Mongoid::Relations::Builders::Embedded::Many)
+      expect(
+        described_class.builder(base, metadata, document)
+      ).to be_a(Mongoid::Relations::Builders::Embedded::Many)
     end
   end
 
@@ -1107,23 +1116,23 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "clears out the relation" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
 
         it "clears the unscoped" do
-          person.addresses.send(:_unscoped).should be_empty
+          expect(person.addresses.send(:_unscoped)).to be_empty
         end
 
         it "marks the documents as deleted" do
-          address.should be_destroyed
+          expect(address).to be_destroyed
         end
 
         it "deletes the documents from the db" do
-          person.reload.addresses.should be_empty
+          expect(person.reload.addresses).to be_empty
         end
 
         it "returns the relation" do
-          relation.should be_empty
+          expect(relation).to be_empty
         end
       end
 
@@ -1138,7 +1147,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "clears out the relation" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
       end
     end
@@ -1158,7 +1167,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "clears out the relation" do
-        person.addresses.should be_empty
+        expect(person.addresses).to be_empty
       end
     end
   end
@@ -1180,35 +1189,35 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "appends to the target" do
-        person.addresses.should eq([ address ])
+        expect(person.addresses).to eq([ address ])
       end
 
       it "appends to the unscoped" do
-        person.addresses.send(:_unscoped).should eq([ address ])
+        expect(person.addresses.send(:_unscoped)).to eq([ address ])
       end
 
       it "sets the base on the inverse relation" do
-        address.addressable.should eq(person)
+        expect(address.addressable).to eq(person)
       end
 
       it "sets the same instance on the inverse relation" do
-        address.addressable.should eql(person)
+        expect(address.addressable).to eql(person)
       end
 
       it "does not save the new document" do
-        address.should_not be_persisted
+        expect(address).to_not be_persisted
       end
 
       it "sets the parent on the child" do
-        address._parent.should eq(person)
+        expect(address._parent).to eq(person)
       end
 
       it "sets the metadata on the child" do
-        address.metadata.should_not be_nil
+        expect(address.__metadata).to_not be_nil
       end
 
       it "sets the index on the child" do
-        address._index.should eq(0)
+        expect(address._index).to eq(0)
       end
     end
 
@@ -1227,7 +1236,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "saves the new document" do
-        address.should be_persisted
+        expect(address).to be_persisted
       end
     end
 
@@ -1238,12 +1247,12 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       before do
-        person.addresses.should_not_receive(:batch_insert)
+        expect(person.addresses).to_not receive(:batch_insert)
         person.addresses.concat([])
       end
 
       it "doesn't update the target" do
-        person.addresses.should be_empty
+        expect(person.addresses).to be_empty
       end
     end
 
@@ -1266,11 +1275,11 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "saves the first document" do
-        address_one.should be_persisted
+        expect(address_one).to be_persisted
       end
 
       it "saves the second document" do
-        address_two.should be_persisted
+        expect(address_two).to be_persisted
       end
     end
 
@@ -1291,31 +1300,31 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "appends to the target" do
-          parent_role.child_roles.should eq([ child_role ])
+          expect(parent_role.child_roles).to eq([ child_role ])
         end
 
         it "sets the base on the inverse relation" do
-          child_role.parent_role.should eq(parent_role)
+          expect(child_role.parent_role).to eq(parent_role)
         end
 
         it "sets the same instance on the inverse relation" do
-          child_role.parent_role.should eql(parent_role)
+          expect(child_role.parent_role).to eql(parent_role)
         end
 
         it "does not save the new document" do
-          child_role.should_not be_persisted
+          expect(child_role).to_not be_persisted
         end
 
         it "sets the parent on the child" do
-          child_role._parent.should eq(parent_role)
+          expect(child_role._parent).to eq(parent_role)
         end
 
         it "sets the metadata on the child" do
-          child_role.metadata.should_not be_nil
+          expect(child_role.__metadata).to_not be_nil
         end
 
         it "sets the index on the child" do
-          child_role._index.should eq(0)
+          expect(child_role._index).to eq(0)
         end
       end
 
@@ -1334,7 +1343,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "saves the new document" do
-          child_role.should be_persisted
+          expect(child_role).to be_persisted
         end
       end
     end
@@ -1352,30 +1361,36 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "returns the number of persisted documents" do
-      person.addresses.count.should eq(1)
+      expect(person.addresses.count).to eq(1)
     end
   end
 
   describe "#create" do
 
-    context "when providing scoped mass assignment" do
+    context "when providing multiple attributes" do
 
       let(:person) do
         Person.create
       end
 
-      let(:video) do
-        person.videos.create(
-          { title: "Inception", year: 1999 }, as: :admin
-        )
+      let!(:addresses) do
+        person.addresses.create([{ street: "Bond" }, { street: "Upper" }])
+      end
+
+      it "creates multiple documents" do
+        expect(addresses.size).to eq(2)
       end
 
-      it "sets the attributes for the provided role" do
-        video.title.should eq("Inception")
+      it "sets the first attributes" do
+        expect(addresses.first.street).to eq("Bond")
       end
 
-      it "does not set the attributes for other roles" do
-        video.year.should be_nil
+      it "sets the second attributes" do
+        expect(addresses.last.street).to eq("Upper")
+      end
+
+      it "persists the children" do
+        expect(person.addresses.count).to eq(2)
       end
     end
 
@@ -1392,39 +1407,39 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "appends to the target" do
-        person.reload.addresses.should eq([ address ])
+        expect(person.reload.addresses).to eq([ address ])
       end
 
       it "appends to the unscoped" do
-        person.reload.addresses.send(:_unscoped).should eq([ address ])
+        expect(person.reload.addresses.send(:_unscoped)).to eq([ address ])
       end
 
       it "sets the base on the inverse relation" do
-        address.addressable.should eq(person)
+        expect(address.addressable).to eq(person)
       end
 
       it "saves the document" do
-        address.should be_persisted
+        expect(address).to be_persisted
       end
 
       it "sets the parent on the child" do
-        address._parent.should eq(person)
+        expect(address._parent).to eq(person)
       end
 
       it "sets the metadata on the child" do
-        address.metadata.should_not be_nil
+        expect(address.__metadata).to_not be_nil
       end
 
       it "sets the index on the child" do
-        address._index.should eq(0)
+        expect(address._index).to eq(0)
       end
 
       it "writes to the attributes" do
-        address.street.should eq("Bond")
+        expect(address.street).to eq("Bond")
       end
 
       it "calls the passed block" do
-        address.state.should eq("CA")
+        expect(address.state).to eq("CA")
       end
 
       context "when embedding a multi word named document" do
@@ -1434,7 +1449,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "saves the embedded document" do
-          person.reload.address_components.first.should eq(component)
+          expect(person.reload.address_components.first).to eq(component)
         end
       end
     end
@@ -1450,7 +1465,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "creates a new child" do
-        child_entry.should be_persisted
+        expect(child_entry).to be_persisted
       end
     end
   end
@@ -1461,20 +1476,26 @@ describe Mongoid::Relations::Embedded::Many do
       Person.create
     end
 
-    context "when providing scoped mass assignment" do
+    context "when providing multiple attributes" do
 
-      let(:video) do
-        person.videos.create!(
-          { title: "Inception", year: 1999 }, as: :admin
-        )
+      let!(:addresses) do
+        person.addresses.create!([{ street: "Bond" }, { street: "Upper" }])
       end
 
-      it "sets the attributes for the provided role" do
-        video.title.should eq("Inception")
+      it "creates multiple documents" do
+        expect(addresses.size).to eq(2)
       end
 
-      it "does not set the attributes for other roles" do
-        video.year.should be_nil
+      it "sets the first attributes" do
+        expect(addresses.first.street).to eq("Bond")
+      end
+
+      it "sets the second attributes" do
+        expect(addresses.last.street).to eq("Upper")
+      end
+
+      it "persists the children" do
+        expect(person.addresses.count).to eq(2)
       end
     end
 
@@ -1485,35 +1506,35 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "appends to the target" do
-        person.addresses.should eq([ address ])
+        expect(person.addresses).to eq([ address ])
       end
 
       it "appends to the unscoped" do
-        person.addresses.send(:_unscoped).should eq([ address ])
+        expect(person.addresses.send(:_unscoped)).to eq([ address ])
       end
 
       it "sets the base on the inverse relation" do
-        address.addressable.should eq(person)
+        expect(address.addressable).to eq(person)
       end
 
       it "saves the document" do
-        address.should be_persisted
+        expect(address).to be_persisted
       end
 
       it "sets the parent on the child" do
-        address._parent.should eq(person)
+        expect(address._parent).to eq(person)
       end
 
       it "sets the metadata on the child" do
-        address.metadata.should_not be_nil
+        expect(address.__metadata).to_not be_nil
       end
 
       it "sets the index on the child" do
-        address._index.should eq(0)
+        expect(address._index).to eq(0)
       end
 
       it "writes to the attributes" do
-        address.street.should eq("Bond")
+        expect(address.street).to eq("Bond")
       end
     end
 
@@ -1552,26 +1573,26 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "deletes the document" do
-        person.addresses.should eq([ address_two ])
+        expect(person.addresses).to eq([ address_two ])
       end
 
       it "deletes the document from the unscoped" do
-        person.addresses.send(:_unscoped).should eq([ address_two ])
+        expect(person.addresses.send(:_unscoped)).to eq([ address_two ])
       end
 
       it "reindexes the relation" do
-        address_two._index.should eq(0)
+        expect(address_two._index).to eq(0)
       end
 
       it "returns the document" do
-        deleted.should eq(address_one)
+        expect(deleted).to eq(address_one)
       end
     end
 
     context "when the document does not exist" do
 
       it "returns nil" do
-        person.addresses.delete(Address.new).should be_nil
+        expect(person.addresses.delete(Address.new)).to be_nil
       end
     end
   end
@@ -1601,15 +1622,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "removes the matching documents" do
-          person.addresses.size.should eq(1)
+          expect(person.addresses.size).to eq(1)
         end
 
         it "removes from the unscoped" do
-          person.addresses.send(:_unscoped).size.should eq(1)
+          expect(person.addresses.send(:_unscoped).size).to eq(1)
         end
 
         it "returns the relation" do
-          deleted.should eq(person.addresses)
+          expect(deleted).to eq(person.addresses)
         end
       end
 
@@ -1620,7 +1641,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "returns an enumerator" do
-          deleted.should be_a(Enumerator)
+          expect(deleted).to be_a(Enumerator)
         end
       end
     end
@@ -1644,15 +1665,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "deletes the matching documents" do
-          person.addresses.count.should eq(1)
+          expect(person.addresses.count).to eq(1)
         end
 
         it "deletes the matching documents from the db" do
-          person.reload.addresses.count.should eq(1)
+          expect(person.reload.addresses.count).to eq(1)
         end
 
         it "returns the relation" do
-          deleted.should eq(person.addresses)
+          expect(deleted).to eq(person.addresses)
         end
       end
     end
@@ -1668,15 +1689,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "deletes the matching documents" do
-          person.addresses.count.should eq(0)
+          expect(person.addresses.count).to eq(0)
         end
 
         it "deletes all the documents from the db" do
-          person.reload.addresses.count.should eq(0)
+          expect(person.reload.addresses.count).to eq(0)
         end
 
         it "returns the relation" do
-          deleted.should eq(person.addresses)
+          expect(deleted).to eq(person.addresses)
         end
       end
     end
@@ -1710,15 +1731,15 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "removes the matching documents" do
-            person.addresses.size.should eq(1)
+            expect(person.addresses.size).to eq(1)
           end
 
           it "removes from the unscoped" do
-            person.addresses.send(:_unscoped).size.should eq(1)
+            expect(person.addresses.send(:_unscoped).size).to eq(1)
           end
 
           it "returns the number deleted" do
-            deleted.should eq(1)
+            expect(deleted).to eq(1)
           end
         end
 
@@ -1729,11 +1750,11 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "removes all documents" do
-            person.addresses.size.should eq(0)
+            expect(person.addresses.size).to eq(0)
           end
 
           it "returns the number deleted" do
-            deleted.should eq(2)
+            expect(deleted).to eq(2)
           end
         end
       end
@@ -1758,15 +1779,15 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "deletes the matching documents" do
-            person.addresses.count.should eq(1)
+            expect(person.addresses.count).to eq(1)
           end
 
           it "deletes the matching documents from the db" do
-            person.reload.addresses.count.should eq(1)
+            expect(person.reload.addresses.count).to eq(1)
           end
 
           it "returns the number deleted" do
-            deleted.should eq(1)
+            expect(deleted).to eq(1)
           end
         end
 
@@ -1777,15 +1798,15 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "deletes all the documents" do
-            person.addresses.count.should eq(0)
+            expect(person.addresses.count).to eq(0)
           end
 
           it "deletes all the documents from the db" do
-            person.reload.addresses.count.should eq(0)
+            expect(person.reload.addresses.count).to eq(0)
           end
 
           it "returns the number deleted" do
-            deleted.should eq(2)
+            expect(deleted).to eq(2)
           end
         end
 
@@ -1803,13 +1824,13 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "removes the documents" do
-            owner.pet.vet_visits.should be_empty
+            expect(owner.pet.vet_visits).to be_empty
           end
 
           it "allows addition and a resave" do
             owner.pet.vet_visits << VetVisit.new(date: Date.today)
             owner.save!
-            owner.pet.vet_visits.first.should be_persisted
+            expect(owner.pet.vet_visits.first).to be_persisted
           end
         end
       end
@@ -1822,15 +1843,15 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "deletes all the documents" do
-            person.addresses.count.should eq(0)
+            expect(person.addresses.count).to eq(0)
           end
 
           it "deletes all the documents from the db" do
-            person.reload.addresses.count.should eq(0)
+            expect(person.reload.addresses.count).to eq(0)
           end
 
           it "returns the number deleted" do
-            deleted.should eq(0)
+            expect(deleted).to eq(0)
           end
         end
 
@@ -1844,15 +1865,15 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "deletes all the documents" do
-            person.addresses.count.should eq(0)
+            expect(person.addresses.count).to eq(0)
           end
 
           it "deletes all the documents from the db" do
-            person.reload.addresses.count.should eq(0)
+            expect(person.reload.addresses.count).to eq(0)
           end
 
           it "returns the number deleted" do
-            deleted.should eq(0)
+            expect(deleted).to eq(0)
           end
         end
 
@@ -1863,15 +1884,15 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "deletes all the documents" do
-            person.addresses.count.should eq(0)
+            expect(person.addresses.count).to eq(0)
           end
 
           it "deletes all the documents from the db" do
-            person.reload.addresses.count.should eq(0)
+            expect(person.reload.addresses.count).to eq(0)
           end
 
           it "returns the number deleted" do
-            deleted.should eq(0)
+            expect(deleted).to eq(0)
           end
         end
       end
@@ -1881,14 +1902,14 @@ describe Mongoid::Relations::Embedded::Many do
   describe ".embedded?" do
 
     it "returns true" do
-      described_class.should be_embedded
+      expect(described_class).to be_embedded
     end
   end
 
   describe ".foreign_key_suffix" do
 
     it "returns nil" do
-      described_class.foreign_key_suffix.should be_nil
+      expect(described_class.foreign_key_suffix).to be_nil
     end
   end
 
@@ -1905,7 +1926,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "returns true" do
-        person.addresses.exists?.should be_true
+        expect(person.addresses.exists?).to be true
       end
     end
 
@@ -1916,7 +1937,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "returns false" do
-        person.addresses.exists?.should be_false
+        expect(person.addresses.exists?).to be false
       end
     end
   end
@@ -1944,7 +1965,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "returns the matching document" do
-          address.should eq(address_one)
+          expect(address).to eq(address_one)
         end
       end
 
@@ -1958,7 +1979,7 @@ describe Mongoid::Relations::Embedded::Many do
 
           it "raises an error" do
             expect {
-              person.addresses.find(Moped::BSON::ObjectId.new)
+              person.addresses.find(BSON::ObjectId.new)
             }.to raise_error(Mongoid::Errors::DocumentNotFound)
           end
         end
@@ -1966,7 +1987,7 @@ describe Mongoid::Relations::Embedded::Many do
         context "when config set not to raise error" do
 
           let(:address) do
-            person.addresses.find(Moped::BSON::ObjectId.new)
+            person.addresses.find(BSON::ObjectId.new)
           end
 
           before do
@@ -1978,7 +1999,7 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "returns nil" do
-            address.should be_nil
+            expect(address).to be_nil
           end
         end
       end
@@ -1993,7 +2014,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "returns the matching documents" do
-          addresses.should eq([ address_one, address_two ])
+          expect(addresses).to eq([ address_one, address_two ])
         end
       end
 
@@ -2007,7 +2028,7 @@ describe Mongoid::Relations::Embedded::Many do
 
           it "raises an error" do
             expect {
-              person.addresses.find([ Moped::BSON::ObjectId.new ])
+              person.addresses.find([ BSON::ObjectId.new ])
             }.to raise_error(Mongoid::Errors::DocumentNotFound)
           end
         end
@@ -2015,7 +2036,7 @@ describe Mongoid::Relations::Embedded::Many do
         context "when config set not to raise error" do
 
           let(:addresses) do
-            person.addresses.find([ Moped::BSON::ObjectId.new ])
+            person.addresses.find([ BSON::ObjectId.new ])
           end
 
           before do
@@ -2027,7 +2048,7 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "returns an empty array" do
-            addresses.should be_empty
+            expect(addresses).to be_empty
           end
         end
       end
@@ -2051,7 +2072,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "returns the document" do
-        found.should eq(address)
+        expect(found).to eq(address)
       end
     end
 
@@ -2064,15 +2085,15 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "sets the new document attributes" do
-        found.street.should eq("King")
+        expect(found.street).to eq("King")
       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.state.should eq("CA")
+        expect(found.state).to eq("CA")
       end
     end
 
@@ -2094,7 +2115,81 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "properly creates the document" do
-        line_item.product.should eq(product)
+        expect(line_item.product).to eq(product)
+      end
+    end
+  end
+
+  describe "#find_or_create_by!" do
+
+    let(:person) do
+      Person.create
+    end
+
+    let!(:address) do
+      person.addresses.build(street: "Bourke", city: "Melbourne")
+    end
+
+    context "when the document exists" do
+
+      let(:found) do
+        person.addresses.find_or_create_by!(street: "Bourke")
+      end
+
+      it "returns the document" do
+        expect(found).to eq(address)
+      end
+    end
+
+    context "when the document does not exist" do
+
+      let(:found) do
+        person.addresses.find_or_create_by!(street: "King") do |address|
+          address.state = "CA"
+        end
+      end
+
+      it "sets the new document attributes" do
+        expect(found.street).to eq("King")
+      end
+
+      it "returns a newly persisted document" do
+        expect(found).to be_persisted
+      end
+
+      it "calls the passed block" do
+        expect(found.state).to eq("CA")
+      end
+
+      context "when validation fails" do
+
+        it "raises an error" do
+          expect {
+            person.addresses.find_or_create_by!(street: "1")
+          }.to raise_error(Mongoid::Errors::Validations)
+        end
+      end
+    end
+
+    context "when the child belongs to another document" do
+
+      let(:product) do
+        Product.create
+      end
+
+      let(:purchase) do
+        Purchase.create
+      end
+
+      let(:line_item) do
+        purchase.line_items.find_or_create_by(
+            product_id: product.id,
+            product_type: product.class.name
+        )
+      end
+
+      it "properly creates the document" do
+        expect(line_item.product).to eq(product)
       end
     end
   end
@@ -2116,7 +2211,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "returns the document" do
-        found.should eq(address)
+        expect(found).to eq(address)
       end
     end
 
@@ -2129,15 +2224,15 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "sets the new document attributes" do
-        found.street.should eq("King")
+        expect(found.street).to eq("King")
       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.state.should eq("CA")
+        expect(found.state).to eq("CA")
       end
     end
   end
@@ -2145,7 +2240,7 @@ describe Mongoid::Relations::Embedded::Many do
   describe ".macro" do
 
     it "returns embeds_many" do
-      described_class.macro.should eq(:embeds_many)
+      expect(described_class.macro).to eq(:embeds_many)
     end
   end
 
@@ -2174,7 +2269,7 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "returns the document with the max value of the supplied field" do
-      max.should eq(address_two)
+      expect(max).to eq(address_two)
     end
   end
 
@@ -2201,7 +2296,7 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "returns the document with the max value of the supplied field" do
-      max.should eq(address_two)
+      expect(max).to eq(address_two)
     end
   end
 
@@ -2236,7 +2331,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "applies the criteria to the documents" do
-          addresses.should eq([ address_one ])
+          expect(addresses).to eq([ address_one ])
         end
       end
 
@@ -2247,7 +2342,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "applies the criteria to the documents" do
-          addresses.should eq([ address_one, address_two ])
+          expect(addresses).to eq([ address_one, address_two ])
         end
       end
 
@@ -2258,7 +2353,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "applies the criteria to the documents" do
-          addresses.should eq([ address_one, address_two ])
+          expect(addresses).to eq([ address_one, address_two ])
         end
       end
     end
@@ -2270,7 +2365,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "applies the criteria to the documents" do
-        addresses.should eq([ address_one ])
+        expect(addresses).to eq([ address_one ])
       end
     end
 
@@ -2281,7 +2376,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "applies the criteria to the documents" do
-        addresses.should eq([ address_one ])
+        expect(addresses).to eq([ address_one ])
       end
     end
 
@@ -2290,8 +2385,7 @@ describe Mongoid::Relations::Embedded::Many do
       describe "#distinct" do
 
         it "returns the distinct values for the fields" do
-          person.addresses.distinct(:street).should =~
-            [ "Market",  "Madison"]
+          expect(person.addresses.distinct(:street)).to eq([ "Market",  "Madison"])
         end
       end
     end
@@ -2322,7 +2416,7 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "returns the min value of the supplied field" do
-      min.should eq(address_one)
+      expect(min).to eq(address_one)
     end
   end
 
@@ -2349,7 +2443,7 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "returns the min value of the supplied field" do
-      min.should eq(address_one)
+      expect(min).to eq(address_one)
     end
   end
 
@@ -2360,8 +2454,9 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "returns the many nested builder class" do
-      described_class.nested_builder(metadata, {}, {}).should
-        be_a(Mongoid::Relations::Builders::NestedAttributes::Many)
+      expect(
+        described_class.nested_builder(metadata, {}, {})
+      ).to be_a(Mongoid::Relations::Builders::NestedAttributes::Many)
     end
   end
 
@@ -2386,15 +2481,15 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "returns the popped document" do
-        popped.should eq(address_two)
+        expect(popped).to eq(address_two)
       end
 
       it "removes the document from the relation" do
-        person.addresses.should eq([ address_one ])
+        expect(person.addresses).to eq([ address_one ])
       end
 
       it "persists the pop" do
-        person.reload.addresses.should eq([ address_one ])
+        expect(person.reload.addresses).to eq([ address_one ])
       end
     end
 
@@ -2415,15 +2510,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "returns the popped documents" do
-          popped.should eq([ address_one, address_two ])
+          expect(popped).to eq([ address_one, address_two ])
         end
 
         it "removes the document from the relation" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
 
         it "persists the pop" do
-          person.reload.addresses.should be_empty
+          expect(person.reload.addresses).to be_empty
         end
       end
 
@@ -2434,15 +2529,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "returns the popped documents" do
-          popped.should eq([ address_one, address_two ])
+          expect(popped).to eq([ address_one, address_two ])
         end
 
         it "removes the document from the relation" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
 
         it "persists the pop" do
-          person.reload.addresses.should be_empty
+          expect(person.reload.addresses).to be_empty
         end
       end
     end
@@ -2452,14 +2547,14 @@ describe Mongoid::Relations::Embedded::Many do
       context "when providing no number" do
 
         it "returns nil" do
-          person.addresses.pop.should be_nil
+          expect(person.addresses.pop).to be_nil
         end
       end
 
       context "when providing a number" do
 
         it "returns nil" do
-          person.addresses.pop(2).should be_nil
+          expect(person.addresses.pop(2)).to be_nil
         end
       end
     end
@@ -2476,11 +2571,11 @@ describe Mongoid::Relations::Embedded::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 be_empty
+      expect(scoped.selector).to be_empty
     end
   end
 
@@ -2499,7 +2594,7 @@ describe Mongoid::Relations::Embedded::Many do
       context "when checking #{method}" do
 
         it "returns true" do
-          addresses.respond_to?(method).should be_true
+          expect(addresses.respond_to?(method)).to be true
         end
       end
     end
@@ -2509,7 +2604,7 @@ describe Mongoid::Relations::Embedded::Many do
       context "when checking #{method}" do
 
         it "returns true" do
-          addresses.respond_to?(method).should be_true
+          expect(addresses.respond_to?(method)).to be true
         end
       end
     end
@@ -2519,7 +2614,7 @@ describe Mongoid::Relations::Embedded::Many do
       context "when checking #{method}" do
 
         it "returns true" do
-          addresses.respond_to?(method).should be_true
+          expect(addresses.respond_to?(method)).to be true
         end
       end
     end
@@ -2543,7 +2638,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "returns the number of persisted documents" do
-        person.addresses.send(method).should eq(2)
+        expect(person.addresses.send(method)).to eq(2)
       end
     end
   end
@@ -2559,15 +2654,15 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "returns the relation criteria" do
-      unscoped.should be_a(Mongoid::Criteria)
+      expect(unscoped).to be_a(Mongoid::Criteria)
     end
 
     it "returns with empty options" do
-      unscoped.options.should be_empty
+      expect(unscoped.options).to be_empty
     end
 
     it "returns with an empty selector" do
-      unscoped.selector.should be_empty
+      expect(unscoped.selector).to be_empty
     end
   end
 
@@ -2580,7 +2675,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "updates nothing" do
-        person.addresses.update_all(street: "test").should be_false
+        expect(person.addresses.update_all(street: "test")).to be false
       end
     end
 
@@ -2603,19 +2698,19 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "resets the matching dirty flags" do
-          address.should_not be_changed
+          expect(address).to_not be_changed
         end
 
         it "updates the first field" do
-          address.reload.number.should eq(26)
+          expect(address.reload.number).to eq(26)
         end
 
         it "updates the second field" do
-          address.reload.post_code.should eq("12437")
+          expect(address.reload.post_code).to eq("12437")
         end
 
         it "does not wipe out other fields" do
-          address.reload.street.should eq("Hobrecht")
+          expect(address.reload.street).to eq("Hobrecht")
         end
       end
     end
@@ -2624,9 +2719,9 @@ describe Mongoid::Relations::Embedded::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(
         [
-          :as, :cascade_callbacks, :cyclic, :order, :versioned,
+          :as, :cascade_callbacks, :cyclic, :order,
           :store_as, :before_add, :after_add, :before_remove, :after_remove
         ]
       )
@@ -2636,7 +2731,7 @@ describe Mongoid::Relations::Embedded::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
 
@@ -2663,15 +2758,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "updates the attributes" do
-          address.locations.first.name.should eq("home")
+          expect(address.locations.first.name).to eq("home")
         end
 
         it "overwrites the existing documents" do
-          address.locations.count.should eq(1)
+          expect(address.locations.count).to eq(1)
         end
 
         it "persists the changes" do
-          address.reload.locations.count.should eq(1)
+          expect(address.reload.locations.count).to eq(1)
         end
       end
     end
@@ -2701,15 +2796,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets up the hierarchy" do
-          animal.circus.should eq(circus)
+          expect(animal.circus).to eq(circus)
         end
 
         it "assigns the attributes" do
-          animal.name.should eq(animal_name)
+          expect(animal.name).to eq(animal_name)
         end
 
         it "uses custom writer methods" do
-          animal.tag_list.should eq(tag_list)
+          expect(animal.tag_list).to eq(tag_list)
         end
       end
 
@@ -2720,15 +2815,15 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "sets up the hierarchy" do
-          animal.circus.should eq(circus)
+          expect(animal.circus).to eq(circus)
         end
 
         it "assigns the attributes" do
-          animal.name.should eq(animal_name)
+          expect(animal.name).to eq(animal_name)
         end
 
         it "uses custom writer methods" do
-          animal.tag_list.should eq(tag_list)
+          expect(animal.tag_list).to eq(tag_list)
         end
       end
     end
@@ -2757,7 +2852,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "sets up the hierarchy" do
-        question.should eq(page_question)
+        expect(question).to eq(page_question)
       end
     end
 
@@ -2780,7 +2875,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "sets up the hierarchy" do
-        question.should eq(page_question)
+        expect(question).to eq(page_question)
       end
     end
 
@@ -2808,7 +2903,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "sets up the hierarchy" do
-        question.should eq(page_question)
+        expect(question).to eq(page_question)
       end
 
       context "when reloading" do
@@ -2822,7 +2917,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "reloads the entire tree" do
-          reloaded_question.should eq(question)
+          expect(reloaded_question).to eq(question)
         end
       end
     end
@@ -2856,11 +2951,11 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "persists the first level document" do
-          person.reload.addresses.first.should eq(address)
+          expect(person.reload.addresses.first).to eq(address)
         end
 
         it "persists the second level document" do
-          person.reload.addresses[0].locations.should eq([ location ])
+          expect(person.reload.addresses[0].locations).to eq([ location ])
         end
       end
     end
@@ -2895,7 +2990,7 @@ describe Mongoid::Relations::Embedded::Many do
 
         it "ignores the nil and persist the remaining items" do
           reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq([ home_phone, office_phone ])
+          expect(reloaded.phone_numbers).to eq([ home_phone, office_phone ])
         end
       end
 
@@ -2916,7 +3011,7 @@ describe Mongoid::Relations::Embedded::Many do
 
         it "ignores the nil and persist the remaining items" do
           reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq([ home_phone, office_phone ])
+          expect(reloaded.phone_numbers).to eq([ home_phone, office_phone ])
         end
       end
 
@@ -2937,7 +3032,7 @@ describe Mongoid::Relations::Embedded::Many do
 
         it "ignores the nil and persist the remaining items" do
           reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq([ home_phone, office_phone ])
+          expect(reloaded.phone_numbers).to eq([ home_phone, office_phone ])
         end
       end
     end
@@ -2959,7 +3054,7 @@ describe Mongoid::Relations::Embedded::Many do
 
         it "ignores the nil and persist the remaining items" do
           reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq(person.phone_numbers)
+          expect(reloaded.phone_numbers).to eq(person.phone_numbers)
         end
       end
 
@@ -2978,7 +3073,7 @@ describe Mongoid::Relations::Embedded::Many do
 
         it "ignores the nil and persist the remaining items" do
           reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq(person.phone_numbers)
+          expect(reloaded.phone_numbers).to eq(person.phone_numbers)
         end
       end
 
@@ -2997,7 +3092,7 @@ describe Mongoid::Relations::Embedded::Many do
 
         it "ignores the nil and persist the remaining items" do
           reloaded = Person.find(person.id)
-          reloaded.phone_numbers.should eq(person.phone_numbers)
+          expect(reloaded.phone_numbers).to eq(person.phone_numbers)
         end
       end
     end
@@ -3018,7 +3113,7 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "retains the reference to the parent" do
-      league.name.should eq("Destroyed")
+      expect(league.name).to eq("Destroyed")
     end
   end
 
@@ -3037,11 +3132,11 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "does not duplicate the embedded documents" do
-      person.addresses.should eq([ address ])
+      expect(person.addresses).to eq([ address ])
     end
 
     it "does not persist duplicate embedded documents" do
-      person.reload.addresses.should eq([ address ])
+      expect(person.reload.addresses).to eq([ address ])
     end
   end
 
@@ -3058,7 +3153,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "allows the operation" do
-        version.number.should eq(1)
+        expect(version.number).to eq(1)
       end
 
       context "when reloading the parent" do
@@ -3068,7 +3163,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "saves the child versions" do
-          from_db.versions.should eq([ version ])
+          expect(from_db.versions).to eq([ version ])
         end
       end
     end
@@ -3095,7 +3190,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "does not lose the parent reference" do
-        from_db.memberships.first.account.should eq(account)
+        expect(from_db.memberships.first.account).to eq(account)
       end
     end
 
@@ -3106,7 +3201,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "does not lose the parent reference" do
-        from_db.memberships.first.account.should eq(account)
+        expect(from_db.memberships.first.account).to eq(account)
       end
     end
   end
@@ -3130,11 +3225,11 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "adds the document to the new paarent" do
-      person_two.addresses.should eq([ address ])
+      expect(person_two.addresses).to eq([ address ])
     end
 
     it "sets the new parent on the document" do
-      address._parent.should eq(person_two)
+      expect(address._parent).to eq(person_two)
     end
 
     context "when reloading the documents" do
@@ -3145,11 +3240,11 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "persists the change to the new parent" do
-        person_two.addresses.should eq([ address ])
+        expect(person_two.addresses).to eq([ address ])
       end
 
       it "keeps the address on the previous document" do
-        person_one.addresses.should eq([ address ])
+        expect(person_one.addresses).to eq([ address ])
       end
     end
   end
@@ -3185,7 +3280,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "applies the default scope" do
-          symptoms.should eq([ cough, headache, nausea ])
+          expect(symptoms).to eq([ cough, headache, nausea ])
         end
       end
 
@@ -3206,7 +3301,7 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "applies the default scope" do
-            symptoms.should eq([ constipation, cough, headache, nausea ])
+            expect(symptoms).to eq([ constipation, cough, headache, nausea ])
           end
         end
       end
@@ -3218,7 +3313,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "removes the default scope" do
-          unscoped.should eq([ nausea, cough, headache ])
+          expect(unscoped).to eq([ nausea, cough, headache ])
         end
       end
     end
@@ -3249,11 +3344,11 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "retains the unscoped index for the excluded document" do
-        relation.send(:_unscoped).first._index.should eq(0)
+        expect(relation.send(:_unscoped).first._index).to eq(0)
       end
 
       it "retains the unscoped index for the included document" do
-        relation.first._index.should eq(1)
+        expect(relation.first._index).to eq(1)
       end
 
       context "when a reindexing operation occurs" do
@@ -3263,11 +3358,11 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "retains the unscoped index for the excluded document" do
-          relation.send(:_unscoped).first._index.should eq(0)
+          expect(relation.send(:_unscoped).first._index).to eq(0)
         end
 
         it "retains the unscoped index for the included document" do
-          relation.first._index.should eq(1)
+          expect(relation.first._index).to eq(1)
         end
       end
     end
@@ -3291,11 +3386,11 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "sets the value" do
-        video.genres.should eq([ "horror", "scifi" ])
+        expect(video.genres).to eq([ "horror", "scifi" ])
       end
 
       it "persists the value" do
-        video.reload.genres.should eq([ "horror", "scifi" ])
+        expect(video.reload.genres).to eq([ "horror", "scifi" ])
       end
 
       context "when reloading the parent" do
@@ -3316,11 +3411,11 @@ describe Mongoid::Relations::Embedded::Many do
           end
 
           it "sets the new value" do
-            loaded_video.genres.should eq([ "comedy" ])
+            expect(loaded_video.genres).to eq([ "comedy" ])
           end
 
           it "persists the new value" do
-            loaded_video.reload.genres.should eq([ "comedy" ])
+            expect(loaded_video.reload.genres).to eq([ "comedy" ])
           end
         end
       end
@@ -3346,15 +3441,15 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "destroys the document" do
-      address_one.should be_destroyed
+      expect(address_one).to be_destroyed
     end
 
     it "reindexes the relation" do
-      address_two._index.should eq(0)
+      expect(address_two._index).to eq(0)
     end
 
     it "removes the document from the unscoped" do
-      person.addresses.send(:_unscoped).should_not include(address_one)
+      expect(person.addresses.send(:_unscoped)).to_not include(address_one)
     end
 
     context "when subsequently updating the next document" do
@@ -3368,11 +3463,11 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "updates the correct document" do
-        addresses.first.number.should eq(10)
+        expect(addresses.first.number).to eq(10)
       end
 
       it "does not add additional documents" do
-        addresses.count.should eq(1)
+        expect(addresses.count).to eq(1)
       end
     end
   end
@@ -3402,7 +3497,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "adds both documents" do
-        result.should eq([ address_one, address_two ])
+        expect(result).to eq([ address_one, address_two ])
       end
     end
   end
@@ -3426,7 +3521,7 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "allows the dot notation criteria" do
-      criteria.should eq([ address ])
+      expect(criteria).to eq([ address ])
     end
   end
 
@@ -3459,7 +3554,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "updates the nested document" do
-        updated.name.should eq("work")
+        expect(updated.name).to eq("work")
       end
     end
   end
@@ -3479,7 +3574,7 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "orders properly with the boolean" do
-      circuit.reload.buses.should eq([ bus_two, bus_one ])
+      expect(circuit.reload.buses).to eq([ bus_two, bus_one ])
     end
   end
 
@@ -3517,11 +3612,11 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "does not duplicate the first relation" do
-      person.reload.symptoms.count.should eq(2)
+      expect(person.reload.symptoms.count).to eq(2)
     end
 
     it "does not duplicate the second relation" do
-      person.reload.appointments.count.should eq(2)
+      expect(person.reload.appointments.count).to eq(2)
     end
   end
 
@@ -3542,29 +3637,29 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "executes the callback" do
-        artist.before_add_called.should be_true
+        expect(artist.before_add_called).to be true
       end
 
       it "executes the callback as proc" do
-        song.before_add_called.should be_true
+        expect(song.before_add_called).to be true
       end
 
       it "adds the document to the relation" do
-        artist.songs.should eq([song])
+        expect(artist.songs).to eq([song])
       end
     end
 
     context "with errors" do
 
       before do
-        artist.should_receive(:before_add_song).and_raise
+        expect(artist).to receive(:before_add_song).and_raise
       end
 
       it "does not add the document to the relation" do
         expect {
           artist.songs << song
         }.to raise_error
-        artist.songs.should be_empty
+        expect(artist.songs).to be_empty
       end
     end
   end
@@ -3581,20 +3676,20 @@ describe Mongoid::Relations::Embedded::Many do
 
     it "executes the callback" do
       artist.labels << label
-      artist.after_add_called.should be_true
+      expect(artist.after_add_called).to be true
     end
 
     context "when errors are raised" do
 
       before do
-        artist.should_receive(:after_add_label).and_raise
+        expect(artist).to receive(:after_add_label).and_raise
       end
 
       it "adds the document to the relation" do
         expect {
           artist.labels << label
         }.to raise_error
-        artist.labels.should eq([ label ])
+        expect(artist.labels).to eq([ label ])
       end
     end
   end
@@ -3622,11 +3717,11 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "executes the callback" do
-          artist.before_remove_embedded_called.should be_true
+          expect(artist.before_remove_embedded_called).to be true
         end
 
         it "removes the document from the relation" do
-          artist.songs.should be_empty
+          expect(artist.songs).to be_empty
         end
       end
 
@@ -3637,18 +3732,18 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "executes the callback" do
-          artist.before_remove_embedded_called.should be_true
+          expect(artist.before_remove_embedded_called).to be true
         end
 
         it "shoud clear the relation" do
-          artist.songs.should be_empty
+          expect(artist.songs).to be_empty
         end
       end
 
       context "when errors are raised" do
 
         before do
-          artist.should_receive(:before_remove_song).and_raise
+          expect(artist).to receive(:before_remove_song).and_raise
         end
 
         describe "#delete" do
@@ -3657,7 +3752,7 @@ describe Mongoid::Relations::Embedded::Many do
             expect {
               artist.songs.delete(song)
             }.to raise_error
-            artist.songs.should eq([ song ])
+            expect(artist.songs).to eq([ song ])
           end
         end
 
@@ -3667,7 +3762,7 @@ describe Mongoid::Relations::Embedded::Many do
             expect {
               artist.songs.clear
             }.to raise_error
-            artist.songs.should eq([ song ])
+            expect(artist.songs).to eq([ song ])
           end
         end
       end
@@ -3696,7 +3791,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "executes the callback" do
-          artist.after_remove_embedded_called.should be_true
+          expect(artist.after_remove_embedded_called).to be true
         end
       end
 
@@ -3708,7 +3803,7 @@ describe Mongoid::Relations::Embedded::Many do
 
         it "executes the callback" do
           artist.labels.clear
-          artist.after_remove_embedded_called.should be_true
+          expect(artist.after_remove_embedded_called).to be true
         end
       end
     end
@@ -3716,7 +3811,7 @@ describe Mongoid::Relations::Embedded::Many do
     context "when errors are raised" do
 
       before do
-        artist.should_receive(:after_remove_label).and_raise
+        expect(artist).to receive(:after_remove_label).and_raise
       end
 
       describe "#delete" do
@@ -3728,7 +3823,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "removes the document from the relation" do
-          artist.labels.should be_empty
+          expect(artist.labels).to be_empty
         end
       end
 
@@ -3741,7 +3836,7 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "should remove from collection" do
-          artist.labels.should be_empty
+          expect(artist.labels).to be_empty
         end
       end
     end
@@ -3764,7 +3859,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "does not push the embedded documents twice" do
-        server.reload.filesystems.count.should eq(1)
+        expect(server.reload.filesystems.count).to eq(1)
       end
     end
   end
@@ -3792,11 +3887,11 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "creates proper documents from the db" do
-        record.name.should eq("Moderat")
+        expect(record.name).to eq("Moderat")
       end
 
       it "assigns ids to the documents" do
-        record.id.should_not be_nil
+        expect(record.id).to_not be_nil
       end
 
       context "when subsequently updating the documents" do
@@ -3806,11 +3901,11 @@ describe Mongoid::Relations::Embedded::Many do
         end
 
         it "updates the document" do
-          record.name.should eq("Apparat")
+          expect(record.name).to eq("Apparat")
         end
 
         it "persists the change" do
-          record.reload.name.should eq("Apparat")
+          expect(record.reload.name).to eq("Apparat")
         end
       end
     end
@@ -3835,7 +3930,7 @@ describe Mongoid::Relations::Embedded::Many do
     end
 
     it "keeps the proxy extensions when remarshalling" do
-      loaded.extension.should eq("Testing")
+      expect(loaded.extension).to eq("Testing")
     end
   end
 end