mongoid 7.4.3 → 7.5.0

data/spec/mongoid/contextual/mongo_spec.rb

@@ -584,6 +584,10 @@ describe Mongoid::Contextual::Mongo do
         d.save!
       end
 
+      after do
+        I18n.locale = :en
+      end
+
       let(:criteria) do
         Dictionary.criteria
       end
@@ -684,6 +688,10 @@ describe Mongoid::Contextual::Mongo do
           I18n.fallbacks = prev_fallbacks
         end
 
+        after do
+          I18n.locale = :en
+        end
+
         let(:distinct) do
           context.distinct(:description).first
         end
@@ -719,6 +727,10 @@ 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
@@ -1470,6 +1482,10 @@ describe Mongoid::Contextual::Mongo 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
@@ -1510,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
@@ -1542,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
@@ -1576,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
@@ -1622,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
@@ -1669,6 +1683,680 @@ describe Mongoid::Contextual::Mongo do
           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.send(method, 1)
+            end
+
+            it "returns an array of documents" do
+              expect(docs).to eq([ 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
 
@@ -1823,6 +2511,80 @@ 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
@@ -1840,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