mongoid 7.2.3 → 7.3.0

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

@@ -417,6 +417,40 @@ describe Mongoid::Criteria::Queryable::Selectable do
           it_behaves_like 'returns a cloned query'
         end
 
+        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
+
         context 'when criteria are handled via Key' do
           shared_examples_for 'adds the conditions to top level' do
 
@@ -467,12 +501,44 @@ describe Mongoid::Criteria::Queryable::Selectable do
             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
-            let(:selection) do
-              query.send(tested_method, :field => 3, :field.lt => 5)
+            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
 
-            it_behaves_like 'combines conditions with $and'
+            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
@@ -505,12 +571,44 @@ describe Mongoid::Criteria::Queryable::Selectable do
             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
-            let(:selection) do
-              query.send(tested_method, :field.gt => 3, :field => 5)
+            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
 
-            it_behaves_like 'combines conditions with $and'
+            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
@@ -1031,6 +1129,38 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       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.send(tested_method, field: 1, :field.gt => 0)
+        end
+
+        it 'combines conditions with $eq' do
+          selection.selector.should == {
+            expected_operator => [
+              'field' => {'$eq' => 1, '$gt' => 0},
+            ]
+          }
+        end
+      end
+
+      context 'regexp argument' do
+        let(:selection) do
+          query.send(tested_method, field: /t/, :field.gt => 0)
+        end
+
+        it 'combines conditions with $regex' do
+          selection.selector.should == {
+            expected_operator => [
+              'field' => {'$regex' => /t/, '$gt' => 0},
+            ]
+          }
+        end
+      end
+
+    end
   end
 
   describe "#or" do
@@ -1270,14 +1400,28 @@ describe Mongoid::Criteria::Queryable::Selectable do
           it_behaves_like 'returns a cloned query'
         end
 
-        shared_examples_for 'adds one condition' do
+        shared_examples_for 'combines conditions with $eq' do
 
-          it "adds one condition" do
+          it "combines conditions with $eq" do
             expect(selection.selector).to eq({
-              'field' => 3,
-              '$and' => [
-                {'field' => {'$lt' => 5}},
-              ],
+              '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
 
@@ -1285,11 +1429,21 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
 
         context 'criteria are provided in the same hash' do
-          let(:selection) do
-            query.send(tested_method, :field => 3, :field.lt => 5)
+          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
 
-          it_behaves_like 'adds one condition'
+          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
@@ -1324,24 +1478,44 @@ describe Mongoid::Criteria::Queryable::Selectable do
           it_behaves_like 'returns a cloned query'
         end
 
-        shared_examples_for 'adds one condition' do
+        shared_examples_for 'combines conditions with $eq' do
 
-          it "adds one condition" do
-            expect(selection.selector).to eq({
-              'field' => {'$gt' => 3},
-              '$and' => ['field' => 5],
-            })
+          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
-          let(:selection) do
-            query.send(tested_method, :field.gt => 3, :field => 5)
+          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
 
-          it_behaves_like 'adds one condition'
+          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
@@ -1861,5 +2035,36 @@ 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
   end
 end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+shared_examples_for "returns a cloned query" do
+
+  it "returns a cloned query" do
+    expect(selection).to_not equal(query)
+  end
+end
+
+shared_examples_for 'requires an argument' do
+  context "when provided no argument" do
+
+    let(:selection) do
+      query.send(query_method)
+    end
+
+    it "raises ArgumentError" do
+      expect do
+        selection.selector
+      end.to raise_error(ArgumentError)
+    end
+  end
+end
+
+shared_examples_for 'requires a non-nil argument' do
+  context "when provided nil" do
+
+    let(:selection) do
+      query.send(query_method, nil)
+    end
+
+    it "raises CriteriaArgumentRequired" do
+      expect do
+        selection.selector
+      end.to raise_error(Mongoid::Errors::CriteriaArgumentRequired, /#{query_method}/)
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 # encoding: utf-8
 
 require "spec_helper"
+require_relative './selectable_shared_examples'
 
 class FieldWithSerializer
   def evolve(object)
@@ -19,43 +20,6 @@ describe Mongoid::Criteria::Queryable::Selectable do
     Mongoid::Query.new("id" => "_id")
   end
 
-  shared_examples_for "returns a cloned query" do
-
-    it "returns a cloned query" do
-      expect(selection).to_not equal(query)
-    end
-  end
-
-  shared_examples_for 'requires an argument' do
-    context "when provided no argument" do
-
-      let(:selection) do
-        query.send(query_method)
-      end
-
-      it "raises ArgumentError" do
-        expect do
-          selection.selector
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  shared_examples_for 'requires a non-nil argument' do
-    context "when provided nil" do
-
-      let(:selection) do
-        query.send(query_method, nil)
-      end
-
-      it "raises CriteriaArgumentRequired" do
-        expect do
-          selection.selector
-        end.to raise_error(Mongoid::Errors::CriteriaArgumentRequired, /#{query_method}/)
-      end
-    end
-  end
-
   shared_examples_for 'supports merge strategies' do
 
     context 'when the field is not aliased' do
@@ -1978,534 +1942,6 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#where" do
-
-    let(:query_method) { :where }
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.where
-      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
-
-    it_behaves_like 'requires a non-nil argument'
-
-    context "when provided a string" do
-
-      let(:selection) do
-        query.where("this.value = 10")
-      end
-
-      it "adds the $where criterion" do
-        expect(selection.selector).to eq({ "$where" => "this.value = 10" })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-
-      context 'when multiple calls with string argument are made' do
-
-        let(:selection) do
-          query.where("this.value = 10").where('foo.bar')
-        end
-
-        it 'combines conditions' do
-          expect(selection.selector).to eq(
-            "$where" => "this.value = 10", '$and' => [{'$where' => 'foo.bar'}],
-          )
-        end
-      end
-
-      context 'when called with string argument and with hash argument' do
-
-        let(:selection) do
-          query.where("this.value = 10").where(foo: 'bar')
-        end
-
-        it 'combines conditions' do
-          expect(selection.selector).to eq(
-            "$where" => "this.value = 10", 'foo' => 'bar',
-          )
-        end
-      end
-
-      context 'when called with hash argument and with string argument' do
-
-        let(:selection) do
-          query.where(foo: 'bar').where("this.value = 10")
-        end
-
-        it 'combines conditions' do
-          expect(selection.selector).to eq(
-            'foo' => 'bar', "$where" => "this.value = 10",
-          )
-        end
-      end
-    end
-
-    context "when provided a single criterion" do
-
-      context "when the value needs no evolution" do
-
-        let(:selection) do
-          query.where(name: "Syd")
-        end
-
-        it "adds the criterion to the selection" do
-          expect(selection.selector).to eq({ "name" => "Syd" })
-        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
-        end
-
-        after(:all) do
-          Object.send(:remove_const, :Document)
-        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
-
-          it "alters the key and value" do
-            expect(selection.selector).to eq({ "user_id" => document.id })
-          end
-        end
-
-        context 'when the field is a String and the value is a BSON::Regexp::Raw' do
-
-          let(:raw_regexp) do
-            BSON::Regexp::Raw.new('^Em')
-          end
-
-          let(:selection) do
-            Login.where(_id: raw_regexp)
-          end
-
-          it 'does not convert the bson raw regexp object to a String' do
-            expect(selection.selector).to eq({ "_id" => raw_regexp })
-          end
-        end
-      end
-    end
-
-    context "when provided complex criterion" do
-
-      context "when performing an $all" do
-
-        context "when performing a single query" do
-
-          let(:selection) do
-            query.where(:field.all => [ 1, 2 ])
-          end
-
-          it "adds the $all criterion" do
-            expect(selection.selector).to eq({ "field" => { "$all" => [ 1, 2 ] }})
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-      end
-
-      context "when performing an $elemMatch" do
-
-        context "when the value is not complex" do
-
-          let(:selection) do
-            query.where(:field.elem_match => { key: 1 })
-          end
-
-          it "adds the $elemMatch criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$elemMatch" => { key: 1 } }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-
-        context "when the value is complex" do
-
-          let(:selection) do
-            query.where(:field.elem_match => { :key.gt => 1 })
-          end
-
-          it "adds the $elemMatch criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$elemMatch" => { "key" => { "$gt" => 1 }}}}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-      end
-
-      context "when performing an $exists" do
-
-        context "when providing boolean values" do
-
-          let(:selection) do
-            query.where(:field.exists => true)
-          end
-
-          it "adds the $exists criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$exists" => true }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-
-        context "when providing string values" do
-
-          let(:selection) do
-            query.where(:field.exists => "t")
-          end
-
-          it "adds the $exists criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$exists" => true }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-      end
-
-      context "when performing a $gt" do
-
-        let(:selection) do
-          query.where(:field.gt => 10)
-        end
-
-        it "adds the $gt criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$gt" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $gte" do
-
-        let(:selection) do
-          query.where(:field.gte => 10)
-        end
-
-        it "adds the $gte criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$gte" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing an $in" do
-
-        let(:selection) do
-          query.where(:field.in => [ 1, 2 ])
-        end
-
-        it "adds the $in criterion" do
-          expect(selection.selector).to eq({ "field" => { "$in" => [ 1, 2 ] }})
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $lt" do
-
-        let(:selection) do
-          query.where(:field.lt => 10)
-        end
-
-        it "adds the $lt criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$lt" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $lte" do
-
-        let(:selection) do
-          query.where(:field.lte => 10)
-        end
-
-        it "adds the $lte criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$lte" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $mod" do
-
-        let(:selection) do
-          query.where(:field.mod => [ 10, 1 ])
-        end
-
-        it "adds the $lte criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$mod" => [ 10, 1 ]}}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $ne" do
-
-        let(:selection) do
-          query.where(:field.ne => 10)
-        end
-
-        it "adds the $ne criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$ne" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $near" do
-
-        let(:selection) do
-          query.where(:field.near => [ 1, 1 ])
-        end
-
-        it "adds the $near criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$near" => [ 1, 1 ] }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $nearSphere" do
-
-        let(:selection) do
-          query.where(:field.near_sphere => [ 1, 1 ])
-        end
-
-        it "adds the $nearSphere criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$nearSphere" => [ 1, 1 ] }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $nin" do
-
-        let(:selection) do
-          query.where(:field.nin => [ 1, 2 ])
-        end
-
-        it "adds the $nin criterion" do
-          expect(selection.selector).to eq({ "field" => { "$nin" => [ 1, 2 ] }})
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $not" do
-
-        let(:selection) do
-          query.where(:field.not => /test/)
-        end
-
-        it "adds the $not criterion" do
-          expect(selection.selector).to eq({ "field" => { "$not" => /test/ }})
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-
-      context "when performing a $size" do
-
-        context "when providing an integer" do
-
-          let(:selection) do
-            query.where(:field.with_size => 10)
-          end
-
-          it "adds the $size criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$size" => 10 }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-
-        context "when providing a string" do
-
-          let(:selection) do
-            query.where(:field.with_size => "10")
-          end
-
-          it "adds the $size criterion" do
-            expect(selection.selector).to eq(
-              { "field" => { "$size" => 10 }}
-            )
-          end
-
-          it "returns a cloned query" do
-            expect(selection).to_not eq(query)
-          end
-        end
-      end
-
-      context "when performing a $type" do
-
-        let(:selection) do
-          query.where(:field.with_type => 10)
-        end
-
-        it "adds the $type criterion" do
-          expect(selection.selector).to eq(
-            { "field" => { "$type" => 10 }}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not eq(query)
-        end
-      end
-    end
-
-    context 'when using an MQL logical operator manually' do
-      let(:base_query) do
-        query.where(test: 1)
-      end
-
-      let(:selection) do
-        base_query.where(mql_operator => ['hello' => 'world'])
-      end
-
-      shared_examples_for 'adds conditions to existing query' do
-        it 'adds conditions to existing query' do
-          selection.selector.should == {
-            'test' => 1,
-            mql_operator => ['hello' => 'world'],
-          }
-        end
-      end
-
-      shared_examples_for 'adds conditions to existing query with an extra $and' do
-        it 'adds conditions to existing query' do
-          selection.selector.should == {
-            'test' => 1,
-            mql_operator => ['hello' => 'world'],
-          }
-        end
-      end
-
-      context '$or' do
-        let(:mql_operator) { '$or' }
-
-        it_behaves_like 'adds conditions to existing query with an extra $and'
-      end
-
-      context '$nor' do
-        let(:mql_operator) { '$nor' }
-
-        it_behaves_like 'adds conditions to existing query with an extra $and'
-      end
-
-      context '$not' do
-        let(:mql_operator) { '$not' }
-
-        it_behaves_like 'adds conditions to existing query'
-      end
-
-      context '$and' do
-        let(:mql_operator) { '$and' }
-
-        it_behaves_like 'adds conditions to existing query'
-      end
-    end
-  end
-
   describe Symbol do
 
     describe "#all" do