mongoid 5.4.1 → 6.0.0.beta

data/spec/mongoid/contextual/mongo_spec.rb

@@ -115,6 +115,21 @@ describe Mongoid::Contextual::Mongo do
       end
     end
 
+    context "when provided a document" do
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      let(:count) do
+        context.count(depeche)
+      end
+
+      it "returns the number of documents that match" do
+        expect(count).to eq(1)
+      end
+    end
+
     context "when provided a block" do
 
       let(:context) do
@@ -167,28 +182,6 @@ describe Mongoid::Contextual::Mongo do
         expect(count).to eq(2)
       end
     end
-
-    context 'when a collation is specified', if: collation_supported? do
-
-      let(:context) do
-        described_class.new(criteria)
-      end
-
-      context 'when the collation is specified on the criteria' do
-
-        let(:criteria) do
-          Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
-        end
-
-        let(:count) do
-          context.count
-        end
-
-        it 'applies the collation' do
-          expect(count).to eq(1)
-        end
-      end
-    end
   end
 
   [ :delete, :delete_all ].each do |method|
@@ -230,34 +223,7 @@ describe Mongoid::Contextual::Mongo do
         end
       end
 
-      context 'when the criteria has a collation', if: collation_supported? do
-
-        let(:criteria) do
-          Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
-        end
-
-        let(:context) do
-          described_class.new(criteria)
-        end
-
-        let!(:deleted) do
-          context.send(method)
-        end
-
-        it "deletes the matching documents" do
-          expect(Band.find(new_order.id)).to eq(new_order)
-        end
-
-        it "deletes the correct number of documents" do
-          expect(Band.count).to eq(1)
-        end
-
-        it "returns the number of documents deleted" do
-          expect(deleted).to eq(1)
-        end
-      end
-
-      context "when the selector is not constraining" do
+      context "when the selector is not contraining" do
 
         let(:criteria) do
           Band.all
@@ -315,33 +281,6 @@ describe Mongoid::Contextual::Mongo do
         it "returns the number of documents destroyed" do
           expect(destroyed).to eq(1)
         end
-
-        context 'when the criteria has a collation', if: collation_supported? do
-
-          let(:criteria) do
-            Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
-          end
-
-          let(:context) do
-            described_class.new(criteria)
-          end
-
-          let!(:destroyed) do
-            context.send(method)
-          end
-
-          it "destroys the matching documents" do
-            expect(Band.find(new_order.id)).to eq(new_order)
-          end
-
-          it "destroys the correct number of documents" do
-            expect(Band.count).to eq(1)
-          end
-
-          it "returns the number of documents destroyed" do
-            expect(destroyed).to eq(1)
-          end
-        end
       end
 
       context "when the selector is not contraining" do
@@ -416,29 +355,6 @@ describe Mongoid::Contextual::Mongo do
         expect(context.distinct(:years)).to eq([ 30, 25 ])
       end
     end
-
-    context 'when a collation is specified', if: collation_supported? do
-
-      before do
-        Band.create(name: 'DEPECHE MODE')
-      end
-
-      let(:context) do
-        described_class.new(criteria)
-      end
-
-      let(:expected_results) do
-        ["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)).to eq(expected_results)
-      end
-    end
   end
 
   describe "#each" do
@@ -455,29 +371,6 @@ describe Mongoid::Contextual::Mongo do
       described_class.new(criteria)
     end
 
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let(:criteria) do
-        Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
-      end
-
-      it "yields mongoid documents to the block" do
-        context.each do |doc|
-          expect(doc).to be_a(Mongoid::Document)
-        end
-      end
-
-      it "iterates over the matching documents" do
-        context.each do |doc|
-          expect(doc.name).to eq("Depeche Mode")
-        end
-      end
-
-      it "returns self" do
-        expect(context.each{}).to be(context)
-      end
-    end
-
     context "when providing a block" do
 
       it "yields mongoid documents to the block" do
@@ -520,22 +413,9 @@ describe Mongoid::Contextual::Mongo do
 
         context "when iterating with next" do
 
-          before do
-            10.times { |i| Band.create(name: "Test #{i}") }
-          end
-
-          let(:criteria) do
-            Band.batch_size(5)
-          end
-
           it "yields mongoid documents" do
             expect(enum.next).to be_a(Mongoid::Document)
           end
-
-          it "does not load all documents" do
-            expect(Mongo::Logger.logger).to receive(:debug?).exactly(2).times.and_call_original
-            enum.next
-          end
         end
       end
     end
@@ -677,7 +557,7 @@ describe Mongoid::Contextual::Mongo do
     end
   end
 
-  describe "#find_one_and_replace" do
+  describe "#find_one_and_update" do
 
     let!(:depeche) do
       Band.create(name: "Depeche Mode")
@@ -700,7 +580,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         let!(:result) do
-          context.find_one_and_replace(name: 'FKA Twigs')
+          context.find_one_and_update("$inc" => { likes: 1 })
         end
 
         it "returns the first matching document" do
@@ -708,7 +588,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "updates the document in the database" do
-          expect(depeche.reload.name).to eq('FKA Twigs')
+          expect(depeche.reload.likes).to eq(1)
         end
       end
 
@@ -723,7 +603,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         let!(:result) do
-          context.find_one_and_replace(likes: 1)
+          context.find_one_and_update("$inc" => { likes: 1 })
         end
 
         it "returns the first matching document" do
@@ -732,7 +612,6 @@ describe Mongoid::Contextual::Mongo do
 
         it "updates the document in the database" do
           expect(tool.reload.likes).to eq(1)
-          expect(tool.reload.name).to be_nil
         end
       end
 
@@ -747,7 +626,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         let!(:result) do
-          context.find_one_and_replace(name: 'FKA Twigs', likes: 1)
+          context.find_one_and_update("$inc" => { likes: 1 })
         end
 
         it "returns the first matching document" do
@@ -774,7 +653,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         let!(:result) do
-          context.find_one_and_replace({ likes: 1 }, return_document: :after)
+          context.find_one_and_update({ "$inc" => { likes: 1 }}, return_document: :after)
         end
 
         it "returns the first matching document" do
@@ -782,15 +661,14 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the updated document" do
-          expect(result.name).to be_nil
           expect(result.likes).to eq(1)
         end
       end
 
-      context 'when a collation is specified on the criteria', if: collation_supported? do
+      context "when removing" do
 
         let(:criteria) do
-          Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
+          Band.where(name: "Depeche Mode")
         end
 
         let(:context) do
@@ -798,16 +676,17 @@ describe Mongoid::Contextual::Mongo do
         end
 
         let!(:result) do
-          context.find_one_and_replace({ likes: 1 }, return_document: :after)
+          context.find_one_and_delete
         end
 
         it "returns the first matching document" do
           expect(result).to eq(depeche)
         end
 
-        it "returns the updated document" do
-          expect(result.likes).to eq(1)
-          expect(result.name).to be_nil
+        it "deletes the document from the database" do
+          expect {
+            depeche.reload
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
         end
       end
     end
@@ -815,7 +694,7 @@ describe Mongoid::Contextual::Mongo do
     context "when the selector does not match" do
 
       let(:criteria) do
-        Band.where(name: "DEPECHE MODE")
+        Band.where(name: "Placebo")
       end
 
       let(:context) do
@@ -823,7 +702,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       let(:result) do
-        context.find_one_and_replace(name: 'FKA Twigs')
+        context.find_one_and_update("$inc" => { likes: 1 })
       end
 
       it "returns nil" do
@@ -832,19 +711,19 @@ describe Mongoid::Contextual::Mongo do
     end
   end
 
-  describe "#find_one_and_update" do
+  [ :first, :one ].each do |method|
 
-    let!(:depeche) do
-      Band.create(name: "Depeche Mode")
-    end
+    describe "##{method}" do
 
-    let!(:tool) do
-      Band.create(name: "Tool")
-    end
+      let!(:depeche_mode) do
+        Band.create(name: "Depeche Mode")
+      end
 
-    context "when the selector matches" do
+      let!(:new_order) do
+        Band.create(name: "New Order")
+      end
 
-      context "when not providing options" do
+      context "when the context is not cached" do
 
         let(:criteria) do
           Band.where(name: "Depeche Mode")
@@ -854,20 +733,12 @@ describe Mongoid::Contextual::Mongo do
           described_class.new(criteria)
         end
 
-        let!(:result) do
-          context.find_one_and_update("$inc" => { likes: 1 })
-        end
-
         it "returns the first matching document" do
-          expect(result).to eq(depeche)
-        end
-
-        it "updates the document in the database" do
-          expect(depeche.reload.likes).to eq(1)
+          expect(context.send(method)).to eq(depeche_mode)
         end
       end
 
-      context "when sorting" do
+      context "when using .desc" do
 
         let(:criteria) do
           Band.desc(:name)
@@ -877,249 +748,104 @@ describe Mongoid::Contextual::Mongo do
           described_class.new(criteria)
         end
 
-        let!(:result) do
-          context.find_one_and_update("$inc" => { likes: 1 })
-        end
-
-        it "returns the first matching document" do
-          expect(result).to eq(tool)
-        end
-
-        it "updates the document in the database" do
-          expect(tool.reload.likes).to eq(1)
-        end
-      end
-
-      context "when limiting fields" do
-
-        let(:criteria) do
-          Band.only(:_id)
-        end
-
-        let(:context) do
-          described_class.new(criteria)
-        end
-
-        let!(:result) do
-          context.find_one_and_update("$inc" => { likes: 1 })
-        end
+        context "when there is sort on the context" do
 
-        it "returns the first matching document" do
-          expect(result).to eq(depeche)
+          it "follows the main sort" do
+            expect(context.send(method)).to eq(new_order)
+          end
         end
 
-        it "limits the returned fields" do
-          expect(result.name).to be_nil
-        end
+        context "when subsequently calling #last" do
 
-        it "updates the document in the database" do
-          expect(depeche.reload.likes).to eq(1)
+          it "returns the correct document" do
+            expect(context.send(method)).to eq(new_order)
+            expect(context.last).to eq(depeche_mode)
+          end
         end
       end
 
-      context "when returning new" do
+      context 'when the criteria has no sort' do
 
         let(:criteria) do
-          Band.where(name: "Depeche Mode")
+          Band.all
         end
 
         let(:context) do
           described_class.new(criteria)
         end
 
-        let!(:result) do
-          context.find_one_and_update({ "$inc" => { likes: 1 }}, return_document: :after)
-        end
-
-        it "returns the first matching document" do
-          expect(result).to eq(depeche)
-        end
-
-        it "returns the updated document" do
-          expect(result.likes).to eq(1)
-        end
-      end
 
-      context 'when a collation is specified on the criteria', if: collation_supported? do
-
-        let(:criteria) do
-          Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
-        end
-
-        let(:context) do
-          described_class.new(criteria)
-        end
-
-        let!(:result) do
-          context.find_one_and_update({ "$inc" => { likes: 1 }}, return_document: :after)
+        it 'applies a sort on _id' do
+          expect(context.send(method)).to eq(depeche_mode)
         end
 
-        it "returns the first matching document" do
-          expect(result).to eq(depeche)
-        end
+        context 'when calling #last' do
 
-        it "returns the updated document" do
-          expect(result.likes).to eq(1)
+          it 'returns the last document, sorted by _id' do
+            expect(context.send(method)).to eq(depeche_mode)
+            expect(context.last).to eq(new_order)
+          end
         end
-      end
-    end
-
-    context "when the selector does not match" do
-
-      let(:criteria) do
-        Band.where(name: "Placebo")
-      end
-
-      let(:context) do
-        described_class.new(criteria)
-      end
-
-      let(:result) do
-        context.find_one_and_update("$inc" => { likes: 1 })
-      end
-
-      it "returns nil" do
-        expect(result).to be_nil
-      end
-    end
-  end
-
-  describe "#find_one_and_delete" do
-
-    let!(:depeche) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:criteria) do
-      Band.where(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(criteria)
-    end
-
-    let!(:result) do
-      context.find_one_and_delete
-    end
-
-    context 'when the selector matches a document' do
-
-      it "returns the first matching document" do
-        expect(result).to eq(depeche)
-      end
-
-      it "deletes the document from the database" do
-        expect {
-          depeche.reload
-        }.to raise_error(Mongoid::Errors::DocumentNotFound)
-      end
-
-      context 'when a collation is specified on the criteria', if: collation_supported? do
 
-        let(:criteria) do
-          Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
-        end
+        context 'with option { sort: :none }' do
 
-        let(:context) do
-          described_class.new(criteria)
-        end
+          let(:opts) do
+            { id_sort: :none }
+          end
 
-        let!(:result) do
-          context.find_one_and_delete
-        end
+          it 'does not apply the sort on _id' do
+            expect(context.send(method, opts)).to eq(depeche_mode)
+          end
 
-        it "returns the first matching document" do
-          expect(result).to eq(depeche)
-        end
+          context 'when calling #last' do
 
-        it "deletes the document from the database" do
-          expect {
-            depeche.reload
-          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            it 'does not apply a sort on _id' do
+              expect(context.send(method, opts)).to eq(depeche_mode)
+              expect(context.last(opts)).to eq(depeche_mode)
+            end
+          end
         end
       end
-    end
-
-    context 'when the selector does not match a document' do
-
-      let(:criteria) do
-        Band.where(name: "Placebo")
-      end
-
-      let(:context) do
-        described_class.new(criteria)
-      end
-
-      let(:result) do
-        context.find_one_and_delete
-      end
-
-      it "returns nil" do
-        expect(result).to be_nil
-      end
-    end
-  end
-
-  [ :first, :one ].each do |method|
-
-    describe "##{method}" do
-
-      let!(:depeche_mode) do
-        Band.create(name: "Depeche Mode")
-      end
-
-      let!(:new_order) do
-        Band.create(name: "New Order")
-      end
 
-      context "when the context is not cached" do
+      context 'when the criteria has a sort' do
 
         let(:criteria) do
-          Band.where(name: "Depeche Mode")
+          Band.desc(:name)
         end
 
         let(:context) do
           described_class.new(criteria)
         end
 
-        it "returns the first matching document" do
-          expect(context.send(method)).to eq(depeche_mode)
-        end
-
-        context 'when the criteria has a collation', if: collation_supported? do
-
-          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)).to eq(depeche_mode)
-          end
+        it 'applies the criteria sort' do
+          expect(context.send(method)).to eq(new_order)
         end
-      end
 
-      context "when using .desc" do
+        context 'when calling #last' do
 
-        let(:criteria) do
-          Band.desc(:name)
+          it 'applies the criteria sort' do
+            expect(context.send(method)).to eq(new_order)
+            expect(context.last).to eq(depeche_mode)
+          end
         end
 
-        let(:context) do
-          described_class.new(criteria)
-        end
+        context 'with option { sort: :none }' do
 
-        context "when there is sort on the context" do
+          let(:opts) do
+            { id_sort: :none }
+          end
 
-          it "follows the main sort" do
-            expect(context.send(method)).to eq(new_order)
+          it 'applies the criteria sort' do
+            expect(context.send(method, opts)).to eq(new_order)
           end
-        end
 
-        context "when subsequently calling #last" do
+          context 'when calling #last' do
 
-          it "returns the correct document" do
-            expect(context.send(method)).to eq(new_order)
-            expect(context.last).to eq(depeche_mode)
+            it 'applies the criteria sort' do
+              expect(context.send(method, opts)).to eq(new_order)
+              expect(context.last(opts)).to eq(depeche_mode)
+            end
           end
         end
       end
@@ -1363,6 +1089,11 @@ describe Mongoid::Contextual::Mongo do
 
     context "when passed the symbol field name" do
 
+      it "limits query to that field" do
+        expect(criteria).to receive(:only).with(:name).and_call_original
+        context.map(:name)
+      end
+
       it "performs mapping" do
         expect(context.map(:name)).to eq ["Depeche Mode", "New Order"]
       end
@@ -2090,31 +1821,26 @@ describe Mongoid::Contextual::Mongo do
 
   describe '#pipeline' do
 
-    context 'when the criteria has a selector', if: non_legacy_server? do
-
-      before do
-        Artist.index(name: "text")
-        Artist.create_indexes
-      end
+    context 'when the criteria has a selector' do
 
       let(:criteria) do
-        Artist.text_search("New Order")
+        Band.where(name: "New Order")
       end
 
       let(:context) do
         described_class.new(criteria)
       end
 
-      let(:pipeline_match) do
-        context.send(:pipeline, :some_field).first['$match']
+      let(:matches_operators) do
+        context.send(:pipeline, 'name').select { |o| o['$match'] }
       end
 
       it 'creates a pipeline with the selector as one of the $match criteria' do
-        expect(pipeline_match).to include({ :'$text' => { :'$search' => "New Order" } })
+        expect(matches_operators).to include('$match' => criteria.selector)
       end
 
       it 'creates a pipeline with the $exists operator as one of the $match criteria' do
-        expect(pipeline_match).to include({ 'some_field' => { '$exists' => true } })
+        expect(matches_operators).to include('$match' => { 'name' => { '$exists' => true } })
       end
     end
   end