mongoid 3.1.7 → 4.0.0.alpha1

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

@@ -7,11 +7,11 @@ describe "when initialize a model with an embedded model" do
   end
 
   it "has changes in the embedded model" do
-    person.pet.changes.should_not be_empty
+    expect(person.pet.changes).to_not be_empty
   end
 
   it "does not have previous_changes in the embedded model" do
-    person.pet.previous_changes.should be_empty
+    expect(person.pet.previous_changes).to be_empty
   end
 end
 
@@ -22,11 +22,11 @@ describe "when creating a model with an embedded model" do
   end
 
   it "does not have changes in the embedded model" do
-    person.pet.changes.should be_empty
+    expect(person.pet.changes).to be_empty
   end
 
   it "has previous_changes in the embedded model" do
-    person.pet.previous_changes.should_not be_empty
+    expect(person.pet.previous_changes).to_not be_empty
   end
 end
 
@@ -41,11 +41,11 @@ describe "when embedding a model on an already saved model" do
   end
 
   it "has not changes on the embedded model" do
-    person.pet.changes.should be_empty
+    expect(person.pet.changes).to be_empty
   end
 
   it "has previous changes on the embedded model" do
-    person.pet.previous_changes.should_not be_empty
+    expect(person.pet.previous_changes).to_not be_empty
   end
 
   describe "and saving the model" do
@@ -55,11 +55,11 @@ describe "when embedding a model on an already saved model" do
     end
 
     it "does not have changes on the embedded model" do
-      person.pet.changes.should be_empty
+      expect(person.pet.changes).to be_empty
     end
 
     it "does not have previous changes on the embedded model" do
-      person.pet.previous_changes.should be_empty
+      expect(person.pet.previous_changes).to be_empty
     end
   end
 end

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

@@ -25,14 +25,14 @@ describe Mongoid::Relations::Embedded::In do
       context "when the document is a different instance" do
 
         it "returns false" do
-          (relation === Person.new).should be_false
+          expect((relation === Person.new)).to be false
         end
       end
 
       context "when the document is the same instance" do
 
         it "returns true" do
-          (relation === target).should be_true
+          expect((relation === target)).to be true
         end
       end
     end
@@ -57,19 +57,19 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the target of the relation" do
-          name.namable.should eq(person)
+          expect(name.namable).to eq(person)
         end
 
         it "sets the base on the inverse relation" do
-          person.name.should eq(name)
+          expect(person.name).to eq(name)
         end
 
         it "sets the same instance on the inverse relation" do
-          person.name.should eql(name)
+          expect(person.name).to eql(name)
         end
 
         it "does not save the target" do
-          person.should_not be_persisted
+          expect(person).to_not be_persisted
         end
       end
 
@@ -88,19 +88,19 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the target of the relation" do
-          name.namable.should eq(person)
+          expect(name.namable).to eq(person)
         end
 
         it "sets the base on the inverse relation" do
-          person.name.should eq(name)
+          expect(person.name).to eq(name)
         end
 
         it "sets the same instance on the inverse relation" do
-          person.name.should eql(name)
+          expect(person.name).to eql(name)
         end
 
         it "does not save the base" do
-          name.should_not be_persisted
+          expect(name).to_not be_persisted
         end
       end
     end
@@ -122,19 +122,19 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the target of the relation" do
-          address.addressable.should eq(person)
+          expect(address.addressable).to eq(person)
         end
 
         it "appends the base on the inverse relation" do
-          person.addresses.should eq([ address ])
+          expect(person.addresses).to eq([ address ])
         end
 
         it "sets the same instance in the inverse relation" do
-          person.addresses.first.should eql(address)
+          expect(person.addresses.first).to eql(address)
         end
 
         it "does not save the target" do
-          person.should_not be_persisted
+          expect(person).to_not be_persisted
         end
       end
 
@@ -153,15 +153,15 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the target of the relation" do
-          address.addressable.should eq(person)
+          expect(address.addressable).to eq(person)
         end
 
         it "sets the same instance in the inverse relation" do
-          person.addresses.first.should eql(address)
+          expect(person.addresses.first).to eql(address)
         end
 
         it "appends the base on the inverse relation" do
-          person.addresses.should eq([ address ])
+          expect(person.addresses).to eq([ address ])
         end
       end
     end
@@ -187,11 +187,11 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          name.namable.should be_nil
+          expect(name.namable).to be_nil
         end
 
         it "removes the inverse relation" do
-          person.name.should be_nil
+          expect(person.name).to be_nil
         end
       end
 
@@ -210,11 +210,11 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          name.namable.should be_nil
+          expect(name.namable).to be_nil
         end
 
         it "removes the inverse relation" do
-          person.name.should be_nil
+          expect(person.name).to be_nil
         end
       end
 
@@ -234,15 +234,15 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          name.namable.should be_nil
+          expect(name.namable).to be_nil
         end
 
         it "removed the inverse relation" do
-          person.name.should be_nil
+          expect(person.name).to be_nil
         end
 
         it "deletes the child document" do
-          name.should be_destroyed
+          expect(name).to be_destroyed
         end
       end
     end
@@ -265,11 +265,11 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          address.addressable.should be_nil
+          expect(address.addressable).to be_nil
         end
 
         it "removes the inverse relation" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
       end
 
@@ -284,7 +284,7 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          address.addressable.should be_nil
+          expect(address.addressable).to be_nil
         end
       end
 
@@ -304,15 +304,15 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          address.addressable.should be_nil
+          expect(address.addressable).to be_nil
         end
 
         it "removed the inverse relation" 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
       end
 
@@ -336,19 +336,19 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          address_one.addressable.should be_nil
+          expect(address_one.addressable).to be_nil
         end
 
         it "removed the inverse relation" do
-          person.addresses.should eq([ address_two ])
+          expect(person.addresses).to eq([ address_two ])
         end
 
         it "deletes the child document" do
-          address_one.should be_destroyed
+          expect(address_one).to be_destroyed
         end
 
         it "reindexes the children" do
-          address_two._index.should eq(0)
+          expect(address_two._index).to eq(0)
         end
       end
     end
@@ -373,28 +373,28 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "returns the embedded one builder" do
-      described_class.builder(base, metadata, target).should be_a(builder_klass)
+      expect(described_class.builder(base, metadata, target)).to be_a(builder_klass)
     end
   end
 
   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
 
   describe ".macro" do
 
     it "returns embeds_one" do
-      described_class.macro.should eq(:embedded_in)
+      expect(described_class.macro).to eq(:embedded_in)
     end
   end
 
@@ -413,8 +413,7 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "returns the single nested builder" do
-      described_class.nested_builder(metadata, attributes, {}).should
-        be_a(nested_builder_klass)
+      expect(described_class.nested_builder(metadata, attributes, {})).to be_a(nested_builder_klass)
     end
   end
 
@@ -437,7 +436,7 @@ describe Mongoid::Relations::Embedded::In do
       context "when checking #{method}" do
 
         it "returns true" do
-          document.respond_to?(method).should be_true
+          expect(document.respond_to?(method)).to be true
         end
       end
     end
@@ -446,7 +445,7 @@ describe Mongoid::Relations::Embedded::In do
   describe ".valid_options" do
 
     it "returns the valid options" do
-      described_class.valid_options.should eq(
+      expect(described_class.valid_options).to eq(
         [ :autobuild, :cyclic, :polymorphic ]
       )
     end
@@ -455,7 +454,7 @@ describe Mongoid::Relations::Embedded::In do
   describe ".validation_default" do
 
     it "returns false" do
-      described_class.validation_default.should be_false
+      expect(described_class.validation_default).to be false
     end
   end
 
@@ -478,23 +477,23 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "saves the child" do
-      Person.last.addresses.last.should eq(address)
+      expect(Person.last.addresses.last).to eq(address)
     end
 
     it "indexes the child" do
-      address._index.should eq(0)
+      expect(address._index).to eq(0)
     end
 
     it "saves the first location with the correct index" do
-      first_location._index.should eq(0)
+      expect(first_location._index).to eq(0)
     end
 
     it "saves the second location with the correct index" do
-      second_location._index.should eq(1)
+      expect(second_location._index).to eq(1)
     end
 
     it "has the locations in the association array" do
-      Person.last.addresses.last.locations.should eq(
+      expect(Person.last.addresses.last.locations).to eq(
         [first_location, second_location]
       )
     end
@@ -515,11 +514,11 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "does not save the child" do
-      address.should_not be_persisted
+      expect(address).to_not be_persisted
     end
 
     it "does not save the deeply embedded children" do
-      address.locations.first.should_not be_persisted
+      expect(address.locations.first).to_not be_persisted
     end
   end
 
@@ -547,15 +546,15 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "sets the new parent" do
-      name.namable.should eq(person)
+      expect(name.namable).to eq(person)
     end
 
     it "removes the previous parent relation" do
-      person_two.name.should be_nil
+      expect(person_two.name).to be_nil
     end
 
     it "sets the new child relation" do
-      person.name.should eq(name)
+      expect(person.name).to eq(name)
     end
 
     context "when reloading" do
@@ -565,15 +564,15 @@ describe Mongoid::Relations::Embedded::In do
       end
 
       it "sets the new parent" do
-        name.namable.should eq(person)
+        expect(name.namable).to eq(person)
       end
 
       it "removes the previous parent relation" do
-        person_two.name.should be_nil
+        expect(person_two.name).to be_nil
       end
 
       it "sets the new child relation" do
-        person.name.should eq(name)
+        expect(person.name).to eq(name)
       end
     end
   end

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,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
@@ -228,35 +228,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 +277,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 +300,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 +311,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 +330,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 +364,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 +383,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 +412,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 +434,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 +452,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 +479,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 +509,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 +545,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 +583,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 +626,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 +652,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 +675,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 +697,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 +721,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 +736,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 +762,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 +789,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 +808,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 +828,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 +859,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 +884,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 +907,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 +917,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 +930,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 +977,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 +1030,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 +1060,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 +1085,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 +1116,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 +1136,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 +1158,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 +1205,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
 
@@ -1243,7 +1221,7 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       it "doesn't update the target" do
-        person.addresses.should be_empty
+        expect(person.addresses).to be_empty
       end
     end
 
@@ -1266,11 +1244,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 +1269,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 +1312,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 +1330,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 first attributes" do
+        expect(addresses.first.street).to eq("Bond")
       end
 
-      it "sets the attributes for the provided role" do
-        video.title.should eq("Inception")
+      it "sets the second attributes" do
+        expect(addresses.last.street).to eq("Upper")
       end
 
-      it "does not set the attributes for other roles" do
-        video.year.should be_nil
+      it "persists the children" do
+        expect(person.addresses.count).to eq(2)
       end
     end
 
@@ -1392,39 +1376,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 +1418,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 +1434,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 +1445,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 "creates multiple documents" do
+        expect(addresses.size).to eq(2)
+      end
+
+      it "sets the first attributes" do
+        expect(addresses.first.street).to eq("Bond")
       end
 
-      it "sets the attributes for the provided role" do
-        video.title.should eq("Inception")
+      it "sets the second attributes" do
+        expect(addresses.last.street).to eq("Upper")
       end
 
-      it "does not set the attributes for other roles" do
-        video.year.should be_nil
+      it "persists the children" do
+        expect(person.addresses.count).to eq(2)
       end
     end
 
@@ -1485,35 +1475,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 +1542,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 +1591,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 +1610,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 +1634,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 +1658,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 +1700,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 +1719,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 +1748,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 +1767,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 +1793,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 +1812,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 +1834,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 +1853,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 +1871,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 +1895,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 +1906,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 +1934,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 +1948,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 +1956,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 +1968,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 +1983,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 +1997,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 +2005,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 +2017,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 +2041,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 +2054,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 +2084,7 @@ 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
@@ -2116,7 +2106,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 +2119,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 +2135,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 +2164,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 +2191,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 +2226,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 +2237,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 +2248,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 +2260,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 +2271,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 +2280,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 +2311,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 +2338,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 +2349,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 +2376,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 +2405,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 +2424,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 +2442,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 +2466,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 +2489,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 +2499,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 +2509,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 +2533,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 +2549,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 +2570,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 +2593,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 +2614,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 +2626,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 +2653,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 +2691,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 +2710,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 +2747,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 +2770,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 +2798,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 +2812,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 +2846,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 +2885,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 +2906,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 +2927,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 +2949,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 +2968,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 +2987,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 +3008,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 +3027,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 +3048,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 +3058,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 +3085,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 +3096,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 +3120,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 +3135,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 +3175,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 +3196,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 +3208,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 +3239,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 +3253,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 +3281,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 +3306,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 +3336,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 +3358,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 +3392,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 +3416,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 +3449,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 +3469,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 +3507,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,15 +3532,15 @@ 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
 
@@ -3564,7 +3554,7 @@ describe Mongoid::Relations::Embedded::Many do
         expect {
           artist.songs << song
         }.to raise_error
-        artist.songs.should be_empty
+        expect(artist.songs).to be_empty
       end
     end
   end
@@ -3581,7 +3571,7 @@ 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
@@ -3594,7 +3584,7 @@ describe Mongoid::Relations::Embedded::Many do
         expect {
           artist.labels << label
         }.to raise_error
-        artist.labels.should eq([ label ])
+        expect(artist.labels).to eq([ label ])
       end
     end
   end
@@ -3622,11 +3612,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,11 +3627,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 "shoud clear the relation" do
-          artist.songs.should be_empty
+          expect(artist.songs).to be_empty
         end
       end
 
@@ -3657,7 +3647,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 +3657,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 +3686,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 +3698,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
@@ -3728,7 +3718,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 +3731,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 +3754,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 +3782,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 +3796,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 +3825,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