mongoid 7.1.1 → 8.1.0

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
@@ -85,7 +84,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         it "adds the conditions to top level" do
           expect(selection.selector).to eq({
-            "field" => {'$gt' => 3 },
+            "field" => {'$gt' => 3},
           })
         end
 
@@ -113,6 +112,54 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
         it_behaves_like 'adds the conditions to top level'
       end
+
+      context 'when the criterion is a time' do
+        let(:selection) do
+          query.send(tested_method, :field.gte => Time.new(2020, 1, 1))
+        end
+
+        it 'adds the conditions' do
+          expect(selection.selector).to eq({
+            "field" => {'$gte' => Time.new(2020, 1, 1)},
+          })
+        end
+
+        it 'keeps argument type' do
+          selection.selector['field']['$gte'].should be_a(Time)
+        end
+      end
+
+      context 'when the criterion is a datetime' do
+        let(:selection) do
+          query.send(tested_method, :field.gte => DateTime.new(2020, 1, 1))
+        end
+
+        it 'adds the conditions' do
+          expect(selection.selector).to eq({
+            "field" => {'$gte' => Time.utc(2020, 1, 1)},
+          })
+        end
+
+        it 'converts argument to a time' do
+          selection.selector['field']['$gte'].should be_a(Time)
+        end
+      end
+
+      context 'when the criterion is a date' do
+        let(:selection) do
+          query.send(tested_method, :field.gte => Date.new(2020, 1, 1))
+        end
+
+        it 'adds the conditions' do
+          expect(selection.selector).to eq({
+            "field" => {'$gte' => Time.utc(2020, 1, 1)},
+          })
+        end
+
+        it 'converts argument to a time' do
+          selection.selector['field']['$gte'].should be_a(Time)
+        end
+      end
     end
 
     context "when provided a nested criterion" do
@@ -283,25 +330,58 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
     context "when provided multiple criteria" do
 
-      context "when the criteria is already included" do
+      context "when the criterion is already included" do
 
-        let(:selection) do
-          query.and({ first: [ 1, 2 ] }).and({ first: [ 1, 2 ] })
+        context 'simple criterion' do
+          let(:selection) do
+            query.and({ first: [ 1, 2 ] }).and({ first: [ 1, 2 ] })
+          end
+
+          it "adds all conditions" do
+            expect(selection.selector).to eq({
+              'first' => [1, 2],
+              "$and" => [
+                { "first" => [ 1, 2 ] }
+              ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
         end
 
-        it "adds all conditions" do
-          expect(selection.selector).to eq({
-            'first' => [1, 2],
-            "$and" => [
-              { "first" => [ 1, 2 ] }
-            ]
-          })
+        context 'Key criterion' do
+          let(:selection) do
+            query.and({ first: [ 1, 2 ] }).and(:first.gt => 3)
+          end
+
+          it "adds all conditions" do
+            expect(selection.selector).to eq({
+              'first' => [1, 2],
+              "$and" => [
+                { "first" => {'$gt' => 3} }
+              ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
         end
 
-        it_behaves_like 'returns a cloned query'
+        context 'Key criterion when existing criterion is an operator' do
+          let(:selection) do
+            query.and(:first.lt => 5).and(:first.gt => 3)
+          end
+
+          it "adds all conditions" do
+            expect(selection.selector).to eq({
+              'first' => {'$lt' => 5, '$gt' => 3},
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
       end
 
-      context "when the new criterion is for different fields" do
+      context "when the new criteria are for different fields" do
 
         let(:selection) do
           query.and({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
@@ -317,22 +397,235 @@ describe Mongoid::Criteria::Queryable::Selectable do
         it_behaves_like 'returns a cloned query'
       end
 
-      context "when the new criterion is for the same field" do
+      context "when the new criteria are for the same field" do
 
-        let(:selection) do
-          query.and({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+        context 'when criteria are simple' do
+          let(:selection) do
+            query.and({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+          end
+
+          it "combines via $and operator" do
+            expect(selection.selector).to eq({
+              "first" => [ 1, 2 ],
+              "$and" => [
+                { "first" => [ 3, 4 ] }
+              ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
         end
 
-        it "combines via $and operator" do
-          expect(selection.selector).to eq({
-            "first" => [ 1, 2 ],
-            "$and" => [
-              { "first" => [ 3, 4 ] }
-            ]
-          })
+        context 'when criteria use operators' do
+          shared_examples 'behave correctly' do
+            let(:selection) do
+              query.and(
+                { field: {first_operator => [ 1, 2 ] }},
+                { field: {second_operator => [ 3, 4 ] }},
+              )
+            end
+
+            it "combines via $and operator and stringifies all keys" do
+              expect(selection.selector).to eq({
+                "field" => {'$in' => [ 1, 2 ]},
+                "$and" => [
+                  { "field" => {'$in' => [ 3, 4 ] }}
+                ]
+              })
+            end
+          end
+
+          [
+            ['$in', '$in'],
+            [:$in, '$in'],
+            ['$in', :$in],
+            [:$in, :$in],
+          ].each do |first_operator, second_operator|
+            context "when first operator is #{first_operator.inspect} and second operator is #{second_operator.inspect}" do
+              let(:first_operator) { first_operator }
+              let(:second_operator) { second_operator }
+
+              include_examples 'behave correctly'
+            end
+          end
         end
 
-        it_behaves_like 'returns a cloned query'
+        context 'when criteria are handled via Key' do
+          shared_examples_for 'adds the conditions to top level' do
+
+            it "adds the conditions to top level" do
+              expect(selection.selector).to eq({
+                "field" => {'$gt' => 3, '$lt' => 5},
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          context 'criteria are provided in the same hash' do
+            let(:selection) do
+              query.send(tested_method, :field.gt => 3, :field.lt => 5)
+            end
+
+            it_behaves_like 'adds the conditions to top level'
+          end
+
+          context 'criteria are provided in separate hashes' do
+            let(:selection) do
+              query.send(tested_method, {:field.gt => 3}, {:field.lt => 5})
+            end
+
+            it_behaves_like 'adds the conditions to top level'
+          end
+
+          context 'when the criterion is wrapped in an array' do
+            let(:selection) do
+              query.send(tested_method, [:field.gt => 3], [:field.lt => 5])
+            end
+
+            it_behaves_like 'adds the conditions to top level'
+          end
+        end
+
+        context 'when criteria are simple and handled via Key' do
+          shared_examples_for 'combines conditions with $and' do
+
+            it "combines conditions with $and" do
+              expect(selection.selector).to eq({
+                "field" => 3,
+                '$and' => ['field' => {'$lt' => 5}],
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          shared_examples_for 'combines conditions with $eq' do
+
+            it "combines conditions with $eq" do
+              expect(selection.selector).to eq({
+                "field" => {'$eq' => 3, '$lt' => 5},
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          shared_examples_for 'combines conditions with $regex' do
+
+            it "combines conditions with $regex" do
+              expect(selection.selector).to eq({
+                "field" => {'$regex' => /t/, '$lt' => 5},
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          context 'criteria are provided in the same hash' do
+            context 'non-regexp argument' do
+              let(:selection) do
+                query.send(tested_method, :field => 3, :field.lt => 5)
+              end
+
+              it_behaves_like 'combines conditions with $eq'
+            end
+
+            context 'regexp argument' do
+              let(:selection) do
+                query.send(tested_method, :field => /t/, :field.lt => 5)
+              end
+
+              it_behaves_like 'combines conditions with $regex'
+            end
+          end
+
+          context 'criteria are provided in separate hashes' do
+            let(:selection) do
+              query.send(tested_method, {:field => 3}, {:field.lt => 5})
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+
+          context 'when the criterion is wrapped in an array' do
+            let(:selection) do
+              query.send(tested_method, [:field => 3], [:field.lt => 5])
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+        end
+
+        context 'when criteria are handled via Key and simple' do
+          shared_examples_for 'combines conditions with $and' do
+
+            it "combines conditions with $and" do
+              expect(selection.selector).to eq({
+                "field" => {'$gt' => 3},
+                '$and' => ['field' => 5],
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          shared_examples_for 'combines conditions with $eq' do
+
+            it "combines conditions with $eq" do
+              expect(selection.selector).to eq({
+                "field" => {'$gt' => 3, '$eq' => 5},
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          shared_examples_for 'combines conditions with $regex' do
+
+            it "combines conditions with $regex" do
+              expect(selection.selector).to eq({
+                "field" => {'$gt' => 3, '$regex' => /t/},
+              })
+            end
+
+            it_behaves_like 'returns a cloned query'
+          end
+
+          context 'criteria are provided in the same hash' do
+            context 'non-regexp argument' do
+              let(:selection) do
+                query.send(tested_method, :field.gt => 3, :field => 5)
+              end
+
+              it_behaves_like 'combines conditions with $eq'
+            end
+
+            context 'regexp argument' do
+              let(:selection) do
+                query.send(tested_method, :field.gt => 3, :field => /t/)
+              end
+
+              it_behaves_like 'combines conditions with $regex'
+            end
+          end
+
+          context 'criteria are provided in separate hashes' do
+            let(:selection) do
+              query.send(tested_method, {:field.gt => 3}, {:field => 5})
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+
+          context 'when the criterion is wrapped in an array' do
+            let(:selection) do
+              query.send(tested_method, [:field.gt => 3], [:field => 5])
+            end
+
+            it_behaves_like 'combines conditions with $and'
+          end
+        end
       end
     end
 
@@ -509,17 +802,14 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#or" do
-
-    let(:tested_method) { :or }
-    let(:expected_operator) { '$or' }
+  shared_examples '$or/$nor' do
 
     it_behaves_like 'a non-hoisting logical operation'
 
     context "when provided no arguments" do
 
       let(:selection) do
-        query.or
+        query.send(tested_method)
       end
 
       it_behaves_like 'returns a cloned query'
@@ -536,7 +826,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
     context "when provided nil" do
 
       let(:selection) do
-        query.or(nil)
+        query.send(tested_method, nil)
       end
 
       it_behaves_like 'returns a cloned query'
@@ -553,42 +843,42 @@ describe Mongoid::Criteria::Queryable::Selectable do
     context "when provided a single criterion" do
 
       let(:selection) do
-        query.or(field: [ 1, 2 ])
+        query.send(tested_method, field: [ 1, 2 ])
       end
 
       it_behaves_like 'returns a cloned query'
 
-      it "adds the $or selector" do
+      it "adds the $or/$nor selector" do
         expect(selection.selector).to eq({
-          "$or" => [{ "field" => [ 1, 2 ] }]
+          expected_operator => [{ "field" => [ 1, 2 ] }]
         })
       end
 
       context 'when the criterion is wrapped in array' do
 
         let(:selection) do
-          query.or([{ field: [ 1, 2 ] }])
+          query.send(tested_method, [{ field: [ 1, 2 ] }])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or selector" do
+        it "adds the $or/$nor selector" do
           expect(selection.selector).to eq({
-            "$or" => [{ "field" => [ 1, 2 ] }]
+            expected_operator => [{ "field" => [ 1, 2 ] }]
           })
         end
 
         context 'when the array has nil as one of the elements' do
 
           let(:selection) do
-            query.or([{ field: [ 1, 2 ] }, nil])
+            query.send(tested_method, [{ field: [ 1, 2 ] }, nil])
           end
 
           it_behaves_like 'returns a cloned query'
 
-          it "adds the $or selector ignoring the nil element" do
+          it "adds the $or/$nor selector ignoring the nil element" do
             expect(selection.selector).to eq({
-              "$or" => [{ "field" => [ 1, 2 ] }]
+              expected_operator => [{ "field" => [ 1, 2 ] }]
             })
           end
         end
@@ -597,27 +887,27 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context 'when query already has a condition on another field' do
 
         let(:selection) do
-          query.where(foo: 'bar').or(field: [ 1, 2 ])
+          query.where(foo: 'bar').send(tested_method, field: [ 1, 2 ])
         end
 
-        it 'moves original conditions under $or' do
+        it 'moves original conditions under $or/$nor' do
           expect(selection.selector).to eq({
-            "$or" => [{'foo' => 'bar'}, { "field" => [ 1, 2 ] }]
+            expected_operator => [{'foo' => 'bar'}, { "field" => [ 1, 2 ] }]
           })
         end
       end
 
-      context 'when query already has an $or condition and another condition' do
+      context 'when query already has an $or/$nor condition and another condition' do
 
         let(:selection) do
-          query.or(field: [ 1, 2 ]).where(foo: 'bar').or(test: 1)
+          query.send(tested_method, field: [ 1, 2 ]).where(foo: 'bar').send(tested_method, test: 1)
         end
 
         it 'unions existing conditions' do
           expect(selection.selector).to eq(
-            '$or' => [
+            expected_operator => [
               {
-                "$or" => [{ "field" => [ 1, 2 ] }],
+                expected_operator => [{ "field" => [ 1, 2 ] }],
                 'foo' => 'bar',
               },
               {'test' => 1},
@@ -632,14 +922,14 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the criteria are for different fields" do
 
         let(:selection) do
-          query.or({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
+          query.send(tested_method, { first: [ 1, 2 ] }, { second: [ 3, 4 ] })
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or selector" do
+        it "adds the $or/$nor selector" do
           expect(selection.selector).to eq({
-            "$or" => [
+            expected_operator => [
               { "first" => [ 1, 2 ] },
               { "second" => [ 3, 4 ] }
             ]
@@ -650,12 +940,12 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when the criteria uses a Key instance" do
 
         let(:selection) do
-          query.or({ first: [ 1, 2 ] }, { :second.gt => 3 })
+          query.send(tested_method, { first: [ 1, 2 ] }, { :second.gt => 3 })
         end
 
-        it "adds the $or selector" do
+        it "adds the $or/$nor selector" do
           expect(selection.selector).to eq({
-            "$or" => [
+            expected_operator => [
               { "first" => [ 1, 2 ] },
               { "second" => { "$gt" => 3 }}
             ]
@@ -663,17 +953,65 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         it_behaves_like 'returns a cloned query'
+
+        context 'when the criterion is a time' do
+          let(:selection) do
+            query.send(tested_method, :field.gte => Time.new(2020, 1, 1))
+          end
+
+          it 'adds the conditions' do
+            expect(selection.selector).to eq(expected_operator => [
+              "field" => {'$gte' => Time.new(2020, 1, 1)},
+            ])
+          end
+
+          it 'keeps the type' do
+            selection.selector[expected_operator].first['field']['$gte'].should be_a(Time)
+          end
+        end
+
+        context 'when the criterion is a datetime' do
+          let(:selection) do
+            query.send(tested_method, :field.gte => DateTime.new(2020, 1, 1))
+          end
+
+          it 'adds the conditions' do
+            expect(selection.selector).to eq(expected_operator => [
+              "field" => {'$gte' => Time.utc(2020, 1, 1)},
+            ])
+          end
+
+          it 'converts argument to a time' do
+            selection.selector[expected_operator].first['field']['$gte'].should be_a(Time)
+          end
+        end
+
+        context 'when the criterion is a date' do
+          let(:selection) do
+            query.send(tested_method, :field.gte => Date.new(2020, 1, 1))
+          end
+
+          it 'adds the conditions' do
+            expect(selection.selector).to eq(expected_operator => [
+              "field" => {'$gte' => Time.utc(2020, 1, 1)},
+            ])
+          end
+
+          it 'converts argument to a time' do
+            selection.selector[expected_operator].first['field']['$gte'].should be_a(Time)
+          end
+        end
       end
 
       context "when a criterion has an aliased field" do
 
         let(:selection) do
-          query.or({ id: 1 })
+          query.send(tested_method, { id: 1 })
         end
 
-        it "adds the $or selector and aliases the field" do
+        it "adds the $or/$nor selector and aliases the field" do
           expect(selection.selector).to eq({
-            "$or" => [ { "_id" => 1 } ]
+            expected_operator => [ { "_id" => 1 } ]
           })
         end
 
@@ -683,14 +1021,14 @@ describe Mongoid::Criteria::Queryable::Selectable do
       context "when a criterion is wrapped in an array" do
 
         let(:selection) do
-          query.or([{ first: [ 1, 2 ] }, { :second.gt => 3 }])
+          query.send(tested_method, [{ first: [ 1, 2 ] }, { :second.gt => 3 }])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or selector" do
+        it "adds the $or/$nor selector" do
           expect(selection.selector).to eq({
-            "$or" => [
+            expected_operator => [
               { "first" => [ 1, 2 ] },
               { "second" => { "$gt" => 3 }}
             ]
@@ -700,19 +1038,54 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context "when the criteria are on the same field" do
 
-        let(:selection) do
-          query.or({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+        context 'simple criteria' do
+          let(:selection) do
+            query.send(tested_method, { first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+          end
+
+          it_behaves_like 'returns a cloned query'
+
+          it "appends both $or/$nor expressions" do
+            expect(selection.selector).to eq({
+              expected_operator => [
+                { "first" => [ 1, 2 ] },
+                { "first" => [ 3, 4 ] }
+              ]
+            })
+          end
         end
 
-        it_behaves_like 'returns a cloned query'
+        context 'Key criteria as one argument' do
+          let(:selection) do
+            query.send(tested_method, :first.gt => 3, :first.lt => 5)
+          end
 
-        it "appends both $or expressions" do
-          expect(selection.selector).to eq({
-            "$or" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
+          it_behaves_like 'returns a cloned query'
+
+          it "adds all criteria" do
+            expect(selection.selector).to eq({
+              expected_operator => [
+                { "first" => {'$gt' => 3, '$lt' => 5} },
+              ]
+            })
+          end
+        end
+
+        context 'Key criteria as multiple arguments' do
+          let(:selection) do
+            query.send(tested_method, {:first.gt => 3}, {:first.lt => 5})
+          end
+
+          it_behaves_like 'returns a cloned query'
+
+          it "adds all criteria" do
+            expect(selection.selector).to eq({
+              expected_operator => [
+                { "first" => {'$gt' => 3} },
+                { "first" => {'$lt' => 5} },
+              ]
+            })
+          end
         end
       end
     end
@@ -722,14 +1095,14 @@ 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.send(tested_method, first: [ 1, 2 ]).send(tested_method, second: [ 3, 4 ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "adds the $or selectors" do
+        it "adds the $or/$nor selectors" do
           expect(selection.selector).to eq({
-            "$or" => [
+            expected_operator => [
               { "first" => [ 1, 2 ] },
               { "second" => [ 3, 4 ] }
             ]
@@ -740,14 +1113,14 @@ 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.send(tested_method, first: [ 1, 2 ]).send(tested_method, first: [ 3, 4 ])
         end
 
         it_behaves_like 'returns a cloned query'
 
-        it "appends both $or expressions" do
+        it "appends both $or/$nor expressions" do
           expect(selection.selector).to eq({
-            "$or" => [
+            expected_operator => [
               { "first" => [ 1, 2 ] },
               { "first" => [ 3, 4 ] }
             ]
@@ -755,141 +1128,54 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
-  end
-
-  describe "#nor" do
-
-    let(:tested_method) { :nor }
-    let(:expected_operator) { '$nor' }
 
-    it_behaves_like 'a non-hoisting logical operation'
+    context 'when giving multiple conditions in one call on the same key with symbol operator' do
 
-    context "when provided no criterion" do
+      context 'non-regexp argument' do
+        let(:selection) do
+          query.send(tested_method, field: 1, :field.gt => 0)
+        end
 
-      let(:selection) do
-        query.nor
+        it 'combines conditions with $eq' do
+          selection.selector.should == {
+            expected_operator => [
+              'field' => {'$eq' => 1, '$gt' => 0},
+            ]
+          }
+        end
       end
 
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
+      context 'regexp argument' do
+        let(:selection) do
+          query.send(tested_method, field: /t/, :field.gt => 0)
+        end
 
-      it "returns the query" do
-        expect(selection).to eq(query)
+        it 'combines conditions with $regex' do
+          selection.selector.should == {
+            expected_operator => [
+              'field' => {'$regex' => /t/, '$gt' => 0},
+            ]
+          }
+        end
       end
 
-      it_behaves_like 'returns a cloned query'
     end
+  end
 
-    context "when provided nil" do
+  describe "#or" do
 
-      let(:selection) do
-        query.nor(nil)
-      end
+    let(:tested_method) { :or }
+    let(:expected_operator) { '$or' }
 
-      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_behaves_like 'returns a cloned query'
-    end
-
-    context "when provided a single criterion" do
-
-      let(:selection) do
-        query.nor(field: [ 1, 2 ])
-      end
-
-      it "adds the $nor selector" do
-        expect(selection.selector).to eq({
-          "$nor" => [{"field" => [ 1, 2 ] }]
-        })
-      end
-
-      it_behaves_like 'returns a cloned query'
-    end
-
-    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_behaves_like 'returns a cloned query'
-      end
-
-      context "when the criterion are on the same field" do
-
-        let(:selection) do
-          query.nor({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
-        end
-
-        it "appends both $nor expressions" do
-          expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
-        end
-
-        it_behaves_like 'returns a cloned query'
-      end
-    end
-
-    context "when chaining the criterion" do
-
-      context "when the criterion are fnor different fields" do
-
-        let(:selection) do
-          query.nor(first: [ 1, 2 ]).nor(second: [ 3, 4 ])
-        end
-
-        it "adds the $nor selectors" do
-          expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "second" => [ 3, 4 ] }
-            ]
-          })
-        end
-
-        it_behaves_like 'returns a cloned query'
-      end
-
-      context "when the criterion are on the same field" do
+    it_behaves_like '$or/$nor'
+  end
 
-        let(:selection) do
-          query.nor(first: [ 1, 2 ]).nor(first: [ 3, 4 ])
-        end
+  describe "#nor" do
 
-        it "appends both $nor expressions" do
-          expect(selection.selector).to eq({
-            "$nor" => [
-              { "first" => [ 1, 2 ] },
-              { "first" => [ 3, 4 ] }
-            ]
-          })
-        end
+    let(:tested_method) { :nor }
+    let(:expected_operator) { '$nor' }
 
-        it_behaves_like 'returns a cloned query'
-      end
-    end
+    it_behaves_like '$or/$nor'
   end
 
   describe "#any_of" do
@@ -1058,6 +1344,34 @@ describe Mongoid::Criteria::Queryable::Selectable do
           )
         end
       end
+
+      context 'when any_of has multiple arguments' do
+
+        let(:selection) do
+          query.or(field: [ 1, 2 ]).where(foo: 'bar').any_of({a: 1}, {b: 2})
+        end
+
+        it 'adds the new condition to top level' do
+          expect(selection.selector).to eq(
+            '$or' => [{'field' => [1, 2]}],
+            'foo' => 'bar',
+            '$and' => [{'$or' => [{'a' => 1}, {'b' => 2}]}],
+          )
+        end
+
+        context 'when query already has a top-level $and' do
+          let(:selection) do
+            query.or(field: [ 1, 2 ]).where('$and' => [foo: 'bar']).any_of({a: 1}, {b: 2})
+          end
+
+          it 'adds the new condition to top level $and' do
+            expect(selection.selector).to eq(
+              '$or' => [{'field' => [1, 2]}],
+              '$and' => [{'foo' => 'bar'}, {'$or' => [{'a' => 1}, {'b' => 2}]}],
+            )
+          end
+        end
+      end
     end
 
     context "when provided multiple criteria" do
@@ -1098,6 +1412,156 @@ describe Mongoid::Criteria::Queryable::Selectable do
         it_behaves_like 'returns a cloned query'
       end
 
+      context 'when criteria are simple and handled via Key' do
+        shared_examples_for 'adds conditions with $or' do
+
+          it "adds conditions with $or" do
+            expect(selection.selector).to eq({
+              '$or' => [
+                {'field' => 3},
+                {'field' => {'$lt' => 5}},
+              ],
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $eq' do
+
+          it "combines conditions with $eq" do
+            expect(selection.selector).to eq({
+              'field' => {
+                '$eq' => 3,
+                '$lt' => 5,
+              },
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $regex' do
+
+          it "combines conditions with $regex" do
+            expect(selection.selector).to eq({
+              'field' => {
+                '$regex' => /t/,
+                '$lt' => 5,
+              },
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        context 'criteria are provided in the same hash' do
+          context 'non-regexp argument' do
+            let(:selection) do
+              query.send(tested_method, :field => 3, :field.lt => 5)
+            end
+
+            it_behaves_like 'combines conditions with $eq'
+          end
+
+          context 'regexp argument' do
+            let(:selection) do
+              query.send(tested_method, :field => /t/, :field.lt => 5)
+            end
+
+            it_behaves_like 'combines conditions with $regex'
+          end
+        end
+
+        context 'criteria are provided in separate hashes' do
+          let(:selection) do
+            query.send(tested_method, {:field => 3}, {:field.lt => 5})
+          end
+
+          it_behaves_like 'adds conditions with $or'
+        end
+
+        context 'when the criterion is wrapped in an array' do
+          let(:selection) do
+            query.send(tested_method, [:field => 3], [:field.lt => 5])
+          end
+
+          it_behaves_like 'adds conditions with $or'
+        end
+      end
+
+      context 'when criteria are handled via Key and simple' do
+        shared_examples_for 'adds conditions with $or' do
+
+          it "adds conditions with $or" do
+            expect(selection.selector).to eq({
+              '$or' => [
+                {'field' => {'$gt' => 3}},
+                {'field' => 5},
+              ],
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $eq' do
+
+          it "combines conditions with $eq" do
+            expect(selection.selector).to eq(
+              'field' => {'$gt' => 3, '$eq' => 5},
+            )
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $regex' do
+
+          it "combines conditions with $regex" do
+            expect(selection.selector).to eq(
+              'field' => {'$gt' => 3, '$regex' => /t/},
+            )
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        context 'criteria are provided in the same hash' do
+          context 'non-regexp argument' do
+            let(:selection) do
+              query.send(tested_method, :field.gt => 3, :field => 5)
+            end
+
+            it_behaves_like 'combines conditions with $eq'
+          end
+
+          context 'regexp argument' do
+            let(:selection) do
+              query.send(tested_method, :field.gt => 3, :field => /t/)
+            end
+
+            it_behaves_like 'combines conditions with $regex'
+          end
+        end
+
+        context 'criteria are provided in separate hashes' do
+          let(:selection) do
+            query.send(tested_method, {:field.gt => 3}, {:field => 5})
+          end
+
+          it_behaves_like 'adds conditions with $or'
+        end
+
+        context 'when the criterion is wrapped in an array' do
+          let(:selection) do
+            query.send(tested_method, [:field.gt => 3], [:field => 5])
+          end
+
+          it_behaves_like 'adds conditions with $or'
+        end
+      end
+
       context "when a criterion has an aliased field" do
 
         let(:selection) do
@@ -1184,6 +1648,42 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
+
+    context 'when using multiple criteria and symbol operators' do
+      context 'when using fields that meaningfully evolve values' do
+
+        let(:query) do
+          Dictionary.any_of({a: 1}, :published.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$or' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in local time,
+            # because we are querying on a Time field and dates are interpreted
+            # in local time when assigning to Time fields
+            {'published' => {'$gt' => Time.local(2020, 2, 3)}},
+          ]}
+        end
+      end
+
+      context 'when using fields that do not meaningfully evolve values' do
+
+        let(:query) do
+          Dictionary.any_of({a: 1}, :submitted_on.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$or' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in UTC,
+            # because we are querying on a Date field and dates are interpreted
+            # in UTC when persisted as dates by Mongoid
+            {'submitted_on' => {'$gt' => Time.utc(2020, 2, 3)}},
+          ]}
+        end
+      end
+    end
   end
 
   describe "#not" do
@@ -1271,6 +1771,25 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
 
+      context "when the criteria uses Key" do
+
+        let(:selection) do
+          query.not(:age.gt => 50)
+        end
+
+        it "negates the gt selection" do
+          expect(selection.selector).to eq(
+            '$and' => ['$nor' => ['age' => {'$gt' => 50}]]
+          )
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it "removes the negation on the clone" do
+          expect(selection).to_not be_negating
+        end
+      end
+
       context "when the following criteria is a where" do
 
         let(:selection) do
@@ -1543,5 +2062,477 @@ describe Mongoid::Criteria::Queryable::Selectable do
         )
       end
     end
+
+    context 'when giving multiple conditions in one call on the same key with symbol operator' do
+
+      context 'non-regexp argument' do
+        let(:selection) do
+          query.not(field: 1, :field.gt => 0)
+        end
+
+        it 'combines conditions with $eq' do
+          selection.selector.should == {
+            '$and' => ['$nor' => [
+              'field' => {'$eq' => 1, '$gt' => 0},
+            ]]
+          }
+        end
+      end
+
+      context 'regexp argument' do
+        let(:selection) do
+          query.not(field: /t/, :field.gt => 0)
+        end
+
+        it 'combines conditions with $regex' do
+          selection.selector.should == {
+            '$and' => ['$nor' => [
+              'field' => {'$regex' => /t/, '$gt' => 0},
+            ]]
+          }
+        end
+      end
+    end
+
+    # This test confirms that MONGOID-5097 has been repaired.
+    context "when using exists on a field of type Time" do
+      let(:criteria) do
+        Dictionary.any_of({:published.exists => true}, published: nil)
+      end
+
+      it "doesn't raise an error" do
+        expect do
+          criteria
+        end.to_not raise_error
+      end
+
+      it "generates the correct selector" do
+        expect(criteria.selector).to eq({
+          "$or" => [ {
+            "published" => { "$exists" => true }
+          }, {
+            "published" => nil
+          } ] } )
+      end
+    end
+  end
+
+  describe "#none_of" do
+    context 'when argument is a mix of Criteria and hashes' do
+      let(:query) { Mongoid::Query.new.where(hello: 'world') }
+      let(:other1) { Mongoid::Query.new.where(foo: 'bar') }
+      let(:other2) { { bar: 42 } }
+      let(:other3) { Mongoid::Query.new.where(a: 2) }
+
+      let(:result) { query.none_of(other1, other2, other3) }
+
+      it 'combines' do
+        expect(result.selector).to eq(
+          'hello' => 'world',
+          '$nor' => [
+            {'foo' => 'bar'},
+            {'bar' => 42},
+            {'a' => 2},
+          ],
+        )
+      end
+    end
+
+    context "when provided no arguments" do
+      let(:selection) { query.none_of }
+
+      it_behaves_like 'returns a cloned query'
+
+      it "does not add any criteria" do
+        expect(selection.selector).to eq({})
+      end
+
+      it "returns the query" do
+        expect(selection).to eq(query)
+      end
+    end
+
+    context "when provided nil" do
+      let(:selection) { query.none_of(nil) }
+
+      it_behaves_like 'returns a cloned query'
+
+      it "does not add any criteria" do
+        expect(selection.selector).to eq({})
+      end
+
+      it "returns the query" do
+        expect(selection).to eq(query)
+      end
+    end
+
+    context "when provided a single criterion" do
+      let(:selection) { query.none_of(field: [ 1, 2 ]) }
+
+      it_behaves_like 'returns a cloned query'
+
+      it 'adds the $nor selector' do
+        expect(selection.selector).to eq(
+          '$nor' => [ { 'field' => [ 1, 2 ] } ],
+        )
+      end
+
+      context 'when the criterion is wrapped in array' do
+        let(:selection) { query.none_of([{ field: [ 1, 2 ] }]) }
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'adds the condition' do
+          expect(selection.selector).to eq(
+            '$nor' => [ { 'field' => [ 1, 2 ] } ],
+          )
+        end
+
+        context 'when the array has nil as one of the elements' do
+          let(:selection) { query.none_of([{ field: [ 1, 2 ] }, nil]) }
+
+          it_behaves_like 'returns a cloned query'
+
+          it 'adds the $nor selector ignoring the nil element' do
+            expect(selection.selector).to eq(
+              '$nor' => [ { 'field' => [ 1, 2 ] } ],
+            )
+          end
+        end
+      end
+
+      context 'when query already has a condition on another field' do
+        context 'when there is one argument' do
+          let(:selection) { query.where(foo: 'bar').none_of(field: [ 1, 2 ]) }
+
+          it 'adds the new condition' do
+            expect(selection.selector).to eq(
+              'foo' => 'bar',
+              '$nor' => [ { 'field' => [1, 2] } ],
+            )
+          end
+        end
+
+        context 'when there are multiple arguments' do
+          let(:selection) do
+            query.where(foo: 'bar').none_of({ field: [ 1, 2 ] }, { hello: 'world' })
+          end
+
+          it 'adds the new condition' do
+            expect(selection.selector).to eq(
+              'foo' => 'bar',
+              '$nor' => [
+                { 'field' => [1, 2] },
+                { 'hello' => 'world' },
+              ],
+            )
+          end
+        end
+      end
+
+      context 'when query already has a $nor condition and another condition' do
+        let(:selection) do
+          query.nor(field: [ 1, 2 ]).where(foo: 'bar').none_of(test: 1)
+        end
+
+        it 'adds the new condition' do
+          expect(selection.selector).to eq(
+            '$nor' => [ { 'field' => [1, 2] } ],
+            'foo' => 'bar',
+            '$and' => [ { '$nor' => [ { 'test' => 1 } ] } ]
+          )
+        end
+      end
+
+      context 'when none_of has multiple arguments' do
+        let(:selection) do
+          query.nor(field: [ 1, 2 ]).where(foo: 'bar').none_of({a: 1}, {b: 2})
+        end
+
+        it 'adds the new condition to top level' do
+          expect(selection.selector).to eq(
+            'foo' => 'bar',
+            '$nor' => [ { 'field' => [1, 2] } ],
+            '$and' => [ { '$nor' => [ { 'a' => 1 }, { 'b' => 2 } ] } ]
+          )
+        end
+
+        context 'when query already has a top-level $and' do
+          let(:selection) do
+            query.nor(field: [ 1, 2 ]).where('$and' => [foo: 'bar']).none_of({a: 1}, {b: 2})
+          end
+
+          it 'adds the new condition to top level $and' do
+            expect(selection.selector).to eq(
+              '$nor' => [ { 'field' => [1, 2] } ],
+              '$and' => [
+                { 'foo' => 'bar' },
+                { '$nor' => [ { 'a' => 1 }, { 'b' => 2 } ] }
+              ],
+            )
+          end
+        end
+      end
+    end
+
+    context "when provided multiple criteria" do
+      context "when the criteria are for different fields" do
+        let(:selection) do
+          query.none_of({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it "adds the $nor selector" do
+          expect(selection.selector).to eq({
+            "$nor" => [
+              { "first" => [ 1, 2 ] },
+              { "second" => [ 3, 4 ] }
+            ]
+          })
+        end
+      end
+
+      context "when the criteria uses a Key instance" do
+        let(:selection) do
+          query.none_of({ first: [ 1, 2 ] }, { :second.gt => 3 })
+        end
+
+        it "adds the $nor selector" do
+          expect(selection.selector).to eq({
+            "$nor" => [
+              { "first" => [ 1, 2 ] },
+              { "second" => { "$gt" => 3 }}
+            ]
+          })
+        end
+
+        it_behaves_like 'returns a cloned query'
+      end
+
+      context 'when criteria are simple and handled via Key' do
+        shared_examples_for 'adds conditions with $nor' do
+          it "adds conditions with $nor" do
+            expect(selection.selector).to eq({
+              '$nor' => [
+                {'field' => 3},
+                {'field' => {'$lt' => 5}},
+              ],
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $eq' do
+          it "combines conditions with $eq" do
+            expect(selection.selector).to eq({
+              '$nor' => [ { 'field' => { '$eq' => 3, '$lt' => 5 } } ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $regex' do
+          it 'combines conditions with $regex' do
+            expect(selection.selector).to eq({
+              '$nor' => [ { 'field' => { '$regex' => /t/, '$lt' => 5 } } ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        context 'criteria are provided in the same hash' do
+          context 'non-regexp argument' do
+            let(:selection) { query.none_of(:field => 3, :field.lt => 5) }
+            it_behaves_like 'combines conditions with $eq'
+          end
+
+          context 'regexp argument' do
+            let(:selection) { query.none_of(:field => /t/, :field.lt => 5) }
+            it_behaves_like 'combines conditions with $regex'
+          end
+        end
+
+        context 'criteria are provided in separate hashes' do
+          let(:selection) { query.none_of({:field => 3}, {:field.lt => 5}) }
+          it_behaves_like 'adds conditions with $nor'
+        end
+
+        context 'when the criterion is wrapped in an array' do
+          let(:selection) { query.none_of([:field => 3], [:field.lt => 5]) }
+          it_behaves_like 'adds conditions with $nor'
+        end
+      end
+
+      context 'when criteria are handled via Key and simple' do
+        shared_examples_for 'adds conditions with $nor' do
+          it 'adds conditions with $nor' do
+            expect(selection.selector).to eq({
+              '$nor' => [
+                { 'field' => { '$gt' => 3 } },
+                { 'field' => 5 },
+              ],
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $eq' do
+          it 'combines conditions with $eq' do
+            expect(selection.selector).to eq(
+              '$nor' => [ { 'field' => {'$gt' => 3, '$eq' => 5} } ],
+            )
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $regex' do
+          it 'combines conditions with $regex' do
+            expect(selection.selector).to eq(
+              '$nor' => [ { 'field' => {'$gt' => 3, '$regex' => /t/} } ],
+            )
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        context 'criteria are provided in the same hash' do
+          context 'non-regexp argument' do
+            let(:selection) { query.none_of(:field.gt => 3, :field => 5) }
+            it_behaves_like 'combines conditions with $eq'
+          end
+
+          context 'regexp argument' do
+            let(:selection) { query.none_of(:field.gt => 3, :field => /t/) }
+            it_behaves_like 'combines conditions with $regex'
+          end
+        end
+
+        context 'criteria are provided in separate hashes' do
+          let(:selection) { query.none_of({:field.gt => 3}, {:field => 5}) }
+          it_behaves_like 'adds conditions with $nor'
+        end
+
+        context 'when the criterion is wrapped in an array' do
+          let(:selection) { query.none_of([:field.gt => 3], [:field => 5]) }
+          it_behaves_like 'adds conditions with $nor'
+        end
+      end
+
+      context 'when a criterion has an aliased field' do
+        let(:selection) { query.none_of({ id: 1 }) }
+        
+        it 'adds the $nor selector and aliases the field' do
+          expect(selection.selector).to eq('$nor' => [{ '_id' => 1 }])
+        end
+
+        it_behaves_like 'returns a cloned query'
+      end
+
+      context 'when a criterion is wrapped in an array' do
+        let(:selection) do
+          query.none_of([{ first: [ 1, 2 ] }, { :second.gt => 3 }])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'adds the $ nor selector' do
+          expect(selection.selector).to eq({
+            '$nor' => [
+              { 'first' => [ 1, 2 ] },
+              { 'second' => { '$gt' => 3 }}
+            ]
+          })
+        end
+      end
+
+      context "when the criteria are on the same field" do
+        let(:selection) do
+          query.none_of({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'appends both $nor expressions' do
+          expect(selection.selector).to eq({
+            "$nor" => [
+              { "first" => [ 1, 2 ] },
+              { "first" => [ 3, 4 ] }
+            ]
+          })
+        end
+      end
+    end
+
+    context 'when chaining the criteria' do
+      context 'when the criteria are for different fields' do
+        let(:selection) do
+          query.none_of(first: [ 1, 2 ]).none_of(second: [ 3, 4 ])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'adds the conditions separately' do
+          expect(selection.selector).to eq(
+            '$nor' => [ { 'first' => [ 1, 2 ] } ],
+            '$and' => [ { '$nor' => [ { 'second' => [ 3, 4 ] } ] } ],
+          )
+        end
+      end
+
+      context "when the criteria are on the same field" do
+        let(:selection) do
+          query.none_of(first: [ 1, 2 ]).none_of(first: [ 3, 4 ])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'adds the conditions separately' do
+          expect(selection.selector).to eq(
+            '$nor' => [ { 'first' => [ 1, 2 ] } ],
+            '$and' => [ { '$nor' => [ { 'first' => [ 3, 4 ] } ] } ]
+          )
+        end
+      end
+    end
+
+    context 'when using multiple criteria and symbol operators' do
+      context 'when using fields that meaningfully evolve values' do
+        let(:query) do
+          Dictionary.none_of({a: 1}, :published.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$nor' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in local time,
+            # because we are querying on a Time field and dates are interpreted
+            # in local time when assigning to Time fields
+            {'published' => {'$gt' => Time.local(2020, 2, 3) } },
+          ] }
+        end
+      end
+
+      context 'when using fields that do not meaningfully evolve values' do
+        let(:query) do
+          Dictionary.none_of({a: 1}, :submitted_on.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$nor' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in UTC,
+            # because we are querying on a Date field and dates are interpreted
+            # in UTC when persisted as dates by Mongoid
+            {'submitted_on' => {'$gt' => Time.utc(2020, 2, 3)}},
+          ]}
+        end
+      end
+    end
   end
 end