mongoid 8.0.10 → 8.1.0

data/spec/mongoid/contextual/mongo_spec.rb

@@ -158,16 +158,6 @@ describe Mongoid::Contextual::Mongo do
         end
       end
     end
-
-    context 'when for_js is present' do
-      let(:context) do
-        Band.for_js('this.name == "Depeche Mode"')
-      end
-
-      it 'counts the expected records' do
-        expect(context.count).to eq(1)
-      end
-    end
   end
 
   describe "#estimated_count" do
@@ -571,6 +561,8 @@ describe Mongoid::Contextual::Mongo do
     end
 
     context "when getting a localized field" do
+      with_default_i18n_configs
+
       before do
         I18n.locale = :en
         d = Dictionary.create!(description: 'english-text')
@@ -670,13 +662,11 @@ describe Mongoid::Contextual::Mongo do
       end
 
       context 'when fallbacks are enabled with a locale list' do
-        with_i18n_fallbacks
+        require_fallbacks
+        with_default_i18n_configs
 
-        around(:all) do |example|
-          prev_fallbacks = I18n.fallbacks.dup
+        before do
           I18n.fallbacks[:he] = [ :en ]
-          example.run
-          I18n.fallbacks = prev_fallbacks
         end
 
         let(:distinct) do
@@ -704,6 +694,8 @@ describe Mongoid::Contextual::Mongo do
       end
 
       context "when the localized field is embedded" do
+        with_default_i18n_configs
+
         before do
           p = Passport.new
           I18n.locale = :en
@@ -849,6 +841,8 @@ describe Mongoid::Contextual::Mongo do
     end
 
     context "when tallying a localized field" do
+      with_default_i18n_configs
+
       before do
         I18n.locale = :en
         d1 = Dictionary.create!(description: 'en1')
@@ -903,6 +897,7 @@ describe Mongoid::Contextual::Mongo do
     end
 
     context "when tallying an embedded localized field" do
+      with_default_i18n_configs
 
       before do
         I18n.locale = :en
@@ -1189,49 +1184,33 @@ describe Mongoid::Contextual::Mongo do
       let!(:person2) { Person.create!(ssn: BSON::Decimal128.new("1")) }
       let(:tally) { Person.tally("ssn") }
 
-      let(:tallied_classes) do
-        tally.keys.map(&:class).sort do |a, b|
-          a.to_s.casecmp(b.to_s)
-        end
-      end
-
       context "< BSON 5" do
         max_bson_version '4.99.99'
 
         it "stores the correct types in the database" do
-          expect(Person.find(person1.id).attributes["ssn"]).to be_a BSON::Regexp::Raw
-          expect(Person.find(person2.id).attributes["ssn"]).to be_a BSON::Decimal128
-        end
-
-        it "tallies the correct type" do
-          expect(tallied_classes).to be == [ 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
-          expect(Person.find(person1.id).ssn).to be_a BSON::Regexp::Raw
-          expect(Person.find(person2.id).ssn).to be_a BigDecimal
+          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
-          expect(tallied_classes).to be == [ BigDecimal, BSON::Regexp::Raw ]
+          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 with decimal128 allowed' do
+      context ">= BSON 5" do
         min_bson_version "5.0"
-        config_override :allow_bson5_decimal128, true
 
         it "stores the correct types in the database" do
-          expect(Person.find(person1.id).ssn).to be_a BSON::Regexp::Raw
-          expect(Person.find(person2.id).ssn).to be_a BSON::Decimal128
+          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
-          expect(tallied_classes).to be == [ BSON::Decimal128, BSON::Regexp::Raw ]
+          tally.keys.map(&:class).sort do |a,b|
+            a.to_s <=> b.to_s
+          end.should == [BigDecimal, BSON::Regexp::Raw]
         end
       end
     end
@@ -1401,64 +1380,177 @@ describe Mongoid::Contextual::Mongo do
 
   describe "#exists?" do
 
-    before do
-      Band.create!(name: "Depeche Mode")
+    let!(:band) do
+      Band.create!(name: "Depeche Mode", active: true)
     end
 
-    context "when the count is zero" do
+    context "when not passing options" do
 
-      let(:criteria) do
-        Band.where(name: "New Order")
+      context "when the count is zero" do
+
+        let(:criteria) do
+          Band.where(name: "New Order")
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns false" do
+          expect(context).to_not be_exists
+        end
       end
 
-      let(:context) do
-        described_class.new(criteria)
+      context "when the count is greater than zero" do
+
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns true" do
+          expect(context).to be_exists
+        end
       end
 
-      it "returns false" do
-        expect(context).to_not be_exists
+      context "when caching is not enabled" do
+
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        context "when exists? already called and query cache is enabled" do
+          query_cache_enabled
+
+          before do
+            context.exists?
+          end
+
+          it "does not hit the database again" do
+            expect_no_queries do
+              expect(context).to be_exists
+            end
+          end
+        end
       end
     end
 
-    context "when the count is greater than zero" do
+    context "when passing an _id" do
 
-      let(:criteria) do
-        Band.where(name: "Depeche Mode")
-      end
+      context "when its of type BSON::ObjectId" do
 
-      let(:context) do
-        described_class.new(criteria)
+        context "when calling it on the class" do
+
+          it "returns true" do
+            expect(Band.exists?(band._id)).to be true
+          end
+        end
+
+        context "when calling it on a criteria that includes the object" do
+
+          it "returns true" do
+            expect(Band.where(name: band.name).exists?(band._id)).to be true
+          end
+        end
+
+        context "when calling it on a criteria that does not include the object" do
+
+          it "returns false" do
+            expect(Band.where(name: "bogus").exists?(band._id)).to be false
+          end
+        end
+
+        context "when the id does not exist" do
+
+          it "returns false" do
+            expect(Band.exists?(BSON::ObjectId.new)).to be false
+          end
+        end
       end
 
-      it "returns true" do
-        expect(context).to be_exists
+      context "when its of type String" do
+
+        context "when the id exists" do
+
+          it "returns true" do
+            expect(Band.exists?(band._id.to_s)).to be true
+          end
+        end
+
+        context "when the id does not exist" do
+
+          it "returns false" do
+            expect(Band.exists?(BSON::ObjectId.new.to_s)).to be false
+          end
+        end
       end
     end
 
-    context "when caching is not enabled" do
+    context "when passing a hash" do
 
-      let(:criteria) do
-        Band.where(name: "Depeche Mode")
+      context "when calling it on the class" do
+
+        it "returns true" do
+          expect(Band.exists?(name: band.name)).to be true
+        end
       end
 
-      let(:context) do
-        described_class.new(criteria)
+      context "when calling it on a criteria that includes the object" do
+
+        it "returns true" do
+          expect(Band.where(active: true).exists?(name: band.name)).to be true
+        end
       end
 
-      context "when exists? already called and query cache is enabled" do
-        query_cache_enabled
+      context "when calling it on a criteria that does not include the object" do
 
-        before do
-          context.exists?
+        it "returns false" do
+          expect(Band.where(active: false).exists?(name: band.name)).to be false
         end
+      end
 
-        it "does not hit the database again" do
-          expect_no_queries do
-            expect(context).to be_exists
-          end
+      context "when the conditions don't match" do
+
+        it "returns false" do
+          expect(Band.exists?(name: "bogus")).to be false
         end
       end
     end
+
+    context "when passing false" do
+
+      it "returns false" do
+        expect(Band.exists?(false)).to be false
+      end
+    end
+
+    context "when passing nil" do
+
+      it "returns false" do
+        expect(Band.exists?(nil)).to be false
+      end
+    end
+
+    context "when the limit is 0" do
+
+      it "returns false" do
+        expect(Band.limit(0).exists?).to be false
+      end
+    end
+
+    context "when the criteria limit is 0" do
+
+      it "returns false" do
+        expect(Band.criteria.limit(0).exists?).to be false
+      end
+    end
   end
 
   describe "#explain" do
@@ -1472,7 +1564,16 @@ describe Mongoid::Contextual::Mongo do
     end
 
     it "returns the criteria explain path" do
-      expect(context.explain).to_not be_empty
+      explain = context.explain
+      expect(explain).to_not be_empty
+      expect(explain.keys).to include("queryPlanner", "executionStats", "serverInfo")
+    end
+
+    it "respects options passed to explain" do
+      explain = context.explain(verbosity: :query_planner)
+      expect(explain).to_not be_empty
+      expect(explain.keys).to include("queryPlanner", "serverInfo")
+      expect(explain.keys).not_to include("executionStats")
     end
   end
 
@@ -3573,65 +3674,16 @@ describe Mongoid::Contextual::Mongo do
 
         context "when the attributes are in the correct type" do
 
-          context "when operation is $set" do
-
-            before do
-              context.update_all("$set" => { name: "Smiths" })
-            end
-
-            it "updates the first matching document" do
-              expect(depeche_mode.reload.name).to eq("Smiths")
-            end
-
-            it "updates the last matching document" do
-              expect(new_order.reload.name).to eq("Smiths")
-            end
-          end
-
-          context "when operation is $push" do
-
-            before do
-              depeche_mode.update_attribute(:genres, ["electronic"])
-              new_order.update_attribute(:genres, ["electronic"])
-              context.update_all("$push" => { genres: "pop" })
-            end
-
-            it "updates the first matching document" do
-              expect(depeche_mode.reload.genres).to eq(["electronic", "pop"])
-            end
-
-            it "updates the last matching document" do
-              expect(new_order.reload.genres).to eq(["electronic", "pop"])
-            end
-          end
-
-          context "when operation is $addToSet" do
-
-            before do
-              context.update_all("$addToSet" => { genres: "electronic" })
-            end
-
-            it "updates the first matching document" do
-              expect(depeche_mode.reload.genres).to eq(["electronic"])
-            end
-
-            it "updates the last matching document" do
-              expect(new_order.reload.genres).to eq(["electronic"])
-            end
-          end
-        end
-
-        context 'when using aliased field names' do
           before do
-            context.update_all('$set' => { years: 100 })
+            context.update_all("$set" => { name: "Smiths" })
           end
 
           it "updates the first matching document" do
-            expect(depeche_mode.reload.years).to eq(100)
+            expect(depeche_mode.reload.name).to eq("Smiths")
           end
 
           it "updates the last matching document" do
-            expect(new_order.reload.years).to eq(100)
+            expect(new_order.reload.name).to eq("Smiths")
           end
         end
 
@@ -3749,4 +3801,836 @@ describe Mongoid::Contextual::Mongo do
       end
     end
   end
+
+  describe "#first!" 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!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the first document" do
+        expect(context.first!).to eq(depeche_mode)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the first document" do
+        expect(context.sort(name: 1).first!).to eq(death_cab)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "raises an error" do
+        expect do
+          context.first!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+      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
+
+    let!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the last document" do
+        expect(context.last!).to eq(death_cab)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the last document" do
+        expect(context.sort(name: 1).last!).to eq(rolling_stones)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "raises an error" do
+        expect do
+          context.last!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+      end
+    end
+  end
+
+  describe "#second" 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!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the second document" do
+        expect(context.second).to eq(new_order)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the second document" do
+        expect(context.sort(name: 1).second).to eq(depeche_mode)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "returns nil" do
+        expect(context.second).to be_nil
+      end
+    end
+  end
+
+  describe "#second!" 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!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the second document" do
+        expect(context.second!).to eq(new_order)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the second document" do
+        expect(context.sort(name: 1).second!).to eq(depeche_mode)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "raises an error" do
+        expect do
+          context.second!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+      end
+    end
+  end
+
+  describe "#third" 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!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the third document" do
+        expect(context.third).to eq(rolling_stones)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the third document" do
+        expect(context.sort(name: 1).third).to eq(new_order)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "returns nil" do
+        expect(context.third).to be_nil
+      end
+    end
+  end
+
+  describe "#third!" 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!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the third document" do
+        expect(context.third!).to eq(rolling_stones)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the third document" do
+        expect(context.sort(name: 1).third!).to eq(new_order)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "raises an error" do
+        expect do
+          context.third!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+      end
+    end
+  end
+
+  describe "#fourth" 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!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the fourth document" do
+        expect(context.fourth).to eq(death_cab)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the fourth document" do
+        expect(context.sort(name: 1).fourth).to eq(rolling_stones)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "returns nil" do
+        expect(context.fourth).to be_nil
+      end
+    end
+  end
+
+  describe "#fourth!" 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!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the fourth document" do
+        expect(context.fourth!).to eq(death_cab)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the fourth document" do
+        expect(context.sort(name: 1).fourth!).to eq(rolling_stones)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "raises an error" do
+        expect do
+          context.fourth!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+      end
+    end
+  end
+
+  describe "#fifth" 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!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let!(:guns_and_roses) do
+      Band.create!(name: "Guns and Roses")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the fifth document" do
+        expect(context.fifth).to eq(guns_and_roses)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the fifth document" do
+        expect(context.sort(name: 1).fifth).to eq(rolling_stones)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "returns nil" do
+        expect(context.fifth).to be_nil
+      end
+    end
+  end
+
+  describe "#fifth!" 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!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let!(:guns_and_roses) do
+      Band.create!(name: "Guns and Roses")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the fifth document" do
+        expect(context.fifth!).to eq(guns_and_roses)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the fifth document" do
+        expect(context.sort(name: 1).fifth!).to eq(rolling_stones)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "raises an error" do
+        expect do
+          context.fifth!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+      end
+    end
+  end
+
+  describe "#second_to_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
+
+    let!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the second_to_last document" do
+        expect(context.second_to_last).to eq(rolling_stones)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the second_to_last document" do
+        expect(context.sort(name: 1).second_to_last).to eq(new_order)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "returns nil" do
+        expect(context.second_to_last).to be_nil
+      end
+    end
+  end
+
+  describe "#second_to_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
+
+    let!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the second_to_last document" do
+        expect(context.second_to_last!).to eq(rolling_stones)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the second_to_last document" do
+        expect(context.sort(name: 1).second_to_last!).to eq(new_order)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "raises an error" do
+        expect do
+          context.second_to_last!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+      end
+    end
+  end
+
+  describe "#third_to_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
+
+    let!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the third_to_last document" do
+        expect(context.third_to_last).to eq(new_order)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the third_to_last document" do
+        expect(context.sort(name: 1).third_to_last).to eq(depeche_mode)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "returns nil" do
+        expect(context.third_to_last).to be_nil
+      end
+    end
+  end
+
+  describe "#third_to_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
+
+    let!(:death_cab) do
+      Band.create!(name: "Death Cab For Cutie")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when there's no sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the third_to_last document" do
+        expect(context.third_to_last!).to eq(new_order)
+      end
+    end
+
+    context "when there's a custom sort" do
+      let(:criteria) do
+        Band.all
+      end
+
+      it "gets the third_to_last document" do
+        expect(context.sort(name: 1).third_to_last!).to eq(depeche_mode)
+      end
+    end
+
+    context "when there are no documents" do
+      let(:criteria) do
+        Band.where(name: "bogus")
+      end
+
+      it "raises an error" do
+        expect do
+          context.third_to_last!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+      end
+    end
+  end
+
+  describe '#load_async' do
+    let!(:band) do
+      Band.create!(name: "Depeche Mode")
+    end
+
+    let(:criteria) do
+      Band.where(name: "Depeche Mode")
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context 'with global thread pool async query executor' do
+      config_override :async_query_executor, :global_thread_pool
+
+      it 'preloads the documents' do
+        context.load_async
+        context.documents_loader.wait
+
+        expect(context.view).not_to receive(:map)
+        expect(context.to_a).to eq([band])
+      end
+
+      it 're-raises exception during preload' do
+        expect_any_instance_of(Mongoid::Contextual::Mongo::DocumentsLoader)
+          .to receive(:execute)
+          .at_least(:once)
+          .and_raise(Mongo::Error::OperationFailure)
+
+        context.load_async
+        context.documents_loader.wait
+
+        expect do
+          context.to_a
+        end.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'with immediate thread pool async query executor' do
+      config_override :async_query_executor, :immediate
+
+      it 'preloads the documents' do
+        context.load_async
+        context.documents_loader.wait
+
+        expect(context.view).not_to receive(:map)
+        expect(context.to_a).to eq([band])
+      end
+
+      it 're-raises exception during preload' do
+        expect_any_instance_of(Mongoid::Contextual::Mongo::DocumentsLoader)
+          .to receive(:execute)
+          .at_least(:once)
+          .and_raise(Mongo::Error::OperationFailure)
+
+        context.load_async
+        context.documents_loader.wait
+
+        expect do
+          context.to_a
+        end.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
 end