mongoid 7.3.5 → 7.5.0

data/spec/mongoid/criteria/queryable/selectable_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 require_relative './selectable_shared_examples'
@@ -480,10 +479,24 @@ describe Mongoid::Criteria::Queryable::Selectable do
           query.elem_match(users: { name: "value" })
         end
 
-        it "adds the $elemMatch expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$elemMatch" => { name: "value" }}
-          })
+        context "when overwrite_chained_operators is false" do
+          config_override :overwrite_chained_operators, false
+
+          it "adds the $elemMatch expression" do
+            expect(selection.selector).to eq({
+              "users" => { "$elemMatch" => { "name" => "value" }}
+            })
+          end
+        end
+
+        context "when overwrite_chained_operators is true" do
+          config_override :overwrite_chained_operators, true
+
+          it "adds the $elemMatch expression" do
+            expect(selection.selector).to eq({
+              "users" => { "$elemMatch" => { name: "value" }}
+            })
+          end
         end
 
         it "returns a cloned query" do
@@ -524,11 +537,26 @@ describe Mongoid::Criteria::Queryable::Selectable do
           )
         end
 
-        it "adds the $elemMatch expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$elemMatch" => { name: "value" }},
-            "comments" => { "$elemMatch" => { text: "value" }}
-          })
+        context "when overwrite_chained_operators is false" do
+          config_override :overwrite_chained_operators, false
+
+          it "adds the $elemMatch expression" do
+            expect(selection.selector).to eq({
+              "users" => { "$elemMatch" => { "name" => "value" }},
+              "comments" => { "$elemMatch" => { "text" => "value" }}
+            })
+          end
+        end
+
+        context "when overwrite_chained_operators is true" do
+          config_override :overwrite_chained_operators, true
+
+          it "adds the $elemMatch expression" do
+            expect(selection.selector).to eq({
+              "users" => { "$elemMatch" => { name: "value" }},
+              "comments" => { "$elemMatch" => { text: "value" }}
+            })
+          end
         end
 
         it "returns a cloned query" do
@@ -547,11 +575,26 @@ describe Mongoid::Criteria::Queryable::Selectable do
             elem_match(comments: { text: "value" })
         end
 
-        it "adds the $elemMatch expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$elemMatch" => { name: "value" }},
-            "comments" => { "$elemMatch" => { text: "value" }}
-          })
+        context "when overwrite_chained_operators is false" do
+          config_override :overwrite_chained_operators, false
+
+          it "adds the $elemMatch expression" do
+            expect(selection.selector).to eq({
+              "users" => { "$elemMatch" => { "name" => "value" }},
+              "comments" => { "$elemMatch" => { "text" => "value" }}
+            })
+          end
+        end
+
+        context "when overwrite_chained_operators is true" do
+          config_override :overwrite_chained_operators, true
+
+          it "adds the $elemMatch expression" do
+            expect(selection.selector).to eq({
+              "users" => { "$elemMatch" => { name: "value" }},
+              "comments" => { "$elemMatch" => { text: "value" }}
+            })
+          end
         end
 
         it "returns a cloned query" do
@@ -567,10 +610,25 @@ describe Mongoid::Criteria::Queryable::Selectable do
             elem_match(users: { state: "new" })
         end
 
-        it "overrides the $elemMatch expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$elemMatch" => { state: "new" }}
-          })
+        context "when overwrite_chained_operators is false" do
+          config_override :overwrite_chained_operators, false
+
+          it "adds an $elemMatch expression" do
+            expect(selection.selector).to eq({
+              "users" => { "$elemMatch" => { "name" => "value" } },
+              "$and" => [ { "users" => { "$elemMatch" => { "state" => "new" } } } ],
+            })
+          end
+        end
+
+        context "when overwrite_chained_operators is true" do
+          config_override :overwrite_chained_operators, true
+
+          it "overrides the $elemMatch expression" do
+            expect(selection.selector).to eq({
+              "users" => { "$elemMatch" => { state: "new" }}
+            })
+          end
         end
 
         it "returns a cloned query" do
@@ -888,18 +946,40 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context "when the criterion are on the same field" do
 
-        let(:selection) do
-          query.gt(first: 10).gt(first: 15)
-        end
+        context "when overwrite_chained_operators is true" do
+          config_override :overwrite_chained_operators, true
 
-        it "overwrites the first $gt selector" do
-          expect(selection.selector).to eq({
-            "first" => { "$gt" => 15 }
-          })
+          let(:selection) do
+            query.gt(first: 10).gt(first: 15)
+          end
+
+          it "overwrites the first $gt selector" do
+            expect(selection.selector).to eq({
+              "first" => { "$gt" => 15 },
+              })
+          end
+
+          it "returns a cloned query" do
+            expect(selection).to_not equal(query)
+          end
         end
 
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
+        context "when overwrite_chained_operators is false" do
+          config_override :overwrite_chained_operators, false
+          let(:selection) do
+            query.gt(first: 10).gt(first: 15)
+          end
+
+          it "overwrites the first $gt selector" do
+            expect(selection.selector).to eq({
+              "first" => { "$gt" => 10 },
+              "$and" => [{ "first" => { "$gt" => 15 } }]
+              })
+          end
+
+          it "returns a cloned query" do
+            expect(selection).to_not equal(query)
+          end
         end
       end
     end
@@ -976,10 +1056,25 @@ describe Mongoid::Criteria::Queryable::Selectable do
           query.gte(first: 10).gte(first: 15)
         end
 
-        it "overwrites the first $gte selector" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$gte" => 15 }
-          })
+        context "when overwrite_chained_operators is false" do
+          config_override :overwrite_chained_operators, false
+
+          it "adds a second $gte selector" do
+            expect(selection.selector).to eq({
+              "first" =>  { "$gte" => 10 },
+              "$and" => [ { "first" => { "$gte" => 15 } } ]
+            })
+          end
+        end
+
+        context "when overwrite_chained_operators is true" do
+          config_override :overwrite_chained_operators, true
+
+          it "overwrites the first $gte selector" do
+            expect(selection.selector).to eq({
+              "first" =>  { "$gte" => 15 }
+            })
+          end
         end
 
         it "returns a cloned query" do
@@ -1153,10 +1248,25 @@ describe Mongoid::Criteria::Queryable::Selectable do
           query.lt(first: 10).lt(first: 15)
         end
 
-        it "overwrites the first $lt selector" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$lt" => 15 }
-          })
+        context "when overwrite_chained_operators is false" do
+          config_override :overwrite_chained_operators, false
+
+          it "adds a second $lt selector" do
+            expect(selection.selector).to eq({
+              "first" =>  { "$lt" => 10 },
+              "$and" => [ { "first" => { "$lt" => 15 } } ]
+            })
+          end
+        end
+
+        context "when overwrite_chained_operators is true" do
+          config_override :overwrite_chained_operators, true
+
+          it "overwrites the first $lt selector" do
+            expect(selection.selector).to eq({
+              "first" =>  { "$lt" => 15 }
+            })
+          end
         end
 
         it "returns a cloned query" do
@@ -1237,10 +1347,25 @@ describe Mongoid::Criteria::Queryable::Selectable do
           query.lte(first: 10).lte(first: 15)
         end
 
-        it "overwrites the first $lte selector" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$lte" => 15 }
-          })
+        context "when overwrite_chained_operators is false" do
+          config_override :overwrite_chained_operators, false
+
+          it "adds a second $lte selector" do
+            expect(selection.selector).to eq({
+              "first" =>  { "$lte" => 10 },
+              "$and" => [ { "first" => { "$lte" => 15 } } ]
+            })
+          end
+        end
+
+        context "when overwrite_chained_operators is true" do
+          config_override :overwrite_chained_operators, true
+
+          it "overwrites the first $lte selector" do
+            expect(selection.selector).to eq({
+              "first" =>  { "$lte" => 15 }
+            })
+          end
         end
 
         it "returns a cloned query" do
@@ -1950,7 +2075,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.all
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -1969,7 +2094,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.elem_match
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -1988,7 +2113,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.exists
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2007,7 +2132,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.gt
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2026,7 +2151,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.gte
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2045,7 +2170,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.in
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2064,7 +2189,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.lt
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2083,7 +2208,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.lte
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2102,7 +2227,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.mod
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2121,7 +2246,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.ne
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2140,7 +2265,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.near
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2159,7 +2284,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.near_sphere
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2178,7 +2303,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.nin
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2217,7 +2342,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.with_size
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2236,7 +2361,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         :field.with_type
       end
 
-      it "returns a selecton key" do
+      it "returns a selection key" do
         expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
@@ -2295,4 +2420,51 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
     end
   end
+
+  describe "Mongoid.overwrite_chained_operators" do
+    [ :eq, :elem_match, :gt, :gte, :lt, :lte, :mod, :ne, :near, :near_sphere ].each do |meth|
+
+      context "when chaining the #{meth} method when using the same field" do
+        let(:op) do
+          {
+            eq: "$eq",
+            elem_match: "$elemMatch",
+            gt: "$gt",
+            gte: "$gte",
+            lt: "$lt",
+            lte: "$lte",
+            mod: "$mod",
+            ne: "$ne",
+            near: "$near",
+            near_sphere: "$nearSphere"
+          }[meth]
+        end
+
+        let(:criteria) do
+          Band.send(meth, {views: 1}).send(meth, {views:2})
+        end
+
+        context "when overwrite_chained_operators is true" do
+          config_override :overwrite_chained_operators, true
+
+          it "overrides the previous operators" do
+            expect(criteria.selector).to eq({
+              "views" => { op => 2 },
+            })
+          end
+        end
+
+        context "when overwrite_chained_operators is false" do
+          config_override :overwrite_chained_operators, false
+
+          it "overrides the previous operators" do
+            expect(criteria.selector).to eq({
+              "views" => { op => 1 },
+              "$and" => [{ "views" => { op => 2 } }]
+            })
+          end
+        end
+      end
+    end
+  end
 end

data/spec/mongoid/criteria/queryable/selectable_where_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 require_relative './selectable_shared_examples'

data/spec/mongoid/criteria/queryable/selector_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 

data/spec/mongoid/criteria/queryable/smash_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 

data/spec/mongoid/criteria/queryable/storable_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
@@ -68,6 +67,43 @@ describe Mongoid::Criteria::Queryable::Storable do
         end
       end
 
+      context "when broken_and feature flag is not set" do
+        config_override :broken_and, false
+
+        context '$and to query with $and onto query whose first one is not $and' do
+          let(:query) do
+            Mongoid::Query.new.where({'foo' => 'baz'}).where('$and' => [{zoom: 'zoom'}])
+          end
+
+          let(:modified) do
+            query.send(query_method, '$and', [{'foo' => 'bar'}])
+          end
+
+          it 'adds to existing $and' do
+            modified.selector.should == {
+              '$and' => [{'zoom' => 'zoom'}, {'foo' => 'bar'}], 'foo' => 'baz'}
+          end
+        end
+      end
+
+      context "when broken_and feature flag is set" do
+        config_override :broken_and, true
+
+        context '$and to query with $and onto query whose first one is not $and' do
+          let(:query) do
+            Mongoid::Query.new.where({'foo' => 'baz'}).where('$and' => [{zoom: 'zoom'}])
+          end
+
+          let(:modified) do
+            query.send(query_method, '$and', [{'foo' => 'bar'}])
+          end
+
+          it 'does not add to existing $and' do
+            modified.selector.should == {
+              '$and' => [{'foo' => 'bar'}], 'foo' => 'baz'}
+          end
+        end
+      end
     end
 
     context '$or operator' do

data/spec/mongoid/criteria/scopable_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
@@ -119,6 +118,133 @@ describe Mongoid::Criteria::Scopable do
     end
   end
 
+  describe "#apply_scope" do
+
+    let(:criteria) do
+      Band.skip(20).where(name: 'Black Sabbath').includes(:same_name)
+    end
+
+    let(:result) do
+      criteria.apply_scope(scope)
+    end
+
+    context "when the scope is a Criteria" do
+
+      context 'when standard scope' do
+        let(:scope) do
+          Band.gt(member_count: 3).limit(3).includes(:artists)
+        end
+
+        it 'merges the criteria' do
+          expect(result.selector).to eq("name" => "Black Sabbath", "member_count" => { "$gt"=>3 })
+          expect(result.options).to eq(skip: 20, limit: 3)
+          expect(result.inclusions.map(&:name)).to eq(%i[same_name artists])
+        end
+      end
+
+      context 'when unscoped' do
+        let(:scope) do
+          Band.unscoped.gt(member_count: 3).limit(3).includes(:artists)
+        end
+
+        it 'unscoped has no effect' do
+          expect(result.selector).to eq("name" => "Black Sabbath", "member_count" => { "$gt"=>3 })
+          expect(result.options).to eq(skip: 20, limit: 3)
+          expect(result.inclusions.map(&:name)).to eq(%i[same_name artists])
+        end
+      end
+    end
+
+    context "when the scope is a Proc" do
+
+      context 'when standard scope' do
+        let(:scope) do
+          -> { gt(member_count: 3).limit(3).includes(:artists) }
+        end
+
+        it 'adds the scope' do
+          expect(result.selector).to eq("name" => "Black Sabbath", "member_count" => { "$gt"=>3 })
+          expect(result.options).to eq(skip: 20, limit: 3)
+          expect(result.inclusions.map(&:name)).to eq(%i[same_name artists])
+        end
+      end
+
+      context 'when unscoped' do
+        let(:scope) do
+          -> { unscoped.gt(member_count: 3).limit(3).includes(:artists) }
+        end
+
+        it 'removes existing scopes then adds the new scope' do
+          expect(result.selector).to eq("member_count" => { "$gt"=>3 })
+          expect(result.options).to eq(limit: 3)
+          expect(result.inclusions.map(&:name)).to eq(%i[same_name artists])
+        end
+      end
+    end
+
+    context "when the scope is a Symbol" do
+
+      context 'when standard scope' do
+        let(:scope) do
+          :highly_rated
+        end
+
+        it 'adds the scope' do
+          expect(result.selector).to eq("name" => "Black Sabbath", "rating" => { "$gte" => 7 })
+          expect(result.options).to eq(skip: 20)
+          expect(result.inclusions.map(&:name)).to eq(%i[same_name])
+        end
+      end
+
+      context 'when unscoped' do
+        let(:scope) do
+          :unscoped
+        end
+
+        it 'removes existing scopes then adds the new scope' do
+          expect(result.selector).to eq({})
+          expect(result.options).to eq({})
+          expect(result.inclusions.map(&:name)).to eq(%i[same_name])
+        end
+      end
+    end
+
+    context 'when model has default_scope' do
+
+      before do
+        Band.default_scope ->{ Band.where(active: true).includes(:records) }
+      end
+
+      after do
+        Band.default_scoping = nil
+      end
+
+      context 'when standard scope' do
+        let(:scope) do
+          -> { gt(member_count: 3).limit(3).includes(:artists) }
+        end
+
+        it 'merges the scope' do
+          expect(result.selector).to eq("active" => true, "name" => "Black Sabbath", "member_count" => { "$gt" => 3 })
+          expect(result.options).to eq(skip: 20, limit: 3)
+          expect(result.inclusions.map(&:name)).to eq(%i[records same_name artists])
+        end
+      end
+
+      context 'when unscoped' do
+        let(:scope) do
+          -> { unscoped.gt(member_count: 3).limit(3).includes(:artists) }
+        end
+
+        it 'removes existing scopes then adds the new scope' do
+          expect(result.selector).to eq("member_count" => { "$gt" => 3 })
+          expect(result.options).to eq(limit: 3)
+          expect(result.inclusions.map(&:name)).to eq(%i[records same_name artists])
+        end
+      end
+    end
+  end
+
   describe "#remove_scoping" do
 
     context "when the other has selection" do

data/spec/mongoid/criteria_projection_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
@@ -8,7 +7,7 @@ describe Mongoid::Criteria do
   describe "#only" do
 
     let!(:band) do
-      Band.create(name: "Depeche Mode", likes: 3, views: 10)
+      Band.create!(name: "Depeche Mode", likes: 3, views: 10)
     end
 
     context "when not using inheritance" do
@@ -158,10 +157,10 @@ describe Mongoid::Criteria do
 
       before do
         I18n.locale = :en
-        d = Dictionary.create(description: 'english-text')
+        d = Dictionary.create!(description: 'english-text')
         I18n.locale = :de
         d.description = 'deutsch-text'
-        d.save
+        d.save!
       end
 
       after do