mongoid 3.1.6 → 4.0.2

data/spec/mongoid/relations/reflections_spec.rb

@@ -27,7 +27,7 @@ describe Mongoid::Relations::Reflections do
       end
 
       it "returns the association metadata" do
-        relation.macro.should eq(:embeds_many)
+        expect(relation.macro).to eq(:embeds_many)
       end
     end
 
@@ -38,7 +38,7 @@ describe Mongoid::Relations::Reflections do
       end
 
       it "returns nil" do
-        relation.should be_nil
+        expect(relation).to be_nil
       end
     end
   end
@@ -60,7 +60,7 @@ describe Mongoid::Relations::Reflections do
         end
 
         it "returns an array of the relations" do
-          relations.size.should eq(2)
+          expect(relations.size).to eq(2)
         end
       end
 
@@ -71,7 +71,7 @@ describe Mongoid::Relations::Reflections do
         end
 
         it "returns an array of the relations" do
-          relations.size.should eq(1)
+          expect(relations.size).to eq(1)
         end
       end
     end
@@ -83,7 +83,7 @@ describe Mongoid::Relations::Reflections do
       end
 
       it "returns an empty array" do
-        relations.should be_empty
+        expect(relations).to be_empty
       end
     end
 
@@ -94,7 +94,7 @@ describe Mongoid::Relations::Reflections do
       end
 
       it "returns an empty array" do
-        relations.should be_empty
+        expect(relations).to be_empty
       end
     end
   end

data/spec/mongoid/relations/synchronization_spec.rb

@@ -37,30 +37,30 @@ describe Mongoid::Relations::Synchronization do
       end
 
       it "has persisted :agent" do
-        agent.persisted?.should be_true
+        expect(agent.persisted?).to be true
       end
 
       it "has persisted :user" do
-        user.persisted?.should be_true
+        expect(user.persisted?).to be true
       end
 
       it "has persisted :person" do
-        person.persisted?.should be_true
+        expect(person.persisted?).to be true
       end
 
       it "does not have persisted :account" do
-        account.persisted?.should be_false
+        expect(account.persisted?).to be false
       end
 
       it "has instantiated a .valid? :account" do
         account.valid?
-        account.valid?.should be_true
+        expect(account.valid?).to be true
       end
 
       context "and is Persisted" do
 
         it "is able to :save" do
-          account.save.should be_true
+          expect(account.save).to be true
         end
       end
 
@@ -71,7 +71,7 @@ describe Mongoid::Relations::Synchronization do
         end
 
         it "is able to :save" do
-          account.save.should be_true
+          expect(account.save).to be true
         end
       end
     end
@@ -92,11 +92,11 @@ describe Mongoid::Relations::Synchronization do
     end
 
     it "does not attempt synchronization" do
-      expect { article.save }.to_not raise_error(TypeError)
+      expect { article.save }.to_not raise_error
     end
 
     it "sets the one side of the relation" do
-      article.preferences.should eq([ preference ])
+      expect(article.preferences).to eq([ preference ])
     end
   end
 
@@ -115,11 +115,11 @@ describe Mongoid::Relations::Synchronization do
     end
 
     it "sets the inverse foreign key" do
-      one.person_ids.should eq([ person.id ])
+      expect(one.person_ids).to eq([ person.id ])
     end
 
     it "resets the synced flag" do
-      person.synced["preference_ids"].should be_false
+      expect(person.synced["preference_ids"]).to be false
     end
 
     context "when subsequently setting with keys" do
@@ -134,7 +134,7 @@ describe Mongoid::Relations::Synchronization do
       end
 
       it "sets the inverse foreign key" do
-        two.reload.person_ids.should eq([ person.id ])
+        expect(two.reload.person_ids).to eq([ person.id ])
       end
     end
   end
@@ -158,15 +158,15 @@ describe Mongoid::Relations::Synchronization do
     end
 
     it "sets the foreign_key" do
-      person.preference_ids.should eq([ one.id, two.id ])
+      expect(person.preference_ids).to eq([ one.id, two.id ])
     end
 
     it "does not set the first inverse key" do
-      one.reload.person_ids.should be_empty
+      expect(one.reload.person_ids).to be_empty
     end
 
     it "does not set the second inverse key" do
-      two.reload.person_ids.should be_empty
+      expect(two.reload.person_ids).to be_empty
     end
 
     context "when saving the base" do
@@ -178,15 +178,15 @@ describe Mongoid::Relations::Synchronization do
         end
 
         it "persists the foreign_key" do
-          person.reload.preference_ids.should eq([ one.id, two.id ])
+          expect(person.reload.preference_ids).to eq([ one.id, two.id ])
         end
 
         it "sets the first inverse key" do
-          one.reload.person_ids.should eq([ person.id ])
+          expect(one.reload.person_ids).to eq([ person.id ])
         end
 
         it "sets the second inverse key" do
-          two.reload.person_ids.should eq([ person.id ])
+          expect(two.reload.person_ids).to eq([ person.id ])
         end
       end
     end
@@ -215,19 +215,19 @@ describe Mongoid::Relations::Synchronization do
     end
 
     it "sets the foreign_key" do
-      person.preference_ids.should eq([ three.id ])
+      expect(person.preference_ids).to eq([ three.id ])
     end
 
     it "does not remove the first inverse key" do
-      one.reload.person_ids.should eq([ person.id ])
+      expect(one.reload.person_ids).to eq([ person.id ])
     end
 
     it "does not remove the second inverse key" do
-      two.reload.person_ids.should eq([ person.id ])
+      expect(two.reload.person_ids).to eq([ person.id ])
     end
 
     it "does not set the third inverse key" do
-      three.reload.person_ids.should be_empty
+      expect(three.reload.person_ids).to be_empty
     end
 
     context "when saving the base" do
@@ -239,19 +239,19 @@ describe Mongoid::Relations::Synchronization do
         end
 
         it "persists the foreign_key" do
-          person.reload.preference_ids.should eq([ three.id ])
+          expect(person.reload.preference_ids).to eq([ three.id ])
         end
 
         it "removes the first inverse key" do
-          one.reload.person_ids.should be_empty
+          expect(one.reload.person_ids).to be_empty
         end
 
         it "removes the second inverse key" do
-          two.reload.person_ids.should be_empty
+          expect(two.reload.person_ids).to be_empty
         end
 
         it "sets the third inverse key" do
-          three.reload.person_ids.should eq([ person.id ])
+          expect(three.reload.person_ids).to eq([ person.id ])
         end
       end
     end
@@ -276,15 +276,15 @@ describe Mongoid::Relations::Synchronization do
     end
 
     it "sets the foreign_key" do
-      person.preference_ids.should be_empty
+      expect(person.preference_ids).to be_empty
     end
 
     it "does not remove the first inverse key" do
-      one.reload.person_ids.should eq([ person.id ])
+      expect(one.reload.person_ids).to eq([ person.id ])
     end
 
     it "does not remove the second inverse key" do
-      two.reload.person_ids.should eq([ person.id ])
+      expect(two.reload.person_ids).to eq([ person.id ])
     end
 
     context "when saving the base" do
@@ -296,15 +296,15 @@ describe Mongoid::Relations::Synchronization do
         end
 
         it "persists the foreign_key" do
-          person.reload.preference_ids.should be_empty
+          expect(person.reload.preference_ids).to be_empty
         end
 
         it "removes the first inverse key" do
-          one.reload.person_ids.should be_empty
+          expect(one.reload.person_ids).to be_empty
         end
 
         it "removes the second inverse key" do
-          two.reload.person_ids.should be_empty
+          expect(two.reload.person_ids).to be_empty
         end
       end
     end
@@ -329,15 +329,15 @@ describe Mongoid::Relations::Synchronization do
     end
 
     it "sets the foreign_key" do
-      person.preference_ids.should be_empty
+      expect(person.preference_ids).to be_empty
     end
 
     it "does not remove the first inverse key" do
-      one.reload.person_ids.should eq([ person.id ])
+      expect(one.reload.person_ids).to eq([ person.id ])
     end
 
     it "does not remove the second inverse key" do
-      two.reload.person_ids.should eq([ person.id ])
+      expect(two.reload.person_ids).to eq([ person.id ])
     end
 
     context "when saving the base" do
@@ -349,15 +349,15 @@ describe Mongoid::Relations::Synchronization do
         end
 
         it "persists the foreign_key" do
-          person.reload.preference_ids.should be_empty
+          expect(person.reload.preference_ids).to be_empty
         end
 
         it "removes the first inverse key" do
-          one.reload.person_ids.should be_empty
+          expect(one.reload.person_ids).to be_empty
         end
 
         it "removes the second inverse key" do
-          two.reload.person_ids.should be_empty
+          expect(two.reload.person_ids).to be_empty
         end
       end
     end
@@ -384,11 +384,11 @@ describe Mongoid::Relations::Synchronization do
       end
 
       it "removes the first inverse key" do
-        one.reload.person_ids.should be_empty
+        expect(one.reload.person_ids).to be_empty
       end
 
       it "removes the second inverse key" do
-        two.reload.person_ids.should be_empty
+        expect(two.reload.person_ids).to be_empty
       end
     end
 
@@ -399,14 +399,14 @@ describe Mongoid::Relations::Synchronization do
       end
 
       it "removes the inverse key" do
-        person.reload.preference_ids.should eq([ two.id ])
+        expect(person.reload.preference_ids).to eq([ two.id ])
       end
     end
   end
 
   context "when appending an existing document to a new one" do
 
-    let!(:peristed) do
+    let!(:persisted) do
       Tag.create
     end
 
@@ -415,20 +415,16 @@ describe Mongoid::Relations::Synchronization do
     end
 
     before do
-      article.tags << Tag.first
+      article.tags << persisted
       article.save
     end
 
-    let(:tag) do
-      Tag.first
-    end
-
     it "persists the foreign key on the inverse" do
-      tag.article_ids.should eq([ article.id ])
+      expect(persisted.article_ids).to eq([ article.id ])
     end
 
     it "persists the inverse relation" do
-      tag.articles.should eq([ article ])
+      expect(persisted.articles).to eq([ article ])
     end
   end
 
@@ -447,7 +443,7 @@ describe Mongoid::Relations::Synchronization do
     end
 
     it "adds the id to the inverse relation" do
-      dog.reload.breed_ids.should eq([ breed.id ])
+      expect(dog.reload.breed_ids).to eq([ breed.id ])
     end
   end
 end

data/spec/mongoid/relations/targets/enumerable_spec.rb

@@ -25,7 +25,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the equality check" do
-          enumerable.should eq([ post ])
+          expect(enumerable).to eq([ post ])
         end
       end
 
@@ -36,7 +36,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the equality check" do
-          enumerable._loaded.values.should eq([ post ])
+          expect(enumerable._loaded.values).to eq([ post ])
         end
       end
 
@@ -61,7 +61,7 @@ describe Mongoid::Relations::Targets::Enumerable do
           end
 
           it "returns the equality check" do
-            enumerable.should eq([ post, post_two ])
+            expect(enumerable).to eq([ post, post_two ])
           end
         end
 
@@ -72,7 +72,7 @@ describe Mongoid::Relations::Targets::Enumerable do
           end
 
           it "returns the equality check" do
-            enumerable.should eq([ post ])
+            expect(enumerable).to eq([ post ])
           end
         end
 
@@ -90,7 +90,7 @@ describe Mongoid::Relations::Targets::Enumerable do
             end
 
             it "returns the equality check" do
-              enumerable.should eq([ post ])
+              expect(enumerable).to eq([ post ])
             end
           end
         end
@@ -104,7 +104,7 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "returns false" do
-        enumerable.should_not eq("person")
+        expect(enumerable).to_not eq("person")
       end
     end
   end
@@ -118,14 +118,14 @@ describe Mongoid::Relations::Targets::Enumerable do
     context "when compared to an array class" do
 
       it "returns true" do
-        expect(enumerable === Array).to be_true
+        expect(enumerable === Array).to be true
       end
     end
 
     context "when compared to a different class" do
 
       it "returns false" do
-        expect(enumerable === Mongoid::Document).to be_false
+        expect(enumerable === Mongoid::Document).to be false
       end
     end
 
@@ -138,7 +138,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns true" do
-          expect(enumerable === other).to be_true
+          expect(enumerable === other).to be true
         end
       end
 
@@ -149,7 +149,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns false" do
-          expect(enumerable === other).to be_false
+          expect(enumerable === other).to be false
         end
       end
     end
@@ -176,11 +176,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "adds the document to the added target" do
-        enumerable._added.should eq({ post.id => post })
+        expect(enumerable._added).to eq({ post.id => post })
       end
 
       it "returns the added documents" do
-        added.should eq([ post ])
+        expect(added).to eq([ post ])
       end
     end
   end
@@ -214,15 +214,15 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "returns true" do
-        any.should be_true
+        expect(any).to be true
       end
 
       it "retains the correct length" do
-        enumerable.length.should eq(2)
+        expect(enumerable.length).to eq(2)
       end
 
       it "retains the correct length when calling to_a" do
-        enumerable.to_a.length.should eq(2)
+        expect(enumerable.to_a.length).to eq(2)
       end
 
       context "when iterating over the relation a second time" do
@@ -232,11 +232,11 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "retains the correct length" do
-          enumerable.length.should eq(2)
+          expect(enumerable.length).to eq(2)
         end
 
         it "retains the correct length when calling to_a" do
-          enumerable.to_a.length.should eq(2)
+          expect(enumerable.to_a.length).to eq(2)
         end
       end
     end
@@ -271,20 +271,20 @@ describe Mongoid::Relations::Targets::Enumerable do
 
     let!(:clear) do
       enumerable.clear do |doc|
-        doc.should be_a(Post)
+        expect(doc).to be_a(Post)
       end
     end
 
     it "clears out the loaded docs" do
-      enumerable._loaded.should be_empty
+      expect(enumerable._loaded).to be_empty
     end
 
     it "clears out the added docs" do
-      enumerable._added.should be_empty
+      expect(enumerable._added).to be_empty
     end
 
     it "retains its loaded state" do
-      enumerable.should_not be__loaded
+      expect(enumerable).to_not be__loaded
     end
   end
 
@@ -320,11 +320,11 @@ describe Mongoid::Relations::Targets::Enumerable do
     end
 
     it "does not retain the first id" do
-      cloned.first.should_not eq(post)
+      expect(cloned.first).to_not eq(post)
     end
 
     it "does not retain the last id" do
-      cloned.last.should_not eq(post_two)
+      expect(cloned.last).to_not eq(post_two)
     end
   end
 
@@ -349,11 +349,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "deletes the document from the enumerable" do
-        enumerable._loaded.should be_empty
+        expect(enumerable._loaded).to be_empty
       end
 
       it "returns the document" do
-        deleted.should eq(post)
+        expect(deleted).to eq(post)
       end
     end
 
@@ -380,11 +380,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "removes the document from the added docs" do
-        enumerable._added.should be_empty
+        expect(enumerable._added).to be_empty
       end
 
       it "returns the document" do
-        deleted.should eq(post)
+        expect(deleted).to eq(post)
       end
     end
 
@@ -407,11 +407,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "does not load the document" do
-        enumerable._loaded.should be_empty
+        expect(enumerable._loaded).to be_empty
       end
 
       it "returns the document" do
-        deleted.should eq(post)
+        expect(deleted).to eq(post)
       end
     end
 
@@ -431,12 +431,12 @@ describe Mongoid::Relations::Targets::Enumerable do
 
       let!(:deleted) do
         enumerable.delete(Post.new) do |doc|
-          doc.should be_nil
+          expect(doc).to be_nil
         end
       end
 
       it "returns nil" do
-        deleted.should be_nil
+        expect(deleted).to be_nil
       end
     end
   end
@@ -462,11 +462,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "deletes the document from the enumerable" do
-        enumerable._loaded.should be_empty
+        expect(enumerable._loaded).to be_empty
       end
 
       it "returns the remaining docs" do
-        deleted.should be_empty
+        expect(deleted).to be_empty
       end
     end
 
@@ -493,11 +493,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "removes the document from the added docs" do
-        enumerable._added.should be_empty
+        expect(enumerable._added).to be_empty
       end
 
       it "returns the remaining docs" do
-        deleted.should be_empty
+        expect(deleted).to be_empty
       end
     end
 
@@ -520,11 +520,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "does not load the document" do
-        enumerable._loaded.should be_empty
+        expect(enumerable._loaded).to be_empty
       end
 
       it "returns the remaining docs" do
-        deleted.should be_empty
+        expect(deleted).to be_empty
       end
     end
 
@@ -547,7 +547,7 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "returns the remaining docs" do
-        deleted.should eq([ post ])
+        expect(deleted).to eq([ post ])
       end
     end
   end
@@ -577,7 +577,7 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "sets the value on the instance" do
-        enumerable.detect{ |post| post.title = "test" }.rating.should eq(10)
+        expect(enumerable.detect{ |post| post.title = "test" }.rating).to eq(10)
       end
     end
   end
@@ -604,16 +604,16 @@ describe Mongoid::Relations::Targets::Enumerable do
 
       let!(:iterated) do
         enumerable.each do |doc|
-          doc.should be_a(Post)
+          expect(doc).to be_a(Post)
         end
       end
 
       it "loads each document" do
-        enumerable._loaded.should eq({ post.id => post })
+        expect(enumerable._loaded).to eq({ post.id => post })
       end
 
       it "becomes loaded" do
-        enumerable.should be__loaded
+        expect(enumerable).to be__loaded
       end
     end
 
@@ -625,16 +625,16 @@ describe Mongoid::Relations::Targets::Enumerable do
 
       let!(:iterated) do
         enumerable.each do |doc|
-          doc.should be_a(Post)
+          expect(doc).to be_a(Post)
         end
       end
 
       it "does not alter the loaded docs" do
-        enumerable._loaded.should eq({ post.id => post })
+        expect(enumerable._loaded).to eq({ post.id => post })
       end
 
       it "stays loaded" do
-        enumerable.should be__loaded
+        expect(enumerable).to be__loaded
       end
     end
 
@@ -660,20 +660,20 @@ describe Mongoid::Relations::Targets::Enumerable do
 
         let!(:iterated) do
           enumerable.each do |doc|
-            doc.should be_a(Post)
+            expect(doc).to be_a(Post)
           end
         end
 
         it "adds the unloaded to the loaded docs" do
-          enumerable._loaded.should eq({ post.id => post })
+          expect(enumerable._loaded).to eq({ post.id => post })
         end
 
         it "keeps the appended in the added docs" do
-          enumerable._added.should eq({ post_two.id => post_two })
+          expect(enumerable._added).to eq({ post_two.id => post_two })
         end
 
         it "stays loaded" do
-          enumerable.should be__loaded
+          expect(enumerable).to be__loaded
         end
       end
 
@@ -685,16 +685,16 @@ describe Mongoid::Relations::Targets::Enumerable do
 
         let!(:iterated) do
           enumerable.each do |doc|
-            doc.should be_a(Post)
+            expect(doc).to be_a(Post)
           end
         end
 
         it "adds the persisted added doc to the loaded" do
-          enumerable._loaded.should eq({ post.id => post })
+          expect(enumerable._loaded).to eq({ post.id => post })
         end
 
         it "stays loaded" do
-          enumerable.should be__loaded
+          expect(enumerable).to be__loaded
         end
       end
     end
@@ -710,7 +710,7 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "returns an enumerator" do
-        enumerable.each.class.include?(Enumerable).should be_true
+        expect(enumerable.each.class.include?(Enumerable)).to be true
       end
 
     end
@@ -745,7 +745,7 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "yields to the in memory documents first" do
-        entries.first.should equal(post)
+        expect(entries.first).to equal(post)
       end
     end
   end
@@ -779,15 +779,15 @@ describe Mongoid::Relations::Targets::Enumerable do
           end
 
           it "returns the first unloaded doc" do
-            first.should eq(post)
+            expect(first).to eq(post)
           end
 
           it "does not load the enumerable" do
-            enumerable.should_not be__loaded
+            expect(enumerable).to_not be__loaded
           end
 
           it "receives query only once" do
-            criteria.should_receive(:first).once
+            expect(criteria).to receive(:first).once
             first
           end
         end
@@ -813,11 +813,11 @@ describe Mongoid::Relations::Targets::Enumerable do
           context "when a perviously persisted unloaded doc exists" do
 
             it "returns the first added doc" do
-              first.should eq(post)
+              expect(first).to eq(post)
             end
 
             it "does not load the enumerable" do
-              enumerable.should_not be__loaded
+              expect(enumerable).to_not be__loaded
             end
           end
         end
@@ -838,11 +838,11 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the first loaded doc" do
-          first.should eq(post)
+          expect(first).to eq(post)
         end
 
         it "does not load the enumerable" do
-          enumerable.should_not be__loaded
+          expect(enumerable).to_not be__loaded
         end
       end
 
@@ -853,11 +853,11 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns nil" do
-          first.should be_nil
+          expect(first).to be_nil
         end
 
         it "does not load the enumerable" do
-          enumerable.should_not be__loaded
+          expect(enumerable).to_not be__loaded
         end
       end
     end
@@ -879,7 +879,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the first loaded doc" do
-          first.should eq(post)
+          expect(first).to eq(post)
         end
       end
 
@@ -902,7 +902,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the first added doc" do
-          first.should eq(post)
+          expect(first).to eq(post)
         end
       end
 
@@ -917,7 +917,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns nil" do
-          first.should be_nil
+          expect(first).to be_nil
         end
       end
     end
@@ -950,15 +950,15 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns true" do
-          included.should be_true
+          expect(included).to be true
         end
 
         it "retains the correct length" do
-          enumerable.length.should eq(2)
+          expect(enumerable.length).to eq(2)
         end
 
         it "retains the correct length when calling to_a" do
-          enumerable.to_a.length.should eq(2)
+          expect(enumerable.to_a.length).to eq(2)
         end
       end
 
@@ -981,7 +981,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns true" do
-          included.should be_true
+          expect(included).to be true
         end
       end
     end
@@ -1001,15 +1001,15 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "returns true" do
-        included.should be_true
+        expect(included).to be true
       end
 
       it "retains the correct length" do
-        enumerable.length.should eq(2)
+        expect(enumerable.length).to eq(2)
       end
 
       it "retains the correct length when calling to_a" do
-        enumerable.to_a.length.should eq(2)
+        expect(enumerable.to_a.length).to eq(2)
       end
 
       context "when iterating over the relation a second time" do
@@ -1019,11 +1019,11 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "retains the correct length" do
-          enumerable.length.should eq(2)
+          expect(enumerable.length).to eq(2)
         end
 
         it "retains the correct length when calling to_a" do
-          enumerable.to_a.length.should eq(2)
+          expect(enumerable.to_a.length).to eq(2)
         end
       end
     end
@@ -1046,11 +1046,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "sets the criteria" do
-        enumerable._unloaded.should eq(criteria)
+        expect(enumerable._unloaded).to eq(criteria)
       end
 
       it "is not loaded" do
-        enumerable.should_not be__loaded
+        expect(enumerable).to_not be__loaded
       end
     end
 
@@ -1065,11 +1065,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "does not set a criteria" do
-        enumerable._unloaded.should be_nil
+        expect(enumerable._unloaded).to be_nil
       end
 
       it "is loaded" do
-        enumerable.should be__loaded
+        expect(enumerable).to be__loaded
       end
     end
   end
@@ -1103,7 +1103,7 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "returns the loaded and added docs" do
-        in_memory.should eq([ post, post_two ])
+        expect(in_memory).to eq([ post, post_two ])
       end
     end
 
@@ -1130,7 +1130,7 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "returns the added docs" do
-        in_memory.should eq([ post_two ])
+        expect(in_memory).to eq([ post_two ])
       end
     end
 
@@ -1150,7 +1150,7 @@ describe Mongoid::Relations::Targets::Enumerable do
 
       it "yields to each in memory document" do
         enumerable.in_memory do |doc|
-          doc.should eq(post_two)
+          expect(doc).to eq(post_two)
         end
       end
     end
@@ -1165,14 +1165,14 @@ describe Mongoid::Relations::Targets::Enumerable do
     context "when checking against enumerable" do
 
       it "returns true" do
-        enumerable.is_a?(::Enumerable).should be_true
+        expect(enumerable.is_a?(::Enumerable)).to be true
       end
     end
 
     context "when checking against array" do
 
       it "returns true" do
-        enumerable.is_a?(Array).should be_true
+        expect(enumerable.is_a?(Array)).to be true
       end
     end
   end
@@ -1204,15 +1204,15 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the last unloaded doc" do
-          last.should eq(post)
+          expect(last).to eq(post)
         end
 
         it "does not load the enumerable" do
-          enumerable.should_not be__loaded
+          expect(enumerable).to_not be__loaded
         end
 
         it "receives query only once" do
-          criteria.should_receive(:last).once
+          expect(criteria).to receive(:last).once
           last
         end
       end
@@ -1232,11 +1232,11 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the last unloaded doc" do
-          last.should eq(post)
+          expect(last).to eq(post)
         end
 
         it "does not load the enumerable" do
-          enumerable.should_not be__loaded
+          expect(enumerable).to_not be__loaded
         end
       end
 
@@ -1247,11 +1247,11 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns nil" do
-          last.should be_nil
+          expect(last).to be_nil
         end
 
         it "does not load the enumerable" do
-          enumerable.should_not be__loaded
+          expect(enumerable).to_not be__loaded
         end
       end
 
@@ -1272,7 +1272,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         context "when accessing from a reloaded child" do
 
           it "returns the last document" do
-            post_one.reload.person.posts.last.should eq(post_two)
+            expect(post_one.reload.person.posts.last).to eq(post_two)
           end
         end
       end
@@ -1295,7 +1295,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the last loaded doc" do
-          last.should eq(post)
+          expect(last).to eq(post)
         end
       end
 
@@ -1318,7 +1318,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the last added doc" do
-          last.should eq(post)
+          expect(last).to eq(post)
         end
       end
 
@@ -1333,7 +1333,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns nil" do
-          last.should be_nil
+          expect(last).to be_nil
         end
       end
     end
@@ -1348,14 +1348,14 @@ describe Mongoid::Relations::Targets::Enumerable do
     context "when checking against enumerable" do
 
       it "returns true" do
-        enumerable.kind_of?(::Enumerable).should be_true
+        expect(enumerable.kind_of?(::Enumerable)).to be true
       end
     end
 
     context "when checking against array" do
 
       it "returns true" do
-        enumerable.kind_of?(Array).should be_true
+        expect(enumerable.kind_of?(Array)).to be true
       end
     end
   end
@@ -1383,15 +1383,15 @@ describe Mongoid::Relations::Targets::Enumerable do
     end
 
     it "loads all the unloaded documents" do
-      enumerable._loaded.should eq({ post.id => post })
+      expect(enumerable._loaded).to eq({ post.id => post })
     end
 
-    it "returns true" do
-      loaded.should be_true
+    it "returns the object" do
+      expect(loaded).to eq([post])
     end
 
     it "sets loaded to true" do
-      enumerable.should be__loaded
+      expect(enumerable).to be__loaded
     end
   end
 
@@ -1422,15 +1422,15 @@ describe Mongoid::Relations::Targets::Enumerable do
     end
 
     it "is not loaded" do
-      enumerable.should_not be__loaded
+      expect(enumerable).to_not be__loaded
     end
 
     it "clears out the loaded docs" do
-      enumerable._loaded.should be_empty
+      expect(enumerable._loaded).to be_empty
     end
 
     it "clears out the added docs" do
-      enumerable._added.should be_empty
+      expect(enumerable._added).to be_empty
     end
   end
 
@@ -1445,7 +1445,7 @@ describe Mongoid::Relations::Targets::Enumerable do
       [].methods.each do |method|
 
         it "returns true for #{method}" do
-          enumerable.should respond_to(method)
+          expect(enumerable).to respond_to(method)
         end
       end
     end
@@ -1480,7 +1480,7 @@ describe Mongoid::Relations::Targets::Enumerable do
           end
 
           it "includes the number of all added documents" do
-            enumerable.size.should eq(1)
+            expect(enumerable.size).to eq(1)
           end
         end
       end
@@ -1505,11 +1505,11 @@ describe Mongoid::Relations::Targets::Enumerable do
       end
 
       it "returns the loaded size plus added size" do
-        size.should eq(2)
+        expect(size).to eq(2)
       end
 
       it "matches the size of the loaded enumerable" do
-        size.should eq(enumerable.to_a.size)
+        expect(size).to eq(enumerable.to_a.size)
       end
     end
 
@@ -1534,7 +1534,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the unloaded count plus added new size" do
-          size.should eq(2)
+          expect(size).to eq(2)
         end
       end
 
@@ -1553,7 +1553,7 @@ describe Mongoid::Relations::Targets::Enumerable do
         end
 
         it "returns the unloaded count plus added new size" do
-          size.should eq(2)
+          expect(size).to eq(2)
         end
       end
     end
@@ -1586,7 +1586,7 @@ describe Mongoid::Relations::Targets::Enumerable do
     end
 
     it "serializes the enumerable" do
-      json.should include(post.title)
+      expect(json).to include(post.title)
     end
   end
 
@@ -1609,7 +1609,7 @@ describe Mongoid::Relations::Targets::Enumerable do
     end
 
     it "serializes the enumerable" do
-      json.should_not include(post.title)
+      expect(json).to_not include(post.title)
     end
   end
 
@@ -1640,8 +1640,8 @@ describe Mongoid::Relations::Targets::Enumerable do
     end
 
     it "serializes the enumerable" do
-      json.size.should eq(1)
-      json[0]['title'].should eq(post.title)
+      expect(json.size).to eq(1)
+      expect(json[0]['title']).to eq(post.title)
     end
   end
 
@@ -1664,11 +1664,11 @@ describe Mongoid::Relations::Targets::Enumerable do
     end
 
     it "serializes the enumerable" do
-      json.size.should eq(1)
+      expect(json.size).to eq(1)
     end
 
     it "includes the proper fields" do
-      json[0].keys.should_not include("title")
+      expect(json[0].keys).to_not include("title")
     end
   end
 
@@ -1700,11 +1700,11 @@ describe Mongoid::Relations::Targets::Enumerable do
     end
 
     it "returns the unique documents" do
-      uniq.should eq([ post ])
+      expect(uniq).to eq([ post ])
     end
 
     it "sets loaded to true" do
-      enumerable.should be__loaded
+      expect(enumerable).to be__loaded
     end
   end
 end