mongoid 7.1.0.rc0 → 7.2.0.rc1

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

@@ -732,108 +732,89 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#geo_spacial" do
+  %i(geo_spatial geo_spacial).each do |meth|
+    describe "#geo_spacial" do
 
-    let(:query_method) { :geo_spacial }
+      let(:query_method) { meth }
 
-    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.geo_spacial(:location.intersects_point => [ 1, 10 ])
-        end
+          let(:selection) do
+            query.public_send(query_method, :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
+            })
+          end
 
-        it_behaves_like "returns a cloned query"
-      end
+          it_behaves_like "returns a cloned query"
+        end
 
-      context "when the geometry is a line intersection" do
+        context "when the geometry is a line intersection" do
 
-        let(:selection) do
-          query.geo_spacial(:location.intersects_line => [[ 1, 10 ], [ 2, 10 ]])
-        end
+          let(:selection) do
+            query.public_send(query_method, :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
+            })
+          end
 
-        it_behaves_like "returns a cloned query"
-      end
+          it_behaves_like "returns a cloned query"
+        end
 
-      context "when the geometry is a polygon intersection" do
+        context "when the geometry is a polygon intersection" do
 
-        let(:selection) do
-          query.geo_spacial(
-            :location.intersects_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-          )
-        end
+          let(:selection) do
+            query.public_send(query_method,
+              :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 ]]]
+          it "adds the $geoIntersects expression" do
+            expect(selection.selector).to eq({
+              "location" => {
+                "$geoIntersects" => {
+                  "$geometry" => {
+                    "type" => "Polygon",
+                    "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+                  }
                 }
               }
-            }
-          })
-        end
-
-        it_behaves_like "returns a cloned query"
-      end
-
-      context "when the geometry is within a polygon" do
+            })
+          end
 
-        let(:selection) do
-          query.geo_spacial(
-            :location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
-          )
+          it_behaves_like "returns a cloned query"
         end
 
-        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 the geometry is within a polygon" do
 
-        context "when used with the $box operator ($geoWithin query) " do
           let(:selection) do
-            query.geo_spacial(
-              :location.within_box => [[ 1, 10 ], [ 2, 10 ]]
+            query.public_send(query_method,
+              :location.within_polygon => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
             )
           end
 
@@ -841,16 +822,37 @@ describe Mongoid::Criteria::Queryable::Selectable do
             expect(selection.selector).to eq({
               "location" => {
                 "$geoWithin" => {
-                  "$box" => [
-                    [ 1, 10 ], [ 2, 10 ]
-                  ]
+                  "$geometry" => {
+                    "type" => "Polygon",
+                    "coordinates" => [[[ 1, 10 ], [ 2, 10 ], [ 1, 10 ]]]
+                  }
                 }
               }
             })
           end
-        end
 
-        it_behaves_like "returns a cloned query"
+          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
       end
     end
   end
@@ -2450,6 +2452,58 @@ describe Mongoid::Criteria::Queryable::Selectable do
         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

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

@@ -52,6 +52,22 @@ describe Mongoid::Criteria::Queryable::Storable do
         end
       end
 
+      context '$and to query with $and which already has the given key' do
+        let(:query) do
+          Mongoid::Query.new.where('$and' => [{foo: 'zoom'}])
+        end
+
+        let(:modified) do
+          query.send(query_method, '$and', [{'foo' => 'bar'}])
+        end
+
+        it 'adds to existing $and' do
+          modified.selector.should == {
+            '$and' => [{'foo' => 'zoom'}, {'foo' => 'bar'}],
+          }
+        end
+      end
+
     end
 
     context '$or operator' do
@@ -74,9 +90,11 @@ describe Mongoid::Criteria::Queryable::Storable do
           query.send(query_method, '$or', [{'foo' => 'bar'}])
         end
 
-        it 'replaces top level' do
+        it 'adds the new conditions' do
           modified.selector.should == {
-            '$or' => [{'zoom' => 'zoom'}, {'foo' => 'bar'}]}
+            'zoom' => 'zoom',
+            '$or' => ['foo' => 'bar'],
+          }
         end
       end
 
@@ -98,6 +116,66 @@ describe Mongoid::Criteria::Queryable::Storable do
     end
   end
 
+  describe '#add_field_expression' do
+    context 'simple field and value write' do
+      let(:modified) do
+        query.add_field_expression('foo', 'bar')
+      end
+
+      it 'adds the condition' do
+        modified.selector.should == {
+          'foo' => 'bar'
+        }
+      end
+    end
+
+    context 'an operator write' do
+      let(:modified) do
+        query.add_field_expression('$eq', {'foo' => 'bar'})
+      end
+
+      it 'is not allowed' do
+        lambda do
+          modified
+        end.should raise_error(ArgumentError, /Field cannot be an operator/)
+      end
+    end
+
+    context 'when another field exists in destination' do
+      let(:base) do
+        query.add_field_expression('foo', 'bar')
+      end
+
+      let(:modified) do
+        base.add_field_expression('zoom', 'zoom')
+      end
+
+      it 'adds the condition' do
+        modified.selector.should == {
+          'foo' => 'bar',
+          'zoom' => 'zoom',
+        }
+      end
+    end
+
+    context 'when field being added already exists in destination' do
+      let(:base) do
+        query.add_field_expression('foo', 'bar')
+      end
+
+      let(:modified) do
+        base.add_field_expression('foo', 'zoom')
+      end
+
+      it 'adds the new condition using $and' do
+        modified.selector.should == {
+          'foo' => 'bar',
+          '$and' => ['foo' => 'zoom'],
+        }
+      end
+    end
+  end
+
   describe '#add_operator_expression' do
     let(:query_method) { :add_operator_expression }
 

data/spec/mongoid/criteria_spec.rb

@@ -786,12 +786,72 @@ describe Mongoid::Criteria do
 
   describe "#field_list" do
 
+    context "when using the default discriminator key" do
+      let(:criteria) do
+        Doctor.only(:_id)
+      end
+
+      it "returns the fields with required _id minus type" do
+        expect(criteria.field_list).to eq([ "_id" ])
+      end
+    end
+
+    context "when using a custom discriminator key" do
+      before do
+        Person.discriminator_key = "dkey"
+      end
+
+      after do
+        Person.discriminator_key = nil
+      end
+
+      let(:criteria) do
+        Doctor.only(:_id, :_type)
+      end
+
+      it "returns the fields with type without dkey" do
+        expect(criteria.field_list).to eq([ "_id", "_type" ])
+      end
+    end
+  end
+
+  describe "#find" do
+    let!(:depeche) do
+      Band.create!(name: "Depeche Mode")
+    end
+
     let(:criteria) do
-      Band.only(:name)
+      Band.where(name: "Depeche Mode")
+    end
+
+    context "when given a block" do
+      it "behaves as Enumerable" do
+        result = criteria.find { |c| c.name == "Depeche Mode" }
+        expect(result).to eq(depeche)
+      end
+    end
+
+    context "when given a Proc and a block" do
+      it "behaves as Enumerable" do
+        result = criteria.find(-> {"default"}) { |c| c.name == "Not Depeche Mode" }
+        expect(result).to eq("default")
+      end
+    end
+
+    context "when given a Proc" do
+      it "behaves as Enumerable" do
+        lambda do
+          criteria.find(-> {"default"})
+        # Proc is not serializable to a BSON type
+        end.should raise_error(BSON::Error::UnserializableClass)
+      end
     end
 
-    it "returns the fields with required _id minus type" do
-      expect(criteria.field_list).to eq([ "_id", "name" ])
+    context "when given an id" do
+      it "behaves as Findable" do
+        result = criteria.find(depeche.id)
+        expect(result).to eq(depeche)
+      end
     end
   end
 
@@ -2337,7 +2397,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the map/reduce results" do
-        expect(map_reduce).to eq([
+        expect(map_reduce.sort_by { |doc| doc['_id'] }).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
           { "_id" => "Tool", "value" => { "likes" => 100 }}
         ])
@@ -2804,13 +2864,36 @@ describe Mongoid::Criteria do
     end
 
     context "when using inheritance" do
+      context "when using the default discriminator key" do
+        let(:criteria) do
+          Doctor.only(:_id)
+        end
 
-      let(:criteria) do
-        Doctor.only(:_id)
+        it "adds _type to the fields" do
+          expect(criteria.options[:fields]).to include("_type")
+        end
       end
 
-      it "adds _type to the fields" do
-        expect(criteria.options[:fields]["_type"]).to eq(1)
+      context "when setting a custom discriminator key" do
+        before do
+          Person.discriminator_key = "dkey"
+        end
+
+        after do
+          Person.discriminator_key = nil
+        end
+
+        let(:criteria) do
+          Doctor.only(:_id)
+        end
+
+        it "adds custom discriminator key to the fields" do
+          expect(criteria.options[:fields]).to include("dkey")
+        end
+
+        it "does not add _type to the fields" do
+          expect(criteria.options[:fields]).to_not include("_type")
+        end
       end
     end
 
@@ -3386,34 +3469,75 @@ describe Mongoid::Criteria do
   end
 
   describe "#type" do
+    context "when using the default discriminator_key" do
+      context "when the type is a string" do
 
-    context "when the type is a string" do
+        let!(:browser) do
+          Browser.create
+        end
 
-      let!(:browser) do
-        Browser.create
-      end
+        let(:criteria) do
+          Canvas.all.type("Browser")
+        end
 
-      let(:criteria) do
-        Canvas.all.type("Browser")
+        it "returns documents with the provided type" do
+          expect(criteria).to eq([ browser ])
+        end
       end
 
-      it "returns documents with the provided type" do
-        expect(criteria).to eq([ browser ])
+      context "when the type is an Array of type" do
+
+        let!(:browser) do
+          Firefox.create
+        end
+
+        let(:criteria) do
+          Canvas.all.type([ "Browser", "Firefox" ])
+        end
+
+        it "returns documents with the provided types" do
+          expect(criteria).to eq([ browser ])
+        end
       end
     end
 
-    context "when the type is an Array of type" do
+    context "when using a custom discriminator_key" do
+      before do
+        Canvas.discriminator_key = "dkey"
+      end
 
-      let!(:browser) do
-        Firefox.create
+      after do
+        Canvas.discriminator_key = nil
       end
 
-      let(:criteria) do
-        Canvas.all.type([ "Browser", "Firefox" ])
+      context "when the type is a string" do
+
+        let!(:browser) do
+          Browser.create
+        end
+
+        let(:criteria) do
+          Canvas.all.type("Browser")
+        end
+
+        it "returns documents with the provided type" do
+          expect(criteria).to eq([ browser ])
+        end
       end
 
-      it "returns documents with the provided types" do
-        expect(criteria).to eq([ browser ])
+      context "when the type is an Array of type" do
+
+        let!(:browser) do
+          Firefox.create
+        end
+
+        let(:criteria) do
+          Canvas.all.type([ "Browser", "Firefox" ])
+        end
+
+        it "returns documents with the provided types" do
+          expect(criteria).to eq([ browser ])
+        end
       end
     end
   end
@@ -3428,6 +3552,38 @@ describe Mongoid::Criteria do
       Band.create(name: "Tool")
     end
 
+    context 'when provided no arguments' do
+      context 'on a model class' do
+        it 'returns an empty criteria' do
+          Band.where.selector.should == {}
+        end
+      end
+
+      context 'on an association' do
+        it 'returns an empty criteria' do
+          match.records.where.selector.should == {}
+        end
+      end
+    end
+
+    context 'when provided multiple arguments' do
+      context 'on a model class' do
+        it 'raises ArgumentError' do
+          lambda do
+            Band.where({foo: 1}, {bar: 2})
+          end.should raise_error(ArgumentError, /where requires zero or one arguments/)
+        end
+      end
+
+      context 'on an association' do
+        it 'raises ArgumentError' do
+          lambda do
+            match.records.where({foo: 1}, {bar: 2})
+          end.should raise_error(ArgumentError, /where requires zero or one arguments/)
+        end
+      end
+    end
+
     context "when provided a string" do
 
       context "when the criteria is embedded" do
@@ -3502,7 +3658,8 @@ describe Mongoid::Criteria do
         end
       end
 
-      context "when querying on a BSON::Decimal128", if: decimal128_supported? do
+      context "when querying on a BSON::Decimal128" do
+        min_server_version '3.4'
 
         let(:decimal) do
           BSON::Decimal128.new("0.0005")
@@ -3590,6 +3747,7 @@ describe Mongoid::Criteria do
     end
 
     context "when the code has scope" do
+      max_server_version '4.2'
 
       let(:criteria) do
         Band.for_js("this.name == param", param: "Depeche Mode")
@@ -3701,7 +3859,7 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#geo_spacial" do
+  describe "#geo_spatial" do
 
     context "when checking within a polygon" do
 
@@ -3714,7 +3872,7 @@ describe Mongoid::Criteria do
       end
 
       let(:criteria) do
-        Bar.geo_spacial(
+        Bar.geo_spatial(
           :location.within_polygon => [[[ 50, 10 ], [ 50, 20 ], [ 60, 20 ], [ 60, 10 ], [ 50, 10 ]]]
         )
       end
@@ -3798,34 +3956,75 @@ describe Mongoid::Criteria do
   end
 
   describe "#type_selection" do
+    context "when using the default discriminator_key" do
+      context "when only one subclass exists" do
 
-    context "when only one subclass exists" do
+        let(:criteria) do
+          described_class.new(Firefox)
+        end
 
-      let(:criteria) do
-        described_class.new(Firefox)
-      end
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
 
-      let(:selection) do
-        criteria.send(:type_selection)
+        it "does not use an $in query" do
+          expect(selection).to eq({ _type: "Firefox" })
+        end
       end
 
-      it "does not use an $in query" do
-        expect(selection).to eq({ _type: "Firefox" })
+      context "when more than one subclass exists" do
+
+        let(:criteria) do
+          described_class.new(Browser)
+        end
+
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
+
+        it "does not use an $in query" do
+          expect(selection).to eq({ _type: { "$in" => [ "Firefox", "Browser" ]}})
+        end
       end
     end
 
-    context "when more than one subclass exists" do
+    context "when using a custom discriminator_key" do
+      before do
+        Canvas.discriminator_key = "dkey"
+      end
 
-      let(:criteria) do
-        described_class.new(Browser)
+      after do
+        Canvas.discriminator_key = nil
       end
 
-      let(:selection) do
-        criteria.send(:type_selection)
+      context "when only one subclass exists" do
+
+        let(:criteria) do
+          described_class.new(Firefox)
+        end
+
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
+
+        it "does not use an $in query" do
+          expect(selection).to eq({ dkey: "Firefox" })
+        end
       end
 
-      it "does not use an $in query" do
-        expect(selection).to eq({ _type: { "$in" => [ "Firefox", "Browser" ]}})
+      context "when more than one subclass exists" do
+
+        let(:criteria) do
+          described_class.new(Browser)
+        end
+
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
+
+        it "does not use an $in query" do
+          expect(selection).to eq({ dkey: { "$in" => [ "Firefox", "Browser" ]}})
+        end
       end
     end
   end