mongoid 7.1.1 → 8.1.0

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
+require_relative './selectable_shared_examples'
 
 class FieldWithSerializer
   def evolve(object)
@@ -19,43 +19,6 @@ describe Mongoid::Criteria::Queryable::Selectable do
     Mongoid::Query.new("id" => "_id")
   end
 
-  shared_examples_for "returns a cloned query" do
-
-    it "returns a cloned query" do
-      expect(selection).to_not equal(query)
-    end
-  end
-
-  shared_examples_for 'requires an argument' do
-    context "when provided no argument" do
-
-      let(:selection) do
-        query.send(query_method)
-      end
-
-      it "raises ArgumentError" do
-        expect do
-          selection.selector
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  shared_examples_for 'requires a non-nil argument' do
-    context "when provided nil" do
-
-      let(:selection) do
-        query.send(query_method, nil)
-      end
-
-      it "raises CriteriaArgumentRequired" do
-        expect do
-          selection.selector
-        end.to raise_error(Mongoid::Errors::CriteriaArgumentRequired, /#{query_method}/)
-      end
-    end
-  end
-
   shared_examples_for 'supports merge strategies' do
 
     context 'when the field is not aliased' do
@@ -516,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
@@ -560,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
@@ -583,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
@@ -603,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
@@ -732,9 +754,9 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#geo_spacial" do
+  describe "#geo_spatial" do
 
-    let(:query_method) { :geo_spacial }
+    let(:query_method) { :geo_spatial }
 
     it_behaves_like 'requires an argument'
     it_behaves_like 'requires a non-nil argument'
@@ -744,7 +766,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the geometry is a point intersection" do
 
         let(:selection) do
-          query.geo_spacial(:location.intersects_point => [ 1, 10 ])
+          query.geo_spatial(:location.intersects_point => [ 1, 10 ])
         end
 
         it "adds the $geoIntersects expression" do
@@ -766,7 +788,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the geometry is a line intersection" do
 
         let(:selection) do
-          query.geo_spacial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
+          query.geo_spatial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
         end
 
         it "adds the $geoIntersects expression" do
@@ -788,9 +810,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the geometry is a polygon intersection" do
 
         let(:selection) do
-          query.geo_spacial(
-            :location.intersects_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-          )
+          query.geo_spatial(:location.intersects_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]])
         end
 
         it "adds the $geoIntersects expression" do
@@ -812,9 +832,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the geometry is within a polygon" do
 
         let(:selection) do
-          query.geo_spacial(
-            :location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-          )
+          query.geo_spatial(:location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]])
         end
 
         it "adds the $geoIntersects expression" do
@@ -832,9 +850,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         context "when used with the $box operator ($geoWithin query) " do
           let(:selection) do
-            query.geo_spacial(
-              :location.within_box => [[ 1, 10 ], [ 2, 10 ]]
-            )
+            query.geo_spatial(:location.within_box => [[ 1, 10 ], [ 2, 10 ]])
           end
 
           it "adds the $geoIntersects expression" do
@@ -922,18 +938,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
@@ -1010,10 +1048,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
@@ -1187,10 +1240,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
@@ -1271,10 +1339,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
@@ -1962,7 +2045,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       # MongoDB server can only handle one text expression at a time,
-      # per https://docs.mongodb.com/manual/reference/operator/query/text/.
+      # per https://www.mongodb.com/docs/manual/reference/operator/query/text/.
       # Nonetheless we test that the query is built correctly when
       # a user supplies more than one text condition.
       it 'merges conditions' do
@@ -1976,657 +2059,129 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#where" do
-
-    let(:query_method) { :where }
+  describe Symbol do
 
-    context "when provided no criterion" do
+    describe "#all" do
 
-      let(:selection) do
-        query.where
+      let(:key) do
+        :field.all
       end
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
+      it "returns a selection key" do
+        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
+      it "sets the name as the key" do
+        expect(key.name).to eq(:field)
       end
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
+      it "sets the operator as $all" do
+        expect(key.operator).to eq("$all")
       end
     end
 
-    it_behaves_like 'requires a non-nil argument'
+    describe "#elem_match" do
 
-    context "when provided a string" do
+      let(:key) do
+        :field.elem_match
+      end
 
-      let(:selection) do
-        query.where("this.value = 10")
+      it "returns a selection key" do
+        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
-      it "adds the $where criterion" do
-        expect(selection.selector).to eq({ "$where" => "this.value = 10" })
+      it "sets the name as the key" do
+        expect(key.name).to eq(:field)
       end
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
+      it "sets the operator as $elemMatch" do
+        expect(key.operator).to eq("$elemMatch")
       end
+    end
 
-      context 'when multiple calls with string argument are made' do
+    describe "#exists" do
 
-        let(:selection) do
-          query.where("this.value = 10").where('foo.bar')
-        end
+      let(:key) do
+        :field.exists
+      end
 
-        it 'combines conditions' do
-          expect(selection.selector).to eq(
-            "$where" => "this.value = 10", '$and' => [{'$where' => 'foo.bar'}],
-          )
-        end
+      it "returns a selection key" do
+        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
       end
 
-      context 'when called with string argument and with hash argument' do
+      it "sets the name as the key" do
+        expect(key.name).to eq(:field)
+      end
 
-        let(:selection) do
-          query.where("this.value = 10").where(foo: 'bar')
-        end
+      it "sets the operator as $exists" do
+        expect(key.operator).to eq("$exists")
+      end
+    end
 
-        it 'combines conditions' do
-          expect(selection.selector).to eq(
-            "$where" => "this.value = 10", 'foo' => 'bar',
-          )
-        end
+    describe "#gt" do
+
+      let(:key) do
+        :field.gt
       end
 
-      context 'when called with hash argument and with string argument' do
+      it "returns a selection key" do
+        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
+      end
 
-        let(:selection) do
-          query.where(foo: 'bar').where("this.value = 10")
-        end
+      it "sets the name as the key" do
+        expect(key.name).to eq(:field)
+      end
 
-        it 'combines conditions' do
-          expect(selection.selector).to eq(
-            'foo' => 'bar', "$where" => "this.value = 10",
-          )
-        end
+      it "sets the operator as $gt" do
+        expect(key.operator).to eq("$gt")
       end
     end
 
-    context "when provided a single criterion" do
+    describe "#gte" do
 
-      context "when the value needs no evolution" do
+      let(:key) do
+        :field.gte
+      end
 
-        let(:selection) do
-          query.where(name: "Syd")
-        end
+      it "returns a selection key" do
+        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
+      end
 
-        it "adds the criterion to the selection" do
-          expect(selection.selector).to eq({ "name" => "Syd" })
-        end
+      it "sets the name as the key" do
+        expect(key.name).to eq(:field)
       end
 
-      context "when the value must be evolved" do
+      it "sets the operator as $gte" do
+        expect(key.operator).to eq("$gte")
+      end
+    end
 
-        before(:all) do
-          class Document
-            def id
-              13
-            end
-            def self.evolve(object)
-              object.id
-            end
-          end
-        end
+    describe "#in" do
 
-        after(:all) do
-          Object.send(:remove_const, :Document)
-        end
+      let(:key) do
+        :field.in
+      end
 
-        context "when the key needs evolution" do
+      it "returns a selection key" do
+        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
+      end
 
-          let(:query) do
-            Mongoid::Query.new({ "user" => "user_id" })
-          end
+      it "sets the name as the key" do
+        expect(key.name).to eq(:field)
+      end
 
-          let(:document) do
-            Document.new
-          end
+      it "sets the operator as $in" do
+        expect(key.operator).to eq("$in")
+      end
+    end
 
-          let(:selection) do
-            query.where(user: document)
-          end
+    describe "#lt" do
 
-          it "alters the key and value" do
-            expect(selection.selector).to eq({ "user_id" => document.id })
-          end
-        end
+      let(:key) do
+        :field.lt
+      end
 
-        context 'when the field is a String and the value is a BSON::Regexp::Raw' do
-
-          let(:raw_regexp) do
-            BSON::Regexp::Raw.new('^Em')
-          end
-
-          let(:selection) do
-            Login.where(_id: raw_regexp)
-          end
-
-          it 'does not convert the bson raw regexp object to a String' do
-            expect(selection.selector).to eq({ "_id" => raw_regexp })
-          end
-        end
-      end
-    end
-
-    context "when provided complex criterion" do
-
-      context "when performing an $all" do
-
-        context "when performing a single query" do
-
-          let(:selection) do
-            query.where(:field.all => [ 1, 2 ])
-          end
-
-          it "adds the $all criterion" do
-            expect(selection.selector).to eq({ "field" => { "$all" => [ 1, 2 ] }})
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-      end
-
-      context "when performing an $elemMatch" do
-
-        context "when the value is not complex" do
-
-          let(:selection) do
-            query.where(:field.elem_match => { key: 1 })
-          end
-
-          it "adds the $elemMatch criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$elemMatch" => { key: 1 } }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-
-        context "when the value is complex" do
-
-          let(:selection) do
-            query.where(:field.elem_match => { :key.gt => 1 })
-          end
-
-          it "adds the $elemMatch criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$elemMatch" => { "key" => { "$gt" => 1 }}}}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-      end
-
-      context "when performing an $exists" do
-
-        context "when providing boolean values" do
-
-          let(:selection) do
-            query.where(:field.exists => true)
-          end
-
-          it "adds the $exists criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$exists" => true }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-
-        context "when providing string values" do
-
-          let(:selection) do
-            query.where(:field.exists => "t")
-          end
-
-          it "adds the $exists criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$exists" => true }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-      end
-
-      context "when performing a $gt" do
-
-        let(:selection) do
-          query.where(:field.gt => 10)
-        end
-
-        it "adds the $gt criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$gt" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $gte" do
-
-        let(:selection) do
-          query.where(:field.gte => 10)
-        end
-
-        it "adds the $gte criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$gte" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing an $in" do
-
-        let(:selection) do
-          query.where(:field.in => [ 1, 2 ])
-        end
-
-        it "adds the $in criterion" do
-          expect(selection.selector).to eq({ "field" => { "$in" => [ 1, 2 ] }})
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $lt" do
-
-        let(:selection) do
-          query.where(:field.lt => 10)
-        end
-
-        it "adds the $lt criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$lt" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $lte" do
-
-        let(:selection) do
-          query.where(:field.lte => 10)
-        end
-
-        it "adds the $lte criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$lte" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $mod" do
-
-        let(:selection) do
-          query.where(:field.mod => [ 10, 1 ])
-        end
-
-        it "adds the $lte criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$mod" => [ 10, 1 ]}}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $ne" do
-
-        let(:selection) do
-          query.where(:field.ne => 10)
-        end
-
-        it "adds the $ne criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$ne" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $near" do
-
-        let(:selection) do
-          query.where(:field.near => [ 1, 1 ])
-        end
-
-        it "adds the $near criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$near" => [ 1, 1 ] }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $nearSphere" do
-
-        let(:selection) do
-          query.where(:field.near_sphere => [ 1, 1 ])
-        end
-
-        it "adds the $nearSphere criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$nearSphere" => [ 1, 1 ] }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $nin" do
-
-        let(:selection) do
-          query.where(:field.nin => [ 1, 2 ])
-        end
-
-        it "adds the $nin criterion" do
-          expect(selection.selector).to eq({ "field" => { "$nin" => [ 1, 2 ] }})
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $not" do
-
-        let(:selection) do
-          query.where(:field.not => /test/)
-        end
-
-        it "adds the $not criterion" do
-          expect(selection.selector).to eq({ "field" => { "$not" => /test/ }})
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $size" do
-
-        context "when providing an integer" do
-
-          let(:selection) do
-            query.where(:field.with_size => 10)
-          end
-
-          it "adds the $size criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$size" => 10 }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-
-        context "when providing a string" do
-
-          let(:selection) do
-            query.where(:field.with_size => "10")
-          end
-
-          it "adds the $size criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$size" => 10 }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-      end
-
-      context "when performing a $type" do
-
-        let(:selection) do
-          query.where(:field.with_type => 10)
-        end
-
-        it "adds the $type criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$type" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-    end
-
-    context 'when using an MQL logical operator manually' do
-      let(:base_query) do
-        query.where(test: 1)
-      end
-
-      let(:selection) do
-        base_query.where(mql_operator => ['hello' => 'world'])
-      end
-
-      shared_examples_for 'adds conditions to existing query' do
-        it 'adds conditions to existing query' do
-          selection.selector.should == {
-            'test' => 1,
-            mql_operator => ['hello' => 'world'],
-          }
-        end
-      end
-
-      shared_examples_for 'adds conditions to existing query with an extra $and' do
-        it 'adds conditions to existing query' do
-          selection.selector.should == {
-            'test' => 1,
-            mql_operator => ['hello' => 'world'],
-          }
-        end
-      end
-
-      context '$or' do
-        let(:mql_operator) { '$or' }
-
-        it_behaves_like 'adds conditions to existing query with an extra $and'
-      end
-
-      context '$nor' do
-        let(:mql_operator) { '$nor' }
-
-        it_behaves_like 'adds conditions to existing query with an extra $and'
-      end
-
-      context '$not' do
-        let(:mql_operator) { '$not' }
-
-        it_behaves_like 'adds conditions to existing query'
-      end
-
-      context '$and' do
-        let(:mql_operator) { '$and' }
-
-        it_behaves_like 'adds conditions to existing query'
-      end
-    end
-  end
-
-  describe Symbol do
-
-    describe "#all" do
-
-      let(:key) do
-        :field.all
-      end
-
-      it "returns a selecton key" do
-        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
-      end
-
-      it "sets the name as the key" do
-        expect(key.name).to eq(:field)
-      end
-
-      it "sets the operator as $all" do
-        expect(key.operator).to eq("$all")
-      end
-    end
-
-    describe "#elem_match" do
-
-      let(:key) do
-        :field.elem_match
-      end
-
-      it "returns a selecton key" do
-        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
-      end
-
-      it "sets the name as the key" do
-        expect(key.name).to eq(:field)
-      end
-
-      it "sets the operator as $elemMatch" do
-        expect(key.operator).to eq("$elemMatch")
-      end
-    end
-
-    describe "#exists" do
-
-      let(:key) do
-        :field.exists
-      end
-
-      it "returns a selecton key" do
-        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
-      end
-
-      it "sets the name as the key" do
-        expect(key.name).to eq(:field)
-      end
-
-      it "sets the operator as $exists" do
-        expect(key.operator).to eq("$exists")
-      end
-    end
-
-    describe "#gt" do
-
-      let(:key) do
-        :field.gt
-      end
-
-      it "returns a selecton key" do
-        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
-      end
-
-      it "sets the name as the key" do
-        expect(key.name).to eq(:field)
-      end
-
-      it "sets the operator as $gt" do
-        expect(key.operator).to eq("$gt")
-      end
-    end
-
-    describe "#gte" do
-
-      let(:key) do
-        :field.gte
-      end
-
-      it "returns a selecton key" do
-        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
-      end
-
-      it "sets the name as the key" do
-        expect(key.name).to eq(:field)
-      end
-
-      it "sets the operator as $gte" do
-        expect(key.operator).to eq("$gte")
-      end
-    end
-
-    describe "#in" do
-
-      let(:key) do
-        :field.in
-      end
-
-      it "returns a selecton key" do
-        expect(key).to be_a(Mongoid::Criteria::Queryable::Key)
-      end
-
-      it "sets the name as the key" do
-        expect(key.name).to eq(:field)
-      end
-
-      it "sets the operator as $in" do
-        expect(key.operator).to eq("$in")
-      end
-    end
-
-    describe "#lt" do
-
-      let(:key) 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
 
@@ -2645,7 +2200,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
 
@@ -2664,7 +2219,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
 
@@ -2683,7 +2238,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
 
@@ -2702,7 +2257,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
 
@@ -2721,7 +2276,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
 
@@ -2740,7 +2295,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
 
@@ -2779,7 +2334,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
 
@@ -2798,7 +2353,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
 
@@ -2857,4 +2412,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