mongoid 7.2.6 → 7.3.0

data/spec/mongoid/criteria/queryable/extensions/boolean_spec.rb

@@ -3,7 +3,7 @@
 
 require "spec_helper"
 
-describe Boolean do
+describe Mongoid::Boolean do
 
   describe ".evolve" do
 

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

@@ -44,7 +44,7 @@ describe Mongoid::Criteria::Queryable::Mergeable do
 
   describe '#_mongoid_expand_keys' do
     it 'expands simple keys' do
-      query.send(:_mongoid_expand_keys, {a: 1}).should == {a: 1}
+      query.send(:_mongoid_expand_keys, {a: 1}).should == {'a' => 1}
     end
 
     let(:gt) do
@@ -68,18 +68,116 @@ describe Mongoid::Criteria::Queryable::Mergeable do
         'age' => {'$gt' => 42, '$lt' => 50}}
     end
 
-    it 'expands simple and Key instances on the same field' do
-      query.send(:_mongoid_expand_keys, {'age' => 42, lt => 50}).should == {
-        'age' => {'$eq' => 42, '$lt' => 50}}
+    context 'given implicit equality and Key instance on the same field' do
+      [42, 'infinite', [nil]].each do |value|
+        context "for non-regular expression value #{value}" do
+          context 'implicit equality then Key instance' do
+            it 'expands implicit equality with $eq and combines with Key operator' do
+              query.send(:_mongoid_expand_keys, {'age' => value, lt => 50}).should == {
+                'age' => {'$eq' => value, '$lt' => 50}}
+            end
+          end
+
+          context 'symbol operator then implicit equality' do
+            it 'expands implicit equality with $eq and combines with Key operator' do
+              query.send(:_mongoid_expand_keys, {gt => 42, 'age' => value}).should == {
+                'age' => {'$gt' => 42, '$eq' => value}}
+            end
+          end
+        end
+      end
     end
 
-    it 'expands Key and simple instances on the same field' do
-      query.send(:_mongoid_expand_keys, {gt => 42, 'age' => 50}).should == {
-        'age' => {'$gt' => 42, '$eq' => 50}}
+    context 'given implicit equality with Regexp argument and Key instance on the same field' do
+      [/42/, BSON::Regexp::Raw.new('42')].each do |value|
+        context "for regular expression value #{value}" do
+          context 'implicit equality then Key instance' do
+            it 'expands implicit equality with $eq and combines with Key operator' do
+              query.send(:_mongoid_expand_keys, {'age' => value, lt => 50}).should == {
+                'age' => {'$regex' => value, '$lt' => 50}}
+            end
+          end
+
+          context 'Key instance then implicit equality' do
+            it 'expands implicit equality with $eq and combines with Key operator' do
+              query.send(:_mongoid_expand_keys, {gt => 50, 'age' => value}).should == {
+                'age' => {'$gt' => 50, '$regex' => value}}
+            end
+          end
+        end
+      end
     end
 
     it 'Ruby does not allow same symbol operator with different values' do
       {gt => 42, gtp => 50}.should == {gtp => 50}
     end
+
+    let(:expanded) do
+      query.send(:_mongoid_expand_keys, condition)
+    end
+
+    context 'field name => value' do
+      shared_examples_for 'expands' do
+
+        it 'expands' do
+          expanded.should == {'foo' => 'bar'}
+        end
+      end
+
+      context 'string key' do
+        let(:condition) do
+          {'foo' => 'bar'}
+        end
+
+        it_behaves_like 'expands'
+      end
+
+      context 'symbol key' do
+        let(:condition) do
+          {foo: 'bar'}
+        end
+
+        it_behaves_like 'expands'
+      end
+    end
+
+    context 'Key instance => value' do
+      let(:key) do
+        Mongoid::Criteria::Queryable::Key.new(:foo, :__override__, '$gt')
+      end
+
+      let(:condition) do
+        {key => 'bar'}
+      end
+
+      it 'expands' do
+        expanded.should == {'foo' => {'$gt' => 'bar'}}
+      end
+    end
+
+    context 'operator => operator value expression' do
+      shared_examples_for 'expands' do
+
+        it 'expands' do
+          expanded.should == {'foo' => {'$in' => ['bar']}}
+        end
+      end
+
+      context 'string key' do
+        let(:condition) do
+          {foo: {'$in' => %w(bar)}}
+        end
+
+        it_behaves_like 'expands'
+      end
+
+      context 'symbol key' do
+        let(:condition) do
+          {foo: {:$in => %w(bar)}}
+        end
+
+        it_behaves_like 'expands'
+      end
+    end
   end
 end

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