mongoid 7.6.0 → 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/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 }