mongoid 7.0.12 → 7.3.3

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

@@ -1,43 +1,263 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
+require_relative './selectable_shared_examples'
+
+class FieldWithSerializer
+  def evolve(object)
+    Integer.evolve(object)
+  end
+
+  def localized?
+    false
+  end
+end
 
 describe Mongoid::Criteria::Queryable::Selectable do
 
   let(:query) do
-   Mongoid::Query.new("id" => "_id")
+    Mongoid::Query.new("id" => "_id")
   end
 
-  shared_examples_for "a cloning selection" do
+  shared_examples_for 'supports merge strategies' do
+
+    context 'when the field is not aliased' do
+
+      context "when the strategy is not set" do
+
+        let(:selection) do
+          query.send(query_method, first: [ 1, 2 ]).send(query_method, first: [ 3, 4 ])
+        end
+
+        it "combines the conditions with $and" do
+          expect(selection.selector).to eq({
+            "first" => { operator => [ 1, 2 ] },
+            '$and' => [{'first' => {operator => [3, 4]}}],
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
+      end
+
+      context "when the strategy is intersect" do
+
+        let(:selection) do
+          query.send(query_method, first: [ 1, 2 ]).intersect.send(query_method, first: [ 2, 3 ])
+        end
+
+        it "intersects the conditions" do
+          expect(selection.selector).to eq({
+            "first" => { operator => [ 2 ] }
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
+      end
+
+      context "when the strategy is override" do
+
+        let(:selection) do
+          query.send(query_method, first: [ 1, 2 ]).override.send(query_method, first: [ 3, 4 ])
+        end
+
+        it "overwrites the first condition" do
+          expect(selection.selector).to eq({
+            "first" => { operator => [ 3, 4 ] }
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
+      end
+
+      context "when the strategy is union" do
+
+        let(:selection) do
+          query.send(query_method, first: [ 1, 2 ]).union.send(query_method, first: [ 3, 4 ])
+        end
+
+        it "unions the conditions" do
+          expect(selection.selector).to eq({
+            "first" => { operator => [ 1, 2, 3, 4 ] }
+          })
+        end
 
-    it "returns a cloned query" do
-      expect(selection).to_not equal(query)
+        it_behaves_like "returns a cloned query"
+      end
     end
-  end
 
-  describe "#all" do
+    context 'when the field is aliased' do
 
-    context "when provided no criterion" do
+      context "when the strategy is not set" do
 
-      let(:selection) do
-        query.all
+        let(:selection) do
+          query.send(query_method, id: [ 1, 2 ]).send(query_method, _id: [ 3, 4 ])
+        end
+
+        it "combines the conditions with $and" do
+          expect(selection.selector).to eq({
+            "_id" => { operator => [ 1, 2 ] },
+            '$and' => [{'_id' => {operator => [3, 4]}}],
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
       end
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
+      context "when the strategy is intersect" do
+
+        let(:selection) do
+          query.send(query_method, id: [ 1, 2 ]).intersect.send(query_method, _id: [ 2, 3 ])
+        end
+
+        it "intersects the conditions" do
+          expect(selection.selector).to eq({
+            "_id" => { operator => [ 2 ] }
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
       end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
+      context "when the strategy is override" do
+
+        let(:selection) do
+          query.send(query_method, _id: [ 1, 2 ]).override.send(query_method, id: [ 3, 4 ])
+        end
+
+        it "overwrites the first condition" do
+          expect(selection.selector).to eq({
+            "_id" => { operator => [ 3, 4 ] }
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
       end
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
+      context "when the strategy is union" do
+
+        let(:selection) do
+          query.send(query_method, _id: [ 1, 2 ]).union.send(query_method, id: [ 3, 4 ])
+        end
+
+        it "unions the conditions" do
+          expect(selection.selector).to eq({
+            "_id" => { operator => [ 1, 2, 3, 4 ] }
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
+      end
+    end
+
+    context 'when the field uses a serializer' do
+
+      let(:query) do
+        Mongoid::Query.new({}, { "field" => FieldWithSerializer.new })
+      end
+
+
+      context "when the strategy is not set" do
+
+        let(:selection) do
+          query.send(query_method, field: [ '1', '2' ]).send(query_method, field: [ '3', '4' ])
+        end
+
+        it "combines the conditions with $and" do
+          expect(selection.selector).to eq({
+            "field" => { operator => [ 1, 2 ] },
+            '$and' => [{'field' => {operator => [3, 4]}}],
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
+      end
+
+      context "when the strategy is set" do
+
+        let(:selection) do
+          query.send(query_method, field: [ '1', '2' ]).intersect.send(query_method, field: [ '2', '3' ])
+        end
+
+        it "intersects the conditions" do
+          expect(selection.selector).to eq({
+            "field" => { operator => [ 2 ] }
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
+      end
+    end
+
+    context 'when operator value is a Range' do
+
+      context "when there is no existing condition and strategy is not specified" do
+
+        let(:selection) do
+          query.send(query_method, foo: 2..4)
+        end
+
+        it 'expands range to array' do
+          expect(selection.selector).to eq({
+            "foo" => { operator => [ 2, 3, 4 ] }
+          })
+
+        end
+      end
+
+      context "when there is no existing condition and strategy is specified" do
+
+        let(:selection) do
+          query.union.send(query_method, foo: 2..4)
+        end
+
+        it 'expands range to array' do
+          expect(selection.selector).to eq({
+            "foo" => { operator => [ 2, 3, 4 ] }
+          })
+
+        end
+      end
+
+      context "when existing condition has Array value" do
+
+        let(:selection) do
+          query.send(query_method, foo: [ 1, 2 ]).union.send(query_method, foo: 2..4)
+        end
+
+        it 'expands range to array' do
+          expect(selection.selector).to eq({
+            "foo" => { operator => [ 1, 2, 3, 4 ] }
+          })
+
+        end
+      end
+
+      context "when existing condition has Range value" do
+
+        let(:selection) do
+          query.send(query_method, foo: 1..2).union.send(query_method, foo: 2..4)
+        end
+
+        it 'expands range to array' do
+          expect(selection.selector).to eq({
+            "foo" => { operator => [ 1, 2, 3, 4 ] }
+          })
+
+        end
       end
     end
+  end
 
-    context "when provided nil" do
+  describe "#all" do
+
+    let(:query_method) { :all }
+    let(:operator) { '$all' }
+
+    context "when provided no criterion" do
 
       let(:selection) do
-        query.all(nil)
+        query.all
       end
 
       it "does not add any criterion" do
@@ -53,6 +273,8 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
     end
 
+    it_behaves_like 'requires a non-nil argument'
+
     context "when provided a single criterion" do
 
       context "when no serializers are provided" do
@@ -74,23 +296,6 @@ describe Mongoid::Criteria::Queryable::Selectable do
           end
         end
 
-        context "when providing a range" do
-
-          let(:selection) do
-            query.all(field: 1..3)
-          end
-
-          it "adds the $all selector with converted range" do
-            expect(selection.selector).to eq({
-              "field" => { "$all" => [ 1, 2, 3 ] }
-            })
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
-
         context "when providing a single value" do
 
           let(:selection) do
@@ -147,23 +352,6 @@ describe Mongoid::Criteria::Queryable::Selectable do
           end
         end
 
-        context "when providing a range" do
-
-          let(:selection) do
-            query.all(field: "1".."3")
-          end
-
-          it "adds the $all selector with converted range" do
-            expect(selection.selector).to eq({
-              "field" => { "$all" => [ 1, 2, 3 ] }
-            })
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
-
         context "when providing a single value" do
 
           let(:selection) do
@@ -226,1926 +414,75 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context "when the criterion are on the same field" do
 
-        context "when no serializers are provided" do
+        it_behaves_like 'supports merge strategies'
+      end
+    end
+  end
 
-          context "when the strategy is the default (union)" do
+  describe "#between" do
 
-            let(:selection) do
-              query.all(first: [ 1, 2 ]).all(first: [ 3, 4 ])
-            end
+    let(:query_method) { :between }
 
-            it "overwrites the first $all selector" do
-              expect(selection.selector).to eq({
-                "first" => { "$all" => [ 1, 2, 3, 4 ] }
-              })
-            end
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-            it "returns a cloned query" do
-              expect(selection).to_not equal(query)
-            end
-          end
+    context "when provided a single range" do
 
-          context "when the strategy is intersect" do
+      let(:selection) do
+        query.between(field: 1..10)
+      end
 
-            let(:selection) do
-              query.all(first: [ 1, 2 ]).intersect.all(first: [ 2, 3 ])
-            end
+      it "adds the $gte and $lte selectors" do
+        expect(selection.selector).to eq({
+          "field" => { "$gte" => 1, "$lte" => 10 }
+        })
+      end
 
-            it "intersects the $all selectors" do
-              expect(selection.selector).to eq({
-                "first" => { "$all" => [ 2 ] }
-              })
-            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)
-            end
-          end
+    context "when provided multiple ranges" do
 
-          context "when the strategy is override" do
+      context "when the ranges are on different fields" do
 
-            let(:selection) do
-              query.all(first: [ 1, 2 ]).override.all(first: [ 3, 4 ])
-            end
+        let(:selection) do
+          query.between(field: 1..10, key: 5..7)
+        end
 
-            it "overwrites the first $all selector" do
-              expect(selection.selector).to eq({
-                "first" => { "$all" => [ 3, 4 ] }
-              })
-            end
+        it "adds the $gte and $lte selectors" do
+          expect(selection.selector).to eq({
+            "field" => { "$gte" => 1, "$lte" => 10 },
+            "key" => { "$gte" => 5, "$lte" => 7 }
+          })
+        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)
+        end
+      end
+    end
+  end
 
-          context "when the strategy is union" do
+  describe "#elem_match" do
 
-            let(:selection) do
-              query.all(first: [ 1, 2 ]).union.all(first: [ 3, 4 ])
-            end
+    let(:query_method) { :elem_match }
 
-            it "unions the $all selectors" do
-              expect(selection.selector).to eq({
-                "first" => { "$all" => [ 1, 2, 3, 4 ] }
-              })
-            end
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-            it "returns a cloned query" do
-              expect(selection).to_not equal(query)
-            end
-          end
-        end
+    context "when provided a criterion" do
 
-        context "when serializers are provided" do
-
-          before(:all) do
-            class Field
-              def evolve(object)
-                Integer.evolve(object)
-              end
-              def localized?
-                false
-              end
-            end
-          end
-
-          after(:all) do
-            Object.send(:remove_const, :Field)
-          end
-
-          let!(:query) do
-            Mongoid::Query.new({}, { "field" => Field.new })
-          end
-
-          context "when the strategy is the default (union)" do
-
-            let(:selection) do
-              query.all(field: [ "1", "2" ]).all(field: [ "3", "4" ])
-            end
-
-            it "overwrites the field $all selector" do
-              expect(selection.selector).to eq({
-                "field" => { "$all" => [ 1, 2, 3, 4 ] }
-              })
-            end
-
-            it "returns a cloned query" do
-              expect(selection).to_not equal(query)
-            end
-          end
-
-          context "when the strategy is intersect" do
-
-            let(:selection) do
-              query.all(field: [ "1", "2" ]).intersect.all(field: [ "2", "3" ])
-            end
-
-            it "intersects the $all selectors" do
-              expect(selection.selector).to eq({
-                "field" => { "$all" => [ 2 ] }
-              })
-            end
-
-            it "returns a cloned query" do
-              expect(selection).to_not equal(query)
-            end
-          end
-
-          context "when the strategy is override" do
-
-            let(:selection) do
-              query.all(field: [ "1", "2" ]).override.all(field: [ "3", "4" ])
-            end
-
-            it "overwrites the field $all selector" do
-              expect(selection.selector).to eq({
-                "field" => { "$all" => [ 3, 4 ] }
-              })
-            end
-
-            it "returns a cloned query" do
-              expect(selection).to_not equal(query)
-            end
-          end
-
-          context "when the strategy is union" do
-
-            let(:selection) do
-              query.all(field: [ "1", "2" ]).union.all(field: [ "3", "4" ])
-            end
-
-            it "unions the $all selectors" do
-              expect(selection.selector).to eq({
-                "field" => { "$all" => [ 1, 2, 3, 4 ] }
-              })
-            end
-
-            it "returns a cloned query" do
-              expect(selection).to_not equal(query)
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe "#and" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.and
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.and(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a single criterion" do
-
-      let(:selection) do
-        query.and(field: [ 1, 2 ])
-      end
-
-      it "adds the $and selector" do
-        expect(selection.selector).to eq({
-          "$and" => [{ "field" => [ 1, 2 ] }]
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a nested criterion" do
-
-      let(:selection) do
-        query.and(:test.elem_match => { :field.in => [ 1, 2 ] })
-      end
-
-      it "adds the $and selector" do
-        expect(selection.selector).to eq({
-          "$and" => [{ "test" => { "$elemMatch" => { "field" => { "$in" => [ 1, 2 ] }}}}]
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided multiple criterion" do
-
-      context "when the criterion is already included" do
-
-        let(:selection) do
-          query.and({ first: [ 1, 2 ] }).and({ first: [ 1, 2 ] })
-        end
-
-        it "does not duplicate the $and selector" do
-          expect(selection.selector).to eq({
-            "$and" => [
-              { "first" => [ 1, 2 ] }
-            ]
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.and({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
-        end
-
-        it "adds the $and selector" do
-          expect(selection.selector).to eq({
-            "$and" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are on the same field" do
-
-        let(:selection) do
-          query.and({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
-        end
-
-        it "appends both $and expressions" do
-          expect(selection.selector).to eq({
-            "$and" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining the criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.and(first: [ 1, 2 ]).and(second: [ 3, 4 ])
-        end
-
-        it "adds the $and selectors" do
-          expect(selection.selector).to eq({
-            "$and" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are on the same field" do
-
-        let(:selection) do
-          query.and(first: [ 1, 2 ]).and(first: [ 3, 4 ])
-        end
-
-        it "appends both $and expressions" do
-          expect(selection.selector).to eq({
-            "$and" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#between" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.between
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.between(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a single range" do
-
-      let(:selection) do
-        query.between(field: 1..10)
-      end
-
-      it "adds the $gte and $lte selectors" do
-        expect(selection.selector).to eq({
-          "field" => { "$gte" => 1, "$lte" => 10 }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided multiple ranges" do
-
-      context "when the ranges are on different fields" do
-
-        let(:selection) do
-          query.between(field: 1..10, key: 5..7)
-        end
-
-        it "adds the $gte and $lte selectors" do
-          expect(selection.selector).to eq({
-            "field" => { "$gte" => 1, "$lte" => 10 },
-            "key" => { "$gte" => 5, "$lte" => 7 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#elem_match" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.elem_match
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.elem_match(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a criterion" do
-
-      context "when there are no nested complex keys" do
-
-        let(:selection) do
-          query.elem_match(users: { name: "value" })
-        end
-
-        it "adds the $elemMatch expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$elemMatch" => { name: "value" }}
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when there are nested complex keys" do
-
-        let(:time) do
-          Time.now
-        end
-
-        let(:selection) do
-          query.elem_match(users: { :time.gt => time })
-        end
-
-        it "adds the $elemMatch expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$elemMatch" => { "time" => { "$gt" => time }}}
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when providing multiple criteria" do
-
-      context "when the fields differ" do
-
-        let(:selection) do
-          query.elem_match(
-            users: { name: "value" },
-            comments: { text: "value" }
-          )
-        end
-
-        it "adds the $elemMatch expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$elemMatch" => { name: "value" }},
-            "comments" => { "$elemMatch" => { text: "value" }}
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining multiple criteria" do
-
-      context "when the fields differ" do
-
-        let(:selection) do
-          query.
-            elem_match(users: { name: "value" }).
-            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" }}
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the fields are the same" do
-
-        let(:selection) do
-          query.
-            elem_match(users: { name: "value" }).
-            elem_match(users: { state: "new" })
-        end
-
-        it "overrides the $elemMatch expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$elemMatch" => { state: "new" }}
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#exists" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.exists
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.exists(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a criterion" do
-
-      context "when provided a boolean" do
-
-        let(:selection) do
-          query.exists(users: true)
-        end
-
-        it "adds the $exists expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$exists" => true }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when provided a string" do
-
-        let(:selection) do
-          query.exists(users: "yes")
-        end
-
-        it "adds the $exists expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$exists" => true }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when providing multiple criteria" do
-
-      context "when the fields differ" do
-
-        context "when providing boolean values" do
-
-          let(:selection) do
-            query.exists(
-              users: true,
-              comments: true
-            )
-          end
-
-          it "adds the $exists expression" do
-            expect(selection.selector).to eq({
-              "users" => { "$exists" => true },
-              "comments" => { "$exists" => true }
-            })
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
-
-        context "when providing string values" do
-
-          let(:selection) do
-            query.exists(
-              users: "y",
-              comments: "true"
-            )
-          end
-
-          it "adds the $exists expression" do
-            expect(selection.selector).to eq({
-              "users" => { "$exists" => true },
-              "comments" => { "$exists" => true }
-            })
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
-      end
-    end
-
-    context "when chaining multiple criteria" do
-
-      context "when the fields differ" do
-
-        let(:selection) do
-          query.
-            exists(users: true).
-            exists(comments: true)
-        end
-
-        it "adds the $exists expression" do
-          expect(selection.selector).to eq({
-            "users" => { "$exists" => true },
-            "comments" => { "$exists" => true }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#geo_spacial" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.geo_spacial
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to be_empty
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it_behaves_like "a cloning selection"
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.geo_spacial(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to be_empty
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it_behaves_like "a cloning selection"
-    end
-
-    context "when provided a criterion" do
-
-      context "when the geometry is a point intersection" do
-
-        let(:selection) do
-          query.geo_spacial(:location.intersects_point => [ 1, 10 ])
-        end
-
-        it "adds the $geoIntersects expression" do
-          expect(selection.selector).to eq({
-            "location" => {
-              "$geoIntersects" => {
-                "$geometry" => {
-                  "type" => "Point",
-                  "coordinates" => [ 1, 10 ]
-                }
-              }
-            }
-          })
-        end
-
-        it_behaves_like "a cloning selection"
-      end
-
-      context "when the geometry is a line intersection" do
-
-        let(:selection) do
-          query.geo_spacial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
-        end
-
-        it "adds the $geoIntersects expression" do
-          expect(selection.selector).to eq({
-            "location" => {
-              "$geoIntersects" => {
-                "$geometry" => {
-                  "type" => "LineString",
-                  "coordinates" => [[ 1, 10 ], [ 2, 10 ]]
-                }
-              }
-            }
-          })
-        end
-
-        it_behaves_like "a cloning selection"
-      end
-
-      context "when the geometry is a polygon intersection" do
-
-        let(:selection) do
-          query.geo_spacial(
-            :location.intersects_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-          )
-        end
-
-        it "adds the $geoIntersects expression" do
-          expect(selection.selector).to eq({
-            "location" => {
-              "$geoIntersects" => {
-                "$geometry" => {
-                  "type" => "Polygon",
-                  "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-                }
-              }
-            }
-          })
-        end
-
-        it_behaves_like "a cloning selection"
-      end
-
-      context "when the geometry is within a polygon" do
-
-        let(:selection) do
-          query.geo_spacial(
-            :location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-          )
-        end
-
-        it "adds the $geoIntersects expression" do
-          expect(selection.selector).to eq({
-            "location" => {
-              "$geoWithin" => {
-                "$geometry" => {
-                  "type" => "Polygon",
-                  "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-                }
-              }
-            }
-          })
-        end
-
-        context "when used with the $box operator ($geoWithin query) " do
-          let(:selection) do
-            query.geo_spacial(
-              :location.within_box => [[ 1, 10 ], [ 2, 10 ]]
-            )
-          end
-
-          it "adds the $geoIntersects expression" do
-            expect(selection.selector).to eq({
-              "location" => {
-                "$geoWithin" => {
-                  "$box" => [
-                    [ 1, 10 ], [ 2, 10 ]
-                  ]
-                }
-              }
-            })
-          end
-        end
-
-        it_behaves_like "a cloning selection"
-      end
-    end
-  end
-
-  describe "#gt" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.gt
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.gt(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a single criterion" do
-
-      let(:selection) do
-        query.gt(field: 10)
-      end
-
-      it "adds the $gt selector" do
-        expect(selection.selector).to eq({
-          "field" => { "$gt" => 10 }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided multiple criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.gt(first: 10, second: 15)
-        end
-
-        it "adds the $gt selectors" do
-          expect(selection.selector).to eq({
-            "first" => { "$gt" => 10 },
-            "second" => { "$gt" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining the criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.gt(first: 10).gt(second: 15)
-        end
-
-        it "adds the $gt selectors" do
-          expect(selection.selector).to eq({
-            "first" => { "$gt" => 10 },
-            "second" => { "$gt" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are on the same field" do
-
-        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
-    end
-  end
-
-  describe "#gte" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.gte
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.gte(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a single criterion" do
-
-      let(:selection) do
-        query.gte(field: 10)
-      end
-
-      it "adds the $gte selector" do
-        expect(selection.selector).to eq({
-          "field" => { "$gte" => 10 }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided multiple criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.gte(first: 10, second: 15)
-        end
-
-        it "adds the $gte selectors" do
-          expect(selection.selector).to eq({
-            "first" => { "$gte" => 10 },
-            "second" => { "$gte" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining the criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.gte(first: 10).gte(second: 15)
-        end
-
-        it "adds the $gte selectors" do
-          expect(selection.selector).to eq({
-            "first" => { "$gte" => 10 },
-            "second" => { "$gte" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are on the same field" do
-
-        let(:selection) do
-          query.gte(first: 10).gte(first: 15)
-        end
-
-        it "overwrites the first $gte selector" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$gte" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#in" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.in
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.in(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a single criterion" do
-
-      context "when providing an array" do
-
-        let(:selection) do
-          query.in(field: [ 1, 2 ])
-        end
-
-        it "adds the $in selector" do
-          expect(selection.selector).to eq({
-            "field" =>  { "$in" => [ 1, 2 ] }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when providing a range" do
-
-        let(:selection) do
-          query.in(field: 1..3)
-        end
-
-        it "adds the $in selector with converted range" do
-          expect(selection.selector).to eq({
-            "field" =>  { "$in" => [ 1, 2, 3 ] }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when providing a single value" do
-
-        let(:selection) do
-          query.in(field: 1)
-        end
-
-        it "adds the $in selector with wrapped value" do
-          expect(selection.selector).to eq({
-            "field" =>  { "$in" => [ 1 ] }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when provided multiple criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.in(first: [ 1, 2 ], second: 3..4)
-        end
-
-        it "adds the $in selectors" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$in" => [ 1, 2 ] },
-            "second" =>  { "$in" => [ 3, 4 ] }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining the criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.in(first: [ 1, 2 ]).in(second: [ 3, 4 ])
-        end
-
-        it "adds the $in selectors" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$in" => [ 1, 2 ] },
-            "second" =>  { "$in" => [ 3, 4 ] }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are on the same field" do
-
-        context "when the strategy is the default (intersection)" do
-
-          let(:selection) do
-            query.in(first: [ 1, 2 ].freeze).in(first: [ 2, 3 ])
-          end
-
-          it "intersects the $in selectors" do
-            expect(selection.selector).to eq({
-              "first" =>  { "$in" => [ 2 ] }
-            })
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
-
-        context 'when the field is aliased' do
-
-          before(:all) do
-            class TestModel
-              include Mongoid::Document
-            end
-          end
-
-          after(:all) do
-            Object.send(:remove_const, :TestModel)
-          end
-
-          let(:bson_object_id) do
-            BSON::ObjectId.new
-          end
-
-          let(:selection) do
-            TestModel.in(id: [bson_object_id.to_s]).in(id: [bson_object_id.to_s])
-          end
-
-          it "intersects the $in selectors" do
-            expect(selection.selector).to eq("_id" =>  { "$in" => [ bson_object_id ] })
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
-
-        context "when the stretegy is intersect" do
-
-          let(:selection) do
-            query.in(first: [ 1, 2 ]).intersect.in(first: [ 2, 3 ])
-          end
-
-          it "intersects the $in selectors" do
-            expect(selection.selector).to eq({
-              "first" =>  { "$in" => [ 2 ] }
-            })
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
-
-        context "when the strategy is override" do
-
-          let(:selection) do
-            query.in(first: [ 1, 2 ]).override.in(first: [ 3, 4 ])
-          end
-
-          it "overwrites the first $in selector" do
-            expect(selection.selector).to eq({
-              "first" =>  { "$in" => [ 3, 4 ] }
-            })
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
-
-        context "when the strategy is union" do
-
-          let(:selection) do
-            query.in(first: [ 1, 2 ]).union.in(first: [ 3, 4 ])
-          end
-
-          it "unions the $in selectors" do
-            expect(selection.selector).to eq({
-              "first" =>  { "$in" => [ 1, 2, 3, 4 ] }
-            })
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#lt" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.lt
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.lt(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a single criterion" do
-
-      let(:selection) do
-        query.lt(field: 10)
-      end
-
-      it "adds the $lt selector" do
-        expect(selection.selector).to eq({
-          "field" =>  { "$lt" => 10 }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided multiple criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.lt(first: 10, second: 15)
-        end
-
-        it "adds the $lt selectors" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$lt" => 10 },
-            "second" =>  { "$lt" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining the criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.lt(first: 10).lt(second: 15)
-        end
-
-        it "adds the $lt selectors" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$lt" => 10 },
-            "second" =>  { "$lt" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are on the same field" do
-
-        let(:selection) do
-          query.lt(first: 10).lt(first: 15)
-        end
-
-        it "overwrites the first $lt selector" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$lt" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#lte" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.lte
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.lte(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a single criterion" do
-
-      let(:selection) do
-        query.lte(field: 10)
-      end
-
-      it "adds the $lte selector" do
-        expect(selection.selector).to eq({
-          "field" =>  { "$lte" => 10 }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided multiple criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.lte(first: 10, second: 15)
-        end
-
-        it "adds the $lte selectors" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$lte" => 10 },
-            "second" =>  { "$lte" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining the criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.lte(first: 10).lte(second: 15)
-        end
-
-        it "adds the $lte selectors" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$lte" => 10 },
-            "second" =>  { "$lte" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are on the same field" do
-
-        let(:selection) do
-          query.lte(first: 10).lte(first: 15)
-        end
-
-        it "overwrites the first $lte selector" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$lte" => 15 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#max_distance" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.max_distance
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.max_distance(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a criterion" do
-
-      context "when a $near criterion exists on the same field" do
-
-        let(:selection) do
-          query.near(location: [ 1, 1 ]).max_distance(location: 50)
-        end
-
-        it "adds the $maxDistance expression" do
-          expect(selection.selector).to eq({
-            "location" =>  { "$near" => [ 1, 1 ], "$maxDistance" => 50 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#mod" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.mod
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.mod(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a criterion" do
-
-      let(:selection) do
-        query.mod(value: [ 10, 1 ])
-      end
-
-      it "adds the $mod expression" do
-        expect(selection.selector).to eq({
-          "value" =>  { "$mod" => [ 10, 1 ] }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when providing multiple criteria" do
-
-      context "when the fields differ" do
-
-        let(:selection) do
-          query.mod(
-            value: [ 10, 1 ],
-            comments: [ 10, 1 ]
-          )
-        end
-
-        it "adds the $mod expression" do
-          expect(selection.selector).to eq({
-            "value" =>  { "$mod" => [ 10, 1 ] },
-            "comments" =>  { "$mod" => [ 10, 1 ] }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining multiple criteria" do
-
-      context "when the fields differ" do
-
-        let(:selection) do
-          query.
-            mod(value: [ 10, 1 ]).
-            mod(result: [ 10, 1 ])
-        end
-
-        it "adds the $mod expression" do
-          expect(selection.selector).to eq({
-            "value" =>  { "$mod" => [ 10, 1 ] },
-            "result" =>  { "$mod" => [ 10, 1 ] }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#ne" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.ne
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.ne(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a criterion" do
-
-      let(:selection) do
-        query.ne(value: 10)
-      end
-
-      it "adds the $ne expression" do
-        expect(selection.selector).to eq({
-          "value" =>  { "$ne" => 10 }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when providing multiple criteria" do
-
-      context "when the fields differ" do
-
-        let(:selection) do
-          query.ne(
-            value: 10,
-            comments: 10
-          )
-        end
-
-        it "adds the $ne expression" do
-          expect(selection.selector).to eq({
-            "value" =>  { "$ne" => 10 },
-            "comments" =>  { "$ne" => 10 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining multiple criteria" do
-
-      context "when the fields differ" do
-
-        let(:selection) do
-          query.
-            ne(value: 10).
-            ne(result: 10)
-        end
-
-        it "adds the $ne expression" do
-          expect(selection.selector).to eq({
-            "value" =>  { "$ne" => 10 },
-            "result" =>  { "$ne" => 10 }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#near" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.near
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.near(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a criterion" do
-
-      let(:selection) do
-        query.near(location: [ 20, 21 ])
-      end
-
-      it "adds the $near expression" do
-        expect(selection.selector).to eq({
-          "location" =>  { "$near" => [ 20, 21 ] }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when providing multiple criteria" do
-
-      context "when the fields differ" do
+      context "when there are no nested complex keys" do
 
         let(:selection) do
-          query.near(
-            location: [ 20, 21 ],
-            comments: [ 20, 21 ]
-          )
+          query.elem_match(users: { name: "value" })
         end
 
-        it "adds the $near expression" do
+        it "adds the $elemMatch expression" do
           expect(selection.selector).to eq({
-            "location" =>  { "$near" => [ 20, 21 ] },
-            "comments" =>  { "$near" => [ 20, 21 ] }
+            "users" => { "$elemMatch" => { name: "value" }}
           })
         end
 
@@ -2153,22 +490,20 @@ describe Mongoid::Criteria::Queryable::Selectable do
           expect(selection).to_not equal(query)
         end
       end
-    end
 
-    context "when chaining multiple criteria" do
+      context "when there are nested complex keys" do
 
-      context "when the fields differ" do
+        let(:time) do
+          Time.now
+        end
 
         let(:selection) do
-          query.
-            near(location: [ 20, 21 ]).
-            near(comments: [ 20, 21 ])
+          query.elem_match(users: { :time.gt => time })
         end
 
-        it "adds the $near expression" do
+        it "adds the $elemMatch expression" do
           expect(selection.selector).to eq({
-            "location" =>  { "$near" => [ 20, 21 ] },
-            "comments" =>  { "$near" => [ 20, 21 ] }
+            "users" => { "$elemMatch" => { "time" => { "$gt" => time }}}
           })
         end
 
@@ -2177,80 +512,22 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
-  end
-
-  describe "#near_sphere" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.near_sphere
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.near_sphere(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a criterion" do
-
-      let(:selection) do
-        query.near_sphere(location: [ 20, 21 ])
-      end
-
-      it "adds the $nearSphere expression" do
-        expect(selection.selector).to eq({
-          "location" =>  { "$nearSphere" => [ 20, 21 ] }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
 
     context "when providing multiple criteria" do
 
       context "when the fields differ" do
 
         let(:selection) do
-          query.near_sphere(
-            location: [ 20, 21 ],
-            comments: [ 20, 21 ]
+          query.elem_match(
+            users: { name: "value" },
+            comments: { text: "value" }
           )
         end
 
-        it "adds the $nearSphere expression" do
+        it "adds the $elemMatch expression" do
           expect(selection.selector).to eq({
-            "location" =>  { "$nearSphere" => [ 20, 21 ] },
-            "comments" =>  { "$nearSphere" => [ 20, 21 ] }
+            "users" => { "$elemMatch" => { name: "value" }},
+            "comments" => { "$elemMatch" => { text: "value" }}
           })
         end
 
@@ -2266,92 +543,14 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         let(:selection) do
           query.
-            near_sphere(location: [ 20, 21 ]).
-            near_sphere(comments: [ 20, 21 ])
-        end
-
-        it "adds the $nearSphere expression" do
-          expect(selection.selector).to eq({
-            "location" =>  { "$nearSphere" => [ 20, 21 ] },
-            "comments" =>  { "$nearSphere" => [ 20, 21 ] }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
-  describe "#nin" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.nin
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.nin(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a single criterion" do
-
-      context "when providing an array" do
-
-        let(:selection) do
-          query.nin(field: [ 1, 2 ])
-        end
-
-        it "adds the $nin selector" do
-          expect(selection.selector).to eq({
-            "field" =>  { "$nin" => [ 1, 2 ] }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when providing a range" do
-
-        let(:selection) do
-          query.nin(field: 1..3)
+            elem_match(users: { name: "value" }).
+            elem_match(comments: { text: "value" })
         end
 
-        it "adds the $nin selector with converted range" do
+        it "adds the $elemMatch expression" do
           expect(selection.selector).to eq({
-            "field" =>  { "$nin" => [ 1, 2, 3 ] }
+            "users" => { "$elemMatch" => { name: "value" }},
+            "comments" => { "$elemMatch" => { text: "value" }}
           })
         end
 
@@ -2360,15 +559,17 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
 
-      context "when providing a single value" do
+      context "when the fields are the same" do
 
         let(:selection) do
-          query.nin(field: 1)
+          query.
+            elem_match(users: { name: "value" }).
+            elem_match(users: { state: "new" })
         end
 
-        it "adds the $nin selector with wrapped value" do
+        it "overrides the $elemMatch expression" do
           expect(selection.selector).to eq({
-            "field" =>  { "$nin" => [ 1 ] }
+            "users" => { "$elemMatch" => { state: "new" }}
           })
         end
 
@@ -2377,48 +578,26 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
+  end
 
-    context "when unioning on the same field" do
-
-      context "when the field is not aliased" do
-
-        let(:selection) do
-          query.nin(first: [ 1, 2 ]).union.nin(first: [ 3, 4 ])
-        end
-
-        it "unions the selection on the field" do
-          expect(selection.selector).to eq(
-            { "first" => { "$nin" => [ 1, 2, 3, 4 ]}}
-          )
-        end
-      end
-
-      context "when the field is aliased" do
-
-        let(:selection) do
-          query.nin(id: [ 1, 2 ]).union.nin(id: [ 3, 4 ])
-        end
-
-        it "unions the selection on the field" do
-          expect(selection.selector).to eq(
-            { "_id" => { "$nin" => [ 1, 2, 3, 4 ]}}
-          )
-        end
-      end
-    end
-
-    context "when provided multiple criterion" do
+  describe "#exists" do
 
-      context "when the criterion are for different fields" do
+    let(:query_method) { :exists }
+
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
+
+    context "when provided a criterion" do
+
+      context "when provided a boolean" do
 
         let(:selection) do
-          query.nin(first: [ 1, 2 ], second: [ 3, 4 ])
+          query.exists(users: true)
         end
 
-        it "adds the $nin selectors" do
+        it "adds the $exists expression" do
           expect(selection.selector).to eq({
-            "first" =>  { "$nin" => [ 1, 2 ] },
-            "second" =>  { "$nin" => [ 3, 4 ] }
+            "users" => { "$exists" => true }
           })
         end
 
@@ -2426,20 +605,16 @@ describe Mongoid::Criteria::Queryable::Selectable do
           expect(selection).to_not equal(query)
         end
       end
-    end
-
-    context "when chaining the criterion" do
 
-      context "when the criterion are for different fields" do
+      context "when provided a string" do
 
         let(:selection) do
-          query.nin(first: [ 1, 2 ]).nin(second: [ 3, 4 ])
+          query.exists(users: "yes")
         end
 
-        it "adds the $nin selectors" do
+        it "adds the $exists expression" do
           expect(selection.selector).to eq({
-            "first" => { "$nin" => [ 1, 2 ] },
-            "second" => { "$nin" => [ 3, 4 ] }
+            "users" => { "$exists" => true }
           })
         end
 
@@ -2447,18 +622,25 @@ describe Mongoid::Criteria::Queryable::Selectable do
           expect(selection).to_not equal(query)
         end
       end
+    end
 
-      context "when the criterion are on the same field" do
+    context "when providing multiple criteria" do
+
+      context "when the fields differ" do
 
-        context "when the stretegy is the default (intersection)" do
+        context "when providing boolean values" do
 
           let(:selection) do
-            query.nin(first: [ 1, 2 ]).nin(first: [ 2, 3 ])
+            query.exists(
+              users: true,
+              comments: true
+            )
           end
 
-          it "intersects the $nin selectors" do
+          it "adds the $exists expression" do
             expect(selection.selector).to eq({
-              "first" => { "$nin" => [ 2 ] }
+              "users" => { "$exists" => true },
+              "comments" => { "$exists" => true }
             })
           end
 
@@ -2467,15 +649,19 @@ describe Mongoid::Criteria::Queryable::Selectable do
           end
         end
 
-        context "when the stretegy is intersect" do
+        context "when providing string values" do
 
           let(:selection) do
-            query.nin(first: [ 1, 2 ]).intersect.nin(first: [ 2, 3 ])
+            query.exists(
+              users: "y",
+              comments: "true"
+            )
           end
 
-          it "intersects the $nin selectors" do
+          it "adds the $exists expression" do
             expect(selection.selector).to eq({
-              "first" => { "$nin" => [ 2 ] }
+              "users" => { "$exists" => true },
+              "comments" => { "$exists" => true }
             })
           end
 
@@ -2483,93 +669,174 @@ describe Mongoid::Criteria::Queryable::Selectable do
             expect(selection).to_not equal(query)
           end
         end
+      end
+    end
+
+    context "when chaining multiple criteria" do
+
+      context "when the fields differ" do
+
+        let(:selection) do
+          query.
+            exists(users: true).
+            exists(comments: true)
+        end
+
+        it "adds the $exists expression" do
+          expect(selection.selector).to eq({
+            "users" => { "$exists" => true },
+            "comments" => { "$exists" => true }
+          })
+        end
+
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
+        end
+      end
+    end
+  end
+
+  %i(geo_spatial geo_spacial).each do |meth|
+    describe "#geo_spacial" do
 
-        context "when the stretegy is override" do
+      let(:query_method) { meth }
+
+      it_behaves_like 'requires an argument'
+      it_behaves_like 'requires a non-nil argument'
+
+      context "when provided a criterion" do
+
+        context "when the geometry is a point intersection" do
 
           let(:selection) do
-            query.nin(first: [ 1, 2 ]).override.nin(first: [ 3, 4 ])
+            query.public_send(query_method, :location.intersects_point => [ 1, 10 ])
           end
 
-          it "overwrites the first $nin selector" do
+          it "adds the $geoIntersects expression" do
             expect(selection.selector).to eq({
-              "first" => { "$nin" => [ 3, 4 ] }
+              "location" => {
+                "$geoIntersects" => {
+                  "$geometry" => {
+                    "type" => "Point",
+                    "coordinates" => [ 1, 10 ]
+                  }
+                }
+              }
             })
           end
 
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
+          it_behaves_like "returns a cloned query"
         end
 
-        context "when the stretegy is union" do
+        context "when the geometry is a line intersection" do
 
           let(:selection) do
-            query.nin(first: [ 1, 2 ]).union.nin(first: [ 3, 4 ])
+            query.public_send(query_method, :location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
           end
 
-          it "unions the $nin selectors" do
+          it "adds the $geoIntersects expression" do
             expect(selection.selector).to eq({
-              "first" => { "$nin" => [ 1, 2, 3, 4 ] }
+              "location" => {
+                "$geoIntersects" => {
+                  "$geometry" => {
+                    "type" => "LineString",
+                    "coordinates" => [[ 1, 10 ], [ 2, 10 ]]
+                  }
+                }
+              }
             })
           end
 
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
+          it_behaves_like "returns a cloned query"
         end
-      end
-    end
-  end
 
-  describe "#nor" do
+        context "when the geometry is a polygon intersection" do
 
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.nor
-      end
+          let(:selection) do
+            query.public_send(query_method,
+              :location.intersects_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+            )
+          end
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
+          it "adds the $geoIntersects expression" do
+            expect(selection.selector).to eq({
+              "location" => {
+                "$geoIntersects" => {
+                  "$geometry" => {
+                    "type" => "Polygon",
+                    "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+                  }
+                }
+              }
+            })
+          end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
+          it_behaves_like "returns a cloned query"
+        end
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
+        context "when the geometry is within a polygon" do
 
-    context "when provided nil" do
+          let(:selection) do
+            query.public_send(query_method,
+              :location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+            )
+          end
 
-      let(:selection) do
-        query.nor(nil)
-      end
+          it "adds the $geoIntersects expression" do
+            expect(selection.selector).to eq({
+              "location" => {
+                "$geoWithin" => {
+                  "$geometry" => {
+                    "type" => "Polygon",
+                    "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+                  }
+                }
+              }
+            })
+          end
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
+          context "when used with the $box operator ($geoWithin query) " do
+            let(:selection) do
+              query.public_send(query_method,
+                :location.within_box => [[ 1, 10 ], [ 2, 10 ]]
+              )
+            end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
+            it "adds the $geoIntersects expression" do
+              expect(selection.selector).to eq({
+                "location" => {
+                  "$geoWithin" => {
+                    "$box" => [
+                      [ 1, 10 ], [ 2, 10 ]
+                    ]
+                  }
+                }
+              })
+            end
+          end
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
+          it_behaves_like "returns a cloned query"
+        end
       end
     end
+  end
+
+  describe "#gt" do
+
+    let(:query_method) { :gt }
+
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
     context "when provided a single criterion" do
 
       let(:selection) do
-        query.nor(field: [ 1, 2 ])
+        query.gt(field: 10)
       end
 
-      it "adds the $nor selector" do
+      it "adds the $gt selector" do
         expect(selection.selector).to eq({
-          "$nor" => [{"field" => [ 1, 2 ] }]
+          "field" => { "$gt" => 10 }
         })
       end
 
@@ -2580,38 +847,16 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
     context "when provided multiple criterion" do
 
-      context "when the criterion are fnor different fields" do
-
-        let(:selection) do
-          query.nor({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
-        end
-
-        it "adds the $nor selector" do
-          expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are on the same field" do
+      context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.nor({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+          query.gt(first: 10, second: 15)
         end
 
-        it "appends both $nor expressions" do
+        it "adds the $gt selectors" do
           expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
+            "first" => { "$gt" => 10 },
+            "second" => { "$gt" => 15 }
           })
         end
 
@@ -2623,18 +868,16 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
     context "when chaining the criterion" do
 
-      context "when the criterion are fnor different fields" do
+      context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.nor(first: [ 1, 2 ]).nor(second: [ 3, 4 ])
+          query.gt(first: 10).gt(second: 15)
         end
 
-        it "adds the $nor selectors" do
+        it "adds the $gt selectors" do
           expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
+            "first" => { "$gt" => 10 },
+            "second" => { "$gt" => 15 }
           })
         end
 
@@ -2646,15 +889,12 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the criterion are on the same field" do
 
         let(:selection) do
-          query.nor(first: [ 1, 2 ]).nor(first: [ 3, 4 ])
+          query.gt(first: 10).gt(first: 15)
         end
 
-        it "appends both $nor expressions" do
+        it "overwrites the first $gt selector" do
           expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
+            "first" => { "$gt" => 15 }
           })
         end
 
@@ -2665,20 +905,23 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#or" do
+  describe "#gte" do
 
-    context "when provided no criterion" do
+    let(:query_method) { :gte }
 
-      let(:selection) do
-        query.or
-      end
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
+    context "when provided a single criterion" do
+
+      let(:selection) do
+        query.gte(field: 10)
       end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
+      it "adds the $gte selector" do
+        expect(selection.selector).to eq({
+          "field" => { "$gte" => 10 }
+        })
       end
 
       it "returns a cloned query" do
@@ -2686,56 +929,85 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
     end
 
-    context "when provided nil" do
+    context "when provided multiple criterion" do
 
-      let(:selection) do
-        query.or(nil)
-      end
+      context "when the criterion are for different fields" do
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
+        let(:selection) do
+          query.gte(first: 10, second: 15)
+        end
+
+        it "adds the $gte selectors" do
+          expect(selection.selector).to eq({
+            "first" => { "$gte" => 10 },
+            "second" => { "$gte" => 15 }
+          })
+        end
+
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
+        end
       end
+    end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
+    context "when chaining the criterion" do
+
+      context "when the criterion are for different fields" do
+
+        let(:selection) do
+          query.gte(first: 10).gte(second: 15)
+        end
+
+        it "adds the $gte selectors" do
+          expect(selection.selector).to eq({
+            "first" => { "$gte" => 10 },
+            "second" => { "$gte" => 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 the criterion are on the same field" do
+
+        let(:selection) do
+          query.gte(first: 10).gte(first: 15)
+        end
+
+        it "overwrites the first $gte selector" do
+          expect(selection.selector).to eq({
+            "first" =>  { "$gte" => 15 }
+          })
+        end
+
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
+        end
       end
     end
+  end
 
-    context "when provided a single criterion" do
-
-      let(:selection) do
-        query.or(field: [ 1, 2 ])
-      end
+  describe "#in" do
 
-      it "adds the $or selector" do
-        expect(selection.selector).to eq({
-          "$or" => [{ "field" => [ 1, 2 ] }]
-        })
-      end
+    let(:query_method) { :in }
+    let(:operator) { '$in' }
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-    context "when provided multiple criterion" do
+    context "when provided a single criterion" do
 
-      context "when the criterion are for different fields" do
+      context "when providing an array" do
 
         let(:selection) do
-          query.or({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
+          query.in(field: [ 1, 2 ])
         end
 
-        it "adds the $or selector" do
+        it "adds the $in selector" do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
+            "field" =>  { "$in" => [ 1, 2 ] }
           })
         end
 
@@ -2744,18 +1016,15 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
 
-      context "when a criterion has a selectable key" do
+      context "when providing a single value" do
 
         let(:selection) do
-          query.or({ first: [ 1, 2 ] }, { :second.gt => 3 })
+          query.in(field: 1)
         end
 
-        it "adds the $or selector" do
+        it "adds the $in selector with wrapped value" do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => { "$gt" => 3 }}
-            ]
+            "field" =>  { "$in" => [ 1 ] }
           })
         end
 
@@ -2763,16 +1032,20 @@ describe Mongoid::Criteria::Queryable::Selectable do
           expect(selection).to_not equal(query)
         end
       end
+    end
 
-      context "when the criterion has an aliased field" do
+    context "when provided multiple criterion" do
+
+      context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.or({ id: 1 })
+          query.in(first: [ 1, 2 ], second: 3..4)
         end
 
-        it "adds the $or selector and aliases the field" do
+        it "adds the $in selectors" do
           expect(selection.selector).to eq({
-            "$or" => [ { "_id" => 1 } ]
+            "first" =>  { "$in" => [ 1, 2 ] },
+            "second" =>  { "$in" => [ 3, 4 ] }
           })
         end
 
@@ -2780,19 +1053,20 @@ describe Mongoid::Criteria::Queryable::Selectable do
           expect(selection).to_not equal(query)
         end
       end
+    end
 
-      context "when a criterion is wrapped in an array" do
+    context "when chaining the criterion" do
+
+      context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.or([{ first: [ 1, 2 ] }, { :second.gt => 3 }])
+          query.in(first: [ 1, 2 ]).in(second: [ 3, 4 ])
         end
 
-        it "adds the $or selector" do
+        it "adds the $in selectors" do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => { "$gt" => 3 }}
-            ]
+            "first" =>  { "$in" => [ 1, 2 ] },
+            "second" =>  { "$in" => [ 3, 4 ] }
           })
         end
 
@@ -2803,16 +1077,47 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context "when the criterion are on the same field" do
 
+        it_behaves_like 'supports merge strategies'
+      end
+    end
+  end
+
+  describe "#lt" do
+
+    let(:query_method) { :lt }
+
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
+
+    context "when provided a single criterion" do
+
+      let(:selection) do
+        query.lt(field: 10)
+      end
+
+      it "adds the $lt selector" do
+        expect(selection.selector).to eq({
+          "field" =>  { "$lt" => 10 }
+        })
+      end
+
+      it "returns a cloned query" do
+        expect(selection).to_not equal(query)
+      end
+    end
+
+    context "when provided multiple criterion" do
+
+      context "when the criterion are for different fields" do
+
         let(:selection) do
-          query.or({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+          query.lt(first: 10, second: 15)
         end
 
-        it "appends both $or expressions" do
+        it "adds the $lt selectors" do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
+            "first" =>  { "$lt" => 10 },
+            "second" =>  { "$lt" => 15 }
           })
         end
 
@@ -2827,15 +1132,13 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.or(first: [ 1, 2 ]).or(second: [ 3, 4 ])
+          query.lt(first: 10).lt(second: 15)
         end
 
-        it "adds the $or selectors" do
+        it "adds the $lt selectors" do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
+            "first" =>  { "$lt" => 10 },
+            "second" =>  { "$lt" => 15 }
           })
         end
 
@@ -2847,15 +1150,12 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the criterion are on the same field" do
 
         let(:selection) do
-          query.or(first: [ 1, 2 ]).or(first: [ 3, 4 ])
+          query.lt(first: 10).lt(first: 15)
         end
 
-        it "appends both $or expressions" do
+        it "overwrites the first $lt selector" do
           expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
+            "first" =>  { "$lt" => 15 }
           })
         end
 
@@ -2866,20 +1166,23 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#with_size" do
+  describe "#lte" do
 
-    context "when provided no criterion" do
+    let(:query_method) { :lte }
 
-      let(:selection) do
-        query.with_size
-      end
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
+    context "when provided a single criterion" do
+
+      let(:selection) do
+        query.lte(field: 10)
       end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
+      it "adds the $lte selector" do
+        expect(selection.selector).to eq({
+          "field" =>  { "$lte" => 10 }
+        })
       end
 
       it "returns a cloned query" do
@@ -2887,36 +1190,39 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
     end
 
-    context "when provided nil" do
+    context "when provided multiple criterion" do
 
-      let(:selection) do
-        query.with_size(nil)
-      end
+      context "when the criterion are for different fields" do
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
+        let(:selection) do
+          query.lte(first: 10, second: 15)
+        end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
+        it "adds the $lte selectors" do
+          expect(selection.selector).to eq({
+            "first" =>  { "$lte" => 10 },
+            "second" =>  { "$lte" => 15 }
+          })
+        end
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
+        end
       end
     end
 
-    context "when provided a single criterion" do
+    context "when chaining the criterion" do
 
-      context "when provided an integer" do
+      context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.with_size(field: 10)
+          query.lte(first: 10).lte(second: 15)
         end
 
-        it "adds the $size selector" do
+        it "adds the $lte selectors" do
           expect(selection.selector).to eq({
-            "field" => { "$size" => 10 }
+            "first" =>  { "$lte" => 10 },
+            "second" =>  { "$lte" => 15 }
           })
         end
 
@@ -2925,15 +1231,15 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
 
-      context "when provided a string" do
+      context "when the criterion are on the same field" do
 
         let(:selection) do
-          query.with_size(field: "10")
+          query.lte(first: 10).lte(first: 15)
         end
 
-        it "adds the $size selector with an integer" do
+        it "overwrites the first $lte selector" do
           expect(selection.selector).to eq({
-            "field" => { "$size" => 10 }
+            "first" =>  { "$lte" => 15 }
           })
         end
 
@@ -2942,61 +1248,75 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
+  end
 
-    context "when provided multiple criterion" do
+  describe "#max_distance" do
 
-      context "when the criterion are for different fields" do
+    let(:query_method) { :max_distance }
 
-        context "when provided integers" do
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-          let(:selection) do
-            query.with_size(first: 10, second: 15)
-          end
+    context "when provided a criterion" do
 
-          it "adds the $size selectors" do
-            expect(selection.selector).to eq({
-              "first" => { "$size" => 10 },
-              "second" => { "$size" => 15 }
-            })
-          end
+      context "when a $near criterion exists on the same field" do
 
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
+        let(:selection) do
+          query.near(location: [ 1, 1 ]).max_distance(location: 50)
         end
 
-        context "when provided strings" do
+        it "adds the $maxDistance expression" do
+          expect(selection.selector).to eq({
+            "location" =>  { "$near" => [ 1, 1 ], "$maxDistance" => 50 }
+          })
+        end
 
-          let(:selection) do
-            query.with_size(first: "10", second: "15")
-          end
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
+        end
+      end
+    end
+  end
 
-          it "adds the $size selectors" do
-            expect(selection.selector).to eq({
-              "first" => { "$size" => 10 },
-              "second" => { "$size" => 15 }
-            })
-          end
+  describe "#mod" do
 
-          it "returns a cloned query" do
-            expect(selection).to_not equal(query)
-          end
-        end
+    let(:query_method) { :mod }
+
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
+
+    context "when provided a criterion" do
+
+      let(:selection) do
+        query.mod(value: [ 10, 1 ])
+      end
+
+      it "adds the $mod expression" do
+        expect(selection.selector).to eq({
+          "value" =>  { "$mod" => [ 10, 1 ] }
+        })
+      end
+
+      it "returns a cloned query" do
+        expect(selection).to_not equal(query)
       end
     end
 
-    context "when chaining the criterion" do
+    context "when providing multiple criteria" do
 
-      context "when the criterion are for different fields" do
+      context "when the fields differ" do
 
         let(:selection) do
-          query.with_size(first: 10).with_size(second: 15)
+          query.mod(
+            value: [ 10, 1 ],
+            comments: [ 10, 1 ]
+          )
         end
 
-        it "adds the $size selectors" do
+        it "adds the $mod expression" do
           expect(selection.selector).to eq({
-            "first" => { "$size" => 10 },
-            "second" => { "$size" => 15 }
+            "value" =>  { "$mod" => [ 10, 1 ] },
+            "comments" =>  { "$mod" => [ 10, 1 ] }
           })
         end
 
@@ -3004,16 +1324,22 @@ describe Mongoid::Criteria::Queryable::Selectable do
           expect(selection).to_not equal(query)
         end
       end
+    end
 
-      context "when the criterion are on the same field" do
+    context "when chaining multiple criteria" do
+
+      context "when the fields differ" do
 
         let(:selection) do
-          query.with_size(first: 10).with_size(first: 15)
+          query.
+            mod(value: [ 10, 1 ]).
+            mod(result: [ 10, 1 ])
         end
 
-        it "overwrites the first $size selector" do
+        it "adds the $mod expression" do
           expect(selection.selector).to eq({
-            "first" => { "$size" => 15 }
+            "value" =>  { "$mod" => [ 10, 1 ] },
+            "result" =>  { "$mod" => [ 10, 1 ] }
           })
         end
 
@@ -3024,39 +1350,23 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#type" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.with_type
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
+  describe "#ne" do
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
+    let(:query_method) { :ne }
 
-    context "when provided nil" do
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-      let(:selection) do
-        query.with_type(nil)
-      end
+    context "when provided a criterion" do
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
+      let(:selection) do
+        query.ne(value: 10)
       end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
+      it "adds the $ne expression" do
+        expect(selection.selector).to eq({
+          "value" =>  { "$ne" => 10 }
+        })
       end
 
       it "returns a cloned query" do
@@ -3064,17 +1374,21 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
     end
 
-    context "when provided a single criterion" do
+    context "when providing multiple criteria" do
 
-      context "when provided an integer" do
+      context "when the fields differ" do
 
         let(:selection) do
-          query.with_type(field: 10)
+          query.ne(
+            value: 10,
+            comments: 10
+          )
         end
 
-        it "adds the $type selector" do
+        it "adds the $ne expression" do
           expect(selection.selector).to eq({
-            "field" => { "$type" => 10 }
+            "value" =>  { "$ne" => 10 },
+            "comments" =>  { "$ne" => 10 }
           })
         end
 
@@ -3082,16 +1396,22 @@ describe Mongoid::Criteria::Queryable::Selectable do
           expect(selection).to_not equal(query)
         end
       end
+    end
 
-      context "when provided a string" do
+    context "when chaining multiple criteria" do
+
+      context "when the fields differ" do
 
         let(:selection) do
-          query.with_type(field: "10")
+          query.
+            ne(value: 10).
+            ne(result: 10)
         end
 
-        it "adds the $type selector" do
+        it "adds the $ne expression" do
           expect(selection.selector).to eq({
-            "field" => { "$type" => 10 }
+            "value" =>  { "$ne" => 10 },
+            "result" =>  { "$ne" => 10 }
           })
         end
 
@@ -3100,40 +1420,47 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
+  end
 
-    context "when provided multiple criterion" do
+  describe "#near" do
 
-      context "when the criterion are for different fields" do
+    let(:query_method) { :near }
 
-        let(:selection) do
-          query.with_type(first: 10, second: 15)
-        end
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-        it "adds the $type selectors" do
-          expect(selection.selector).to eq({
-            "first" => { "$type" => 10 },
-            "second" => { "$type" => 15 }
-          })
-        end
+    context "when provided a criterion" do
 
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
+      let(:selection) do
+        query.near(location: [ 20, 21 ])
+      end
+
+      it "adds the $near expression" do
+        expect(selection.selector).to eq({
+          "location" =>  { "$near" => [ 20, 21 ] }
+        })
+      end
+
+      it "returns a cloned query" do
+        expect(selection).to_not equal(query)
       end
     end
 
-    context "when chaining the criterion" do
+    context "when providing multiple criteria" do
 
-      context "when the criterion are for different fields" do
+      context "when the fields differ" do
 
         let(:selection) do
-          query.with_type(first: 10).with_type(second: 15)
+          query.near(
+            location: [ 20, 21 ],
+            comments: [ 20, 21 ]
+          )
         end
 
-        it "adds the $type selectors" do
+        it "adds the $near expression" do
           expect(selection.selector).to eq({
-            "first" => { "$type" => 10 },
-            "second" => { "$type" => 15 }
+            "location" =>  { "$near" => [ 20, 21 ] },
+            "comments" =>  { "$near" => [ 20, 21 ] }
           })
         end
 
@@ -3141,16 +1468,22 @@ describe Mongoid::Criteria::Queryable::Selectable do
           expect(selection).to_not equal(query)
         end
       end
+    end
 
-      context "when the criterion are on the same field" do
+    context "when chaining multiple criteria" do
+
+      context "when the fields differ" do
 
         let(:selection) do
-          query.with_type(first: 10).with_type(first: 15)
+          query.
+            near(location: [ 20, 21 ]).
+            near(comments: [ 20, 21 ])
         end
 
-        it "overwrites the first $type selector" do
+        it "adds the $near expression" do
           expect(selection.selector).to eq({
-            "first" => { "$type" => 15 }
+            "location" =>  { "$near" => [ 20, 21 ] },
+            "comments" =>  { "$near" => [ 20, 21 ] }
           })
         end
 
@@ -3161,508 +1494,450 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#text_search" do
+  describe "#near_sphere" do
 
-    context "when providing a search string" do
+    let(:query_method) { :near_sphere }
+
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
+
+    context "when provided a criterion" do
 
       let(:selection) do
-        query.text_search("testing")
+        query.near_sphere(location: [ 20, 21 ])
       end
 
-      it "constructs a text search document" do
-        expect(selection.selector).to eq({ '$text' => { '$search' => "testing" }})
+      it "adds the $nearSphere expression" do
+        expect(selection.selector).to eq({
+          "location" =>  { "$nearSphere" => [ 20, 21 ] }
+        })
       end
 
-      it "returns the cloned selectable" do
-        expect(selection).to be_a(Mongoid::Criteria::Queryable::Selectable)
+      it "returns a cloned query" do
+        expect(selection).to_not equal(query)
       end
+    end
 
-      context "when providing text search options" do
+    context "when providing multiple criteria" do
+
+      context "when the fields differ" do
 
         let(:selection) do
-          query.text_search("essais", { :$language => "fr" })
+          query.near_sphere(
+            location: [ 20, 21 ],
+            comments: [ 20, 21 ]
+          )
         end
 
-        it "constructs a text search document" do
-          expect(selection.selector['$text']['$search']).to eq("essais")
+        it "adds the $nearSphere expression" do
+          expect(selection.selector).to eq({
+            "location" =>  { "$nearSphere" => [ 20, 21 ] },
+            "comments" =>  { "$nearSphere" => [ 20, 21 ] }
+          })
         end
 
-        it "add the options to the text search document" do
-          expect(selection.selector['$text'][:$language]).to eq("fr")
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
         end
-
-        it_behaves_like "a cloning selection"
       end
     end
 
-    context 'when given more than once' do
-      let(:selection) do
-        query.text_search("one").text_search('two')
-      end
+    context "when chaining multiple criteria" do
 
-      # MongoDB server can only handle one text expression at a time,
-      # per https://docs.mongodb.com/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
-        expect(Mongoid.logger).to receive(:warn)
-        expect(selection.selector).to eq('$and' => [
-            {'$text' => {'$search' => 'one'}}
-          ],
-          '$text' => {'$search' => 'two'},
-        )
-      end
-    end
-  end
+      context "when the fields differ" do
 
-  describe "#where" do
+        let(:selection) do
+          query.
+            near_sphere(location: [ 20, 21 ]).
+            near_sphere(comments: [ 20, 21 ])
+        end
 
-    context "when provided no criterion" do
+        it "adds the $nearSphere expression" do
+          expect(selection.selector).to eq({
+            "location" =>  { "$nearSphere" => [ 20, 21 ] },
+            "comments" =>  { "$nearSphere" => [ 20, 21 ] }
+          })
+        end
 
-      let(:selection) do
-        query.where
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
+        end
       end
+    end
+  end
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
+  describe "#nin" do
 
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
+    let(:query_method) { :nin }
+    let(:operator) { '$nin' }
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-    context "when provided nil" do
+    context "when provided a single criterion" do
 
-      let(:selection) do
-        query.where(nil)
-      end
+      context "when providing an array" do
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
+        let(:selection) do
+          query.nin(field: [ 1, 2 ])
+        end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
+        it "adds the $nin selector" do
+          expect(selection.selector).to eq({
+            "field" =>  { "$nin" => [ 1, 2 ] }
+          })
+        end
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
+        end
       end
-    end
 
-    context "when provided a string" do
+      context "when providing a single value" do
 
-      let(:selection) do
-        query.where("this.value = 10")
-      end
+        let(:selection) do
+          query.nin(field: 1)
+        end
 
-      it "adds the $where criterion" do
-        expect(selection.selector).to eq({ "$where" => "this.value = 10" })
-      end
+        it "adds the $nin selector with wrapped value" do
+          expect(selection.selector).to eq({
+            "field" =>  { "$nin" => [ 1 ] }
+          })
+        end
 
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
+        end
       end
     end
 
-    context "when provided a single criterion" do
+    context "when provided multiple criterion" do
 
-      context "when the value needs no evolution" do
+      context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.where(name: "Syd")
-        end
-
-        it "adds the criterion to the selection" do
-          expect(selection.selector).to eq({ "name" => "Syd" })
+          query.nin(first: [ 1, 2 ], second: [ 3, 4 ])
         end
-      end
-
-      context "when the value must be evolved" do
 
-        before(:all) do
-          class Document
-            def id
-              13
-            end
-            def self.evolve(object)
-              object.id
-            end
-          end
+        it "adds the $nin selectors" do
+          expect(selection.selector).to eq({
+            "first" =>  { "$nin" => [ 1, 2 ] },
+            "second" =>  { "$nin" => [ 3, 4 ] }
+          })
         end
 
-        after(:all) do
-          Object.send(:remove_const, :Document)
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
         end
+      end
+    end
 
-        context "when the key needs evolution" do
-
-          let(:query) do
-            Mongoid::Query.new({ "user" => "user_id" })
-          end
-
-          let(:document) do
-            Document.new
-          end
-
-          let(:selection) do
-            query.where(user: document)
-          end
+    context "when chaining the criterion" do
 
-          it "alters the key and value" do
-            expect(selection.selector).to eq({ "user_id" => document.id })
-          end
+      context "when the criterion are for different fields" do
+
+        let(:selection) do
+          query.nin(first: [ 1, 2 ]).nin(second: [ 3, 4 ])
         end
 
-        context 'when the field is a String and the value is a BSON::Regexp::Raw' do
+        it "adds the $nin selectors" do
+          expect(selection.selector).to eq({
+            "first" => { "$nin" => [ 1, 2 ] },
+            "second" => { "$nin" => [ 3, 4 ] }
+          })
+        end
 
-          let(:raw_regexp) do
-            BSON::Regexp::Raw.new('^Em')
-          end
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
+        end
+      end
 
-          let(:selection) do
-            Login.where(_id: raw_regexp)
-          end
+      context "when the criterion are on the same field" do
 
-          it 'does not convert the bson raw regexp object to a String' do
-            expect(selection.selector).to eq({ "_id" => raw_regexp })
-          end
-        end
+        it_behaves_like 'supports merge strategies'
       end
     end
+  end
 
-    context "when provided complex criterion" do
+  describe "#with_size" do
 
-      context "when performing an $all" do
+    let(:query_method) { :with_size }
 
-        context "when performing a single query" do
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-          let(:selection) do
-            query.where(:field.all => [ 1, 2 ])
-          end
+    context "when provided a single criterion" do
 
-          it "adds the $all criterion" do
-            expect(selection.selector).to eq({ "field" => { "$all" => [ 1, 2 ] }})
-          end
+      context "when provided an integer" do
 
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
+        let(:selection) do
+          query.with_size(field: 10)
         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 "adds the $size selector" do
+          expect(selection.selector).to eq({
+            "field" => { "$size" => 10 }
+          })
+        end
 
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
         end
+      end
 
-        context "when the value is complex" do
+      context "when provided a string" do
 
-          let(:selection) do
-            query.where(:field.elem_match => { :key.gt => 1 })
-          end
+        let(:selection) do
+          query.with_size(field: "10")
+        end
 
-          it "adds the $elemMatch criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$elemMatch" => { "key" => { "$gt" => 1 }}}}
-            )
-          end
+        it "adds the $size selector with an integer" do
+          expect(selection.selector).to eq({
+            "field" => { "$size" => 10 }
+          })
+        end
 
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
+        it "returns a cloned query" do
+          expect(selection).to_not equal(query)
         end
       end
+    end
 
-      context "when performing an $exists" do
+    context "when provided multiple criterion" do
 
-        context "when providing boolean values" do
+      context "when the criterion are for different fields" do
+
+        context "when provided integers" do
 
           let(:selection) do
-            query.where(:field.exists => true)
+            query.with_size(first: 10, second: 15)
           end
 
-          it "adds the $exists criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$exists" => true }}
-            )
+          it "adds the $size selectors" do
+            expect(selection.selector).to eq({
+              "first" => { "$size" => 10 },
+              "second" => { "$size" => 15 }
+            })
           end
 
           it "returns a cloned query" do
-            expect(selection).to_not eq(query)
+            expect(selection).to_not equal(query)
           end
         end
 
-        context "when providing string values" do
+        context "when provided strings" do
 
           let(:selection) do
-            query.where(:field.exists => "t")
+            query.with_size(first: "10", second: "15")
           end
 
-          it "adds the $exists criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$exists" => true }}
-            )
+          it "adds the $size selectors" do
+            expect(selection.selector).to eq({
+              "first" => { "$size" => 10 },
+              "second" => { "$size" => 15 }
+            })
           end
 
           it "returns a cloned query" do
-            expect(selection).to_not eq(query)
+            expect(selection).to_not equal(query)
           end
         end
       end
+    end
 
-      context "when performing a $gt" do
+    context "when chaining the criterion" do
+
+      context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.where(:field.gt => 10)
+          query.with_size(first: 10).with_size(second: 15)
         end
 
-        it "adds the $gt criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$gt" => 10 }}
-          )
+        it "adds the $size selectors" do
+          expect(selection.selector).to eq({
+            "first" => { "$size" => 10 },
+            "second" => { "$size" => 15 }
+          })
         end
 
         it "returns a cloned query" do
-          expect(selection).to_not eq(query)
+          expect(selection).to_not equal(query)
         end
       end
 
-      context "when performing a $gte" do
+      context "when the criterion are on the same field" do
 
         let(:selection) do
-          query.where(:field.gte => 10)
+          query.with_size(first: 10).with_size(first: 15)
         end
 
-        it "adds the $gte criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$gte" => 10 }}
-          )
+        it "overwrites the first $size selector" do
+          expect(selection.selector).to eq({
+            "first" => { "$size" => 15 }
+          })
         end
 
         it "returns a cloned query" do
-          expect(selection).to_not eq(query)
+          expect(selection).to_not equal(query)
         end
       end
+    end
+  end
 
-      context "when performing an $in" do
+  describe "#with_type" do
 
-        let(:selection) do
-          query.where(:field.in => [ 1, 2 ])
-        end
+    let(:query_method) { :with_type }
 
-        it "adds the $in criterion" do
-          expect(selection.selector).to eq({ "field" => { "$in" => [ 1, 2 ] }})
-        end
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
+    context "when provided a single criterion" do
 
-      context "when performing a $lt" do
+      context "when provided an integer" do
 
         let(:selection) do
-          query.where(:field.lt => 10)
+          query.with_type(field: 10)
         end
 
-        it "adds the $lt criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$lt" => 10 }}
-          )
+        it "adds the $type selector" do
+          expect(selection.selector).to eq({
+            "field" => { "$type" => 10 }
+          })
         end
 
         it "returns a cloned query" do
-          expect(selection).to_not eq(query)
+          expect(selection).to_not equal(query)
         end
       end
 
-      context "when performing a $lte" do
+      context "when provided a string" do
 
         let(:selection) do
-          query.where(:field.lte => 10)
+          query.with_type(field: "10")
         end
 
-        it "adds the $lte criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$lte" => 10 }}
-          )
+        it "adds the $type selector" do
+          expect(selection.selector).to eq({
+            "field" => { "$type" => 10 }
+          })
         end
 
         it "returns a cloned query" do
-          expect(selection).to_not eq(query)
+          expect(selection).to_not equal(query)
         end
       end
+    end
+
+    context "when provided multiple criterion" do
 
-      context "when performing a $mod" do
+      context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.where(:field.mod => [ 10, 1 ])
+          query.with_type(first: 10, second: 15)
         end
 
-        it "adds the $lte criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$mod" => [ 10, 1 ]}}
-          )
+        it "adds the $type selectors" do
+          expect(selection.selector).to eq({
+            "first" => { "$type" => 10 },
+            "second" => { "$type" => 15 }
+          })
         end
 
         it "returns a cloned query" do
-          expect(selection).to_not eq(query)
+          expect(selection).to_not equal(query)
         end
       end
+    end
+
+    context "when chaining the criterion" do
 
-      context "when performing a $ne" do
+      context "when the criterion are for different fields" do
 
         let(:selection) do
-          query.where(:field.ne => 10)
+          query.with_type(first: 10).with_type(second: 15)
         end
 
-        it "adds the $ne criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$ne" => 10 }}
-          )
+        it "adds the $type selectors" do
+          expect(selection.selector).to eq({
+            "first" => { "$type" => 10 },
+            "second" => { "$type" => 15 }
+          })
         end
 
         it "returns a cloned query" do
-          expect(selection).to_not eq(query)
+          expect(selection).to_not equal(query)
         end
       end
 
-      context "when performing a $near" do
+      context "when the criterion are on the same field" do
 
         let(:selection) do
-          query.where(:field.near => [ 1, 1 ])
+          query.with_type(first: 10).with_type(first: 15)
         end
 
-        it "adds the $near criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$near" => [ 1, 1 ] }}
-          )
+        it "overwrites the first $type selector" do
+          expect(selection.selector).to eq({
+            "first" => { "$type" => 15 }
+          })
         end
 
         it "returns a cloned query" do
-          expect(selection).to_not eq(query)
+          expect(selection).to_not equal(query)
         end
       end
+    end
+  end
 
-      context "when performing a $nearSphere" do
-
-        let(:selection) do
-          query.where(:field.near_sphere => [ 1, 1 ])
-        end
+  describe "#text_search" do
 
-        it "adds the $nearSphere criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$nearSphere" => [ 1, 1 ] }}
-          )
-        end
+    context "when providing a search string" do
 
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
+      let(:selection) do
+        query.text_search("testing")
       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 "constructs a text search document" do
+        expect(selection.selector).to eq({ '$text' => { '$search' => "testing" }})
+      end
 
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
+      it "returns the cloned selectable" do
+        expect(selection).to be_a(Mongoid::Criteria::Queryable::Selectable)
       end
 
-      context "when performing a $not" do
+      context "when providing text search options" do
 
         let(:selection) do
-          query.where(:field.not => /test/)
-        end
-
-        it "adds the $not criterion" do
-          expect(selection.selector).to eq({ "field" => { "$not" => /test/ }})
+          query.text_search("essais", { :$language => "fr" })
         end
 
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
+        it "constructs a text search document" do
+          expect(selection.selector['$text']['$search']).to eq("essais")
         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
+        it "add the options to the text search document" do
+          expect(selection.selector['$text'][:$language]).to eq("fr")
         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
+        it_behaves_like "returns a cloned query"
       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
+    context 'when given more than once' do
+      let(:selection) do
+        query.text_search("one").text_search('two')
+      end
 
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
+      # MongoDB server can only handle one text expression at a time,
+      # per https://docs.mongodb.com/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
+        expect(Mongoid.logger).to receive(:warn)
+        expect(selection.selector).to eq('$and' => [
+            {'$text' => {'$search' => 'one'}}
+          ],
+          '$text' => {'$search' => 'two'},
+        )
       end
     end
   end
@@ -3987,7 +2262,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         it "merges the strategies on the same field" do
           expect(selection.selector).to eq(
-            { "field" => { "$gt" => 5, "$lt" => 10, "$ne" => 7 }}
+            "field" => { "$gt" => 5, "$lt" => 10, "$ne" => 7 }
           )
         end
       end
@@ -3998,8 +2273,8 @@ describe Mongoid::Criteria::Queryable::Selectable do
           query.where(field: 5).where(field: 10)
         end
 
-        it "overrides the previous field" do
-          expect(selection.selector).to eq({ "field" => 10 })
+        it "combines conditions" do
+          expect(selection.selector).to eq("field" => 5, '$and' => [{'field' => 10}] )
         end
       end
     end
@@ -4014,7 +2289,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         it "merges the strategies on the same field" do
           expect(selection.selector).to eq(
-            { "field" => { "$gt" => 5, "$lt" => 10, "$ne" => 7 }}
+            "field" => { "$gt" => 5, "$lt" => 10, "$ne" => 7 }
           )
         end
       end