mongoid 3.1.6 → 4.0.2

data/spec/mongoid/relations/options_spec.rb

@@ -15,7 +15,7 @@ describe Mongoid::Relations::Options do
       end
 
       it "returns true" do
-        described_class.validate!(options).should be_true
+        expect(described_class.validate!(options)).to be true
       end
     end
 

data/spec/mongoid/relations/polymorphic_spec.rb

@@ -25,19 +25,15 @@ describe Mongoid::Relations::Polymorphic do
         end
 
         it "sets polymorphic to true" do
-          klass.should be_polymorphic
+          expect(klass).to be_polymorphic
         end
 
         it "adds the foreign key type field" do
-          klass.fields["ratable_type"].should_not be_nil
-        end
-
-        it "adds the foreign key inverse field field" do
-          klass.fields["ratable_field"].should_not be_nil
+          expect(klass.fields["ratable_type"]).to_not be_nil
         end
 
         it "returns self" do
-          polymorphed.should eq(klass)
+          expect(polymorphed).to eq(klass)
         end
       end
 
@@ -56,15 +52,15 @@ describe Mongoid::Relations::Polymorphic do
         end
 
         it "sets polymorphic to true" do
-          klass.should be_polymorphic
+          expect(klass).to be_polymorphic
         end
 
         it "does not add the foreign key type field" do
-          klass.fields["ratable_type"].should be_nil
+          expect(klass.fields["ratable_type"]).to be_nil
         end
 
         it "does not add the foreign key inverse field field" do
-          klass.fields["ratable_field"].should be_nil
+          expect(klass.fields["ratable_field"]).to be_nil
         end
       end
     end
@@ -83,15 +79,15 @@ describe Mongoid::Relations::Polymorphic do
       end
 
       it "sets polymorphic to false" do
-        klass.should_not be_polymorphic
+        expect(klass).to_not be_polymorphic
       end
 
       it "does not add the foreign key type field" do
-        klass.fields["ratable_type"].should be_nil
+        expect(klass.fields["ratable_type"]).to be_nil
       end
 
       it "does not add the foreign key inverse field field" do
-        klass.fields["ratable_field"].should be_nil
+        expect(klass.fields["ratable_field"]).to be_nil
       end
     end
   end
@@ -101,14 +97,14 @@ describe Mongoid::Relations::Polymorphic do
     context "when the document is in a polymorphic relation" do
 
       it "returns true" do
-        Movie.should be_polymorphic
+        expect(Movie).to be_polymorphic
       end
     end
 
     context "when the document is not in a polymorphic relation" do
 
       it "returns false" do
-        Survey.should_not be_polymorphic
+        expect(Survey).to_not be_polymorphic
       end
     end
   end
@@ -118,14 +114,14 @@ describe Mongoid::Relations::Polymorphic do
     context "when the document is in a polymorphic relation" do
 
       it "returns true" do
-        Movie.new.should be_polymorphic
+        expect(Movie.new).to be_polymorphic
       end
     end
 
     context "when the document is not in a polymorphic relation" do
 
       it "returns false" do
-        Survey.new.should_not be_polymorphic
+        expect(Survey.new).to_not be_polymorphic
       end
     end
   end

data/spec/mongoid/relations/proxy_spec.rb

@@ -27,7 +27,7 @@ describe Mongoid::Relations::Proxy do
     end
 
     it "extends the proxied object" do
-      person.should be_a(Testable)
+      expect(person).to be_a(Testable)
     end
 
     context "when extending from the relation definition" do
@@ -41,7 +41,7 @@ describe Mongoid::Relations::Proxy do
       end
 
       it "extends the proxy" do
-        found.should eq(address)
+        expect(found).to eq(address)
       end
     end
   end

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

@@ -27,7 +27,7 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the target relation" do
-            service.target.should eq(target)
+            expect(service.target).to eq(target)
           end
         end
       end
@@ -48,11 +48,11 @@ describe Mongoid::Relations::Referenced::In do
       end
 
       it "sets the relation" do
-        agent.game.should eq(game)
+        expect(agent.game).to eq(game)
       end
 
       it "sets the foreign_key" do
-        agent.game_id.should eq(game.id)
+        expect(agent.game_id).to eq(game.id)
       end
     end
 
@@ -75,15 +75,15 @@ describe Mongoid::Relations::Referenced::In do
       end
 
       it "sets the relation" do
-        address.account.should eq(account)
+        expect(address.account).to eq(account)
       end
 
       it "does not erase the metadata" do
-        address.metadata.should_not be_nil
+        expect(address.__metadata).to_not be_nil
       end
 
       it "allows saving of the embedded document" do
-        address.save.should be_true
+        expect(address.save).to be true
       end
     end
 
@@ -106,23 +106,23 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the target of the relation" do
-            game.person.target.should eq(person)
+            expect(game.person.target).to eq(person)
           end
 
           it "sets the foreign key on the relation" do
-            game.person_id.should eq(person.id)
+            expect(game.person_id).to eq(person.id)
           end
 
           it "sets the base on the inverse relation" do
-            person.game.should eq(game)
+            expect(person.game).to eq(game)
           end
 
           it "sets the same instance on the inverse relation" do
-            person.game.should eql(game)
+            expect(person.game).to eql(game)
           end
 
           it "does not save the target" do
-            person.should_not be_persisted
+            expect(person).to_not be_persisted
           end
         end
 
@@ -141,23 +141,23 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the target of the relation" do
-            game.person.target.should eq(person)
+            expect(game.person.target).to eq(person)
           end
 
           it "sets the foreign key of the relation" do
-            game.person_id.should eq(person.id)
+            expect(game.person_id).to eq(person.id)
           end
 
           it "sets the base on the inverse relation" do
-            person.game.should eq(game)
+            expect(person.game).to eq(game)
           end
 
           it "sets the same instance on the inverse relation" do
-            person.game.should eql(game)
+            expect(person.game).to eql(game)
           end
 
           it "does not saves the target" do
-            person.should_not be_persisted
+            expect(person).to_not be_persisted
           end
         end
       end
@@ -180,11 +180,11 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the correct value in the type field" do
-            comment.commentable_type.should eq("Canvas::Test")
+            expect(comment.commentable_type).to eq("Canvas::Test")
           end
 
           it "can retrieve the document from the database" do
-            comment.reload.commentable.should eq(canvas)
+            expect(comment.reload.commentable).to eq(canvas)
           end
         end
 
@@ -203,27 +203,23 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the target of the relation" do
-            rating.ratable.target.should eq(bar)
+            expect(rating.ratable.target).to eq(bar)
           end
 
           it "sets the foreign key on the relation" do
-            rating.ratable_id.should eq(bar.id)
-          end
-
-          it "does not set the inverse of field on the relation" do
-            rating.ratable_field.should be_nil
+            expect(rating.ratable_id).to eq(bar.id)
           end
 
           it "sets the base on the inverse relation" do
-            bar.rating.should eq(rating)
+            expect(bar.rating).to eq(rating)
           end
 
           it "sets the same instance on the inverse relation" do
-            bar.rating.should eql(rating)
+            expect(bar.rating).to eql(rating)
           end
 
           it "does not save the target" do
-            bar.should_not be_persisted
+            expect(bar).to_not be_persisted
           end
         end
 
@@ -242,27 +238,23 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the target of the relation" do
-            rating.ratable.target.should eq(bar)
+            expect(rating.ratable.target).to eq(bar)
           end
 
           it "sets the foreign key of the relation" do
-            rating.ratable_id.should eq(bar.id)
-          end
-
-          it "does not set the inverse of field on the relation" do
-            rating.ratable_field.should be_nil
+            expect(rating.ratable_id).to eq(bar.id)
           end
 
           it "sets the base on the inverse relation" do
-            bar.rating.should eq(rating)
+            expect(bar.rating).to eq(rating)
           end
 
           it "sets the same instance on the inverse relation" do
-            bar.rating.should eql(rating)
+            expect(bar.rating).to eql(rating)
           end
 
           it "does not saves the target" do
-            bar.should_not be_persisted
+            expect(bar).to_not be_persisted
           end
         end
       end
@@ -287,15 +279,15 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the target of the relation" do
-            post.person.target.should eq(person)
+            expect(post.person.target).to eq(person)
           end
 
           it "sets the foreign key on the relation" do
-            post.person_id.should eq(person.id)
+            expect(post.person_id).to eq(person.id)
           end
 
           it "does not save the target" do
-            person.should_not be_persisted
+            expect(person).to_not be_persisted
           end
         end
 
@@ -314,15 +306,15 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the target of the relation" do
-            post.person.target.should eq(person)
+            expect(post.person.target).to eq(person)
           end
 
           it "sets the foreign key of the relation" do
-            post.person_id.should eq(person.id)
+            expect(post.person_id).to eq(person.id)
           end
 
           it "does not saves the target" do
-            person.should_not be_persisted
+            expect(person).to_not be_persisted
           end
         end
       end
@@ -358,7 +350,7 @@ describe Mongoid::Relations::Referenced::In do
 
           it "should assign as expected" do
             eye.suspended_in = eye_bowl
-            eye.suspended_in.target.should eq(eye_bowl)
+            expect(eye.suspended_in.target).to eq(eye_bowl)
           end
         end
 
@@ -379,15 +371,15 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "sets the target of the relation" do
-              rating.ratable.target.should eq(movie)
+              expect(rating.ratable.target).to eq(movie)
             end
 
             it "sets the foreign key on the relation" do
-              rating.ratable_id.should eq(movie.id)
+              expect(rating.ratable_id).to eq(movie.id)
             end
 
             it "does not save the target" do
-              movie.should_not be_persisted
+              expect(movie).to_not be_persisted
             end
           end
 
@@ -406,15 +398,15 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "sets the target of the relation" do
-              rating.ratable.target.should eq(movie)
+              expect(rating.ratable.target).to eq(movie)
             end
 
             it "sets the foreign key of the relation" do
-              rating.ratable_id.should eq(movie.id)
+              expect(rating.ratable_id).to eq(movie.id)
             end
 
             it "does not saves the target" do
-              movie.should_not be_persisted
+              expect(movie).to_not be_persisted
             end
           end
         end
@@ -427,15 +419,15 @@ describe Mongoid::Relations::Referenced::In do
     context "when dependent is destroy" do
 
       let(:account) do
-        Account.create
+        Account.create!(name: 'checkings')
       end
 
       let(:drug) do
-        Drug.create
+        Drug.create!
       end
 
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       context "when relation is has_one" do
@@ -454,6 +446,17 @@ describe Mongoid::Relations::Referenced::In do
 
         context "when parent exists" do
 
+          context "when child touch the parent" do
+
+            let!(:account_from_db) { account.reload }
+
+            it "queries only the parent" do
+              expect_query(1) do
+                expect(account_from_db.person.id).to eq(person.id)
+              end
+            end
+          end
+
           context "when child is destroyed" do
 
             before do
@@ -461,11 +464,11 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "deletes child" do
-              account.should be_destroyed
+              expect(account).to be_destroyed
             end
 
             it "deletes parent" do
-              person.should be_destroyed
+              expect(person).to be_destroyed
             end
           end
         end
@@ -494,11 +497,11 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "deletes child" do
-              drug.should be_destroyed
+              expect(drug).to be_destroyed
             end
 
             it "deletes parent" do
-              person.should be_destroyed
+              expect(person).to be_destroyed
             end
           end
         end
@@ -542,11 +545,11 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "deletes child" do
-              account.should be_destroyed
+              expect(account).to be_destroyed
             end
 
             it "deletes parent" do
-              person.should be_destroyed
+              expect(person).to be_destroyed
             end
           end
         end
@@ -575,11 +578,11 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "deletes child" do
-              drug.should be_destroyed
+              expect(drug).to be_destroyed
             end
 
             it "deletes parent" do
-              person.should be_destroyed
+              expect(person).to be_destroyed
             end
           end
         end
@@ -618,15 +621,15 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "deletes child" do
-              account.should be_destroyed
+              expect(account).to be_destroyed
             end
 
             it "doesn't delete parent" do
-              person.should_not be_destroyed
+              expect(person).to_not be_destroyed
             end
 
             it "removes the link" do
-              person.account.should be_nil
+              expect(person.account).to be_nil
             end
           end
         end
@@ -650,15 +653,15 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "deletes child" do
-              drug.should be_destroyed
+              expect(drug).to be_destroyed
             end
 
             it "doesn't deletes parent" do
-              person.should_not be_destroyed
+              expect(person).to_not be_destroyed
             end
 
             it "removes the link" do
-              person.drugs.should eq([])
+              expect(person.drugs).to eq([])
             end
           end
         end
@@ -681,11 +684,11 @@ describe Mongoid::Relations::Referenced::In do
       end
 
       it "removes the relation" do
-        agent.game.should be_nil
+        expect(agent.game).to be_nil
       end
 
       it "removes the foreign_key" do
-        agent.game_id.should be_nil
+        expect(agent.game_id).to be_nil
       end
     end
 
@@ -709,15 +712,15 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the relation to nil" do
-            game.person.should be_nil
+            expect(game.person).to be_nil
           end
 
           it "removed the inverse relation" do
-            person.game.should be_nil
+            expect(person.game).to be_nil
           end
 
           it "removes the foreign key value" do
-            game.person_id.should be_nil
+            expect(game.person_id).to be_nil
           end
         end
 
@@ -737,84 +740,25 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the relation to nil" do
-            game.person.should be_nil
+            expect(game.person).to be_nil
           end
 
           it "removed the inverse relation" do
-            person.game.should be_nil
+            expect(person.game).to be_nil
           end
 
           it "removes the foreign key value" do
-            game.person_id.should be_nil
+            expect(game.person_id).to be_nil
           end
 
           it "does not delete the child" do
-            game.should_not be_destroyed
+            expect(game).to_not be_destroyed
           end
         end
       end
 
       context "when the relation is polymorphic" do
 
-        context "when multiple relations against the same class exist" do
-
-          context "when the parent is a new record" do
-
-            let(:face) do
-              Face.new
-            end
-
-            let(:eye) do
-              Eye.new
-            end
-
-            before do
-              face.left_eye = eye
-              eye.eyeable = nil
-            end
-
-            it "sets the relation to nil" do
-              eye.eyeable.should be_nil
-            end
-
-            it "removed the inverse relation" do
-              face.left_eye.should be_nil
-            end
-
-            it "removes the foreign key value" do
-              eye.eyeable_id.should be_nil
-            end
-          end
-
-          context "when the parent is not a new record" do
-
-            let(:face) do
-              Face.new
-            end
-
-            let(:eye) do
-              Eye.create
-            end
-
-            before do
-              face.left_eye = eye
-              eye.eyeable = nil
-            end
-
-            it "sets the relation to nil" do
-              eye.eyeable.should be_nil
-            end
-
-            it "removed the inverse relation" do
-              face.left_eye.should be_nil
-            end
-
-            it "removes the foreign key value" do
-              eye.eyeable_id.should be_nil
-            end
-          end
-        end
-
         context "when one relation against the same class exists" do
 
           context "when the parent is a new record" do
@@ -833,15 +777,15 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "sets the relation to nil" do
-              rating.ratable.should be_nil
+              expect(rating.ratable).to be_nil
             end
 
             it "removed the inverse relation" do
-              bar.rating.should be_nil
+              expect(bar.rating).to be_nil
             end
 
             it "removes the foreign key value" do
-              rating.ratable_id.should be_nil
+              expect(rating.ratable_id).to be_nil
             end
           end
 
@@ -861,15 +805,15 @@ describe Mongoid::Relations::Referenced::In do
             end
 
             it "sets the relation to nil" do
-              rating.ratable.should be_nil
+              expect(rating.ratable).to be_nil
             end
 
             it "removed the inverse relation" do
-              bar.rating.should be_nil
+              expect(bar.rating).to be_nil
             end
 
             it "removes the foreign key value" do
-              rating.ratable_id.should be_nil
+              expect(rating.ratable_id).to be_nil
             end
           end
         end
@@ -896,15 +840,15 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the relation to nil" do
-            post.person.should be_nil
+            expect(post.person).to be_nil
           end
 
           it "removed the inverse relation" do
-            person.posts.should be_empty
+            expect(person.posts).to be_empty
           end
 
           it "removes the foreign key value" do
-            post.person_id.should be_nil
+            expect(post.person_id).to be_nil
           end
         end
 
@@ -924,15 +868,15 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the relation to nil" do
-            post.person.should be_nil
+            expect(post.person).to be_nil
           end
 
           it "removed the inverse relation" do
-            person.posts.should be_empty
+            expect(person.posts).to be_empty
           end
 
           it "removes the foreign key value" do
-            post.person_id.should be_nil
+            expect(post.person_id).to be_nil
           end
         end
       end
@@ -955,15 +899,15 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the relation to nil" do
-            rating.ratable.should be_nil
+            expect(rating.ratable).to be_nil
           end
 
           it "removed the inverse relation" do
-            movie.ratings.should be_empty
+            expect(movie.ratings).to be_empty
           end
 
           it "removes the foreign key value" do
-            rating.ratable_id.should be_nil
+            expect(rating.ratable_id).to be_nil
           end
         end
 
@@ -983,15 +927,15 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "sets the relation to nil" do
-            rating.ratable.should be_nil
+            expect(rating.ratable).to be_nil
           end
 
           it "removed the inverse relation" do
-            movie.ratings.should be_empty
+            expect(movie.ratings).to be_empty
           end
 
           it "removes the foreign key value" do
-            rating.ratable_id.should be_nil
+            expect(rating.ratable_id).to be_nil
           end
         end
       end
@@ -1005,112 +949,38 @@ describe Mongoid::Relations::Referenced::In do
     end
 
     let(:document) do
-      stub
+      double
     end
 
     let(:metadata) do
-      stub(extension?: false)
+      double(extension?: false)
     end
 
     it "returns the embedded in builder" do
-      described_class.builder(nil, metadata, document).should
-        be_a_kind_of(builder_klass)
-    end
-  end
-
-  describe ".eager_load" do
-
-    before do
-      Mongoid.identity_map_enabled = true
-    end
-
-    after do
-      Mongoid.identity_map_enabled = false
-    end
-
-    context "when the relation is not polymorphic" do
-
-      let!(:person) do
-        Person.create
-      end
-
-      let!(:post) do
-        person.posts.create(title: "testing")
-      end
-
-      let(:metadata) do
-        Post.relations["person"]
-      end
-
-      let(:eager) do
-        described_class.eager_load(metadata, Post.all)
-      end
-
-      let!(:map) do
-        Mongoid::IdentityMap.get(Person, person.id)
-      end
-
-      it "puts the document in the identity map" do
-        map.should eq(person)
-      end
-    end
-
-    context "when the relation is polymorphic" do
-
-      let(:metadata) do
-        Rating.relations["ratable"]
-      end
-
-      it "raises an error" do
-        expect {
-          described_class.eager_load(metadata, Rating.all)
-        }.to raise_error(Mongoid::Errors::EagerLoad)
-      end
-    end
-
-    context "when the ids has been duplicated" do
-
-      let!(:person) do
-        Person.create
-      end
-
-      let!(:posts) do
-        2.times {|i| person.posts.create(title: "testing#{i}") }
-        person.posts
-      end
-
-      let(:metadata) do
-        Post.relations["person"]
-      end
-
-      let(:eager) do
-        described_class.eager_load(metadata, posts.map(&:person_id))
-      end
-
-      it "duplication should be removed" do
-        eager.count.should eq(1)
-      end
+      expect(
+        described_class.builder(nil, metadata, document)
+      ).to be_a_kind_of(builder_klass)
     end
   end
 
   describe ".embedded?" do
 
     it "returns false" do
-      described_class.should_not be_embedded
+      expect(described_class).to_not be_embedded
     end
   end
 
   describe ".foreign_key_suffix" do
 
     it "returns _id" do
-      described_class.foreign_key_suffix.should eq("_id")
+      expect(described_class.foreign_key_suffix).to eq("_id")
     end
   end
 
   describe ".macro" do
 
     it "returns belongs_to" do
-      described_class.macro.should eq(:belongs_to)
+      expect(described_class.macro).to eq(:belongs_to)
     end
   end
 
@@ -1133,7 +1003,7 @@ describe Mongoid::Relations::Referenced::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
@@ -1142,14 +1012,14 @@ describe Mongoid::Relations::Referenced::In do
   describe ".stores_foreign_key?" do
 
     it "returns true" do
-      described_class.stores_foreign_key?.should be_true
+      expect(described_class.stores_foreign_key?).to be true
     end
   end
 
   describe ".valid_options" do
 
     it "returns the valid options" do
-      described_class.valid_options.should eq(
+      expect(described_class.valid_options).to eq(
         [
           :autobuild,
           :autosave,
@@ -1167,7 +1037,7 @@ describe Mongoid::Relations::Referenced::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
 
@@ -1188,11 +1058,11 @@ describe Mongoid::Relations::Referenced::In do
       end
 
       it "sets the parent" do
-        game_one.parent.should eq(game_two)
+        expect(game_one.parent).to eq(game_two)
       end
 
       it "does not set the parent recursively" do
-        game_two.parent.should be_nil
+        expect(game_two.parent).to be_nil
       end
     end
   end
@@ -1254,7 +1124,7 @@ describe Mongoid::Relations::Referenced::In do
           end
 
           it "allows the reset of the has one" do
-            b.c.should eq(c)
+            expect(b.c).to eq(c)
           end
         end
       end
@@ -1281,19 +1151,19 @@ describe Mongoid::Relations::Referenced::In do
     end
 
     it "clones the relation" do
-      post.person.should eq(person)
+      expect(post.person).to eq(person)
     end
 
     it "sets the foreign key" do
-      post.person_id.should eq(person.id)
+      expect(post.person_id).to eq(person.id)
     end
 
     it "does not remove the previous relation" do
-      game.person.should eq(person)
+      expect(game.person).to eq(person)
     end
 
     it "does not remove the previous foreign key" do
-      game.person_id.should eq(person.id)
+      expect(game.person_id).to eq(person.id)
     end
 
     context "when reloading" do
@@ -1304,19 +1174,19 @@ describe Mongoid::Relations::Referenced::In do
       end
 
       it "persists the relation" do
-        post.reload.person.should eq(person)
+        expect(post.reload.person).to eq(person)
       end
 
       it "persists the foreign key" do
-        post.reload.person_id.should eq(game.person_id)
+        expect(post.reload.person_id).to eq(game.person_id)
       end
 
       it "does not remove the previous relation" do
-        game.person.should eq(person)
+        expect(game.person).to eq(person)
       end
 
       it "does not remove the previous foreign key" do
-        game.person_id.should eq(person.id)
+        expect(game.person_id).to eq(person.id)
       end
     end
   end
@@ -1338,11 +1208,11 @@ describe Mongoid::Relations::Referenced::In do
       end
 
       it "sets the correct has one" do
-        comment.account.should eq(account)
+        expect(comment.account).to eq(account)
       end
 
       it "sets the correct has many" do
-        comment.movie.should eq(movie)
+        expect(comment.movie).to eq(movie)
       end
     end
   end
@@ -1378,11 +1248,11 @@ describe Mongoid::Relations::Referenced::In do
       end
 
       it "reloads the document from the database" do
-        reloaded.title.should eq("Madam")
+        expect(reloaded.title).to eq("Madam")
       end
 
       it "sets a new document instance" do
-        reloaded.should_not equal(person_one)
+        expect(reloaded).to_not equal(person_one)
       end
     end
 
@@ -1398,56 +1268,11 @@ describe Mongoid::Relations::Referenced::In do
       end
 
       it "reloads the new document from the database" do
-        reloaded.title.should eq("Sir")
+        expect(reloaded.title).to eq("Sir")
       end
 
       it "sets a new document instance" do
-        reloaded.should_not equal(person_one)
-      end
-    end
-  end
-
-  context "when the parent and child are persisted" do
-
-    context "when the identity map is enabled" do
-
-      before do
-        Mongoid.identity_map_enabled = true
-      end
-
-      after do
-        Mongoid.identity_map_enabled = false
-      end
-
-      let(:series) do
-        Series.create
-      end
-
-      let!(:book_one) do
-        series.books.create
-      end
-
-      let!(:book_two) do
-        series.books.create
-      end
-
-      let(:id) do
-        Book.first.id
-      end
-
-      context "when asking for the inverse multiple times" do
-
-        before do
-          Book.find(id).series.books.to_a
-        end
-
-        it "does not append and save duplicate docs" do
-          Book.find(id).series.books.to_a.length.should eq(2)
-        end
-
-        it "returns the same documents from the map" do
-          Book.find(id).should equal(Book.find(id))
-        end
+        expect(reloaded).to_not equal(person_one)
       end
     end
   end
@@ -1465,11 +1290,11 @@ describe Mongoid::Relations::Referenced::In do
     end
 
     it "allows strings to be passed as the id" do
-      cookie.jar.should eq(jar)
+      expect(cookie.jar).to eq(jar)
     end
 
     it "persists the relation" do
-      cookie.reload.jar.should eq(jar)
+      expect(cookie.reload.jar).to eq(jar)
     end
   end
 
@@ -1494,7 +1319,7 @@ describe Mongoid::Relations::Referenced::In do
       end
 
       it "sets the new document on the relation" do
-        game.person.should eq(person_two)
+        expect(game.person).to eq(person_two)
       end
     end
   end