mongoid 7.6.2 → 8.0.1

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

@@ -754,127 +754,119 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  %i(geo_spatial geo_spacial).each do |meth|
-    describe "#geo_spacial" do
+  describe "#geo_spatial" do
 
-      let(:query_method) { meth }
+    let(:query_method) { :geo_spatial }
 
-      it_behaves_like 'requires an argument'
-      it_behaves_like 'requires a non-nil argument'
+    it_behaves_like 'requires an argument'
+    it_behaves_like 'requires a non-nil argument'
 
-      context "when provided a criterion" do
+    context "when provided a criterion" do
 
-        context "when the geometry is a point intersection" do
+      context "when the geometry is a point intersection" do
 
-          let(:selection) do
-            query.public_send(query_method, :location.intersects_point => [ 1, 10 ])
-          end
+        let(:selection) do
+          query.geo_spatial(:location.intersects_point => [ 1, 10 ])
+        end
 
-          it "adds the $geoIntersects expression" do
-            expect(selection.selector).to eq({
-              "location" => {
-                "$geoIntersects" => {
-                  "$geometry" => {
-                    "type" => "Point",
-                    "coordinates" => [ 1, 10 ]
-                  }
+        it "adds the $geoIntersects expression" do
+          expect(selection.selector).to eq({
+            "location" => {
+              "$geoIntersects" => {
+                "$geometry" => {
+                  "type" => "Point",
+                  "coordinates" => [ 1, 10 ]
                 }
               }
-            })
-          end
-
-          it_behaves_like "returns a cloned query"
+            }
+          })
         end
 
-        context "when the geometry is a line intersection" do
+        it_behaves_like "returns a cloned query"
+      end
+
+      context "when the geometry is a line intersection" do
 
-          let(:selection) do
-            query.public_send(query_method, :location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
-          end
+        let(:selection) do
+          query.geo_spatial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
+        end
 
-          it "adds the $geoIntersects expression" do
-            expect(selection.selector).to eq({
-              "location" => {
-                "$geoIntersects" => {
-                  "$geometry" => {
-                    "type" => "LineString",
-                    "coordinates" => [[ 1, 10 ], [ 2, 10 ]]
-                  }
+        it "adds the $geoIntersects expression" do
+          expect(selection.selector).to eq({
+            "location" => {
+              "$geoIntersects" => {
+                "$geometry" => {
+                  "type" => "LineString",
+                  "coordinates" => [[ 1, 10 ], [ 2, 10 ]]
                 }
               }
-            })
-          end
-
-          it_behaves_like "returns a cloned query"
+            }
+          })
         end
 
-        context "when the geometry is a polygon intersection" do
+        it_behaves_like "returns a cloned query"
+      end
 
-          let(:selection) do
-            query.public_send(query_method,
-              :location.intersects_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-            )
-          end
+      context "when the geometry is a polygon intersection" do
 
-          it "adds the $geoIntersects expression" do
-            expect(selection.selector).to eq({
-              "location" => {
-                "$geoIntersects" => {
-                  "$geometry" => {
-                    "type" => "Polygon",
-                    "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-                  }
+        let(:selection) do
+          query.geo_spatial(:location.intersects_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]])
+        end
+
+        it "adds the $geoIntersects expression" do
+          expect(selection.selector).to eq({
+            "location" => {
+              "$geoIntersects" => {
+                "$geometry" => {
+                  "type" => "Polygon",
+                  "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
                 }
               }
-            })
-          end
+            }
+          })
+        end
+
+        it_behaves_like "returns a cloned query"
+      end
 
-          it_behaves_like "returns a cloned query"
+      context "when the geometry is within a polygon" do
+
+        let(:selection) do
+          query.geo_spatial(:location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]])
         end
 
-        context "when the geometry is within a polygon" do
+        it "adds the $geoIntersects expression" do
+          expect(selection.selector).to eq({
+            "location" => {
+              "$geoWithin" => {
+                "$geometry" => {
+                  "type" => "Polygon",
+                  "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+                }
+              }
+            }
+          })
+        end
 
+        context "when used with the $box operator ($geoWithin query) " do
           let(:selection) do
-            query.public_send(query_method,
-              :location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-            )
+            query.geo_spatial(:location.within_box => [[ 1, 10 ], [ 2, 10 ]])
           end
 
           it "adds the $geoIntersects expression" do
             expect(selection.selector).to eq({
               "location" => {
                 "$geoWithin" => {
-                  "$geometry" => {
-                    "type" => "Polygon",
-                    "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-                  }
+                  "$box" => [
+                    [ 1, 10 ], [ 2, 10 ]
+                  ]
                 }
               }
             })
           end
-
-          context "when used with the $box operator ($geoWithin query) " do
-            let(:selection) do
-              query.public_send(query_method,
-                :location.within_box => [[ 1, 10 ], [ 2, 10 ]]
-              )
-            end
-
-            it "adds the $geoIntersects expression" do
-              expect(selection.selector).to eq({
-                "location" => {
-                  "$geoWithin" => {
-                    "$box" => [
-                      [ 1, 10 ], [ 2, 10 ]
-                    ]
-                  }
-                }
-              })
-            end
-          end
-
-          it_behaves_like "returns a cloned query"
         end
+
+        it_behaves_like "returns a cloned query"
       end
     end
   end

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

@@ -35,8 +35,6 @@ describe Mongoid::Criteria::Queryable::Selectable do
     it_behaves_like 'requires a non-nil argument'
 
     context "when provided a string" do
-      # String criteria compile to $where, which requires the opt-in.
-      config_override :allow_unsafe_query_operators, true
 
       let(:selection) do
         query.where("this.value = 10")
@@ -588,202 +586,4 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
     end
   end
-
-  describe 'top-level operator injection guard' do
-    context 'when allow_unsafe_query_operators is true' do
-      config_override :allow_unsafe_query_operators, true
-
-      context 'when passing $where' do
-        it 'does not raise' do
-          expect do
-            query.where('$where' => 'this.name == "admin"')
-          end.not_to raise_error
-        end
-      end
-
-      context 'when passing a string criterion' do
-        it 'does not raise' do
-          expect do
-            query.where('this.name == "admin"')
-          end.not_to raise_error
-        end
-      end
-
-      context 'when passing a string criterion to a negated query' do
-        it 'does not raise' do
-          expect do
-            query.not.where('this.name == "admin"')
-          end.not_to raise_error
-        end
-      end
-
-      context 'when passing $function' do
-        it 'does not raise' do
-          expect do
-            query.where('$function' => { body: 'function() { return true; }', args: [], lang: 'js' })
-          end.not_to raise_error
-        end
-      end
-    end
-
-    context 'when allow_unsafe_query_operators is false' do
-      config_override :allow_unsafe_query_operators, false
-
-      context 'when passing $where' do
-        it 'raises InvalidQuery' do
-          expect do
-            query.where('$where' => 'this.name == "admin"')
-          end.to raise_error(Mongoid::Errors::InvalidQuery, /\$where/)
-        end
-      end
-
-      context 'when passing $function' do
-        it 'raises InvalidQuery' do
-          expect do
-            query.where('$function' => { body: 'function() { return true; }', args: [], lang: 'js' })
-          end.to raise_error(Mongoid::Errors::InvalidQuery, /\$function/)
-        end
-      end
-
-      context 'when the error mentions allow_unsafe_query_operators' do
-        it 'includes the config opt-in in the message' do
-          expect do
-            query.where('$where' => 'true')
-          end.to raise_error(Mongoid::Errors::InvalidQuery, /allow_unsafe_query_operators/)
-        end
-      end
-
-      context 'when passing a string criterion' do
-        it 'raises InvalidQuery' do
-          expect do
-            query.where('this.name == "admin"')
-          end.to raise_error(Mongoid::Errors::InvalidQuery, /\$where/)
-        end
-
-        it 'includes the config opt-in in the message' do
-          expect do
-            query.where('this.name == "admin"')
-          end.to raise_error(Mongoid::Errors::InvalidQuery, /allow_unsafe_query_operators/)
-        end
-      end
-
-      context 'when passing a string criterion to a negated query' do
-        it 'raises InvalidQuery' do
-          expect do
-            query.not.where('this.name == "admin"')
-          end.to raise_error(Mongoid::Errors::InvalidQuery, /\$where/)
-        end
-      end
-
-      %w[$and $or $nor $not $text $comment $expr $jsonSchema $alwaysFalse $alwaysTrue].each do |op|
-        context "when passing #{op} (allowlisted)" do
-          it 'does not raise' do
-            value = case op
-                    when '$and', '$or', '$nor', '$not' then [ { 'x' => 1 } ]
-                    when '$text' then { '$search' => 'hi' }
-                    when '$expr' then { '$gt' => [ '$a', 1 ] }
-                    when '$jsonSchema' then { 'required' => [ 'x' ] }
-                    else true
-                    end
-            expect { query.where(op => value) }.not_to raise_error
-          end
-        end
-      end
-    end
-  end
-
-  describe 'nested operator injection guard' do
-    js = 'this.name == "admin"'
-
-    function_expr = {
-      '$function' => { 'body' => 'function() { return true; }', 'args' => [], 'lang' => 'js' }
-    }.freeze
-
-    accumulator_expr = {
-      '$accumulator' => {
-        'init' => 'function() { return 0; }',
-        'accumulate' => 'function() { return 0; }',
-        'accumulateArgs' => [],
-        'merge' => 'function() { return 0; }',
-        'lang' => 'js'
-      }
-    }.freeze
-
-    # Every path into the selector that does not route through #expr_query,
-    # plus the nested forms that a top-level key check cannot see.
-    unsafe_queries = {
-      'and with a $where key' => ->(query) { query.and('$where' => js) },
-      'or with a $where key' => ->(query) { query.or('$where' => js) },
-      'nor with a $where key' => ->(query) { query.nor('$where' => js) },
-      'not with a $where key' => ->(query) { query.not('$where' => js) },
-      'any_of with a $where key' => ->(query) { query.any_of('$where' => js) },
-      # none_of is not available on this branch; it landed in 8.1 via MONGOID-5453.
-      'elem_match with a nested $where' => ->(query) { query.elem_match(a: { '$where' => js }) },
-      'where with $where inside $or' => ->(query) { query.where('$or' => [ { '$where' => js } ]) },
-      'where with $function inside $expr' => ->(query) { query.where('$expr' => function_expr) },
-      'where with $accumulator inside $expr' => ->(query) { query.where('$expr' => accumulator_expr) },
-      'where with $where three levels deep' => lambda { |query|
-        query.where('$and' => [ { '$or' => [ { '$where' => js } ] } ])
-      },
-      'where with a symbol $where key inside $or' => ->(query) { query.where('$or' => [ { :$where => js } ]) }
-    }.freeze
-
-    context 'when allow_unsafe_query_operators is false' do
-      config_override :allow_unsafe_query_operators, false
-
-      unsafe_queries.each do |description, builder|
-        context "when querying with #{description}" do
-          it 'raises InvalidQuery' do
-            expect do
-              builder.call(query)
-            end.to raise_error(Mongoid::Errors::InvalidQuery, /\$where|\$function|\$accumulator/)
-          end
-        end
-      end
-
-      it 'includes the config opt-in in the message' do
-        expect do
-          query.or('$where' => js)
-        end.to raise_error(Mongoid::Errors::InvalidQuery, /allow_unsafe_query_operators/)
-      end
-
-      context 'when the nested expression is safe' do
-        it 'permits $or with field expressions' do
-          expect do
-            query.where('$or' => [ { 'a' => 1 }, { 'b' => { '$gt' => 2 } } ])
-          end.not_to raise_error
-        end
-
-        it 'permits $expr with aggregation operators' do
-          expect do
-            query.where('$expr' => { '$gt' => [ '$a', '$b' ] })
-          end.not_to raise_error
-        end
-
-        it 'permits a field whose name resembles a javascript operator' do
-          expect do
-            query.where('where' => js)
-          end.not_to raise_error
-        end
-
-        it 'permits a value that resembles a javascript operator' do
-          expect do
-            query.where('name' => '$where')
-          end.not_to raise_error
-        end
-      end
-    end
-
-    context 'when allow_unsafe_query_operators is true' do
-      config_override :allow_unsafe_query_operators, true
-
-      unsafe_queries.each do |description, builder|
-        context "when querying with #{description}" do
-          it 'does not raise' do
-            expect { builder.call(query) }.not_to raise_error
-          end
-        end
-      end
-    end
-  end
 end

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

@@ -44,7 +44,7 @@ describe Mongoid::Criteria::Queryable::Selector do
       end
     end
 
-    context "when selector contains a $nin string" do
+    context "when selector contains a $nin" do
 
       let(:initial) do
         { "$nin" => ["foo"] }
@@ -72,35 +72,7 @@ describe Mongoid::Criteria::Queryable::Selector do
       end
     end
 
-    context "when selector contains a $nin symbol" do
-
-      let(:initial) do
-        { :$nin => ["foo"] }
-      end
-
-      before do
-        selector["field"] = initial
-      end
-
-      context "when merging in a new $nin" do
-
-        let(:other) do
-          { "field" => { :$nin => ["bar"] } }
-        end
-
-        before do
-          selector.merge!(other)
-        end
-
-        it "combines the two $nin queries into one" do
-          expect(selector).to eq({
-            "field" => { :$nin => ["foo", "bar"] }
-          })
-        end
-      end
-    end
-
-    context "when selector contains a $in string" do
+    context "when selector contains a $in" do
 
       let(:initial) do
         { "$in" => [1, 2] }
@@ -145,51 +117,6 @@ describe Mongoid::Criteria::Queryable::Selector do
       end
     end
 
-    context "when selector contains a $in symbol" do
-
-      let(:initial) do
-        { :$in => [1, 2] }
-      end
-
-      before do
-        selector["field"] = initial
-      end
-
-      context "when merging in a new $in with an intersecting value" do
-
-        let(:other) do
-          { "field" => { :$in => [1] } }
-        end
-
-        before do
-          selector.merge!(other)
-        end
-
-        it "intersects the $in values" do
-          expect(selector).to eq({
-                                     "field" => { :$in => [1] }
-                                 })
-        end
-      end
-
-      context "when merging in a new $in with no intersecting values" do
-
-        let(:other) do
-          { "field" => { :$in => [3] } }
-        end
-
-        before do
-          selector.merge!(other)
-        end
-
-        it "intersects the $in values" do
-          expect(selector).to eq({
-                                     "field" => { :$in => [] }
-                                 })
-        end
-      end
-    end
-
     context "when selector is not nested" do
 
       before do
@@ -460,8 +387,20 @@ describe Mongoid::Criteria::Queryable::Selector do
             selector.send(method, "key", array)
           end
 
-          it "serializes each element in the array" do
-            expect(selector["key"]).to eq([ big_one.to_s, big_two.to_s ])
+          context 'when serializing bigdecimal to string' do
+            config_override :map_big_decimal_to_decimal128, false
+
+            it "serializes each element in the array" do
+              expect(selector["key"]).to eq([ big_one.to_s, big_two.to_s ])
+            end
+          end
+
+          context 'when serializing bigdecimal to decimal128' do
+            config_override :map_big_decimal_to_decimal128, true
+
+            it "serializes each element in the array" do
+              expect(selector["key"]).to eq([ BSON::Decimal128.new(big_one), BSON::Decimal128.new(big_two)])
+            end
           end
         end
       end

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

@@ -210,79 +210,7 @@ describe Mongoid::Criteria::Queryable::Storable do
         }
       end
     end
-
-    context 'when value is a hash combine values with different operator keys' do
-      let(:base) do
-        query.add_field_expression('foo', {'$in' => ['bar']})
-      end
-
-      let(:modified) do
-        base.add_field_expression('foo', {'$nin' => ['zoom']})
-      end
-
-      it 'combines the conditions using $and' do
-        modified.selector.should == {
-          'foo' => {
-            '$in' => ['bar'],
-            '$nin' => ['zoom']
-          }
-        }
-      end
-    end
-
-    context 'when value is a hash with symbol operator key combine values with different operator keys' do
-      let(:base) do
-        query.add_field_expression('foo', {:$in => ['bar']})
-      end
-
-      let(:modified) do
-        base.add_field_expression('foo', {:$nin => ['zoom']})
-      end
-
-      it 'combines the conditions using $and' do
-        modified.selector.should == {
-          'foo' => {
-            :$in => ['bar'],
-            :$nin => ['zoom']
-          }
-        }
-      end
-    end
-
-    context 'when value is a hash add values with same operator keys using $and' do
-      let(:base) do
-        query.add_field_expression('foo', {'$in' => ['bar']})
-      end
-
-      let(:modified) do
-        base.add_field_expression('foo', {'$in' => ['zoom']})
-      end
-
-      it 'adds the new condition using $and' do
-        modified.selector.should == {
-          'foo' => {'$in' => ['bar']},
-          '$and' => ['foo' => {'$in' => ['zoom']}]
-        }
-      end
-    end
-
-  context 'when value is a hash with symbol operator key add values with same operator keys using $and' do
-    let(:base) do
-      query.add_field_expression('foo', {:$in => ['bar']})
-    end
-
-    let(:modified) do
-      base.add_field_expression('foo', {:$in => ['zoom']})
-    end
-
-    it 'adds the new condition using $and' do
-      modified.selector.should == {
-        'foo' => {:$in => ['bar']},
-        '$and' => ['foo' => {:$in => ['zoom']}]
-      }
-    end
   end
-end
 
   describe '#add_operator_expression' do
     let(:query_method) { :add_operator_expression }