mongoid 7.5.4 → 8.0.1

data/spec/mongoid/contextual/mongo_spec.rb

@@ -44,39 +44,6 @@ describe Mongoid::Contextual::Mongo do
     end
   end
 
-  describe "#cached?" do
-
-    context "when the criteria is cached" do
-
-      let(:criteria) do
-        Band.all.cache
-      end
-
-      let(:context) do
-        described_class.new(criteria)
-      end
-
-      it "returns true" do
-        expect(context).to be_cached
-      end
-    end
-
-    context "when the criteria is not cached" do
-
-      let(:criteria) do
-        Band.all
-      end
-
-      let(:context) do
-        described_class.new(criteria)
-      end
-
-      it "returns false" do
-        expect(context).to_not be_cached
-      end
-    end
-  end
-
   describe "#count" do
 
     let!(:depeche) do
@@ -102,15 +69,17 @@ describe Mongoid::Contextual::Mongo do
       end
     end
 
-    context "when context is cached" do
+    context "when the query cache is enabled" do
+      query_cache_enabled
 
       let(:context) do
-        described_class.new(criteria.cache)
+        described_class.new(criteria)
       end
 
-      it "returns the count cached value after first call" do
-        expect(context.view).to receive(:count_documents).once.and_return(1)
-        2.times { expect(context.count).to eq(1) }
+      it "only executes the count query once" do
+        expect_query(1) do
+          2.times { expect(context.count).to eq(1) }
+        end
       end
     end
 
@@ -217,16 +186,18 @@ describe Mongoid::Contextual::Mongo do
       end
     end
 
-    context "when context is cached" do
+    context "when the query cache is enabled" do
+      query_cache_enabled
 
       let(:context) do
-        described_class.new(criteria.cache)
+        described_class.new(criteria)
       end
 
-      it "returns the count cached value after first call" do
-        expect(context.view).to receive(:estimated_document_count).once.and_return(1)
-        2.times do
-          context.estimated_count
+      it "the results are not cached" do
+        expect_query(2) do
+          2.times do
+            context.estimated_count
+          end
         end
       end
     end
@@ -561,8 +532,22 @@ describe Mongoid::Contextual::Mongo do
       context "when legacy_pluck_distinct is set" do
         config_override :legacy_pluck_distinct, true
 
-        it "returns the non-demongoized distinct field values" do
-          expect(context.distinct(:sales).sort).to eq([ "1E2", "2E3" ])
+        context 'when storing BigDecimal as string' do
+          config_override :map_big_decimal_to_decimal128, false
+
+          it "returns the non-demongoized distinct field values" do
+            expect(context.distinct(:sales).sort).to eq([ "1E2", "2E3" ])
+          end
+        end
+
+        context 'when storing BigDecimal as decimal128' do
+          config_override :map_big_decimal_to_decimal128, true
+          min_bson_version '4.15.0'
+          max_bson_version '4.99.99'
+
+          it "returns the non-demongoized distinct field values" do
+            expect(context.distinct(:sales).sort).to eq([ BSON::Decimal128.new("1E2"), BSON::Decimal128.new("2E3") ])
+          end
         end
       end
 
@@ -584,10 +569,6 @@ describe Mongoid::Contextual::Mongo do
         d.save!
       end
 
-      after do
-        I18n.locale = :en
-      end
-
       let(:criteria) do
         Dictionary.criteria
       end
@@ -688,10 +669,6 @@ describe Mongoid::Contextual::Mongo do
           I18n.fallbacks = prev_fallbacks
         end
 
-        after do
-          I18n.locale = :en
-        end
-
         let(:distinct) do
           context.distinct(:description).first
         end
@@ -727,10 +704,6 @@ describe Mongoid::Contextual::Mongo do
           Person.create!(passport: p, employer_id: 12345)
         end
 
-        after do
-          I18n.locale = :en
-        end
-
         let(:criteria) do
           Person.where(employer_id: 12345)
         end
@@ -794,9 +767,11 @@ describe Mongoid::Contextual::Mongo do
 
       context "when legacy_pluck_distinct is set" do
         config_override :legacy_pluck_distinct, true
+        config_override :map_big_decimal_to_decimal128, true
+        max_bson_version '4.99.99'
 
         it "returns the distinct matching fields" do
-          expect(context.distinct("label.sales")).to eq([ "1E2" ])
+          expect(context.distinct("label.sales")).to eq([ BSON::Decimal128.new('1E+2') ])
         end
       end
 
@@ -809,6 +784,435 @@ describe Mongoid::Contextual::Mongo do
     end
   end
 
+  describe "#tally" do
+    let(:fans1) { [ Fanatic.new(age:1), Fanatic.new(age:2) ] }
+    let(:fans2) { [ Fanatic.new(age:1), Fanatic.new(age:2) ] }
+    let(:fans3) { [ Fanatic.new(age:1), Fanatic.new(age:3) ] }
+
+    let(:genres1) { [ { x: 1, y: { z: 1 } }, { x: 2, y: { z: 2 } }, { y: 3 } ]}
+    let(:genres2) { [ { x: 1, y: { z: 1 } }, { x: 2, y: { z: 2 } }, { y: 4 } ]}
+    let(:genres3) { [ { x: 1, y: { z: 1 } }, { x: 3, y: { z: 3 } }, { y: 5 } ]}
+
+    let(:label1) {  Label.new(name: "Atlantic") }
+    let(:label2) {  Label.new(name: "Atlantic") }
+    let(:label3) {  Label.new(name: "Columbia") }
+
+    before do
+      Band.create!(origin: "tally", name: "Depeche Mode", years: 30, sales: "1E2", label: label1, genres: genres1)
+      Band.create!(origin: "tally", name: "New Order", years: 30, sales: "2E3", label: label2, genres: genres2)
+      Band.create!(origin: "tally", name: "10,000 Maniacs", years: 30, sales: "1E2", label: label3, genres: genres3)
+      Band.create!(origin: "tally2", fanatics: fans1, genres: [1, 2])
+      Band.create!(origin: "tally2", fanatics: fans2, genres: [1, 2])
+      Band.create!(origin: "tally2", fanatics: fans3, genres: [1, 3])
+    end
+
+    let(:criteria) { Band.where(origin: "tally") }
+
+    context "when tallying a string" do
+      let(:tally) do
+        criteria.tally(:name)
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq("Depeche Mode" => 1, "New Order" => 1, "10,000 Maniacs" => 1)
+      end
+    end
+
+    context "using an aliased field" do
+      let(:tally) do
+        criteria.tally(:years)
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(30 => 3)
+      end
+    end
+
+    context "when tallying a demongoizable field" do
+      let(:tally) do
+        criteria.tally(:sales)
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(BigDecimal("1E2") => 2, BigDecimal("2E3") => 1)
+      end
+    end
+
+    context "when tallying a localized field" do
+      before do
+        I18n.locale = :en
+        d1 = Dictionary.create!(description: 'en1')
+        d2 = Dictionary.create!(description: 'en1')
+        d3 = Dictionary.create!(description: 'en1')
+        d4 = Dictionary.create!(description: 'en2')
+        I18n.locale = :de
+        d1.description = 'de1'
+        d2.description = 'de1'
+        d3.description = 'de2'
+        d4.description = 'de3'
+        d1.save!
+        d2.save!
+        d3.save!
+        d4.save!
+
+        I18n.locale = :en
+      end
+
+      context "when getting the demongoized field" do
+        let(:tallied) do
+          Dictionary.tally(:description)
+        end
+
+        it "returns the translation for the current locale" do
+          expect(tallied).to eq("en1" => 3, "en2" => 1)
+        end
+      end
+
+      context "when getting a specific locale" do
+        let(:tallied) do
+          Dictionary.tally("description.de")
+        end
+
+        it "returns the translation for the the specific locale" do
+          expect(tallied).to eq("de1" => 2, "de2" => 1, "de3" => 1)
+        end
+      end
+
+      context "when getting the full hash" do
+        let(:tallied) do
+          Dictionary.tally("description_translations")
+        end
+
+        it "returns the correct hash" do
+          expect(tallied).to eq(
+            {"de" => "de1", "en" => "en1" } => 2,
+            {"de" => "de2", "en" => "en1" } => 1,
+            {"de" => "de3", "en" => "en2" } => 1
+          )
+        end
+      end
+    end
+
+    context "when tallying an embedded localized field" do
+
+      before do
+        I18n.locale = :en
+        address1a = Address.new(name: "en1")
+        address1b = Address.new(name: "en2")
+        address2a = Address.new(name: "en1")
+        address2b = Address.new(name: "en3")
+        I18n.locale = :de
+        address1a.name = "de1"
+        address1b.name = "de2"
+        address2a.name = "de1"
+        address2b.name = "de3"
+        Person.create!(addresses: [ address1a, address1b ])
+        Person.create!(addresses: [ address2a, address2b ])
+
+        I18n.locale = :en
+      end
+
+      context "when getting the demongoized field" do
+        let(:tallied) do
+          Person.tally("addresses.name")
+        end
+
+        it "returns the translation for the current locale" do
+          expect(tallied).to eq(
+            [ "en1", "en2" ] => 1,
+            [ "en1", "en3" ] => 1,
+          )
+        end
+      end
+
+      context "when getting a specific locale" do
+        let(:tallied) do
+          Person.tally("addresses.name.de")
+        end
+
+        it "returns the translation for the the specific locale" do
+          expect(tallied).to eq(
+            [ "de1", "de2" ] => 1,
+            [ "de1", "de3" ] => 1,
+          )
+        end
+      end
+
+      context "when getting the full hash" do
+        let(:tallied) do
+          Person.tally("addresses.name_translations")
+        end
+
+        it "returns the correct hash" do
+          expect(tallied).to eq(
+            [{ "de" => "de1", "en" => "en1" }, { "de" => "de2", "en" => "en2" }] => 1,
+            [{ "de" => "de1", "en" => "en1" }, { "de" => "de3", "en" => "en3" }] => 1,
+          )
+        end
+      end
+
+    end
+
+    context "when tallying an embedded field" do
+      let(:tally) do
+        criteria.tally("label.name")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq("Atlantic" => 2, "Columbia" => 1)
+      end
+    end
+
+    context "when tallying an element in an embeds_many field" do
+      let(:criteria) { Band.where(origin: "tally2") }
+
+      let(:tally) do
+        criteria.tally("fanatics.age")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when tallying an embeds_many field" do
+      let(:criteria) { Band.where(origin: "tally2") }
+
+      let(:tally) do
+        criteria.tally("fanatics")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          fans1.map(&:attributes) => 1,
+          fans2.map(&:attributes) => 1,
+          fans3.map(&:attributes) => 1,
+        )
+      end
+    end
+
+    context "when tallying a field of type array" do
+      let(:criteria) { Band.where(origin: "tally2") }
+
+      let(:tally) do
+        criteria.tally("genres")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when tallying an element from an array of hashes" do
+      let(:criteria) { Band.where(origin: "tally") }
+
+      let(:tally) do
+        criteria.tally("genres.x")
+      end
+
+      it "returns the correct hash without the nil keys" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when tallying an element from an array of hashes; with duplicate" do
+
+      before do
+        Band.create!(origin: "tally", genres: [ { x: 1 }, {x: 1} ] )
+      end
+
+      let(:criteria) { Band.where(origin: "tally") }
+
+      let(:tally) do
+        criteria.tally("genres.x")
+      end
+
+      it "returns the correct hash without the nil keys" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1,
+          [1, 1] => 1,
+        )
+      end
+    end
+
+    context "when tallying an aliased field of type array" do
+
+      before do
+        Person.create!(array: [ 1, 2 ])
+        Person.create!(array: [ 1, 3 ])
+      end
+
+      let(:tally) do
+        Person.tally("array")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 1,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when going multiple levels deep in arrays" do
+      let(:criteria) { Band.where(origin: "tally") }
+
+      let(:tally) do
+        criteria.tally("genres.y.z")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when going multiple levels deep in an array" do
+      let(:criteria) { Band.where(origin: "tally") }
+
+      let(:tally) do
+        criteria.tally("genres.y.z")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when tallying deeply nested arrays/embedded associations" do
+
+      before do
+        Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ])
+        Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ])
+        Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))) ])
+      end
+
+      let(:tally) do
+        Person.tally("addresses.code.deepest.array.y.z")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [ [ 1, 2 ] ] => 2,
+          [ [ 1, 3 ] ] => 1
+        )
+      end
+    end
+
+    context "when tallying deeply nested arrays/embedded associations" do
+
+      before do
+        Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))),
+                                    Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ])
+        Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))),
+                                    Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ])
+        Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))),
+                                    Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))) ])
+      end
+
+      let(:tally) do
+        Person.tally("addresses.code.deepest.array.y.z")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [ [ 1, 2 ], [ 1, 2 ] ] => 2,
+          [ [ 1, 3 ], [ 1, 3 ] ] => 1
+        )
+      end
+    end
+
+    context "when some keys are missing" do
+      before do
+        3.times { Band.create!(origin: "tally") }
+      end
+
+      let(:tally) do
+        criteria.tally(:name)
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          "Depeche Mode" => 1,
+          "New Order" => 1,
+          "10,000 Maniacs" => 1,
+          nil => 3
+        )
+      end
+    end
+
+    context "when the first element is an embeds_one" do
+      before do
+        Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 2) ]))
+        Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 2) ]))
+        Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 3) ]))
+      end
+
+      let(:tally) do
+        Person.tally("name.translations.language")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when tallying demongoizable values from typeless fields" do
+
+      let!(:person1) { Person.create!(ssn: /hello/) }
+      let!(:person2) { Person.create!(ssn: BSON::Decimal128.new("1")) }
+      let(:tally) { Person.tally("ssn") }
+
+      context "< BSON 5" do
+        max_bson_version '4.99.99'
+
+        it "stores the correct types in the database" do
+          Person.find(person1.id).attributes["ssn"].should be_a BSON::Regexp::Raw
+          Person.find(person2.id).attributes["ssn"].should be_a BSON::Decimal128
+        end
+
+        it "tallies the correct type" do
+          tally.keys.map(&:class).sort do |a,b|
+            a.to_s <=> b.to_s
+          end.should == [BSON::Decimal128, BSON::Regexp::Raw]
+        end
+      end
+
+      context ">= BSON 5" do
+        min_bson_version "5.0"
+
+        it "stores the correct types in the database" do
+          Person.find(person1.id).ssn.should be_a BSON::Regexp::Raw
+          Person.find(person2.id).ssn.should be_a BigDeimal
+        end
+
+        it "tallies the correct type" do
+          tally.keys.map(&:class).sort do |a,b|
+            a.to_s <=> b.to_s
+          end.should == [BigDecimal, BSON::Regexp::Raw]
+        end
+      end
+    end
+  end
+
   describe "#each" do
 
     before do
@@ -1017,51 +1421,15 @@ describe Mongoid::Contextual::Mongo do
         described_class.new(criteria)
       end
 
-      context "when exists? already called" do
+      context "when exists? already called and query cache is enabled" do
+        query_cache_enabled
 
         before do
           context.exists?
         end
 
-        it "hits the database again" do
-          expect(context).to receive(:view).once.and_call_original
-          expect(context).to be_exists
-        end
-      end
-    end
-
-    context "when caching is enabled" do
-
-      let(:criteria) do
-        Band.where(name: "Depeche Mode").cache
-      end
-
-      let(:context) do
-        described_class.new(criteria)
-      end
-
-      context "when the cache is loaded" do
-
-        before do
-          context.to_a
-        end
-
-        it "does not hit the database" do
-          expect(context).to receive(:view).never
-          expect(context).to be_exists
-        end
-      end
-
-      context "when the cache is not loaded" do
-
-        context "when a count has been executed" do
-
-          before do
-            context.count
-          end
-
-          it "does not hit the database" do
-            expect(context).to receive(:view).never
+        it "does not hit the database again" do
+          expect_no_queries do
             expect(context).to be_exists
           end
         end
@@ -1420,7 +1788,7 @@ describe Mongoid::Contextual::Mongo do
       it "deletes the document from the database" do
         expect {
           depeche.reload
-        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Band with id\(s\)/)
       end
 
       context 'when a collation is specified on the criteria' do
@@ -1445,7 +1813,7 @@ describe Mongoid::Contextual::Mongo do
         it "deletes the document from the database" do
           expect {
             depeche.reload
-          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Band with id\(s\)/)
         end
       end
     end
@@ -1554,31 +1922,13 @@ describe Mongoid::Contextual::Mongo do
           expect(context.send(method)).to eq(depeche_mode)
         end
 
-        context "when calling ##{method}" do
+        context 'when calling #last' do
 
-          it 'returns the requested document, sorted by _id' do
+          it 'returns the last document, sorted by _id' do
             expect(context.send(method)).to eq(depeche_mode)
             expect(context.last).to eq(rolling_stones)
           end
         end
-
-        context 'with option { id_sort: :none }' do
-          let(:opts) do
-            { id_sort: :none }
-          end
-
-          it 'applies the sort on _id' do
-            expect(context.send(method, opts)).to eq(depeche_mode)
-          end
-
-          context "when calling ##{method}" do
-
-            it 'doesn\'t apply a sort on _id' do
-              expect(context.send(method, opts)).to eq(depeche_mode)
-              expect(context.last(opts)).to eq(depeche_mode)
-            end
-          end
-        end
       end
 
       context 'when the criteria has a sort' do
@@ -1602,25 +1952,6 @@ describe Mongoid::Contextual::Mongo do
             expect(context.last).to eq(depeche_mode)
           end
         end
-
-        context 'with option { id_sort: :none }' do
-
-          let(:opts) do
-            { id_sort: :none }
-          end
-
-          it 'uses the preexisting sort' do
-            expect(context.send(method, opts)).to eq(rolling_stones)
-          end
-
-          context 'when calling #last' do
-
-            it 'uses the preexisting sort' do
-              expect(context.send(method, opts)).to eq(rolling_stones)
-              expect(context.last(opts)).to eq(depeche_mode)
-            end
-          end
-        end
       end
 
       context "when using .sort" do
@@ -1649,28 +1980,17 @@ describe Mongoid::Contextual::Mongo do
         end
       end
 
-      context "when the context is cached" do
+      context "when the query cache is enabled" do
+        query_cache_enabled
 
         let(:criteria) do
-          Band.where(name: "Depeche Mode").cache
+          Band.where(name: "Depeche Mode")
         end
 
         let(:context) do
           described_class.new(criteria)
         end
 
-        context "when the cache is loaded" do
-
-          before do
-            context.to_a
-          end
-
-          it "returns the first document without touching the database" do
-            expect(context).to receive(:view).never
-            expect(context.send(method)).to eq(depeche_mode)
-          end
-        end
-
         context "when first method was called before" do
 
           before do
@@ -1678,8 +1998,9 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "returns the first document without touching the database" do
-            expect(context).to receive(:view).never
-            expect(context.send(method)).to eq(depeche_mode)
+            expect_no_queries do
+              expect(context.send(method)).to eq(depeche_mode)
+            end
           end
         end
       end
@@ -1733,77 +2054,21 @@ describe Mongoid::Contextual::Mongo do
           end
         end
 
-        context "when the context is cached" do
+        context "when the query cache is enabled" do
 
           let(:context) do
             described_class.new(criteria)
           end
 
-          context "when the whole context is loaded" do
-
-            before do
-              context.to_a
-            end
-
-            context "when all of the documents are cached" do
-
-              let(:criteria) do
-                Band.all.cache
-              end
-
-              context "when requesting all of the documents" do
-
-                let(:docs) do
-                  context.send(method, 3)
-                end
-
-                it "returns all of the documents without touching the database" do
-                  expect(context).to receive(:view).never
-                  expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
-                end
-              end
-
-              context "when requesting fewer than all of the documents" do
-
-                let(:docs) do
-                  context.send(method, 2)
-                end
-
-                it "returns all of the documents without touching the database" do
-                  expect(context).to receive(:view).never
-                  expect(docs).to eq([ depeche_mode, new_order ])
-                end
-              end
-            end
-
-            context "when only one document is cached" do
-
-              let(:criteria) do
-                Band.where(name: "Depeche Mode").cache
-              end
-
-              context "when requesting one document" do
-
-                let(:docs) do
-                  context.send(method, 1)
-                end
-
-                it "returns one document without touching the database" do
-                  expect(context).to receive(:view).never
-                  expect(docs).to eq([ depeche_mode ])
-                end
-              end
-            end
-          end
-
-          context "when the first method was called before" do
+          context "when calling first beforehand" do
+            query_cache_enabled
 
             let(:context) do
               described_class.new(criteria)
             end
 
             let(:criteria) do
-              Band.all.cache
+              Band.all
             end
 
             before do
@@ -1821,8 +2086,9 @@ describe Mongoid::Contextual::Mongo do
                 let(:limit) { 3 }
 
                 it "returns all documents without touching the database" do
-                  expect(context).to receive(:view).never
-                  expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                  expect_no_queries do
+                    expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                  end
                 end
               end
 
@@ -1830,8 +2096,9 @@ describe Mongoid::Contextual::Mongo do
                 let(:limit) { 2 }
 
                 it "returns the correct documents without touching the database" do
-                  expect(context).to receive(:view).never
-                  expect(docs).to eq([ depeche_mode, new_order ])
+                  expect_no_queries do
+                    expect(docs).to eq([ depeche_mode, new_order ])
+                  end
                 end
               end
             end
@@ -1843,8 +2110,9 @@ describe Mongoid::Contextual::Mongo do
                 let(:limit) { 2 }
 
                 it "returns the correct documents without touching the database" do
-                  expect(context).to receive(:view).never
-                  expect(docs).to eq([ depeche_mode, new_order ])
+                  expect_no_queries do
+                    expect(docs).to eq([ depeche_mode, new_order ])
+                  end
                 end
               end
 
@@ -1852,8 +2120,9 @@ describe Mongoid::Contextual::Mongo do
                 let(:limit) { 3 }
 
                 it "returns the correct documents and touches the database" do
-                  expect(context).to receive(:view).exactly(3).times.and_call_original
-                  expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                  expect_query(1) do
+                    expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                  end
                 end
               end
             end
@@ -1865,8 +2134,9 @@ describe Mongoid::Contextual::Mongo do
                 let(:limit) { 1 }
 
                 it "returns the correct documents without touching the database" do
-                  expect(context).to receive(:view).never
-                  expect(docs).to eq([ depeche_mode ])
+                  expect_no_queries do
+                    expect(docs).to eq([ depeche_mode ])
+                  end
                 end
               end
 
@@ -1874,8 +2144,9 @@ describe Mongoid::Contextual::Mongo do
                 let(:limit) { 3 }
 
                 it "returns the correct documents and touches the database" do
-                  expect(context).to receive(:view).exactly(3).times.and_call_original
-                  expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                  expect_query(1) do
+                    expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                  end
                 end
               end
             end
@@ -1883,24 +2154,15 @@ describe Mongoid::Contextual::Mongo do
         end
       end
 
-      context "when given an empty hash" do
-        let(:context) { described_class.new(criteria) }
-        let(:criteria) { Band.criteria }
-        let(:docs) { context.send(method, {}) }
-
-        it "behaves as if limit is nil" do
-          expect(docs).to eq(depeche_mode)
-        end
-      end
-      
-      context "when calling #first then #last" do
+      context "when calling #first then #last and the query cache is enabled" do
+        query_cache_enabled
 
         let(:context) do
           described_class.new(criteria)
         end
 
         let(:criteria) do
-          Band.all.cache
+          Band.all
         end
 
         before do
@@ -1915,8 +2177,10 @@ describe Mongoid::Contextual::Mongo do
           let(:before_limit) { 2 }
           let(:limit) { 1 }
 
-          it "gets the correct document" do
-            expect(docs).to eq([rolling_stones])
+          it "gets the correct document and hits the database" do
+            expect_query(1) do
+              expect(docs).to eq([rolling_stones])
+            end
           end
         end
       end
@@ -2006,30 +2270,10 @@ describe Mongoid::Contextual::Mongo do
       context 'when calling #first' do
 
         it 'returns the first document, sorted by _id' do
-          pending "MONGOID-5416"
           expect(context.last).to eq(rolling_stones)
           expect(context.first).to eq(depeche_mode)
         end
       end
-
-      context 'with option { id_sort: :none }' do
-        let(:opts) do
-          { id_sort: :none }
-        end
-
-        it 'doesn\'t apply the sort on _id' do
-          expect(context.last(opts)).to eq(depeche_mode)
-        end
-
-        context 'when calling #first' do
-
-          it 'doesn\'t apply the sort on _id' do
-            pending "MONGOID-5416"
-            expect(context.last(opts)).to eq(rolling_stones)
-            expect(context.first(opts)).to eq(depeche_mode)
-          end
-        end
-      end
     end
 
     context 'when the criteria has a sort' do
@@ -2054,25 +2298,6 @@ describe Mongoid::Contextual::Mongo do
           expect(context.first).to eq(rolling_stones)
         end
       end
-
-      context 'with option { id_sort: :none }' do
-
-        let(:opts) do
-          { id_sort: :none }
-        end
-
-        it 'uses the preexisting sort' do
-          expect(context.last(opts)).to eq(depeche_mode)
-        end
-
-        context 'when calling #first' do
-
-          it 'uses the preexisting sort' do
-            expect(context.last(opts)).to eq(depeche_mode)
-            expect(context.first(opts)).to eq(rolling_stones)
-          end
-        end
-      end
     end
 
     context "when using .sort" do
@@ -2101,28 +2326,17 @@ describe Mongoid::Contextual::Mongo do
       end
     end
 
-    context "when the context is cached" do
+    context "when the query cache is enabled" do
+      query_cache_enabled
 
       let(:criteria) do
-        Band.where(name: "Depeche Mode").cache
+        Band.where(name: "Depeche Mode")
       end
 
       let(:context) do
         described_class.new(criteria)
       end
 
-      context "when the cache is loaded" do
-
-        before do
-          context.to_a
-        end
-
-        it "returns the last document without touching the database" do
-          expect(context).to receive(:view).never
-          expect(context.last).to eq(depeche_mode)
-        end
-      end
-
       context "when last method was called before" do
 
         before do
@@ -2130,8 +2344,9 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the last document without touching the database" do
-          expect(context).to receive(:view).never
-          expect(context.last).to eq(depeche_mode)
+          expect_no_queries do
+            expect(context.last).to eq(depeche_mode)
+          end
         end
       end
     end
@@ -2191,71 +2406,15 @@ describe Mongoid::Contextual::Mongo do
           described_class.new(criteria)
         end
 
-        context "when the whole context is loaded" do
-
-          before do
-            context.to_a
-          end
-
-          context "when all of the documents are cached" do
-
-            let(:criteria) do
-              Band.all.cache
-            end
-
-            context "when requesting all of the documents" do
-
-              let(:docs) do
-                context.last(3)
-              end
-
-              it "returns all of the documents without touching the database" do
-                expect(context).to receive(:view).never
-                expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
-              end
-            end
-
-            context "when requesting fewer than all of the documents" do
-
-              let(:docs) do
-                context.last(2)
-              end
-
-              it "returns all of the documents without touching the database" do
-                expect(context).to receive(:view).never
-                expect(docs).to eq([ new_order, rolling_stones ])
-              end
-            end
-          end
-
-          context "when only one document is cached" do
-
-            let(:criteria) do
-              Band.where(name: "Depeche Mode").cache
-            end
-
-            context "when requesting one document" do
-
-              let(:docs) do
-                context.last(1)
-              end
-
-              it "returns one document without touching the database" do
-                expect(context).to receive(:view).never
-                expect(docs).to eq([ depeche_mode ])
-              end
-            end
-          end
-        end
-
-        context "when the last method was called before" do
+        context "when query cache is enabled" do
+          query_cache_enabled
 
           let(:context) do
             described_class.new(criteria)
           end
 
           let(:criteria) do
-            Band.all.cache
+            Band.all
           end
 
           before do
@@ -2272,18 +2431,20 @@ describe Mongoid::Contextual::Mongo do
             context "when getting all of the documents" do
               let(:limit) { 3 }
 
-              it "returns all documents without touching the database" do
-                expect(context).to receive(:view).never
-                expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+              it "returns all documents without touching the db" do
+                expect_no_queries do
+                  expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                end
               end
             end
 
             context "when getting fewer documents" do
               let(:limit) { 2 }
 
-              it "returns the correct documents without touching the database" do
-                expect(context).to receive(:view).never
-                expect(docs).to eq([ new_order, rolling_stones ])
+              it "returns the correct documents without touching the db" do
+                expect_no_queries do
+                  expect(docs).to eq([ new_order, rolling_stones ])
+                end
               end
             end
           end
@@ -2294,9 +2455,10 @@ describe Mongoid::Contextual::Mongo do
             context "when getting the same number of documents" do
               let(:limit) { 2 }
 
-              it "returns the correct documents without touching the database" do
-                expect(context).to receive(:view).never
-                expect(docs).to eq([ new_order, rolling_stones ])
+              it "returns the correct documents without touching the db" do
+                expect_no_queries do
+                  expect(docs).to eq([ new_order, rolling_stones ])
+                end
               end
             end
 
@@ -2304,8 +2466,9 @@ describe Mongoid::Contextual::Mongo do
               let(:limit) { 3 }
 
               it "returns the correct documents and touches the database" do
-                expect(context).to receive(:view).twice.and_call_original
-                expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                expect_query(1) do
+                  expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                end
               end
             end
           end
@@ -2317,8 +2480,9 @@ describe Mongoid::Contextual::Mongo do
               let(:limit) { 1 }
 
               it "returns the correct documents without touching the database" do
-                expect(context).to receive(:view).never
-                expect(docs).to eq([ rolling_stones ])
+                expect_no_queries do
+                  expect(docs).to eq([ rolling_stones ])
+                end
               end
             end
 
@@ -2326,8 +2490,9 @@ describe Mongoid::Contextual::Mongo do
               let(:limit) { 3 }
 
               it "returns the correct documents and touches the database" do
-                expect(context).to receive(:view).twice.and_call_original
-                expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                expect_query(1) do
+                  expect(docs).to eq([ depeche_mode, new_order, rolling_stones ])
+                end
               end
             end
           end
@@ -2335,14 +2500,15 @@ describe Mongoid::Contextual::Mongo do
       end
     end
 
-    context "when calling #last then #first" do
+    context "when calling #last then #first and the query cache is enabled" do
+      query_cache_enabled
 
       let(:context) do
         described_class.new(criteria)
       end
 
       let(:criteria) do
-        Band.all.cache
+        Band.all
       end
 
       before do
@@ -2358,26 +2524,16 @@ describe Mongoid::Contextual::Mongo do
         let(:limit) { 1 }
 
         it "hits the database" do
-          expect(context).to receive(:view).exactly(3).times.and_call_original
-          docs
+          expect_query(1) do
+            docs
+          end
         end
 
         it "gets the correct document" do
-          pending "MONGOID-5416"
           expect(docs).to eq([ depeche_mode ])
         end
       end
     end
-
-    context "when given an empty hash" do
-      let(:context) { described_class.new(criteria) }
-      let(:criteria) { Band.criteria }
-      let(:docs) { context.last({}) }
-
-      it "behaves as if limit is nil" do
-        expect(docs).to eq(rolling_stones)
-      end
-    end
   end
 
   describe "#initialize" do
@@ -2426,37 +2582,28 @@ describe Mongoid::Contextual::Mongo do
           described_class.new(criteria)
         end
 
-        it "returns the number of documents that match" do
-          expect(context.send(method)).to eq(2)
-        end
+        context "when broken_view_options is false" do
+          driver_config_override :broken_view_options, false
 
-        context "when calling more than once" do
-          it "returns the cached value for subsequent calls" do
-            expect(context.view).to receive(:count_documents).once.and_return(2)
-            2.times { expect(context.send(method)).to eq(2) }
+          it "returns the number of documents that match" do
+            expect(context.send(method)).to eq(1)
           end
         end
 
-        context "when the results have been iterated over" do
-
-          before do
-            context.entries
-          end
+        context "when broken_view_options is true" do
+          driver_config_override :broken_view_options, true
 
-          it "returns the cached value for all calls" do
-            expect(context.view).to receive(:count_documents).once.and_return(2)
+          it "returns the number of documents that match" do
             expect(context.send(method)).to eq(2)
           end
+        end
 
-          context "when the results have been iterated over multiple times" do
-
-            before do
-              context.entries
-            end
+        context "when calling more than once with different limits" do
+          driver_config_override :broken_view_options, false
 
-            it "resets the length on each full iteration" do
-              expect(context.size).to eq(2)
-            end
+          it "does not cache the value" do
+            expect(context.limit(1).send(method)).to eq(1)
+            expect(context.limit(2).send(method)).to eq(2)
           end
         end
       end
@@ -2475,10 +2622,12 @@ describe Mongoid::Contextual::Mongo do
           expect(context.send(method)).to eq(1)
         end
 
-        context "when calling more than once" do
-          it "returns the cached value for subsequent calls" do
-            expect(context.view).to receive(:count_documents).once.and_return(1)
-            2.times { expect(context.send(method)).to eq(1) }
+        context "when calling more than once with different skips" do
+          driver_config_override :broken_view_options, false
+
+          it "does not cache the value" do
+            expect(context.skip(0).send(method)).to eq(1)
+            expect(context.skip(1).send(method)).to eq(0)
           end
         end
 
@@ -2600,7 +2749,7 @@ describe Mongoid::Contextual::Mongo do
       it "raises an error" do
         expect do
           Person.take!
-        end.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Person./)
       end
     end
   end
@@ -2622,9 +2771,10 @@ describe Mongoid::Contextual::Mongo do
 
     context "when passed the symbol field name" do
 
-      it "performs mapping and warns" do
-        expect(Mongoid::Warnings).to receive(:warn_map_field_deprecated)
-        expect(context.map(:name)).to eq ["Depeche Mode", "New Order"]
+      it "raises an error" do
+        expect do
+          context.map(:name)
+        end.to raise_error(ArgumentError)
       end
     end