mongoid 3.1.6 → 4.0.0

data/spec/mongoid/criteria_spec.rb

@@ -17,7 +17,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns true" do
-          criteria.should eq(other)
+          expect(criteria).to eq(other)
         end
       end
 
@@ -28,7 +28,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns false" do
-          criteria.should_not eq(other)
+          expect(criteria).to_not eq(other)
         end
       end
     end
@@ -46,7 +46,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns true" do
-          criteria.should eq(other)
+          expect(criteria).to eq(other)
         end
       end
 
@@ -65,7 +65,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns false" do
-          criteria.should_not eq(other)
+          expect(criteria).to_not eq(other)
         end
       end
     end
@@ -73,7 +73,7 @@ describe Mongoid::Criteria do
     context "when the other is neither a criteria or enumerable" do
 
       it "returns false" do
-        criteria.should_not eq("test")
+        expect(criteria).to_not eq("test")
       end
     end
   end
@@ -87,14 +87,14 @@ describe Mongoid::Criteria do
       end
 
       it "returns true" do
-        (described_class === other).should be_true
+        expect(described_class === other).to be true
       end
     end
 
     context "when the other is not a criteria" do
 
       it "returns false" do
-        (described_class === []).should be_false
+        expect(described_class === []).to be false
       end
     end
   end
@@ -124,7 +124,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the sorted documents" do
-        criteria.should eq([ friedel, hobrecht, pfluger ])
+        expect(criteria).to eq([ friedel, hobrecht, pfluger ])
       end
     end
   end
@@ -140,11 +140,11 @@ describe Mongoid::Criteria do
     end
 
     it "adds the batch size option" do
-      criteria.options[:batch_size].should eq(1000)
+      expect(criteria.options[:batch_size]).to eq(1000)
     end
 
     it "returns the correct documents" do
-      criteria.should eq([ person ])
+      expect(criteria).to eq([ person ])
     end
   end
 
@@ -169,23 +169,23 @@ describe Mongoid::Criteria do
       end
 
       it "returns an avg" do
-        aggregates["avg"].should eq(750)
+        expect(aggregates["avg"]).to eq(750)
       end
 
       it "returns a count" do
-        aggregates["count"].should eq(2)
+        expect(aggregates["count"]).to eq(2)
       end
 
       it "returns a max" do
-        aggregates["max"].should eq(1000)
+        expect(aggregates["max"]).to eq(1000)
       end
 
       it "returns a min" do
-        aggregates["min"].should eq(500)
+        expect(aggregates["min"]).to eq(500)
       end
 
       it "returns a sum" do
-        aggregates["sum"].should eq(1500)
+        expect(aggregates["sum"]).to eq(1500)
       end
     end
   end
@@ -211,7 +211,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the avg of the provided field" do
-        avg.should eq(750)
+        expect(avg).to eq(750)
       end
     end
   end
@@ -233,7 +233,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the matching documents" do
-        criteria.should eq([ match ])
+        expect(criteria).to eq([ match ])
       end
     end
   end
@@ -255,7 +255,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the matching documents" do
-        criteria.should eq([ match ])
+        expect(criteria).to eq([ match ])
       end
     end
   end
@@ -271,7 +271,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the criteria as a json hash" do
-      criteria.as_json.should eq([ band.serializable_hash ])
+      expect(criteria.as_json).to eq([ band.serializable_hash ])
     end
   end
 
@@ -290,7 +290,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -309,15 +309,15 @@ describe Mongoid::Criteria do
         end
 
         it "returns the new document" do
-          band.should be_new_record
+          expect(band).to be_new_record
         end
 
         it "sets the criteria attributes" do
-          band.name.should eq("Depeche Mode")
+          expect(band.name).to eq("Depeche Mode")
         end
 
         it "sets the attributes passed to build" do
-          band.genres.should eq([ "electro" ])
+          expect(band.genres).to eq([ "electro" ])
         end
       end
 
@@ -330,15 +330,15 @@ describe Mongoid::Criteria do
           end
 
           it "returns the new document" do
-            band.should be_new_record
+            expect(band).to be_new_record
           end
 
           it "sets the criteria attributes" do
-            band.name.should eq("Depeche Mode")
+            expect(band.name).to eq("Depeche Mode")
           end
 
           it "sets the attributes passed to build" do
-            band.genres.should eq([ "electro" ])
+            expect(band.genres).to eq([ "electro" ])
           end
         end
       end
@@ -362,9 +362,9 @@ describe Mongoid::Criteria do
       end
 
       it "does not hit the database after first iteration" do
-        criteria.context.query.should_receive(:each).never
+        expect(criteria.context.query).to receive(:each).never
         criteria.each do |doc|
-          doc.should eq(person)
+          expect(doc).to eq(person)
         end
       end
     end
@@ -380,9 +380,9 @@ describe Mongoid::Criteria do
       end
 
       it "does not hit the database after first iteration" do
-        criteria.context.query.should_receive(:each).never
+        expect(criteria.context.query).to receive(:each).never
         criteria.each do |doc|
-          doc.should eq(person)
+          expect(doc).to eq(person)
         end
       end
     end
@@ -410,47 +410,47 @@ describe Mongoid::Criteria do
       end
 
       it "contains an equal selector" do
-        clone.selector.should eq({ "name" => "Depeche Mode" })
+        expect(clone.selector).to eq({ "name" => "Depeche Mode" })
       end
 
       it "clones the selector" do
-        clone.selector.should_not equal(criteria.selector)
+        expect(clone.selector).to_not equal(criteria.selector)
       end
 
       it "contains equal options" do
-        clone.options.should eq({ sort: { "name" => 1 }})
+        expect(clone.options).to eq({ sort: { "name" => 1 }})
       end
 
       it "clones the options" do
-        clone.options.should_not equal(criteria.options)
+        expect(clone.options).to_not equal(criteria.options)
       end
 
       it "contains equal inclusions" do
-        clone.inclusions.should eq([ Band.relations["records"] ])
+        expect(clone.inclusions).to eq([ Band.relations["records"] ])
       end
 
       it "clones the inclusions" do
-        clone.inclusions.should_not equal(criteria.inclusions)
+        expect(clone.inclusions).to_not equal(criteria.inclusions)
       end
 
       it "contains equal documents" do
-        clone.documents.should eq([ band ])
+        expect(clone.documents).to eq([ band ])
       end
 
       it "clones the documents" do
-        clone.documents.should_not equal(criteria.documents)
+        expect(clone.documents).to_not equal(criteria.documents)
       end
 
       it "contains equal scoping options" do
-        clone.scoping_options.should eq([ nil, nil ])
+        expect(clone.scoping_options).to eq([ nil, nil ])
       end
 
       it "clones the scoping options" do
-        clone.scoping_options.should_not equal(criteria.scoping_options)
+        expect(clone.scoping_options).to_not equal(criteria.scoping_options)
       end
 
       it "sets the context to nil" do
-        clone.instance_variable_get(:@context).should be_nil
+        expect(clone.instance_variable_get(:@context)).to be_nil
       end
     end
   end
@@ -462,7 +462,7 @@ describe Mongoid::Criteria do
     end
 
     it "sets the cache option to true" do
-      criteria.cache.should be_cached
+      expect(criteria.cache).to be_cached
     end
   end
 
@@ -477,7 +477,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the embedded context" do
-        criteria.context.should be_a(Mongoid::Contextual::Memory)
+        expect(criteria.context).to be_a(Mongoid::Contextual::Memory)
       end
     end
 
@@ -488,71 +488,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the mongo context" do
-        criteria.context.should be_a(Mongoid::Contextual::Mongo)
-      end
-    end
-  end
-
-  describe "#create" do
-
-    let(:criteria) do
-      Band.where(name: "Depeche Mode")
-    end
-
-    context "when provided valid attributes" do
-      let(:band) do
-        criteria.create(genres: [ "electro" ])
-      end
-
-      it "returns the created document" do
-        band.should be_persisted
-      end
-
-      it "sets the criteria attributes" do
-        band.name.should eq("Depeche Mode")
-      end
-
-      it "sets the attributes passed to build" do
-        band.genres.should eq([ "electro" ])
-      end
-    end
-
-    context "when provided a block" do
-      context "when provided valid attributes & using block" do
-        let(:band) do
-          criteria.create do |c|
-            c.genres = [ "electro" ]
-          end
-        end
-
-        it "returns the created document" do
-          band.should be_persisted
-        end
-
-        it "sets the criteria attributes" do
-          band.name.should eq("Depeche Mode")
-        end
-
-        it "sets the attributes passed to build" do
-          band.genres.should eq([ "electro" ])
-        end
-      end
-    end
-
-  end
-
-  describe "#create!" do
-
-    let(:criteria) do
-      Account.where(number: "11123213")
-    end
-
-    context "when provided invalid attributes" do
-
-      it "raises an error" do
-        expect {
-          criteria.create!
-        }.to raise_error(Mongoid::Errors::Validations)
+        expect(criteria.context).to be_a(Mongoid::Contextual::Mongo)
       end
     end
   end
@@ -574,7 +510,7 @@ describe Mongoid::Criteria do
       end
 
       it "deletes all the documents from the database" do
-        Band.count.should eq(0)
+        expect(Band.count).to eq(0)
       end
     end
   end
@@ -592,7 +528,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the documents" do
-      criteria.documents.should eq([ band ])
+      expect(criteria.documents).to eq([ band ])
     end
   end
 
@@ -611,7 +547,7 @@ describe Mongoid::Criteria do
     end
 
     it "sets the documents" do
-      criteria.documents.should eq([ band ])
+      expect(criteria.documents).to eq([ band ])
     end
   end
 
@@ -629,7 +565,7 @@ describe Mongoid::Criteria do
 
       it "iterates over the matching documents" do
         criteria.each do |doc|
-          doc.should eq(band)
+          expect(doc).to eq(band)
         end
       end
     end
@@ -652,7 +588,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -669,7 +605,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns true" do
-        criteria.should be_embedded
+        expect(criteria).to be_embedded
       end
     end
 
@@ -680,7 +616,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns false" do
-        criteria.should_not be_embedded
+        expect(criteria).to_not be_embedded
       end
     end
   end
@@ -733,7 +669,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -750,7 +686,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns true" do
-        criteria.exists?.should be_true
+        expect(criteria.exists?).to be true
       end
     end
 
@@ -761,7 +697,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns false" do
-        criteria.exists?.should be_false
+        expect(criteria.exists?).to be false
       end
     end
   end
@@ -773,14 +709,14 @@ describe Mongoid::Criteria do
     end
 
     it "returns the criteria explain path" do
-      criteria.explain["cursor"].should eq("BasicCursor")
+      expect(criteria.explain["cursor"]).to eq("BasicCursor")
     end
   end
 
   describe "#extract_id" do
 
     let(:id) do
-      Moped::BSON::ObjectId.new
+      BSON::ObjectId.new
     end
 
     context "when an id exists" do
@@ -792,7 +728,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the id" do
-        criteria.extract_id.should eq(id)
+        expect(criteria.extract_id).to eq(id)
       end
     end
 
@@ -805,7 +741,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the _id" do
-        criteria.extract_id.should eq(id)
+        expect(criteria.extract_id).to eq(id)
       end
     end
   end
@@ -817,1525 +753,197 @@ describe Mongoid::Criteria do
     end
 
     it "returns the fields minus type" do
-      criteria.field_list.should eq([ "name" ])
+      expect(criteria.field_list).to eq([ "name" ])
     end
   end
 
-  describe "#find" do
-
-    context "when finding by a document" do
-
-      let(:band) do
-        Band.create(name: "Tool")
-      end
-
-      let!(:record) do
-        band.records.create(name: "Undertow")
-      end
-
-      context "when the document is the root" do
-
-        let(:found) do
-          Band.find(band)
-        end
-
-        it "returns the matching document" do
-          expect(found).to eq(band)
-        end
-      end
-
-      context "when the document is the proxy" do
-
-        let(:found) do
-          Band.find(band.records.first.band)
-        end
+  describe "#find_and_modify" do
 
-        it "returns the matching document" do
-          expect(found).to eq(band)
-        end
-      end
+    let!(:depeche) do
+      Band.create(name: "Depeche Mode")
     end
 
-    context "when the identity map is enabled" do
-
-      before(:all) do
-        Mongoid.identity_map_enabled = true
-      end
+    let!(:tool) do
+      Band.create(name: "Tool")
+    end
 
-      after(:all) do
-        Mongoid.identity_map_enabled = false
-      end
+    context "when the selector matches" do
 
-      let!(:depeche) do
-        Band.create(name: "Depeche Mode")
-      end
+      context "when the identity map is enabled" do
 
-      let!(:placebo) do
-        Band.create(name: "Placebo")
-      end
+        context "when returning the updated document" do
 
-      context "when a parent and a child are in the identity map" do
+          let(:criteria) do
+            Band.where(name: "Depeche Mode")
+          end
 
-        let!(:canvas) do
-          Canvas.create
-        end
+          let(:result) do
+            criteria.find_and_modify({ "$inc" => { likes: 1 }}, new: true)
+          end
 
-        let!(:browser) do
-          Browser.create
+          it "returns the first matching document" do
+            expect(result).to eq(depeche)
+          end
         end
 
-        context "when fetching a child class by a parent id" do
+        context "when not returning the updated document" do
 
-          it "raises a not found error" do
-            expect {
-              Browser.find(canvas.id)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          let(:criteria) do
+            Band.where(name: "Depeche Mode")
           end
-        end
-      end
 
-      context "when providing a single id" do
+          let!(:result) do
+            criteria.find_and_modify("$inc" => { likes: 1 })
+          end
 
-        let(:from_map) do
-          Band.find(depeche.id)
-        end
+          before do
+            depeche.reload
+          end
 
-        it "returns the document from the map" do
-          from_map.should equal(depeche)
+          it "returns the first matching document" do
+            expect(result).to eq(depeche)
+          end
         end
       end
 
-      context "when providing a single id as a String" do
-
-        let(:from_map) do
-          Band.find(depeche.id.to_s)
-        end
+      context "when not providing options" do
 
-        it "returns the document from the map" do
-          from_map.should equal(depeche)
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
         end
-      end
 
-      context "when providing multiple ids" do
-
-        let(:from_map) do
-          Band.find(depeche.id, placebo.id)
+        let!(:result) do
+          criteria.find_and_modify("$inc" => { likes: 1 })
         end
 
-        it "returns the first match from the map" do
-          from_map.first.should equal(depeche)
+        it "returns the first matching document" do
+          expect(result).to eq(depeche)
         end
 
-        it "returns the second match from the map" do
-          from_map.last.should equal(placebo)
+        it "updates the document in the database" do
+          expect(depeche.reload.likes).to eq(1)
         end
       end
-    end
-
-    context "when using object ids" do
-
-      let!(:band) do
-        Band.create
-      end
 
-      context "when a parent and a child are in the identity map" do
+      context "when sorting" do
 
-        let!(:canvas) do
-          Canvas.create
+        let(:criteria) do
+          Band.desc(:name)
         end
 
-        let!(:browser) do
-          Browser.create
+        let!(:result) do
+          criteria.find_and_modify("$inc" => { likes: 1 })
         end
 
-        context "when fetching a child class by a parent id" do
+        it "returns the first matching document" do
+          expect(result).to eq(tool)
+        end
 
-          it "raises a not found error" do
-            expect {
-              Browser.find(canvas.id)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
-          end
+        it "updates the document in the database" do
+          expect(tool.reload.likes).to eq(1)
         end
       end
 
-      context "when providing a single id" do
-
-        context "when the id matches" do
-
-          let(:found) do
-            Band.find(band.id)
-          end
+      context "when limiting fields" do
 
-          it "returns the matching document" do
-            found.should eq(band)
-          end
+        let(:criteria) do
+          Band.only(:_id)
         end
 
-        context "when the id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(Moped::BSON::ObjectId.new)
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(Moped::BSON::ObjectId.new)
-            end
-
-            it "returns nil" do
-              found.should be_nil
-            end
-          end
+        let!(:result) do
+          criteria.find_and_modify("$inc" => { likes: 1 })
         end
-      end
 
-      context "when providing a splat of ids" do
-
-        let!(:band_two) do
-          Band.create(name: "Tool")
+        it "returns the first matching document" do
+          expect(result).to eq(depeche)
         end
 
-        context "when all ids match" do
-
-          let(:found) do
-            Band.find(band.id, band_two.id)
-          end
-
-          it "contains the first match" do
-            found.should include(band)
-          end
-
-          it "contains the second match" do
-            found.should include(band_two)
-          end
-
-          context "when ids are duplicates" do
-            let(:found) do
-              Band.find(band.id, band.id)
-            end
-
-            it "contains only the first match" do
-              found.should eq([band])
-            end
-          end
+        it "limits the returned fields" do
+          expect(result.name).to be_nil
         end
 
-        context "when any id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(band.id, Moped::BSON::ObjectId.new)
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(band.id, Moped::BSON::ObjectId.new)
-            end
-
-            it "returns only the matching documents" do
-              found.should eq([ band ])
-            end
-          end
+        it "updates the document in the database" do
+          expect(depeche.reload.likes).to eq(1)
         end
       end
 
-      context "when providing an array of ids" do
+      context "when returning new" do
 
-        let!(:band_two) do
-          Band.create(name: "Tool")
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
         end
 
-        context "when all ids match" do
-
-          let(:found) do
-            Band.find([ band.id, band_two.id ])
-          end
-
-          it "contains the first match" do
-            found.should include(band)
-          end
-
-          it "contains the second match" do
-            found.should include(band_two)
-          end
-
-          context "when ids are duplicates" do
-            let(:found) do
-              Band.find([ band.id, band.id ])
-            end
-
-            it "contains only the first match" do
-              found.should eq([band])
-            end
-          end
+        let!(:result) do
+          criteria.find_and_modify({ "$inc" => { likes: 1 }}, new: true)
         end
 
-        context "when any id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find([ band.id, Moped::BSON::ObjectId.new ])
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find([ band.id, Moped::BSON::ObjectId.new ])
-            end
-
-            it "returns only the matching documents" do
-              found.should eq([ band ])
-            end
-          end
+        it "returns the first matching document" do
+          expect(result).to eq(depeche)
         end
-      end
-    end
-
-    context "when using string ids" do
-
-      before(:all) do
-        Band.field :_id, type: String
-      end
-
-      after(:all) do
-        Band.field :_id, type: Moped::BSON::ObjectId, default: ->{ Moped::BSON::ObjectId.new }
-      end
 
-      let!(:band) do
-        Band.create do |band|
-          band.id = "tool"
+        it "returns the updated document" do
+          expect(result.likes).to eq(1)
         end
       end
 
-      context "when providing a single id" do
-
-        context "when the id matches" do
-
-          let(:found) do
-            Band.find(band.id)
-          end
+      context "when removing" do
 
-          it "returns the matching document" do
-            found.should eq(band)
-          end
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
         end
 
-        context "when the id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find("depeche-mode")
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
+        let!(:result) do
+          criteria.find_and_modify({}, remove: true)
+        end
 
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find("depeche-mode")
-            end
-
-            it "returns nil" do
-              found.should be_nil
-            end
-          end
-        end
-      end
-
-      context "when providing a splat of ids" do
-
-        let!(:band_two) do
-          Band.create do |band|
-            band.id = "depeche-mode"
-          end
-        end
-
-        context "when all ids match" do
-
-          let(:found) do
-            Band.find(band.id, band_two.id)
-          end
-
-          it "contains the first match" do
-            found.should include(band)
-          end
-
-          it "contains the second match" do
-            found.should include(band_two)
-          end
-        end
-
-        context "when any id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(band.id, "new-order")
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(band.id, "new-order")
-            end
-
-            it "returns only the matching documents" do
-              found.should eq([ band ])
-            end
-          end
-        end
-      end
-
-      context "when providing an array of ids" do
-
-        let!(:band_two) do
-          Band.create do |band|
-            band.id = "depeche-mode"
-          end
-        end
-
-        context "when all ids match" do
-
-          let(:found) do
-            Band.find([ band.id, band_two.id ])
-          end
-
-          it "contains the first match" do
-            found.should include(band)
-          end
-
-          it "contains the second match" do
-            found.should include(band_two)
-          end
-        end
-
-        context "when any id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find([ band.id, "new-order" ])
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find([ band.id, "new-order" ])
-            end
-
-            it "returns only the matching documents" do
-              found.should eq([ band ])
-            end
-          end
-        end
-      end
-    end
-
-    context "when using hash ids" do
-
-      before(:all) do
-        Band.field :_id, type: Hash
-      end
-
-      after(:all) do
-        Band.field :_id, type: Moped::BSON::ObjectId, default: ->{ Moped::BSON::ObjectId.new }
-      end
-
-      let!(:band) do
-        Band.create do |band|
-          band.id = {"new-order" => true, "Depeche Mode" => false}
-        end
-      end
-
-      context "when providing a single id" do
-
-        context "when the id matches" do
-
-          let(:found) do
-            Band.find(band.id)
-          end
-
-          it "returns the matching document" do
-            found.should eq(band)
-          end
-        end
-
-        context "when the id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find({"new-order" => false, "Faith no More" => true})
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find({"new-order" => false, "Faith no More" => true})
-            end
-
-            it "returns nil" do
-              found.should be_nil
-            end
-          end
-        end
-      end
-
-      context "when providing a splat of ids" do
-
-        let!(:band_two) do
-          Band.create do |band|
-            band.id = {"Radiohead" => false, "Nirvana"=> true}
-          end
-        end
-
-        context "when all ids match" do
-
-          let(:found) do
-            Band.find(band.id, band_two.id)
-          end
-
-          it "contains the first match" do
-            found.should include(band)
-          end
-
-          it "contains the second match" do
-            found.should include(band_two)
-          end
-        end
-
-        context "when any id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(band.id, {"Radiohead" => true, "Nirvana"=> false})
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(band.id, {"Radiohead" => true, "Nirvana"=> false})
-            end
-
-            it "returns only the matching documents" do
-              found.should eq([ band ])
-            end
-          end
-        end
-      end
-
-      context "when providing an array of ids" do
-
-        let!(:band_two) do
-          Band.create do |band|
-            band.id = {"Radiohead" => false, "Nirvana"=> true}
-          end
-        end
-
-        context "when all ids match" do
-
-          let(:found) do
-            Band.find([ band.id, band_two.id ])
-          end
-
-          it "contains the first match" do
-            found.should include(band)
-          end
-
-          it "contains the second match" do
-            found.should include(band_two)
-          end
-        end
-
-        context "when any id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find([ band.id, {"Radiohead" => true, "Nirvana"=> false} ])
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find([ band.id, {"Radiohead" => true, "Nirvana"=> false} ])
-            end
-
-            it "returns only the matching documents" do
-              found.should eq([ band ])
-            end
-          end
-        end
-      end
-    end
-
-    context "when using integer ids" do
-
-      before(:all) do
-        Band.field :_id, type: Integer
-      end
-
-      after(:all) do
-        Band.field :_id, type: Moped::BSON::ObjectId, default: ->{ Moped::BSON::ObjectId.new }
-      end
-
-      let!(:band) do
-        Band.create do |band|
-          band.id = 1
-        end
-      end
-
-      context "when providing a single id" do
-
-        context "when the id matches" do
-
-          let(:found) do
-            Band.find(band.id)
-          end
-
-          it "returns the matching document" do
-            found.should eq(band)
-          end
-        end
-
-        context "when the id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(3)
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(3)
-            end
-
-            it "returns nil" do
-              found.should be_nil
-            end
-          end
-        end
-      end
-
-      context "when providing a splat of ids" do
-
-        let!(:band_two) do
-          Band.create do |band|
-            band.id = 2
-          end
-        end
-
-        context "when all ids match" do
-
-          let(:found) do
-            Band.find(band.id, band_two.id)
-          end
-
-          it "contains the first match" do
-            found.should include(band)
-          end
-
-          it "contains the second match" do
-            found.should include(band_two)
-          end
-        end
-
-        context "when any id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(band.id, 3)
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(band.id, 3)
-            end
-
-            it "returns only the matching documents" do
-              found.should eq([ band ])
-            end
-          end
-        end
-      end
-
-      context "when providing an array of ids" do
-
-        let!(:band_two) do
-          Band.create do |band|
-            band.id = 2
-          end
-        end
-
-        context "when all ids match" do
-
-          let(:found) do
-            Band.find([ band.id, band_two.id ])
-          end
-
-          it "contains the first match" do
-            found.should include(band)
-          end
-
-          it "contains the second match" do
-            found.should include(band_two)
-          end
-        end
-
-        context "when any id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find([ band.id, 3 ])
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find([ band.id, 3 ])
-            end
-
-            it "returns only the matching documents" do
-              found.should eq([ band ])
-            end
-          end
-        end
-      end
-
-      context "when providing a range" do
-
-        let!(:band_two) do
-          Band.create do |band|
-            band.id = 2
-          end
-        end
-
-        context "when all ids match" do
-
-          let(:found) do
-            Band.find(1..2)
-          end
-
-          it "contains the first match" do
-            found.should include(band)
-          end
-
-          it "contains the second match" do
-            found.should include(band_two)
-          end
-        end
-
-        context "when any id does not match" do
-
-          context "when raising a not found error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(1..3)
-            end
-
-            it "raises an error" do
-              expect {
-                found
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
-            end
-          end
-
-          context "when raising no error" do
-
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
-            let(:found) do
-              Band.find(1..3)
-            end
-
-            it "contains the first match" do
-              found.should include(band)
-            end
-
-            it "contains the second match" do
-              found.should include(band_two)
-            end
-
-            it "returns only the matches" do
-              found.count.should eq(2)
-            end
-          end
-        end
-      end
-    end
-
-    context "when using string and object ids" do
-
-      let!(:band) do
-        Band.create
-      end
-
-      context "when providing multiple ids" do
-
-        context "when ids are duplicates" do
-
-          let(:found) do
-            Band.find([ band.id.to_s, band.id ])
-          end
-
-          it "contains only the first match" do
-            found.should eq([band])
-          end
-        end
-      end
-    end
-  end
-
-  describe "#find_and_modify" do
-
-    let!(:depeche) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let!(:tool) do
-      Band.create(name: "Tool")
-    end
-
-    context "when the selector matches" do
-
-      context "when the identity map is enabled" do
-
-        before(:all) do
-          Mongoid.identity_map_enabled = true
-        end
-
-        after(:all) do
-          Mongoid.identity_map_enabled = false
-        end
-
-        context "when returning the updated document" do
-
-          let(:criteria) do
-            Band.where(name: "Depeche Mode")
-          end
-
-          let(:result) do
-            criteria.find_and_modify({ "$inc" => { likes: 1 }}, new: true)
-          end
-
-          it "returns the first matching document" do
-            result.should eq(depeche)
-          end
-
-          it "updates the document in the identity map" do
-            Mongoid::IdentityMap.get(Band, result.id).likes.should eq(1)
-          end
-        end
-
-        context "when not returning the updated document" do
-
-          let(:criteria) do
-            Band.where(name: "Depeche Mode")
-          end
-
-          let!(:result) do
-            criteria.find_and_modify("$inc" => { likes: 1 })
-          end
-
-          before do
-            depeche.reload
-          end
-
-          it "returns the first matching document" do
-            result.should eq(depeche)
-          end
-
-          it "updates the document in the identity map" do
-            Mongoid::IdentityMap.get(Band, depeche.id).likes.should eq(1)
-          end
-        end
-      end
-
-      context "when not providing options" do
-
-        let(:criteria) do
-          Band.where(name: "Depeche Mode")
-        end
-
-        let!(:result) do
-          criteria.find_and_modify("$inc" => { likes: 1 })
-        end
-
-        it "returns the first matching document" do
-          result.should eq(depeche)
-        end
-
-        it "updates the document in the database" do
-          depeche.reload.likes.should eq(1)
-        end
-      end
-
-      context "when sorting" do
-
-        let(:criteria) do
-          Band.desc(:name)
-        end
-
-        let!(:result) do
-          criteria.find_and_modify("$inc" => { likes: 1 })
-        end
-
-        it "returns the first matching document" do
-          result.should eq(tool)
-        end
-
-        it "updates the document in the database" do
-          tool.reload.likes.should eq(1)
-        end
-      end
-
-      context "when limiting fields" do
-
-        let(:criteria) do
-          Band.only(:_id)
-        end
-
-        let!(:result) do
-          criteria.find_and_modify("$inc" => { likes: 1 })
-        end
-
-        it "returns the first matching document" do
-          result.should eq(depeche)
-        end
-
-        it "limits the returned fields" do
-          result.name.should be_nil
-        end
-
-        it "updates the document in the database" do
-          depeche.reload.likes.should eq(1)
-        end
-      end
-
-      context "when returning new" do
-
-        let(:criteria) do
-          Band.where(name: "Depeche Mode")
-        end
-
-        let!(:result) do
-          criteria.find_and_modify({ "$inc" => { likes: 1 }}, new: true)
-        end
-
-        it "returns the first matching document" do
-          result.should eq(depeche)
-        end
-
-        it "returns the updated document" do
-          result.likes.should eq(1)
-        end
-      end
-
-      context "when removing" do
-
-        let(:criteria) do
-          Band.where(name: "Depeche Mode")
-        end
-
-        let!(:result) do
-          criteria.find_and_modify({}, remove: true)
-        end
-
-        it "returns the first matching document" do
-          result.should eq(depeche)
-        end
+        it "returns the first matching document" do
+          expect(result).to eq(depeche)
+        end
 
         it "deletes the document from the database" do
           expect {
             depeche.reload
           }.to raise_error(Mongoid::Errors::DocumentNotFound)
-        end
-      end
-    end
-
-    context "when the selector does not match" do
-
-      let(:criteria) do
-        Band.where(name: "Placebo")
-      end
-
-      let(:result) do
-        criteria.find_and_modify("$inc" => { likes: 1 })
-      end
-
-      it "returns nil" do
-        result.should be_nil
-      end
-    end
-  end
-
-  describe "first_or_initialize" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    context "when the document is found" do
-
-      let(:found) do
-        Band.where(name: "Depeche Mode").first_or_initialize
-      end
-
-      it "returns the document" do
-        found.should eq(band)
-      end
-    end
-
-    context "when the document is not found" do
-
-      context "when attributes are provided" do
-
-        let(:document) do
-          Band.where(name: "Tool").first_or_initialize(origin: "Essex")
-        end
-
-        it "returns a new document" do
-          document.name.should eq("Tool")
-        end
-
-        it "returns a non persisted document" do
-          document.should_not be_persisted
-        end
-
-        it "sets the additional attributes" do
-          document.origin.should eq("Essex")
-        end
-      end
-
-      context "when attributes are not provided" do
-
-        let(:document) do
-          Band.where(name: "Tool").first_or_initialize
-        end
-
-        it "returns a new document" do
-          document.name.should eq("Tool")
-        end
-
-        it "returns a non persisted document" do
-          document.should_not be_persisted
-        end
-      end
-
-      context "when a block is provided" do
-
-        let(:document) do
-          Band.where(name: "Tool").first_or_initialize do |doc|
-            doc.active = false
-          end
-        end
-
-        it "returns a new document" do
-          document.name.should eq("Tool")
-        end
-
-        it "returns a non persisted document" do
-          document.should_not be_persisted
-        end
-
-        it "yields to the block" do
-          document.active.should be_false
-        end
-      end
-
-      context "when the criteria is complex" do
-
-        context "when the document is not found" do
-
-          let(:document) do
-            Band.in(name: [ "New Order" ]).first_or_initialize(active: false)
-          end
-
-          it "returns a new document" do
-            document.active.should be_false
-          end
-
-          it "returns a non persisted document" do
-            document.should_not be_persisted
-          end
-        end
-      end
-    end
-  end
-
-  describe "#freeze" do
-
-    let(:criteria) do
-      Band.all
-    end
-
-    before do
-      criteria.freeze
-    end
-
-    it "freezes the criteria" do
-      criteria.should be_frozen
-    end
-
-    it "initializes inclusions" do
-      criteria.inclusions.should be_empty
-    end
-
-    it "initializes the context" do
-      criteria.context.should_not be_nil
-    end
-  end
-
-  describe "#for_ids" do
-
-    context "when only 1 id exists" do
-
-      let(:id) do
-        Moped::BSON::ObjectId.new
-      end
-
-      let(:criteria) do
-        Band.queryable.for_ids([ id ])
-      end
-
-      it "does not turn the selector into an $in" do
-        criteria.selector.should eq({ "_id" => id })
-      end
-    end
-  end
-
-  describe "#from_map_or_db" do
-
-    before(:all) do
-      Mongoid.identity_map_enabled = true
-    end
-
-    after(:all) do
-      Mongoid.identity_map_enabled = false
-    end
-
-    context "when the document is in the identity map" do
-
-      let!(:band) do
-        Band.create(name: "Depeche Mode")
-      end
-
-      let(:criteria) do
-        Band.where(_id: band.id)
-      end
-
-      let(:from_map) do
-        criteria.from_map_or_db
-      end
-
-      it "returns the document from the map" do
-        from_map.should equal(band)
-      end
-    end
-
-    context "when the document is not in the identity map" do
-
-      let!(:band) do
-        Band.create(name: "Depeche Mode")
-      end
-
-      let(:criteria) do
-        Band.where(_id: band.id)
-      end
-
-      before do
-        Mongoid::IdentityMap.clear
-      end
-
-      let(:from_db) do
-        criteria.from_map_or_db
-      end
-
-      it "returns the document from the database" do
-        from_db.should_not equal(band)
-      end
-
-      it "returns the correct document" do
-        from_db.should eq(band)
-      end
-    end
-
-    context "when the selector is cleared in the identity map" do
-
-      let!(:band) do
-        Band.create(name: "Depeche Mode")
-      end
-
-      let(:criteria) do
-        Band.where(name: "Depeche Mode")
-      end
-
-      before do
-        Mongoid::IdentityMap.clear
-        Mongoid::IdentityMap.clear_many(Band, { "name" => "Depeche Mode" })
-      end
-
-      let(:from_db) do
-        criteria.from_map_or_db
-      end
-
-      it "returns nil" do
-        from_db.should be_nil
-      end
-    end
-  end
-
-  describe "#multiple_from_map_or_db" do
-
-    before(:all) do
-      Mongoid.identity_map_enabled = true
-    end
-
-    after(:all) do
-      Mongoid.identity_map_enabled = false
-    end
-
-    context "when the document is in the identity map" do
-
-      let!(:band) do
-        Band.create(name: "Depeche Mode")
-      end
-
-      let!(:band_two) do
-        Band.create(name: "Tool")
-      end
-
-      context "when providing a single id" do
-
-        let(:criteria) do
-          Band.where(_id: band.id)
-        end
-
-        let(:from_map) do
-          criteria.multiple_from_map_or_db([ band.id ])
-        end
-
-        it "returns the document from the map" do
-          from_map.should include(band)
-        end
-      end
-
-      context "when providing multiple ids" do
-
-        let(:criteria) do
-          Band.where(:_id.in => [ band.id, band_two.id ])
-        end
-
-        let(:from_map) do
-          criteria.multiple_from_map_or_db([ band.id, band_two.id ])
-        end
-
-        it "returns the documents from the map" do
-          from_map.should include(band, band_two)
-        end
-      end
-    end
-
-    context "when the document is not in the identity map" do
-
-      let!(:band) do
-        Band.create(name: "Depeche Mode")
-      end
-
-      let!(:band_two) do
-        Band.create(name: "Tool")
-      end
-
-      before do
-        Mongoid::IdentityMap.clear
+        end
       end
+    end
 
-      context "when providing a single id" do
-
-        let(:criteria) do
-          Band.where(_id: band.id)
-        end
+    context "when the selector does not match" do
 
-        let(:from_db) do
-          criteria.multiple_from_map_or_db([ band.id ])
-        end
+      let(:criteria) do
+        Band.where(name: "Placebo")
+      end
 
-        it "returns the document from the database" do
-          from_db.first.should_not equal(band)
-        end
+      let(:result) do
+        criteria.find_and_modify("$inc" => { likes: 1 })
+      end
 
-        it "returns the correct document" do
-          from_db.first.should eq(band)
-        end
+      it "returns nil" do
+        expect(result).to be_nil
       end
+    end
+  end
 
-      context "when providing multiple ids" do
+  describe "#freeze" do
 
-        let(:criteria) do
-          Band.where(:_id.in => [ band.id, band_two.id ])
-        end
+    let(:criteria) do
+      Band.all
+    end
 
-        let(:from_db) do
-          criteria.multiple_from_map_or_db([ band.id, band_two.id ])
-        end
+    before do
+      criteria.freeze
+    end
 
-        it "returns the document from the database" do
-          from_db.first.should_not equal(band)
-        end
+    it "freezes the criteria" do
+      expect(criteria).to be_frozen
+    end
 
-        it "returns the correct document" do
-          from_db.first.should eq(band)
-        end
-      end
+    it "initializes inclusions" do
+      expect(criteria.inclusions).to be_empty
+    end
+
+    it "initializes the context" do
+      expect(criteria.context).to_not be_nil
     end
   end
 
@@ -2354,7 +962,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -2373,7 +981,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -2392,7 +1000,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -2415,14 +1023,14 @@ describe Mongoid::Criteria do
         end
 
         it "returns the matching documents" do
-          criteria.should eq([ match ])
+          expect(criteria).to eq([ match ])
         end
       end
 
       context "when querying on a foreign key" do
 
         let(:id) do
-          Moped::BSON::ObjectId.new
+          BSON::ObjectId.new
         end
 
         let!(:match_one) do
@@ -2436,7 +1044,7 @@ describe Mongoid::Criteria do
           end
 
           it "returns the matching documents" do
-            criteria.should eq([ match_one ])
+            expect(criteria).to eq([ match_one ])
           end
         end
 
@@ -2447,7 +1055,7 @@ describe Mongoid::Criteria do
           end
 
           it "returns the matching documents" do
-            criteria.should eq([ match_one ])
+            expect(criteria).to eq([ match_one ])
           end
         end
 
@@ -2460,7 +1068,7 @@ describe Mongoid::Criteria do
             end
 
             it "returns the matching documents" do
-              criteria.should eq([ match_one ])
+              expect(criteria).to eq([ match_one ])
             end
           end
 
@@ -2475,7 +1083,7 @@ describe Mongoid::Criteria do
             end
 
             it "returns the matching documents" do
-              criteria.should eq([ game ])
+              expect(criteria).to eq([ game ])
             end
           end
         end
@@ -2490,30 +1098,22 @@ describe Mongoid::Criteria do
     end
 
     it "sets the class" do
-      criteria.klass.should eq(Band)
+      expect(criteria.klass).to eq(Band)
     end
 
     it "sets the aliased fields" do
-      criteria.aliased_fields.should eq(Band.aliased_fields)
+      expect(criteria.aliased_fields).to eq(Band.aliased_fields)
     end
 
     it "sets the serializers" do
-      criteria.serializers.should eq(Band.fields)
+      expect(criteria.serializers).to eq(Band.fields)
     end
   end
 
   describe "#includes" do
 
-    before do
-      Mongoid.identity_map_enabled = true
-    end
-
-    after do
-      Mongoid.identity_map_enabled = false
-    end
-
     let!(:person) do
-      Person.create
+      Person.create(age: 1)
     end
 
     context "when providing a name that is not a relation" do
@@ -2571,30 +1171,20 @@ describe Mongoid::Criteria do
           B.create(c: c_two)
         end
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:results) do
-          C.includes(:b).entries.detect do |c|
+          C.includes(:b).to_a.detect do |c|
             c.id == c_two.id
           end
         end
 
-        let(:from_map) do
-          Mongoid::IdentityMap[B.collection_name][b.id]
-        end
-
         it "returns the correct documents" do
-          results.should eq(c_two)
+          expect(results).to eq(c_two)
         end
 
-        it "inserts the first document into the identity map" do
-          from_map.should eq(b)
-        end
-
-        it "retrieves the document from the identity map" do
-          results.b.should equal(from_map)
+        it "does not query the db" do
+          expect_query(0) do
+            results.b
+          end
         end
       end
     end
@@ -2648,42 +1238,26 @@ describe Mongoid::Criteria do
             C.create(d: d_two)
           end
 
-          before do
-            Mongoid::IdentityMap.clear
-          end
-
           let!(:results) do
             D.includes(:b, :c).entries.detect do |d|
               d.id == d_two.id
             end
           end
 
-          let(:from_map_b) do
-            Mongoid::IdentityMap[B.collection_name][b.id]
-          end
-
-          let(:from_map_c) do
-            Mongoid::IdentityMap[C.collection_name][c.id]
-          end
-
           it "returns the correct documents" do
-            results.should eq(d_two)
-          end
-
-          it "inserts the b document into the identity map" do
-            from_map_b.should eq(b)
+            expect(results).to eq(d_two)
           end
 
-          it "inserts the c document into the identity map" do
-            from_map_c.should eq(c)
-          end
-
-          it "retrieves the b document from the identity map" do
-            results.b.should equal(from_map_b)
+          it "does not query the db on b" do
+            expect_query(0) do
+              results.b
+            end
           end
 
-          it "retrieves the c document from the identity map" do
-            results.c.should equal(from_map_c)
+          it "does not query the db on c" do
+            expect_query(0) do
+              results.b
+            end
           end
         end
       end
@@ -2735,42 +1309,26 @@ describe Mongoid::Criteria do
             2.times.map { C.create(d: d_two) }
           end
 
-          before do
-            Mongoid::IdentityMap.clear
-          end
-
           let!(:results) do
             D.includes(:b, :c).entries.detect do |d|
               d.id == d_two.id
             end
           end
 
-          let(:from_map_bs) do
-            bs.map { |b| Mongoid::IdentityMap[B.collection_name][b.id] }
-          end
-
-          let(:from_map_cs) do
-            cs.map { |c| Mongoid::IdentityMap[C.collection_name][c.id] }
-          end
-
           it "returns the correct documents" do
-            results.should eq(d_two)
-          end
-
-          it "inserts the b documents into the identity map" do
-            from_map_bs.should eq(bs)
-          end
-
-          it "inserts the c documents into the identity map" do
-            from_map_cs.should eq(cs)
+            expect(results).to eq(d_two)
           end
 
-          it "retrieves the b documents from the identity map" do
-            results.b.should match_array(from_map_bs)
+          it "does not query the db on b" do
+            expect_query(0) do
+              results.b
+            end
           end
 
-          it "retrieves the c documents from the identity map" do
-            results.c.should match_array(from_map_cs)
+          it "does not query the db on c" do
+            expect_query(0) do
+              results.b
+            end
           end
         end
       end
@@ -2787,16 +1345,12 @@ describe Mongoid::Criteria do
       end
 
       it "does not duplicate the metadata in the inclusions" do
-        criteria.inclusions.should eq([ metadata ])
+        expect(criteria.inclusions).to eq([ metadata ])
       end
     end
 
     context "when mapping the results more than once" do
 
-      before do
-        Mongoid::IdentityMap.clear
-      end
-
       let!(:post) do
         person.posts.create(title: "one")
       end
@@ -2811,7 +1365,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the proper results" do
-        results.first.title.should eq("one")
+        expect(results.first.title).to eq("one")
       end
     end
 
@@ -2848,10 +1402,6 @@ describe Mongoid::Criteria do
 
         context "when calling first" do
 
-          before do
-            Mongoid::IdentityMap.clear
-          end
-
           let(:criteria) do
             peep.reload.addresses.includes(:band)
           end
@@ -2860,37 +1410,30 @@ describe Mongoid::Criteria do
             criteria.context
           end
 
-          before do
-            context.should_receive(:eager_load_one).with(address_one).once.and_call_original
-          end
-
           let!(:document) do
             criteria.first
           end
 
-          let(:eager_loaded) do
-            Mongoid::IdentityMap[Band.collection_name]
-          end
-
           it "eager loads the first document" do
-            eager_loaded[depeche.id].should eq(depeche)
+            expect_query(0) do
+              expect(document.band).to eq(depeche)
+            end
           end
 
           it "does not eager load the last document" do
-            eager_loaded[tool.id].should be_nil
+            doc = criteria.last
+            expect_query(1) do
+              expect(doc.band).to eq(tool)
+            end
           end
 
           it "returns the document" do
-            document.should eq(address_one)
+            expect(document).to eq(address_one)
           end
         end
 
         context "when calling last" do
 
-          before do
-            Mongoid::IdentityMap.clear
-          end
-
           let(:criteria) do
             peep.reload.addresses.includes(:band)
           end
@@ -2899,37 +1442,30 @@ describe Mongoid::Criteria do
             criteria.context
           end
 
-          before do
-            context.should_receive(:eager_load_one).with(address_two).once.and_call_original
-          end
-
           let!(:document) do
             criteria.last
           end
 
-          let(:eager_loaded) do
-            Mongoid::IdentityMap[Band.collection_name]
+          it "eager loads the last document" do
+            expect_query(0) do
+              expect(document.band).to eq(tool)
+            end
           end
 
           it "does not eager load the first document" do
-            eager_loaded[depeche.id].should be_nil
-          end
-
-          it "eager loads the last document" do
-            eager_loaded[tool.id].should eq(tool)
+            doc = criteria.first
+            expect_query(1) do
+              expect(doc.band).to eq(depeche)
+            end
           end
 
           it "returns the document" do
-            document.should eq(address_two)
+            expect(document).to eq(address_two)
           end
         end
 
         context "when iterating all documents" do
 
-          before do
-            Mongoid::IdentityMap.clear
-          end
-
           let(:criteria) do
             peep.reload.addresses.includes(:band)
           end
@@ -2938,32 +1474,24 @@ describe Mongoid::Criteria do
             criteria.context
           end
 
-          before do
-            context.
-              should_receive(:eager_load).
-              with([ address_one, address_two ]).
-              once.
-              and_call_original
-          end
-
           let!(:documents) do
             criteria.to_a
           end
 
-          let(:eager_loaded) do
-            Mongoid::IdentityMap[Band.collection_name]
-          end
-
           it "eager loads the first document" do
-            eager_loaded[depeche.id].should eq(depeche)
+            expect_query(0) do
+              expect(documents.first.band).to eq(depeche)
+            end
           end
 
           it "eager loads the last document" do
-            eager_loaded[tool.id].should eq(tool)
+            expect_query(0) do
+              expect(documents.last.band).to eq(tool)
+            end
           end
 
           it "returns the documents" do
-            documents.should eq([ address_one, address_two ])
+            expect(documents).to eq([ address_one, address_two ])
           end
         end
       end
@@ -2971,7 +1499,7 @@ describe Mongoid::Criteria do
       context "when the criteria is from the root" do
 
         let!(:person_two) do
-          Person.create
+          Person.create(age: 2)
         end
 
         let!(:post_one) do
@@ -2982,38 +1510,31 @@ describe Mongoid::Criteria do
           person_two.posts.create(title: "two")
         end
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         context "when calling first" do
 
-          let!(:criteria) do
+          let(:criteria) do
             Post.includes(:person)
           end
 
-          let!(:context) do
-            criteria.context
-          end
-
-          before do
-            context.should_receive(:eager_load_one).with(post_one).once.and_call_original
-          end
-
           let!(:document) do
             criteria.first
           end
 
-          it "eager loads for the first document" do
-            Mongoid::IdentityMap[Person.collection_name][person.id].should eq(person)
+          it "eager loads the first document" do
+            expect_query(0) do
+              expect(document.person).to eq(person)
+            end
           end
 
-          it "does not eager loads for the last document" do
-            Mongoid::IdentityMap[Person.collection_name][person_two.id].should be_nil
+          it "does not eager load the last document" do
+            doc = criteria.last
+            expect_query(1) do
+              expect(doc.person).to eq(person_two)
+            end
           end
 
           it "returns the first document" do
-            document.should eq(post_one)
+            expect(document).to eq(post_one)
           end
         end
 
@@ -3023,28 +1544,25 @@ describe Mongoid::Criteria do
             Post.includes(:person)
           end
 
-          let!(:context) do
-            criteria.context
-          end
-
-          before do
-            context.should_receive(:eager_load_one).with(post_two).once.and_call_original
-          end
-
           let!(:document) do
             criteria.last
           end
 
-          it "eager loads for the first document" do
-            Mongoid::IdentityMap[Person.collection_name][person_two.id].should eq(person_two)
+          it "eager loads the last document" do
+            expect_query(0) do
+              expect(document.person).to eq(person_two)
+            end
           end
 
-          it "does not eager loads for the last document" do
-            Mongoid::IdentityMap[Person.collection_name][person.id].should be_nil
+          it "does not eager load the first document" do
+            doc = criteria.first
+            expect_query(1) do
+              expect(doc.person).to eq(person)
+            end
           end
 
           it "returns the last document" do
-            document.should eq(post_two)
+            expect(document).to eq(post_two)
           end
         end
       end
@@ -3053,7 +1571,7 @@ describe Mongoid::Criteria do
     context "when providing inclusions to the default scope" do
 
       before do
-        Person.default_scope(Person.includes(:posts))
+        Person.default_scope(->{ Person.includes(:posts) })
       end
 
       after do
@@ -3070,20 +1588,8 @@ describe Mongoid::Criteria do
 
       context "when the criteria has no options" do
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:criteria) do
-          Person.all
-        end
-
-        let!(:context) do
-          criteria.context
-        end
-
-        before do
-          context.should_receive(:eager_load).with([ person ]).once.and_call_original
+          Person.asc(:age).all
         end
 
         let!(:documents) do
@@ -3091,15 +1597,19 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          documents.should eq([ person ])
+          expect(documents).to eq([ person ])
         end
 
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_one.id].should eq(post_one)
+        it "eager loads the first document" do
+          expect_query(0) do
+            expect(documents.first.posts.first).to eq(post_one)
+          end
         end
 
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_two.id].should eq(post_two)
+        it "eager loads the last document" do
+          expect_query(0) do
+            expect(documents.first.posts.last).to eq(post_two)
+          end
         end
 
         context "when executing the query twice" do
@@ -3113,43 +1623,23 @@ describe Mongoid::Criteria do
           end
 
           before do
-            new_context.should_receive(:eager_load_one).with(person).once.and_call_original
+            expect(new_context).to receive(:eager_load_one).with(person).once.and_call_original
           end
 
           let!(:from_db) do
             new_criteria.first
           end
 
-          let(:mapped) do
-            Mongoid::IdentityMap[Post.collection_name][{"person_id" => person.id}]
-          end
-
           it "does not duplicate documents in the relation" do
-            person.posts.size.should eq(2)
-          end
-
-          it "does not duplicate documents in the map" do
-            mapped.size.should eq(2)
+            expect(person.posts.size).to eq(2)
           end
         end
       end
 
       context "when calling first on the criteria" do
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let(:criteria) do
-          Person.all
-        end
-
-        let!(:context) do
-          criteria.context
-        end
-
-        before do
-          context.should_receive(:eager_load_one).with(person).once.and_call_original
+          Person.asc(:age).all
         end
 
         let!(:from_db) do
@@ -3157,26 +1647,26 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          from_db.should eq(person)
+          expect(from_db).to eq(person)
         end
 
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_one.id].should eq(post_one)
+        it "eager loads the first document" do
+          expect_query(0) do
+            expect(from_db.posts.first).to eq(post_one)
+          end
         end
 
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_two.id].should eq(post_two)
+        it "eager loads the last document" do
+          expect_query(0) do
+            expect(from_db.posts.last).to eq(post_two)
+          end
         end
       end
 
       context "when calling last on the criteria" do
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let(:criteria) do
-          Person.all
+          Person.asc(:age).all
         end
 
         let!(:context) do
@@ -3184,7 +1674,7 @@ describe Mongoid::Criteria do
         end
 
         before do
-          context.should_receive(:eager_load_one).with(person).once.and_call_original
+          expect(context).to receive(:eager_load_one).with(person).once.and_call_original
         end
 
         let!(:from_db) do
@@ -3192,15 +1682,19 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          from_db.should eq(person)
+          expect(from_db).to eq(person)
         end
 
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_one.id].should eq(post_one)
+        it "eager loads the first document" do
+          expect_query(0) do
+            expect(from_db.posts.first).to eq(post_one)
+          end
         end
 
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_two.id].should eq(post_two)
+        it "eager loads the last document" do
+          expect_query(0) do
+            expect(from_db.posts.last).to eq(post_two)
+          end
         end
       end
 
@@ -3214,20 +1708,8 @@ describe Mongoid::Criteria do
           person_two.posts.create(title: "three")
         end
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:criteria) do
-          Person.asc(:_id).limit(1)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          context.should_receive(:eager_load).with([ person ]).once.and_call_original
+          Person.asc(:age).limit(1)
         end
 
         let!(:documents) do
@@ -3235,19 +1717,19 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          criteria.should eq([ person ])
-        end
-
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_one.id].should eq(post_one)
+          expect(criteria).to eq([ person ])
         end
 
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_two.id].should eq(post_two)
+        it "eager loads the first document" do
+          expect_query(0) do
+            expect(documents.first.posts.first).to eq(post_one)
+          end
         end
 
-        it "does not insert the third post into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_three.id].should be_nil
+        it "eager loads the second document" do
+          expect_query(0) do
+            expect(documents.first.posts.last).to eq(post_two)
+          end
         end
       end
     end
@@ -3264,20 +1746,8 @@ describe Mongoid::Criteria do
 
       context "when the criteria has no options" do
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:criteria) do
-          Person.includes(:preferences)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          context.should_receive(:eager_load).with([ person ]).once.and_call_original
+          Person.asc(:age).includes(:preferences)
         end
 
         let!(:documents) do
@@ -3285,148 +1755,73 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          documents.should eq([ person ])
-        end
-
-        let(:preference_map) do
-          Mongoid::IdentityMap[Preference.collection_name]
-        end
-
-        it "inserts the first document into the identity map" do
-          preference_map[preference_one.id].should eq(preference_one)
-        end
-
-        it "inserts the second document into the identity map" do
-          preference_map[preference_two.id].should eq(preference_two)
-        end
-      end
-
-      context "when calling first on the criteria" do
-
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
-        let!(:criteria) do
-          Person.includes(:preferences)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          context.should_receive(:eager_load_one).with(person).once.and_call_original
-        end
-
-        let!(:from_db) do
-          criteria.first
-        end
-
-        it "returns the correct documents" do
-          from_db.should eq(person)
+          expect(documents).to eq([ person ])
         end
 
-        let(:preference_map) do
-          Mongoid::IdentityMap[Preference.collection_name]
-        end
-
-        it "inserts the first document into the identity map" do
-          preference_map[preference_one.id].should eq(preference_one)
-        end
-
-        it "inserts the second document into the identity map" do
-          preference_map[preference_two.id].should eq(preference_two)
-        end
-      end
-
-      context "when calling last on the criteria" do
-
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
-        let!(:criteria) do
-          Person.includes(:preferences)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          context.should_receive(:eager_load_one).with(person).once.and_call_original
-        end
-
-        let!(:from_db) do
-          criteria.last
-        end
-
-        it "returns the correct documents" do
-          from_db.should eq(person)
-        end
-
-        let(:preference_map) do
-          Mongoid::IdentityMap[Preference.collection_name]
-        end
-
-        it "inserts the first document into the identity map" do
-          preference_map[preference_one.id].should eq(preference_one)
+        it "eager loads the first document" do
+          expect_query(0) do
+            expect(documents.first.preferences.first).to eq(preference_one)
+          end
         end
 
-        it "inserts the second document into the identity map" do
-          preference_map[preference_two.id].should eq(preference_two)
+        it "eager loads the last document" do
+          expect_query(0) do
+            expect(documents.first.preferences.last).to eq(preference_two)
+          end
         end
       end
 
-      context "when the criteria has limiting options" do
+      context "when calling first on the criteria" do
 
-        let!(:person_two) do
-          Person.create
+        let!(:criteria) do
+          Person.asc(:age).includes(:preferences)
         end
 
-        let!(:preference_three) do
-          person_two.preferences.create(name: "three")
+        let!(:from_db) do
+          criteria.first
         end
 
-        before do
-          Mongoid::IdentityMap.clear
+        it "returns the correct documents" do
+          expect(from_db).to eq(person)
         end
 
-        let!(:criteria) do
-          Person.includes(:preferences).asc(:_id).limit(1)
+        it "eager loads the first document" do
+          expect_query(0) do
+            expect(from_db.preferences.first).to eq(preference_one)
+          end
         end
 
-        let(:context) do
-          criteria.context
+        it "eager loads the last document" do
+          expect_query(0) do
+            expect(from_db.preferences.last).to eq(preference_two)
+          end
         end
+      end
 
-        before do
-          context.should_receive(:eager_load).with([ person ]).once.and_call_original
-        end
+      context "when calling last on the criteria" do
 
-        let!(:documents) do
-          criteria.entries
+        let!(:criteria) do
+          Person.asc(:age).includes(:preferences)
         end
 
-        let(:preference_map) do
-          Mongoid::IdentityMap[Preference.collection_name]
+        let!(:from_db) do
+          criteria.last
         end
 
         it "returns the correct documents" do
-          documents.should eq([ person ])
+          expect(from_db).to eq(person)
         end
 
-        it "inserts the first document into the identity map" do
-          preference_map[preference_one.id].should eq(preference_one)
-        end
-
-        it "inserts the second document into the identity map" do
-          preference_map[preference_two.id].should eq(preference_two)
+        it "eager loads the first document" do
+          expect_query(0) do
+            expect(from_db.preferences.first).to eq(preference_one)
+          end
         end
 
-        it "does not insert the third preference into the identity map" do
-          preference_map[preference_three.id].should be_nil
+        it "eager loads the last document" do
+          expect_query(0) do
+            expect(from_db.preferences.last).to eq(preference_two)
+          end
         end
       end
     end
@@ -3443,20 +1838,8 @@ describe Mongoid::Criteria do
 
       context "when the criteria has no options" do
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:criteria) do
-          Person.includes(:posts)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          context.should_receive(:eager_load).with([ person ]).once.and_call_original
+          Person.asc(:age).includes(:posts)
         end
 
         let!(:documents) do
@@ -3464,34 +1847,26 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          documents.should eq([ person ])
+          expect(documents).to eq([ person ])
         end
 
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_one.id].should eq(post_one)
+        it "eager loads the first document" do
+          expect_query(0) do
+            expect(documents.first.posts.first).to eq(post_one)
+          end
         end
 
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_two.id].should eq(post_two)
+        it "eager loads the last document" do
+          expect_query(0) do
+            expect(documents.first.posts.last).to eq(post_two)
+          end
         end
       end
 
       context "when calling first on the criteria" do
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:criteria) do
-          Person.includes(:posts)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          context.should_receive(:eager_load_one).with(person).once.and_call_original
+          Person.asc(:age).includes(:posts)
         end
 
         let!(:from_db) do
@@ -3499,49 +1874,25 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          from_db.should eq(person)
-        end
-
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_one.id].should eq(post_one)
-        end
-
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_two.id].should eq(post_two)
+          expect(from_db).to eq(person)
         end
 
         context "when subsequently getting all documents" do
 
-          before do
-            context.should_receive(:eager_load).with([ person ]).once.and_call_original
-          end
-
           let!(:documents) do
             criteria.entries
           end
 
           it "returns the correct documents" do
-            documents.should eq([ person ])
+            expect(documents).to eq([ person ])
           end
         end
       end
 
       context "when calling last on the criteria" do
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:criteria) do
-          Person.includes(:posts)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          context.should_receive(:eager_load_one).with(person).once.and_call_original
+          Person.asc(:age).includes(:posts)
         end
 
         let!(:from_db) do
@@ -3549,29 +1900,17 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          from_db.should eq(person)
-        end
-
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_one.id].should eq(post_one)
-        end
-
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_two.id].should eq(post_two)
+          expect(from_db).to eq(person)
         end
 
         context "when subsequently getting all documents" do
 
-          before do
-            context.should_receive(:eager_load).with([ person ]).once.and_call_original
-          end
-
           let!(:documents) do
             criteria.entries
           end
 
           it "returns the correct documents" do
-            documents.should eq([ person ])
+            expect(documents).to eq([ person ])
           end
         end
       end
@@ -3586,12 +1925,8 @@ describe Mongoid::Criteria do
           person_two.posts.create(title: "three")
         end
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:criteria) do
-          Person.includes(:posts).asc(:_id).limit(1)
+          Person.includes(:posts).asc(:age).limit(1)
         end
 
         let(:context) do
@@ -3599,7 +1934,7 @@ describe Mongoid::Criteria do
         end
 
         before do
-          context.should_receive(:eager_load).with([ person ]).once.and_call_original
+          expect(context).to receive(:eager_load).with([ person ]).once.and_call_original
         end
 
         let!(:documents) do
@@ -3607,19 +1942,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          documents.should eq([ person ])
-        end
-
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_one.id].should eq(post_one)
-        end
-
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_two.id].should eq(post_two)
-        end
-
-        it "does not insert the third post into the identity map" do
-          Mongoid::IdentityMap[Post.collection_name][post_three.id].should be_nil
+          expect(documents).to eq([ person ])
         end
       end
     end
@@ -3636,12 +1959,8 @@ describe Mongoid::Criteria do
 
       context "when the criteria has no options" do
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:criteria) do
-          Person.includes(:game)
+          Person.asc(:age).includes(:game)
         end
 
         let(:context) do
@@ -3649,7 +1968,7 @@ describe Mongoid::Criteria do
         end
 
         before do
-          context.should_receive(:eager_load).with([ person ]).once.and_call_original
+          expect(context).to receive(:eager_load).with([ person ]).once.and_call_original
         end
 
         let!(:documents) do
@@ -3657,49 +1976,22 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          documents.should eq([ person ])
-        end
-
-        it "deletes the replaced document from the identity map" do
-          Mongoid::IdentityMap[Game.collection_name][game_one.id].should be_nil
-        end
-
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Game.collection_name][game_two.id].should eq(game_two)
-        end
-
-        context "when asking from map or db" do
-
-          let(:in_map) do
-            Mongoid::IdentityMap[Game.collection_name][game_two.id]
-          end
-
-          let(:game) do
-            Game.where("person_id" => person.id).from_map_or_db
-          end
-
-          it "returns the document from the map" do
-            game.should equal(in_map)
-          end
+          expect(documents).to eq([ person ])
         end
       end
 
       context "when the criteria has limiting options" do
 
         let!(:person_two) do
-          Person.create
+          Person.create(age: 2)
         end
 
         let!(:game_three) do
           person_two.create_game(name: "Skyrim")
         end
 
-        before do
-          Mongoid::IdentityMap.clear
-        end
-
         let!(:criteria) do
-          Person.where(id: person.id).includes(:game).asc(:_id).limit(1)
+          Person.where(id: person.id).includes(:game).asc(:age).limit(1)
         end
 
         let(:context) do
@@ -3707,7 +1999,7 @@ describe Mongoid::Criteria do
         end
 
         before do
-          context.should_receive(:eager_load).with([ person ]).once.and_call_original
+          expect(context).to receive(:eager_load).with([ person ]).once.and_call_original
         end
 
         let!(:documents) do
@@ -3715,15 +2007,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          documents.should eq([ person ])
-        end
-
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Game.collection_name][game_two.id].should eq(game_two)
-        end
-
-        it "does not load the extra child into the map" do
-          Mongoid::IdentityMap[Game.collection_name][game_three.id].should be_nil
+          expect(documents).to eq([ person ])
         end
       end
     end
@@ -3731,7 +2015,7 @@ describe Mongoid::Criteria do
     context "when including a belongs to" do
 
       let(:person_two) do
-        Person.create
+        Person.create(age: 2)
       end
 
       let!(:game_one) do
@@ -3742,10 +2026,6 @@ describe Mongoid::Criteria do
         person_two.create_game(name: "two")
       end
 
-      before do
-        Mongoid::IdentityMap.clear
-      end
-
       context "when providing no options" do
 
         let!(:criteria) do
@@ -3757,11 +2037,7 @@ describe Mongoid::Criteria do
         end
 
         before do
-          context.
-            should_receive(:eager_load).
-            with([ game_one, game_two ]).
-            once.
-            and_call_original
+          expect(context).to receive(:eager_load).with([ game_one, game_two ]).once.and_call_original
         end
 
         let!(:documents) do
@@ -3769,15 +2045,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          criteria.should eq([ game_one, game_two ])
-        end
-
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Person.collection_name][person.id].should eq(person)
-        end
-
-        it "inserts the second document into the identity map" do
-          Mongoid::IdentityMap[Person.collection_name][person_two.id].should eq(person_two)
+          expect(criteria).to eq([ game_one, game_two ])
         end
       end
 
@@ -3792,7 +2060,7 @@ describe Mongoid::Criteria do
         end
 
         before do
-          context.should_receive(:eager_load).with([ game_one ]).once.and_call_original
+          expect(context).to receive(:eager_load).with([ game_one ]).once.and_call_original
         end
 
         let!(:documents) do
@@ -3800,15 +2068,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the correct documents" do
-          documents.should eq([ game_one ])
-        end
-
-        it "inserts the first document into the identity map" do
-          Mongoid::IdentityMap[Person.collection_name][person.id].should eq(person)
-        end
-
-        it "does not load the documents outside of the limit" do
-          Mongoid::IdentityMap[Person.collection_name][person_two.id].should be_nil
+          expect(documents).to eq([ game_one ])
         end
       end
     end
@@ -3831,12 +2091,8 @@ describe Mongoid::Criteria do
         person.create_game(name: "two")
       end
 
-      before do
-        Mongoid::IdentityMap.clear
-      end
-
       let!(:criteria) do
-        Person.includes(:posts, :game)
+        Person.includes(:posts, :game).asc(:age)
       end
 
       let(:context) do
@@ -3844,7 +2100,7 @@ describe Mongoid::Criteria do
       end
 
       before do
-        context.should_receive(:eager_load).with([ person ]).once.and_call_original
+        expect(context).to receive(:eager_load).with([ person ]).once.and_call_original
       end
 
       let!(:documents) do
@@ -3852,23 +2108,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the correct documents" do
-        criteria.should eq([ person ])
-      end
-
-      it "inserts the first has many document into the identity map" do
-        Mongoid::IdentityMap[Post.collection_name][post_one.id].should eq(post_one)
-      end
-
-      it "inserts the second has many document into the identity map" do
-        Mongoid::IdentityMap[Post.collection_name][post_two.id].should eq(post_two)
-      end
-
-      it "removes the first has one document from the identity map" do
-        Mongoid::IdentityMap[Game.collection_name][game_one.id].should be_nil
-      end
-
-      it "inserts the second has one document into the identity map" do
-        Mongoid::IdentityMap[Game.collection_name][game_two.id].should eq(game_two)
+        expect(criteria).to eq([ person ])
       end
     end
   end
@@ -3884,7 +2124,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the inclusions" do
-      criteria.inclusions.should eq([ metadata ])
+      expect(criteria.inclusions).to eq([ metadata ])
     end
   end
 
@@ -3903,7 +2143,7 @@ describe Mongoid::Criteria do
     end
 
     it "sets the inclusions" do
-      criteria.inclusions.should eq([ metadata ])
+      expect(criteria.inclusions).to eq([ metadata ])
     end
   end
 
@@ -3922,7 +2162,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -3941,7 +2181,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -3973,15 +2213,29 @@ describe Mongoid::Criteria do
       Band.create(name: "Tool", likes: 100)
     end
 
-    let(:map_reduce) do
-      Band.limit(2).map_reduce(map, reduce).out(inline: 1)
+    context "when no timeout options are provided" do
+
+      let(:map_reduce) do
+        Band.limit(2).map_reduce(map, reduce).out(inline: 1)
+      end
+
+      it "returns the map/reduce results" do
+        expect(map_reduce).to eq([
+          { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
+          { "_id" => "Tool", "value" => { "likes" => 100 }}
+        ])
+      end
     end
 
-    it "returns the map/reduce results" do
-      map_reduce.should eq([
-        { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
-        { "_id" => "Tool", "value" => { "likes" => 100 }}
-      ])
+    context "when timeout options are provided" do
+
+      let(:map_reduce) do
+        Band.limit(2).no_timeout.map_reduce(map, reduce).out(replace: "test_bands")
+      end
+
+      it "sets the timeout option on the query" do
+        expect(map_reduce.send(:documents).operation.flags).to eq([ :no_cursor_timeout ])
+      end
     end
   end
 
@@ -4008,7 +2262,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the max of the provided field" do
-          max.should eq(1000)
+          expect(max).to eq(1000)
         end
       end
 
@@ -4021,7 +2275,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the document with the max value for the field" do
-          max.should eq(depeche)
+          expect(max).to eq(depeche)
         end
       end
     end
@@ -4046,7 +2300,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -4077,27 +2331,27 @@ describe Mongoid::Criteria do
       end
 
       it "merges the selector" do
-        merged.selector.should eq({ "name" => "Depeche Mode" })
+        expect(merged.selector).to eq({ "name" => "Depeche Mode" })
       end
 
       it "merges the options" do
-        merged.options.should eq({ sort: { "name" => 1 }})
+        expect(merged.options).to eq({ sort: { "name" => 1 }})
       end
 
       it "merges the documents" do
-        merged.documents.should eq([ band ])
+        expect(merged.documents).to eq([ band ])
       end
 
       it "merges the scoping options" do
-        merged.scoping_options.should eq([ nil, nil ])
+        expect(merged.scoping_options).to eq([ nil, nil ])
       end
 
       it "merges the inclusions" do
-        merged.inclusions.should eq([ metadata ])
+        expect(merged.inclusions).to eq([ metadata ])
       end
 
       it "returns a new criteria" do
-        merged.should_not equal(criteria)
+        expect(merged).to_not equal(criteria)
       end
     end
 
@@ -4116,23 +2370,23 @@ describe Mongoid::Criteria do
       end
 
       it "merges the selector" do
-        merged.selector.should eq({ "name" => "Depeche Mode" })
+        expect(merged.selector).to eq({ "name" => "Depeche Mode" })
       end
 
       it "merges the options" do
-        merged.options.should eq({ sort: { "name" => 1 }})
+        expect(merged.options).to eq({ sort: { "name" => 1 }})
       end
 
       it "merges the scoping options" do
-        merged.scoping_options.should eq([ nil, nil ])
+        expect(merged.scoping_options).to eq([ nil, nil ])
       end
 
       it "merges the inclusions" do
-        merged.inclusions.should eq([ metadata ])
+        expect(merged.inclusions).to eq([ metadata ])
       end
 
       it "returns a new criteria" do
-        merged.should_not equal(criteria)
+        expect(merged).to_not equal(criteria)
       end
     end
   end
@@ -4162,27 +2416,27 @@ describe Mongoid::Criteria do
     end
 
     it "merges the selector" do
-      merged.selector.should eq({ "name" => "Depeche Mode" })
+      expect(merged.selector).to eq({ "name" => "Depeche Mode" })
     end
 
     it "merges the options" do
-      merged.options.should eq({ sort: { "name" => 1 }})
+      expect(merged.options).to eq({ sort: { "name" => 1 }})
     end
 
     it "merges the documents" do
-      merged.documents.should eq([ band ])
+      expect(merged.documents).to eq([ band ])
     end
 
     it "merges the scoping options" do
-      merged.scoping_options.should eq([ nil, nil ])
+      expect(merged.scoping_options).to eq([ nil, nil ])
     end
 
     it "merges the inclusions" do
-      merged.inclusions.should eq([ metadata ])
+      expect(merged.inclusions).to eq([ metadata ])
     end
 
     it "returns the same criteria" do
-      merged.should equal(criteria)
+      expect(merged).to equal(criteria)
     end
   end
 
@@ -4209,7 +2463,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the min of the provided field" do
-          min.should eq(500)
+          expect(min).to eq(500)
         end
       end
 
@@ -4222,7 +2476,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the document with the min value for the field" do
-          min.should eq(tool)
+          expect(min).to eq(tool)
         end
       end
     end
@@ -4243,7 +2497,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -4262,7 +2516,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -4281,7 +2535,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -4300,7 +2554,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -4319,7 +2573,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -4338,7 +2592,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -4357,11 +2611,13 @@ describe Mongoid::Criteria do
         end
 
         it "limits the returned fields" do
-          criteria.first.name.should be_nil
+          expect {
+            criteria.first.name
+          }.to raise_error(ActiveModel::MissingAttributeError)
         end
 
         it "does not add _type to the fields" do
-          criteria.options[:fields]["_type"].should be_nil
+          expect(criteria.options[:fields]["_type"]).to be_nil
         end
       end
 
@@ -4372,15 +2628,17 @@ describe Mongoid::Criteria do
         end
 
         it "includes the limited fields" do
-          criteria.first.name.should_not be_nil
+          expect(criteria.first.name).to_not be_nil
         end
 
         it "excludes the non included fields" do
-          criteria.first.active.should be_nil
+          expect {
+            criteria.first.active
+          }.to raise_error(ActiveModel::MissingAttributeError)
         end
 
         it "does not add _type to the fields" do
-          criteria.options[:fields]["_type"].should be_nil
+          expect(criteria.options[:fields]["_type"]).to be_nil
         end
       end
 
@@ -4392,7 +2650,7 @@ describe Mongoid::Criteria do
 
         it "only limits the fields on the correct model" do
           criteria.each do |band|
-            Person.new.age.should eq(100)
+            expect(Person.new.age).to eq(100)
           end
         end
       end
@@ -4405,7 +2663,7 @@ describe Mongoid::Criteria do
 
         it "only limits the fields on the correct criteria" do
           criteria.each do |band|
-            Band.new.active.should be_true
+            expect(Band.new.active).to be true
           end
         end
       end
@@ -4419,7 +2677,7 @@ describe Mongoid::Criteria do
         it "only limits the fields on the correct criteria" do
           criteria.each do |band|
             Band.all.each do |b|
-              b.active.should be_true
+              expect(b.active).to be true
             end
           end
         end
@@ -4433,7 +2691,7 @@ describe Mongoid::Criteria do
       end
 
       it "adds _type to the fields" do
-        criteria.options[:fields]["_type"].should eq(1)
+        expect(criteria.options[:fields]["_type"]).to eq(1)
       end
     end
 
@@ -4446,7 +2704,7 @@ describe Mongoid::Criteria do
         end
 
         it "properly uses the database field name" do
-          criteria.options.should eq(fields: { "mobile_phones" => 1 })
+          expect(criteria.options).to eq(fields: { "mobile_phones" => 1 })
         end
       end
     end
@@ -4471,7 +2729,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the matching documents" do
-          criteria.should eq([ match ])
+          expect(criteria).to eq([ match ])
         end
       end
 
@@ -4482,7 +2740,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the matching documents" do
-          criteria.should eq([ match ])
+          expect(criteria).to eq([ match ])
         end
       end
     end
@@ -4502,6 +2760,28 @@ describe Mongoid::Criteria do
       Band.create(name: "Photek", likes: 1)
     end
 
+    context "when the field is aliased" do
+
+      let!(:expensive) do
+        Product.create(price: 100000)
+      end
+
+      let!(:cheap) do
+        Product.create(price: 1)
+      end
+
+      context "when using alias_attribute" do
+
+        let(:plucked) do
+          Product.pluck(:price)
+        end
+
+        it "uses the aliases" do
+          expect(plucked).to eq([ 100000, 1 ])
+        end
+      end
+    end
+
     context "when the criteria matches" do
 
       context "when there are no duplicate values" do
@@ -4515,7 +2795,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the values" do
-          plucked.should eq([ "Depeche Mode", "Tool", "Photek" ])
+          expect(plucked).to eq([ "Depeche Mode", "Tool", "Photek" ])
         end
 
         context "when subsequently executing the criteria without a pluck" do
@@ -4526,6 +2806,17 @@ describe Mongoid::Criteria do
         end
       end
 
+      context "when plucking mult-fields" do
+
+        let(:plucked) do
+          Band.where(:name.exists => true).pluck(:name, :likes)
+        end
+
+        it "returns the values" do
+          expect(plucked).to eq([ ["Depeche Mode", 3], ["Tool", 3], ["Photek", 1] ])
+        end
+      end
+
       context "when there are duplicate values" do
 
         let(:plucked) do
@@ -4533,7 +2824,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the duplicates" do
-          plucked.should eq([ 3, 3, 1 ])
+          expect(plucked).to eq([ 3, 3, 1 ])
         end
       end
     end
@@ -4545,7 +2836,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns an empty array" do
-        plucked.should be_empty
+        expect(plucked).to be_empty
       end
     end
 
@@ -4556,7 +2847,32 @@ describe Mongoid::Criteria do
       end
 
       it "returns the field values" do
-        plucked.should eq([ depeche.id, tool.id, photek.id ])
+        expect(plucked).to eq([ depeche.id, tool.id, photek.id ])
+      end
+    end
+
+    context "when plucking a field that doesnt exist" do
+
+      context "when pluck one field" do
+
+        let(:plucked) do
+          Band.all.pluck(:foo)
+        end
+
+        it "returns a empty array" do
+          expect(plucked).to eq([])
+        end
+      end
+
+      context "when pluck multiple fields" do
+
+        let(:plucked) do
+          Band.all.pluck(:foo, :bar)
+        end
+
+        it "returns a empty array" do
+          expect(plucked).to eq([[], [], []])
+        end
       end
     end
   end
@@ -4576,7 +2892,7 @@ describe Mongoid::Criteria do
     context "when asking about a model public class method" do
 
       it "returns true" do
-        criteria.should respond_to(:ages)
+        expect(criteria).to respond_to(:ages)
       end
     end
 
@@ -4585,7 +2901,7 @@ describe Mongoid::Criteria do
       context "when including private methods" do
 
         it "returns true" do
-          criteria.respond_to?(:for_ids, true).should be_true
+          expect(criteria.respond_to?(:for_ids, true)).to be true
         end
       end
     end
@@ -4593,7 +2909,7 @@ describe Mongoid::Criteria do
     context "when asking about a model class public instance method" do
 
       it "returns true" do
-        criteria.respond_to?(:join).should be_true
+        expect(criteria.respond_to?(:join)).to be true
       end
     end
 
@@ -4602,14 +2918,14 @@ describe Mongoid::Criteria do
       context "when not including private methods" do
 
         it "returns false" do
-          criteria.should_not respond_to(:fork)
+          expect(criteria).to_not respond_to(:fork)
         end
       end
 
       context "when including private methods" do
 
         it "returns true" do
-          criteria.respond_to?(:fork, true).should be_true
+          expect(criteria.respond_to?(:fork, true)).to be true
         end
       end
     end
@@ -4617,7 +2933,7 @@ describe Mongoid::Criteria do
     context "when asking about a criteria instance method" do
 
       it "returns true" do
-        criteria.should respond_to(:context)
+        expect(criteria).to respond_to(:context)
       end
     end
 
@@ -4626,14 +2942,14 @@ describe Mongoid::Criteria do
       context "when not including private methods" do
 
         it "returns false" do
-          criteria.should_not respond_to(:puts)
+          expect(criteria).to_not respond_to(:puts)
         end
       end
 
       context "when including private methods" do
 
         it "returns true" do
-          criteria.respond_to?(:puts, true).should be_true
+          expect(criteria.respond_to?(:puts, true)).to be true
         end
       end
     end
@@ -4656,7 +2972,7 @@ describe Mongoid::Criteria do
     end
 
     it "sorts the results in memory" do
-      sorted.should eq([ tool, depeche ])
+      expect(sorted).to eq([ tool, depeche ])
     end
   end
 
@@ -4683,7 +2999,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the sum of the provided field" do
-          sum.should eq(1500)
+          expect(sum).to eq(1500)
         end
       end
 
@@ -4694,7 +3010,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the sum for the provided block" do
-          sum.should eq(1500)
+          expect(sum).to eq(1500)
         end
       end
     end
@@ -4711,7 +3027,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the executed criteria" do
-      criteria.to_ary.should eq([ band ])
+      expect(criteria.to_ary).to eq([ band ])
     end
   end
 
@@ -4726,7 +3042,7 @@ describe Mongoid::Criteria do
     end
 
     it "executes the criteria while properly giving the hint to Mongo" do
-      expect { criteria.to_ary }.to raise_error(Moped::Errors::QueryFailure,  %r{failed with error 10113: "bad hint"})
+      expect { criteria.to_ary }.to raise_error(Moped::Errors::QueryFailure)
     end
   end
 
@@ -4741,7 +3057,7 @@ describe Mongoid::Criteria do
     end
 
     it "executes the criteria while properly giving the hint to Mongo" do
-      expect { criteria.to_ary }.to raise_error(Moped::Errors::QueryFailure,  %r{failed with error 10113: "bad hint"})
+      expect { criteria.to_ary }.to raise_error(Moped::Errors::QueryFailure)
     end
   end
 
@@ -4759,7 +3075,32 @@ describe Mongoid::Criteria do
     end
 
     it "executes the criteria while properly giving the max scan to Mongo" do
-      criteria.to_ary.should eq [band]
+      expect(criteria.to_ary).to eq [band]
+    end
+  end
+
+  describe "#text_search" do
+
+    let(:criteria) do
+      Word.all
+    end
+
+    before do
+      Word.with(database: "admin").mongo_session.command(setParameter: 1, textSearchEnabled: true)
+      Word.create_indexes
+      Word.create!(name: "phase", origin: "latin")
+    end
+
+    after(:all) do
+      Word.remove_indexes
+    end
+
+    let(:search) do
+      criteria.text_search("phase")
+    end
+
+    it "returns all fields" do
+      expect(search.first.origin).to eq("latin")
     end
   end
 
@@ -4770,7 +3111,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns self" do
-      criteria.to_criteria.should eq(criteria)
+      expect(criteria.to_criteria).to eq(criteria)
     end
   end
 
@@ -4781,11 +3122,11 @@ describe Mongoid::Criteria do
     end
 
     it "returns a proc" do
-      criteria.to_proc.should be_a(Proc)
+      expect(criteria.to_proc).to be_a(Proc)
     end
 
     it "wraps the criteria in the proc" do
-      criteria.to_proc[].should eq(criteria)
+      expect(criteria.to_proc[]).to eq(criteria)
     end
   end
 
@@ -4802,7 +3143,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns documents with the provided type" do
-        criteria.should eq([ browser ])
+        expect(criteria).to eq([ browser ])
       end
     end
 
@@ -4817,7 +3158,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns documents with the provided types" do
-        criteria.should eq([ browser ])
+        expect(criteria).to eq([ browser ])
       end
     end
   end
@@ -4850,7 +3191,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the matching documents" do
-          criteria.should eq([ match ])
+          expect(criteria).to eq([ match ])
         end
       end
     end
@@ -4864,18 +3205,18 @@ describe Mongoid::Criteria do
         end
 
         it "returns the matching documents" do
-          criteria.should eq([ match ])
+          expect(criteria).to eq([ match ])
         end
       end
 
       context "when the criteria is an exact fk array match" do
 
         let(:id_one) do
-          Moped::BSON::ObjectId.new
+          BSON::ObjectId.new
         end
 
         let(:id_two) do
-          Moped::BSON::ObjectId.new
+          BSON::ObjectId.new
         end
 
         let(:criteria) do
@@ -4883,7 +3224,7 @@ describe Mongoid::Criteria do
         end
 
         it "does not wrap the array in another array" do
-          criteria.selector.should eq({ "agent_ids" => [ id_one, id_two ]})
+          expect(criteria.selector).to eq({ "agent_ids" => [ id_one, id_two ]})
         end
       end
     end
@@ -4902,7 +3243,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the matching documents" do
-        criteria.should eq([ match ])
+        expect(criteria).to eq([ match ])
       end
     end
 
@@ -4913,7 +3254,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the matching documents" do
-        criteria.should eq([ match ])
+        expect(criteria).to eq([ match ])
       end
     end
   end
@@ -4927,7 +3268,7 @@ describe Mongoid::Criteria do
     context "when the method exists on the class" do
 
       before do
-        Person.should_receive(:minor).and_call_original
+        expect(Person).to receive(:minor).and_call_original
       end
 
       it "calls the method on the class" do
@@ -4938,7 +3279,7 @@ describe Mongoid::Criteria do
     context "when the method exists on the criteria" do
 
       before do
-        criteria.should_receive(:to_criteria).and_call_original
+        expect(criteria).to receive(:to_criteria).and_call_original
       end
 
       it "calls the method on the criteria" do
@@ -4949,7 +3290,7 @@ describe Mongoid::Criteria do
     context "when the method exists on array" do
 
       before do
-        criteria.should_receive(:entries).and_call_original
+        expect(criteria).to receive(:entries).and_call_original
       end
 
       it "calls the method on the criteria" do
@@ -4960,7 +3301,7 @@ describe Mongoid::Criteria do
     context "when the method does not exist" do
 
       before do
-        criteria.should_receive(:entries).never
+        expect(criteria).to receive(:entries).never
       end
 
       it "raises an error" do
@@ -4986,7 +3327,7 @@ describe Mongoid::Criteria do
     end
 
     it "passes the block through method_missing" do
-      criteria.uniq(&:name).should eq([ band_one ])
+      expect(criteria.uniq(&:name)).to eq([ band_one ])
     end
   end
 
@@ -4996,94 +3337,36 @@ describe Mongoid::Criteria do
       Band.where(name: "Depeche Mode").with(collection: "artists")
     end
 
-    after do
-      Band.persistence_options.clear
-    end
-
     it "retains the criteria selection" do
-      criteria.selector.should eq("name" => "Depeche Mode")
+      expect(criteria.selector).to eq("name" => "Depeche Mode")
     end
 
     it "sets the persistence options" do
-      Band.persistence_options.should eq(collection: "artists")
+      expect(criteria.persistence_options).to eq(collection: "artists")
     end
   end
 
-  describe "#within_box" do
+  describe "#geo_spacial" do
 
-    before do
-      Bar.create_indexes
-    end
-
-    let!(:match) do
-      Bar.create(location: [ 52.30, 13.25 ])
-    end
-
-    let(:criteria) do
-      Bar.within_box(location: [[ 50, 10 ], [ 60, 20 ]])
-    end
-
-    it "returns the matching documents" do
-      criteria.should eq([ match ])
-    end
-  end
-
-  describe "#within_circle" do
-
-    before do
-      Bar.create_indexes
-    end
-
-    let!(:match) do
-      Bar.create(location: [ 52.30, 13.25 ])
-    end
-
-    let(:criteria) do
-      Bar.within_circle(location: [[ 52, 13 ], 0.5 ])
-    end
-
-    it "returns the matching documents" do
-      criteria.should eq([ match ])
-    end
-  end
-
-  describe "#within_polygon" do
-
-    before do
-      Bar.create_indexes
-    end
-
-    let!(:match) do
-      Bar.create(location: [ 52.30, 13.25 ])
-    end
-
-    let(:criteria) do
-      Bar.within_polygon(
-        location: [[ 50, 10 ], [ 50, 20 ], [ 60, 20 ], [ 60, 10 ]]
-      )
-    end
-
-    it "returns the matching documents" do
-      criteria.should eq([ match ])
-    end
-  end
+    context "when checking within a polygon" do
 
-  describe "#within_spherical_circle" do
-
-    before do
-      Bar.create_indexes
-    end
+      before do
+        Bar.create_indexes
+      end
 
-    let!(:match) do
-      Bar.create(location: [ 52.30, 13.25 ])
-    end
+      let!(:match) do
+        Bar.create(location: [ 52.30, 13.25 ])
+      end
 
-    let(:criteria) do
-      Bar.within_spherical_circle(location: [[ 52, 13 ], 0.5 ])
-    end
+      let(:criteria) do
+        Bar.geo_spacial(
+          :location.within_polygon => [[[ 50, 10 ], [ 50, 20 ], [ 60, 20 ], [ 60, 10 ], [ 50, 10 ]]]
+        )
+      end
 
-    it "returns the matching documents" do
-      criteria.should eq([ match ])
+      it "returns the matching documents" do
+        expect(criteria).to eq([ match ])
+      end
     end
   end
 
@@ -5102,7 +3385,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -5117,7 +3400,7 @@ describe Mongoid::Criteria do
     end
 
     it "returns the matching documents" do
-      criteria.should eq([ match ])
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -5132,7 +3415,7 @@ describe Mongoid::Criteria do
         end
 
         it "properly uses the database field name" do
-          criteria.options.should eq(fields: { "mobile_phones" => 0 })
+          expect(criteria.options).to eq(fields: { "mobile_phones" => 0 })
         end
       end
     end