mongoid 6.4.4 → 7.5.1

data/spec/mongoid/contextual/mongo_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Contextual::Mongo do
@@ -7,7 +9,7 @@ describe Mongoid::Contextual::Mongo do
     describe "##{method}" do
 
       before do
-        Band.create(name: "Depeche Mode")
+        Band.create!(name: "Depeche Mode")
       end
 
       context "when the count is zero" do
@@ -78,11 +80,11 @@ describe Mongoid::Contextual::Mongo do
   describe "#count" do
 
     let!(:depeche) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:new_order) do
-      Band.create(name: "New Order")
+      Band.create!(name: "New Order")
     end
 
     let(:criteria) do
@@ -106,11 +108,8 @@ describe Mongoid::Contextual::Mongo do
         described_class.new(criteria.cache)
       end
 
-      before do
-        expect(context.view).to receive(:count).once.and_return(1)
-      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) }
       end
     end
@@ -134,7 +133,7 @@ describe Mongoid::Contextual::Mongo do
       context "and a limit true" do
 
         before do
-          2.times { Band.create(name: "Depeche Mode", likes: 1) }
+          2.times { Band.create!(name: "Depeche Mode", likes: 1) }
         end
 
         let(:count) do
@@ -152,7 +151,7 @@ describe Mongoid::Contextual::Mongo do
     context "when provided limit" do
 
       before do
-        2.times { Band.create(name: "Depeche Mode") }
+        2.times { Band.create!(name: "Depeche Mode") }
       end
 
       let(:context) do
@@ -168,7 +167,8 @@ describe Mongoid::Contextual::Mongo do
       end
     end
 
-    context 'when a collation is specified', if: collation_supported? do
+    context 'when a collation is specified' do
+      min_server_version '3.4'
 
       let(:context) do
         described_class.new(criteria)
@@ -191,16 +191,81 @@ describe Mongoid::Contextual::Mongo do
     end
   end
 
+  describe "#estimated_count" do
+
+    let!(:depeche) do
+      Band.create!(name: "Depeche Mode")
+    end
+
+    let!(:new_order) do
+      Band.create!(name: "New Order")
+    end
+
+    let(:criteria) do
+      Band.where
+    end
+
+    context "when not providing options" do
+      it 'returns the correct count' do
+        expect(criteria.estimated_count).to eq(2)
+      end
+    end
+
+    context "when providing options" do
+      it 'returns the correct count' do
+        expect(criteria.estimated_count(maxTimeMS: 1000)).to eq(2)
+      end
+    end
+
+    context "when context is cached" do
+
+      let(:context) do
+        described_class.new(criteria.cache)
+      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
+        end
+      end
+    end
+
+    context "when the criteria contains a selector", :focus do
+      let(:criteria) do
+        Band.where(name: "New Order")
+      end
+
+      context "when not providing options" do
+        it 'raises an error' do
+          expect do
+            criteria.estimated_count
+          end.to raise_error(Mongoid::Errors::InvalidEstimatedCountCriteria)
+        end
+      end
+
+      context "when providing options" do
+        it 'raises an error' do
+          expect do
+            criteria.estimated_count(maxTimeMS: 1000)
+          end.to raise_error(Mongoid::Errors::InvalidEstimatedCountCriteria)
+        end
+      end
+    end
+  end
+
+
+
   [ :delete, :delete_all ].each do |method|
 
     describe "##{method}" do
 
       let!(:depeche_mode) do
-        Band.create(name: "Depeche Mode")
+        Band.create!(name: "Depeche Mode")
       end
 
       let!(:new_order) do
-        Band.create(name: "New Order")
+        Band.create!(name: "New Order")
       end
 
       context "when the selector is contraining" do
@@ -229,7 +294,8 @@ describe Mongoid::Contextual::Mongo do
           expect(deleted).to eq(1)
         end
 
-        context 'when the criteria has a collation', if: collation_supported? do
+        context 'when the criteria has a collation' do
+          min_server_version '3.4'
 
           let(:criteria) do
             Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
@@ -300,11 +366,11 @@ describe Mongoid::Contextual::Mongo do
     describe "##{method}" do
 
       let!(:depeche_mode) do
-        Band.create(name: "Depeche Mode")
+        Band.create!(name: "Depeche Mode")
       end
 
       let!(:new_order) do
-        Band.create(name: "New Order")
+        Band.create!(name: "New Order")
       end
 
       context "when the selector is contraining" do
@@ -333,7 +399,8 @@ describe Mongoid::Contextual::Mongo do
           expect(destroyed).to eq(1)
         end
 
-        context 'when the criteria has a collation', if: collation_supported? do
+        context 'when the criteria has a collation' do
+          min_server_version '3.4'
 
           let(:criteria) do
             Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
@@ -384,7 +451,7 @@ describe Mongoid::Contextual::Mongo do
     context 'when the write concern is unacknowledged' do
 
       before do
-        2.times { Band.create }
+        2.times { Band.create! }
       end
 
       let(:criteria) do
@@ -406,27 +473,83 @@ describe Mongoid::Contextual::Mongo do
   describe "#distinct" do
 
     before do
-      Band.create(name: "Depeche Mode", years: 30)
-      Band.create(name: "New Order", years: 25)
+      Band.create!(name: "Depeche Mode", years: 30, sales: "1E2")
+      Band.create!(name: "New Order", years: 25, sales: "2E3")
+      Band.create!(name: "10,000 Maniacs", years: 20, sales: "1E2")
     end
 
-    context "when limiting the result set" do
+    with_config_values :legacy_pluck_distinct, true, false do
+      context "when limiting the result set" do
 
-      let(:criteria) do
-        Band.where(name: "Depeche Mode")
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns the distinct matching fields" do
+          expect(context.distinct(:name)).to eq([ "Depeche Mode" ])
+        end
       end
 
-      let(:context) do
-        described_class.new(criteria)
+      context "when not limiting the result set" do
+
+        let(:criteria) do
+          Band.criteria
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns the distinct field values" do
+          expect(context.distinct(:name).sort).to eq([ "10,000 Maniacs", "Depeche Mode", "New Order" ].sort)
+        end
       end
 
-      it "returns the distinct matching fields" do
-        expect(context.distinct(:name)).to eq([ "Depeche Mode" ])
+      context "when providing an aliased field" do
+
+        let(:criteria) do
+          Band.criteria
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns the distinct field values" do
+          expect(context.distinct(:years).sort).to eq([ 20, 25, 30 ])
+        end
       end
-    end
 
-    context "when not limiting the result set" do
+      context 'when a collation is specified' do
+        min_server_version '3.4'
+
+        before do
+          Band.create!(name: 'DEPECHE MODE')
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        let(:expected_results) do
+          ["10,000 Maniacs", "Depeche Mode", "New Order"]
+        end
+
+        let(:criteria) do
+          Band.where({}).collation(locale: 'en_US', strength: 2)
+        end
+
+        it 'applies the collation' do
+          expect(context.distinct(:name).sort).to eq(expected_results.sort)
+        end
+      end
+    end
 
+    context "when providing a demongoizable field" do
       let(:criteria) do
         Band.criteria
       end
@@ -435,46 +558,253 @@ describe Mongoid::Contextual::Mongo do
         described_class.new(criteria)
       end
 
-      it "returns the distinct field values" do
-        expect(context.distinct(:name)).to eq([ "Depeche Mode", "New Order" ])
+      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" ])
+        end
+      end
+
+      context "when legacy_pluck_distinct is not set" do
+        config_override :legacy_pluck_distinct, false
+
+        it "returns the non-demongoized distinct field values" do
+          expect(context.distinct(:sales).sort).to eq([ BigDecimal("1E2"), BigDecimal("2E3") ])
+        end
       end
     end
 
-    context "when providing an aliased field" do
+    context "when getting a localized field" do
+      before do
+        I18n.locale = :en
+        d = Dictionary.create!(description: 'english-text')
+        I18n.locale = :de
+        d.description = 'deutsch-text'
+        d.save!
+      end
+
+      after do
+        I18n.locale = :en
+      end
 
       let(:criteria) do
-        Band.criteria
+        Dictionary.criteria
       end
 
       let(:context) do
         described_class.new(criteria)
       end
 
-      it "returns the distinct field values" do
-        expect(context.distinct(:years)).to eq([ 30, 25 ])
+      context "when getting the field without _translations" do
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it "gets the full hash" do
+            expect(context.distinct(:description)).to eq([{ "de" => "deutsch-text", "en" => "english-text" }])
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          it "gets the demongoized localized field" do
+            expect(context.distinct(:description)).to eq([ 'deutsch-text' ])
+          end
+        end
       end
-    end
 
-    context 'when a collation is specified', if: collation_supported? do
+      context "when getting the field with _translations" do
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
 
-      before do
-        Band.create(name: 'DEPECHE MODE')
+          it "gets an empty list" do
+            expect(context.distinct(:description_translations)).to eq([])
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          it "gets the full hash" do
+            expect(context.distinct(:description_translations)).to eq([ { "de" => "deutsch-text", "en" => "english-text" } ])
+          end
+        end
       end
 
-      let(:context) do
-        described_class.new(criteria)
+      context 'when plucking a specific locale' do
+
+        let(:distinct) do
+          context.distinct(:'description.de')
+        end
+
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it 'returns the specific translation' do
+            expect(distinct).to eq([ 'deutsch-text' ])
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          it 'returns the specific translation' do
+            expect(distinct).to eq([ "deutsch-text" ])
+          end
+        end
       end
 
-      let(:expected_results) do
-        ["Depeche Mode", "New Order"]
+      context 'when plucking a specific locale from _translations field' do
+
+        let(:distinct) do
+          context.distinct(:'description_translations.de')
+        end
+
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it 'returns the empty list' do
+            expect(distinct).to eq([])
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          it 'returns the specific translations' do
+            expect(distinct).to eq(['deutsch-text'])
+          end
+        end
       end
 
-      let(:criteria) do
-        Band.where({}).collation(locale: 'en_US', strength: 2)
+      context 'when fallbacks are enabled with a locale list' do
+        require_fallbacks
+
+        around(:all) do |example|
+          prev_fallbacks = I18n.fallbacks.dup
+          I18n.fallbacks[:he] = [ :en ]
+          example.run
+          I18n.fallbacks = prev_fallbacks
+        end
+
+        after do
+          I18n.locale = :en
+        end
+
+        let(:distinct) do
+          context.distinct(:description).first
+        end
+
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it "does not correctly use the fallback" do
+            distinct.should == {"de"=>"deutsch-text", "en"=>"english-text"}
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          it "correctly uses the fallback" do
+            I18n.locale = :en
+            d = Dictionary.create!(description: 'english-text')
+            I18n.locale = :he
+            distinct.should == "english-text"
+          end
+        end
+      end
+
+      context "when the localized field is embedded" do
+        before do
+          p = Passport.new
+          I18n.locale = :en
+          p.name = "Neil"
+          I18n.locale = :he
+          p.name = "Nissim"
+
+          Person.create!(passport: p, employer_id: 12345)
+        end
+
+        after do
+          I18n.locale = :en
+        end
+
+        let(:criteria) do
+          Person.where(employer_id: 12345)
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        let(:distinct) do
+          context.distinct("pass.name").first
+        end
+
+        let(:distinct_translations) do
+          context.distinct("pass.name_translations").first
+        end
+
+        let(:distinct_translations_field) do
+          context.distinct("pass.name_translations.en").first
+        end
+
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it "returns the full hash" do
+            expect(distinct).to eq({ "en" => "Neil", "he" => "Nissim" })
+          end
+
+          it "returns the empty hash" do
+            expect(distinct_translations).to eq(nil)
+          end
+
+          it "returns the empty hash" do
+            expect(distinct_translations_field).to eq(nil)
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          it "returns the translation for the current locale" do
+            expect(distinct).to eq("Nissim")
+          end
+
+          it "returns the full _translation hash" do
+            expect(distinct_translations).to eq({ "en" => "Neil", "he" => "Nissim" })
+          end
+
+          it "returns the translation for the requested locale" do
+            expect(distinct_translations_field).to eq("Neil")
+          end
+        end
+      end
+    end
+
+    context "when getting an embedded field" do
+
+      let(:label) { Label.new(sales: "1E2") }
+      let!(:band) { Band.create!(label: label) }
+      let(:criteria) { Band.where(_id: band.id) }
+      let(:context) { described_class.new(criteria) }
+
+      context "when legacy_pluck_distinct is set" do
+        config_override :legacy_pluck_distinct, true
+
+        it "returns the distinct matching fields" do
+          expect(context.distinct("label.sales")).to eq([ "1E2" ])
+        end
       end
 
-      it 'applies the collation' do
-        expect(context.distinct(:name)).to eq(expected_results)
+      context "when legacy_pluck_distinct is not set" do
+        config_override :legacy_pluck_distinct, false
+        it "returns the distinct matching fields" do
+          expect(context.distinct("label.sales")).to eq([ BigDecimal("1E2") ])
+        end
       end
     end
   end
@@ -482,7 +812,7 @@ describe Mongoid::Contextual::Mongo do
   describe "#each" do
 
     before do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let(:criteria) do
@@ -493,7 +823,8 @@ describe Mongoid::Contextual::Mongo do
       described_class.new(criteria)
     end
 
-    context 'when the criteria has a collation', if: collation_supported? do
+    context 'when the criteria has a collation' do
+      min_server_version '3.4'
 
       let(:criteria) do
         Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
@@ -559,7 +890,7 @@ describe Mongoid::Contextual::Mongo do
         context "when iterating with next" do
 
           before do
-            10.times { |i| Band.create(name: "Test #{i}") }
+            10.times { |i| Band.create!(name: "Test #{i}") }
           end
 
           let(:criteria) do
@@ -571,12 +902,50 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "does not load all documents" do
-            expect(Mongo::Logger.logger).to receive(:debug?).exactly(2).times.and_call_original
+            subscriber = Mrss::EventSubscriber.new
+            context.view.client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+
             enum.next
+
+            find_events = subscriber.all_events.select do |evt|
+              evt.command_name == 'find'
+            end
+            expect(find_events.length).to be(2)
+            get_more_events = subscriber.all_events.select do |evt|
+              evt.command_name == 'getMore'
+            end
+            expect(get_more_events.length).to be(0)
+          ensure
+            context.view.client.unsubscribe(Mongo::Monitoring::COMMAND, subscriber)
           end
         end
       end
     end
+
+    context 'when the criteria has a parent document' do
+
+      before do
+        Post.create!(person: person)
+        Post.create!(person: person)
+        Post.create!(person: person)
+      end
+
+      let(:person) do
+        Person.new
+      end
+
+      let(:criteria) do
+        person.posts.all
+      end
+
+      let(:persons) do
+        criteria.collect(&:person)
+      end
+
+      it 'sets the same parent object on each related object' do
+        expect(persons.uniq.size).to eq(1)
+      end
+    end
   end
 
   describe "#eager_load" do
@@ -591,12 +960,12 @@ describe Mongoid::Contextual::Mongo do
 
     context "when no documents are returned" do
 
-      let(:game_metadata) do
+      let(:game_association) do
         Person.reflect_on_association(:game)
       end
 
       it "does not make any additional database queries" do
-        expect(game_metadata).to receive(:eager_load).never
+        expect(game_association).to receive(:eager_load).never
         context.send(:eager_load, [])
       end
     end
@@ -605,7 +974,7 @@ describe Mongoid::Contextual::Mongo do
   describe "#exists?" do
 
     before do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     context "when the count is zero" do
@@ -718,11 +1087,11 @@ describe Mongoid::Contextual::Mongo do
   describe "#find_one_and_replace" do
 
     let!(:depeche) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:tool) do
-      Band.create(name: "Tool")
+      Band.create!(name: "Tool")
     end
 
     context "when the selector matches" do
@@ -825,7 +1194,8 @@ describe Mongoid::Contextual::Mongo do
         end
       end
 
-      context 'when a collation is specified on the criteria', if: collation_supported? do
+      context 'when a collation is specified on the criteria' do
+        min_server_version '3.4'
 
         let(:criteria) do
           Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
@@ -873,11 +1243,11 @@ describe Mongoid::Contextual::Mongo do
   describe "#find_one_and_update" do
 
     let!(:depeche) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:tool) do
-      Band.create(name: "Tool")
+      Band.create!(name: "Tool")
     end
 
     context "when the selector matches" do
@@ -978,7 +1348,8 @@ describe Mongoid::Contextual::Mongo do
         end
       end
 
-      context 'when a collation is specified on the criteria', if: collation_supported? do
+      context 'when a collation is specified on the criteria' do
+        min_server_version '3.4'
 
         let(:criteria) do
           Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
@@ -1025,7 +1396,7 @@ describe Mongoid::Contextual::Mongo do
   describe "#find_one_and_delete" do
 
     let!(:depeche) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let(:criteria) do
@@ -1052,7 +1423,8 @@ describe Mongoid::Contextual::Mongo do
         }.to raise_error(Mongoid::Errors::DocumentNotFound)
       end
 
-      context 'when a collation is specified on the criteria', if: collation_supported? do
+      context 'when a collation is specified on the criteria' do
+        min_server_version '3.4'
 
         let(:criteria) do
           Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
@@ -1103,11 +1475,15 @@ describe Mongoid::Contextual::Mongo do
     describe "##{method}" do
 
       let!(:depeche_mode) do
-        Band.create(name: "Depeche Mode")
+        Band.create!(name: "Depeche Mode")
       end
 
       let!(:new_order) do
-        Band.create(name: "New Order")
+        Band.create!(name: "New Order")
+      end
+
+      let!(:rolling_stones) do
+        Band.create!(name: "The Rolling Stones")
       end
 
       context "when the context is not cached" do
@@ -1124,7 +1500,8 @@ describe Mongoid::Contextual::Mongo do
           expect(context.send(method)).to eq(depeche_mode)
         end
 
-        context 'when the criteria has a collation', if: collation_supported? do
+        context 'when the criteria has a collation' do
+          min_server_version '3.4'
 
           let(:criteria) do
             Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
@@ -1149,14 +1526,14 @@ describe Mongoid::Contextual::Mongo do
         context "when there is sort on the context" do
 
           it "follows the main sort" do
-            expect(context.send(method)).to eq(new_order)
+            expect(context.send(method)).to eq(rolling_stones)
           end
         end
 
         context "when subsequently calling #last" do
 
           it "returns the correct document" do
-            expect(context.send(method)).to eq(new_order)
+            expect(context.send(method)).to eq(rolling_stones)
             expect(context.last).to eq(depeche_mode)
           end
         end
@@ -1181,23 +1558,22 @@ describe Mongoid::Contextual::Mongo do
 
           it 'returns the last document, sorted by _id' do
             expect(context.send(method)).to eq(depeche_mode)
-            expect(context.last).to eq(new_order)
+            expect(context.last).to eq(rolling_stones)
           end
         end
 
-        context 'with option { sort: :none }' do
-
+        context 'with option { id_sort: :none }' do
           let(:opts) do
             { id_sort: :none }
           end
 
-          it 'does not apply the sort on _id' do
+          it 'applies the sort on _id' do
             expect(context.send(method, opts)).to eq(depeche_mode)
           end
 
           context 'when calling #last' do
 
-            it 'does not apply a sort on _id' 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
@@ -1215,33 +1591,32 @@ describe Mongoid::Contextual::Mongo do
           described_class.new(criteria)
         end
 
-
         it 'applies the criteria sort' do
-          expect(context.send(method)).to eq(new_order)
+          expect(context.send(method)).to eq(rolling_stones)
         end
 
         context 'when calling #last' do
 
           it 'applies the criteria sort' do
-            expect(context.send(method)).to eq(new_order)
+            expect(context.send(method)).to eq(rolling_stones)
             expect(context.last).to eq(depeche_mode)
           end
         end
 
-        context 'with option { sort: :none }' do
+        context 'with option { id_sort: :none }' do
 
           let(:opts) do
             { id_sort: :none }
           end
 
-          it 'applies the criteria sort' do
-            expect(context.send(method, opts)).to eq(new_order)
+          it 'uses the preexisting sort' do
+            expect(context.send(method, opts)).to eq(rolling_stones)
           end
 
           context 'when calling #last' do
 
-            it 'applies the criteria sort' do
-              expect(context.send(method, opts)).to eq(new_order)
+            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
@@ -1261,14 +1636,14 @@ describe Mongoid::Contextual::Mongo do
         context "when there is sort on the context" do
 
           it "follows the main sort" do
-            expect(context.send(method)).to eq(new_order)
+            expect(context.send(method)).to eq(rolling_stones)
           end
         end
 
         context "when subsequently calling #last" do
 
           it "returns the correct document" do
-            expect(context.send(method)).to eq(new_order)
+            expect(context.send(method)).to eq(rolling_stones)
             expect(context.last).to eq(depeche_mode)
           end
         end
@@ -1308,43 +1683,717 @@ describe Mongoid::Contextual::Mongo do
           end
         end
       end
-    end
-  end
 
-  describe "#initialize" do
+      context "when including a limit" do
 
-    let(:criteria) do
-      Band.where(name: "Depeche Mode").no_timeout
-    end
+        context "when the context is not cached" do
 
-    let(:context) do
-      described_class.new(criteria)
-    end
+          let(:context) do
+            described_class.new(criteria)
+          end
 
-    it "sets the criteria" do
-      expect(context.criteria).to eq(criteria)
-    end
+          context "when the limit is 1" do
+            let(:criteria) do
+              Band.criteria
+            end
 
-    it "sets the klass" do
-      expect(context.klass).to eq(Band)
-    end
+            let(:docs) do
+              context.send(method, 1)
+            end
 
-    it "sets the view" do
-      expect(context.view).to be_a(Mongo::Collection::View)
-    end
+            it "returns an array of documents" do
+              expect(docs).to eq([ depeche_mode ])
+            end
+          end
 
-    it "sets the view selector" do
-      expect(context.view.selector).to eq({ "name" => "Depeche Mode" })
-    end
-  end
+          context "when the limit is >1" do
+            let(:criteria) do
+              Band.criteria
+            end
+
+            let(:docs) do
+              context.send(method, 2)
+            end
+
+            it "returns the number of documents in order" do
+              expect(docs).to eq([ depeche_mode, new_order ])
+            end
+          end
+
+          context 'when the criteria has a collation' do
+            min_server_version '3.4'
+
+            let(:criteria) do
+              Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
+            end
+
+            it "returns the first matching document" do
+              expect(context.send(method, 1)).to eq([ depeche_mode ])
+            end
+          end
+        end
+
+        context "when the context is cached" 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
+
+            let(:context) do
+              described_class.new(criteria)
+            end
+
+            let(:criteria) do
+              Band.all.cache
+            end
+
+            before do
+              context.first(before_limit)
+            end
+
+            let(:docs) do
+              context.send(method, limit)
+            end
+
+            context "when getting all of the documents before" do
+              let(:before_limit) { 3 }
+
+              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 ])
+                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([ depeche_mode, new_order ])
+                end
+              end
+            end
+
+            context "when getting fewer documents before" do
+              let(:before_limit) { 2 }
+
+              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([ depeche_mode, new_order ])
+                end
+              end
+
+              context "when getting more documents" 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 ])
+                end
+              end
+            end
+
+            context "when getting one document before" do
+              let(:before_limit) { 1 }
+
+              context "when getting one document" 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 ])
+                end
+              end
+
+              context "when getting more than one document" 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 ])
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context "when calling #first then #last" do
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        let(:criteria) do
+          Band.all.cache
+        end
+
+        before do
+          context.first(before_limit)
+        end
+
+        let(:docs) do
+          context.last(limit)
+        end
+
+        context "when getting one from the beginning and one from the end" do
+          let(:before_limit) { 2 }
+          let(:limit) { 1 }
+
+          it "gets the correct document" do
+            expect(docs).to eq([rolling_stones])
+          end
+        end
+      end
+    end
+  end
+
+  describe "#last" do
+    let!(:depeche_mode) do
+      Band.create!(name: "Depeche Mode")
+    end
+
+    let!(:new_order) do
+      Band.create!(name: "New Order")
+    end
+
+    let!(:rolling_stones) do
+      Band.create!(name: "The Rolling Stones")
+    end
+
+    context "when the context is not cached" do
+
+      let(:criteria) do
+        Band.where(name: "Depeche Mode")
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      it "returns the last matching document" do
+        expect(context.last).to eq(depeche_mode)
+      end
+
+      context 'when the criteria has a collation' do
+        min_server_version '3.4'
+
+        let(:criteria) do
+          Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
+        end
+
+        it "returns the last matching document" do
+          expect(context.last).to eq(depeche_mode)
+        end
+      end
+    end
+
+    context "when using .desc" do
+
+      let(:criteria) do
+        Band.desc(:name)
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      context "when there is sort on the context" do
+
+        it "follows the main sort" do
+          expect(context.last).to eq(depeche_mode)
+        end
+      end
+
+      context "when subsequently calling #first" do
+
+        it "returns the correct document" do
+          expect(context.last).to eq(depeche_mode)
+          expect(context.first).to eq(rolling_stones)
+        end
+      end
+    end
+
+    context 'when the criteria has no sort' do
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      it 'applies a sort on _id' do
+        expect(context.last).to eq(rolling_stones)
+      end
+
+      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
+
+      let(:criteria) do
+        Band.desc(:name)
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+
+      it 'applies the criteria sort' do
+        expect(context.last).to eq(depeche_mode)
+      end
+
+      context 'when calling #first' do
+
+        it 'applies the criteria sort' do
+          expect(context.last).to eq(depeche_mode)
+          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
+
+      let(:criteria) do
+        Band.all.sort(:name => -1).criteria
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      context "when there is sort on the context" do
+
+        it "follows the main sort" do
+          expect(context.last).to eq(depeche_mode)
+        end
+      end
+
+      context "when subsequently calling #first" do
+
+        it "returns the correct document" do
+          expect(context.last).to eq(depeche_mode)
+          expect(context.first).to eq(rolling_stones)
+        end
+      end
+    end
+
+    context "when the context is cached" 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 "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
+          context.last
+        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
+    end
+
+    context "when including a limit" do
+
+      context "when the context is not cached" do
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        context "when the limit is 1" do
+          let(:criteria) do
+            Band.criteria
+          end
+
+          let(:docs) do
+            context.last(1)
+          end
+
+          it "returns an array of documents" do
+            expect(docs).to eq([ rolling_stones ])
+          end
+        end
+
+        context "when the limit is >1" do
+          let(:criteria) do
+            Band.criteria
+          end
+
+          let(:docs) do
+            context.last(2)
+          end
+
+          it "returns the number of documents in order" do
+            expect(docs).to eq([ new_order, rolling_stones ])
+          end
+        end
+
+        context 'when the criteria has a collation' do
+          min_server_version '3.4'
+
+          let(:criteria) do
+            Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
+          end
+
+          it "returns the first matching document" do
+            expect(context.last(1)).to eq([ depeche_mode ])
+          end
+        end
+      end
+
+      context "when the context is cached" 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.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
+
+          let(:context) do
+            described_class.new(criteria)
+          end
+
+          let(:criteria) do
+            Band.all.cache
+          end
+
+          before do
+            context.last(before_limit)
+          end
+
+          let(:docs) do
+            context.last(limit)
+          end
+
+          context "when getting all of the documents before" do
+            let(:before_limit) { 3 }
+
+            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 ])
+              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 ])
+              end
+            end
+          end
+
+          context "when getting fewer documents before" do
+            let(:before_limit) { 2 }
+
+            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 ])
+              end
+            end
+
+            context "when getting more documents" 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 ])
+              end
+            end
+          end
+
+          context "when getting one document before" do
+            let(:before_limit) { 1 }
+
+            context "when getting one document" 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 ])
+              end
+            end
+
+            context "when getting more than one document" 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 ])
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context "when calling #last then #first" do
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      let(:criteria) do
+        Band.all.cache
+      end
+
+      before do
+        context.last(before_limit)
+      end
+
+      let(:docs) do
+        context.first(limit)
+      end
+
+      context "when getting one from the beginning and one from the end" do
+        let(:before_limit) { 2 }
+        let(:limit) { 1 }
+
+        it "hits the database" do
+          expect(context).to receive(:view).exactly(3).times.and_call_original
+          docs
+        end
+
+        it "gets the correct document" do
+          pending "MONGOID-5416"
+          expect(docs).to eq([ depeche_mode ])
+        end
+      end
+    end
+  end
+
+  describe "#initialize" do
+
+    let(:criteria) do
+      Band.where(name: "Depeche Mode").no_timeout
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it "sets the criteria" do
+      expect(context.criteria).to eq(criteria)
+    end
+
+    it "sets the klass" do
+      expect(context.klass).to eq(Band)
+    end
+
+    it "sets the view" do
+      expect(context.view).to be_a(Mongo::Collection::View)
+    end
+
+    it "sets the view selector" do
+      expect(context.view.selector).to eq({ "name" => "Depeche Mode" })
+    end
+  end
 
   [ :length, :size ].each do |method|
 
     describe "##{method}" do
 
       before do
-        Band.create(name: "Depeche Mode")
-        Band.create(name: "New Order")
+        Band.create!(name: "Depeche Mode")
+        Band.create!(name: "New Order")
       end
 
       context "when the criteria has a limit" do
@@ -1362,12 +2411,8 @@ describe Mongoid::Contextual::Mongo do
         end
 
         context "when calling more than once" do
-
-          before do
-            expect(context.view).to receive(:count).once.and_return(2)
-          end
-
           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) }
           end
         end
@@ -1376,10 +2421,10 @@ describe Mongoid::Contextual::Mongo do
 
           before do
             context.entries
-            expect(context.view).to receive(:count).once.and_return(2)
           end
 
           it "returns the cached value for all calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(2)
             expect(context.send(method)).to eq(2)
           end
 
@@ -1411,12 +2456,8 @@ describe Mongoid::Contextual::Mongo do
         end
 
         context "when calling more than once" do
-
-          before do
-            expect(context.view).to receive(:count).once.and_return(1)
-          end
-
           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) }
           end
         end
@@ -1425,10 +2466,10 @@ describe Mongoid::Contextual::Mongo do
 
           before do
             context.entries
-            expect(context.view).to receive(:count).once.and_return(1)
           end
 
           it "returns the cached value for all calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(1)
             expect(context.send(method)).to eq(1)
           end
 
@@ -1450,11 +2491,11 @@ describe Mongoid::Contextual::Mongo do
   describe "#limit" do
 
     let!(:depeche_mode) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:new_order) do
-      Band.create(name: "New Order")
+      Band.create!(name: "New Order")
     end
 
     let(:criteria) do
@@ -1470,11 +2511,85 @@ describe Mongoid::Contextual::Mongo do
     end
   end
 
+  describe "#take" do
+
+    let!(:depeche_mode) do
+      Band.create!(name: "Depeche Mode")
+    end
+
+    let!(:new_order) do
+      Band.create!(name: "New Order")
+    end
+
+    let!(:rolling_stones) do
+      Band.create!(name: "The Rolling Stones")
+    end
+
+    let(:criteria) do
+      Band.all
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it "takes the correct number results" do
+      expect(context.take(2)).to eq([ depeche_mode, new_order ])
+    end
+
+    it "returns an array when passing 1" do
+      expect(context.take(1)).to eq([ depeche_mode ])
+    end
+
+    it "does not return an array when not passing an argument" do
+      expect(context.take).to eq(depeche_mode)
+    end
+
+    it "returns all the documents taking more than whats in the db" do
+      expect(context.take(5)).to eq([ depeche_mode, new_order, rolling_stones ])
+    end
+  end
+
+  describe "#take!" do
+
+    let!(:depeche_mode) do
+      Band.create!(name: "Depeche Mode")
+    end
+
+    let!(:new_order) do
+      Band.create!(name: "New Order")
+    end
+
+    let!(:rolling_stones) do
+      Band.create!(name: "The Rolling Stones")
+    end
+
+    let(:criteria) do
+      Band.all
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it "takes the first document" do
+      expect(context.take!).to eq(depeche_mode)
+    end
+
+    context "when there are no documents" do
+      it "raises an error" do
+        expect do
+          Person.take!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+  end
+
   describe "#map" do
 
     before do
-      Band.create(name: "Depeche Mode")
-      Band.create(name: "New Order")
+      Band.create!(name: "Depeche Mode")
+      Band.create!(name: "New Order")
     end
 
     let(:criteria) do
@@ -1487,7 +2602,8 @@ describe Mongoid::Contextual::Mongo do
 
     context "when passed the symbol field name" do
 
-      it "performs mapping" 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"]
       end
     end
@@ -1503,11 +2619,11 @@ describe Mongoid::Contextual::Mongo do
   describe "#map_reduce" do
 
     let!(:depeche_mode) do
-      Band.create(name: "Depeche Mode", likes: 200)
+      Band.create!(name: "Depeche Mode", likes: 200)
     end
 
     let!(:tool) do
-      Band.create(name: "Tool", likes: 100)
+      Band.create!(name: "Tool", likes: 100)
     end
 
     let(:map) do
@@ -1528,6 +2644,10 @@ describe Mongoid::Contextual::Mongo do
       }}
     end
 
+    let(:ordered_results) do
+      results['results'].sort_by { |doc| doc['_id'] }
+    end
+
     context "when no selection is provided" do
 
       let(:criteria) do
@@ -1559,36 +2679,40 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "contains the entire raw results" do
-        expect(results["results"]).to eq([
+        expect(ordered_results).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
           { "_id" => "Tool", "value" => { "likes" => 100 }}
         ])
       end
 
-      it "contains the execution time" do
-        expect(results.time).to_not be_nil
-      end
+      context 'when statistics are available' do
+        max_server_version '4.2'
 
-      it "contains the count statistics" do
-        expect(results["counts"]).to eq({
-          "input" => 2, "emit" => 2, "reduce" => 0, "output" => 2
-        })
-      end
+        it "contains the execution time" do
+          expect(results.time).to_not be_nil
+        end
 
-      it "contains the input count" do
-        expect(results.input).to eq(2)
-      end
+        it "contains the count statistics" do
+          expect(results["counts"]).to eq({
+            "input" => 2, "emit" => 2, "reduce" => 0, "output" => 2
+          })
+        end
 
-      it "contains the emitted count" do
-        expect(results.emitted).to eq(2)
-      end
+        it "contains the input count" do
+          expect(results.input).to eq(2)
+        end
 
-      it "contains the reduced count" do
-        expect(results.reduced).to eq(0)
-      end
+        it "contains the emitted count" do
+          expect(results.emitted).to eq(2)
+        end
 
-      it "contains the output count" do
-        expect(results.output).to eq(2)
+        it "contains the reduced count" do
+          expect(results.reduced).to eq(0)
+        end
+
+        it "contains the output count" do
+          expect(results.output).to eq(2)
+        end
       end
     end
 
@@ -1617,35 +2741,39 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "contains the entire raw results" do
-        expect(results["results"]).to eq([
+        expect(ordered_results).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         ])
       end
 
-      it "contains the execution time" do
-        expect(results.time).to_not be_nil
-      end
+      context 'when statistics are available' do
+        max_server_version '4.2'
 
-      it "contains the count statistics" do
-        expect(results["counts"]).to eq({
-          "input" => 1, "emit" => 1, "reduce" => 0, "output" => 1
-        })
-      end
+        it "contains the execution time" do
+          expect(results.time).to_not be_nil
+        end
 
-      it "contains the input count" do
-        expect(results.input).to eq(1)
-      end
+        it "contains the count statistics" do
+          expect(results["counts"]).to eq({
+            "input" => 1, "emit" => 1, "reduce" => 0, "output" => 1
+          })
+        end
 
-      it "contains the emitted count" do
-        expect(results.emitted).to eq(1)
-      end
+        it "contains the input count" do
+          expect(results.input).to eq(1)
+        end
 
-      it "contains the reduced count" do
-        expect(results.reduced).to eq(0)
-      end
+        it "contains the emitted count" do
+          expect(results.emitted).to eq(1)
+        end
+
+        it "contains the reduced count" do
+          expect(results.reduced).to eq(0)
+        end
 
-      it "contains the output count" do
-        expect(results.output).to eq(1)
+        it "contains the output count" do
+          expect(results.output).to eq(1)
+        end
       end
     end
 
@@ -1685,7 +2813,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "contains the entire raw results" do
-        expect(results["results"]).to eq([
+        expect(ordered_results).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
           { "_id" => "Tool", "value" => { "likes" => 100 }}
         ])
@@ -1693,6 +2821,9 @@ describe Mongoid::Contextual::Mongo do
     end
 
     context "when limiting is provided" do
+      # map/reduce with limit is not supported on sharded clusters:
+      # https://jira.mongodb.org/browse/SERVER-2099
+      require_topology :single, :replica_set
 
       let(:criteria) do
         Band.limit(1)
@@ -1799,6 +2930,8 @@ describe Mongoid::Contextual::Mongo do
     end
 
     context "when the output specifies a different db" do
+      # Limit is not supported in sharded clusters
+      require_topology :single, :replica_set
 
       let(:criteria) do
         Band.limit(1)
@@ -1915,11 +3048,11 @@ describe Mongoid::Contextual::Mongo do
   describe "#skip" do
 
     let!(:depeche_mode) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:new_order) do
-      Band.create(name: "New Order")
+      Band.create!(name: "New Order")
     end
 
     let(:criteria) do
@@ -1938,11 +3071,11 @@ describe Mongoid::Contextual::Mongo do
   describe "#sort" do
 
     let!(:depeche_mode) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:new_order) do
-      Band.create(name: "New Order")
+      Band.create!(name: "New Order")
     end
 
     let(:criteria) do
@@ -1981,11 +3114,11 @@ describe Mongoid::Contextual::Mongo do
   describe "#update" do
 
     let!(:depeche_mode) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:new_order) do
-      Band.create(name: "New Order")
+      Band.create!(name: "New Order")
     end
 
     let(:criteria) do
@@ -1999,11 +3132,11 @@ describe Mongoid::Contextual::Mongo do
     context "when adding an element to a HABTM set" do
 
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       let(:preference) do
-        Preference.create
+        Preference.create!
       end
 
       before do
@@ -2133,7 +3266,8 @@ describe Mongoid::Contextual::Mongo do
       end
     end
 
-    context 'when provided array filters', if: array_filters_supported? do
+    context 'when provided array filters' do
+      min_server_version '3.6'
 
       before do
         Band.delete_all
@@ -2141,12 +3275,12 @@ describe Mongoid::Contextual::Mongo do
         b.labels << Label.new(name: 'Warner')
         b.labels << Label.new(name: 'Sony')
         b.labels << Label.new(name: 'Cbs')
-        b.save
+        b.save!
 
         b = Band.new(name: 'FKA Twigs')
         b.labels << Label.new(name: 'Warner')
         b.labels << Label.new(name: 'Cbs')
-        b.save
+        b.save!
       end
 
 
@@ -2172,11 +3306,11 @@ describe Mongoid::Contextual::Mongo do
   describe "#update_all" do
 
     let!(:depeche_mode) do
-      Band.create(name: "Depeche Mode", origin: "Essex")
+      Band.create!(name: "Depeche Mode", origin: "Essex")
     end
 
     let!(:new_order) do
-      Band.create(name: "New Order")
+      Band.create!(name: "New Order")
     end
 
     let(:criteria) do
@@ -2305,7 +3439,8 @@ describe Mongoid::Contextual::Mongo do
       end
     end
 
-    context 'when provided array filters', if: array_filters_supported? do
+    context 'when provided array filters' do
+      min_server_version '3.6'
 
       before do
         Band.delete_all
@@ -2313,12 +3448,12 @@ describe Mongoid::Contextual::Mongo do
         b.labels << Label.new(name: 'Warner')
         b.labels << Label.new(name: 'Sony')
         b.labels << Label.new(name: 'Cbs')
-        b.save
+        b.save!
 
         b = Band.new(name: 'FKA Twigs')
         b.labels << Label.new(name: 'Warner')
         b.labels << Label.new(name: 'Cbs')
-        b.save
+        b.save!
       end
 
 
@@ -2328,7 +3463,7 @@ describe Mongoid::Contextual::Mongo do
 
       let!(:update) do
         context.update_all({ '$set' => { 'labels.$[i].name' => 'Sony' } },
-                           array_filters: [{ 'i.name' => 'Cbs' }])
+                       array_filters: [{ 'i.name' => 'Cbs' }])
       end
 
       it 'applies the array filters' do
@@ -2343,7 +3478,7 @@ describe Mongoid::Contextual::Mongo do
 
   describe '#pipeline' do
 
-    context 'when the criteria has a selector', if: non_legacy_server? do
+    context 'when the criteria has a selector' do
 
       before do
         Artist.index(name: "text")