mongoid 7.1.6 → 7.2.2

data/spec/mongoid/copyable_spec_models.rb

@@ -6,6 +6,7 @@ module CopyableSpec
     include Mongoid::Document
 
     embeds_many :locations
+    embeds_many :influencers
   end
 
   class Location
@@ -17,4 +18,31 @@ module CopyableSpec
   class Building
     include Mongoid::Document
   end
+
+  class Influencer
+    include Mongoid::Document
+
+    embeds_many :blurbs
+  end
+
+  class Youtuber < Influencer
+  end
+
+  class Blurb
+    include Mongoid::Document
+  end
+
+  # Do not include Attributes::Dynamic
+  class Reg
+    include Mongoid::Document
+
+    field :name, type: String
+  end
+
+  class Dyn
+    include Mongoid::Document
+    include Mongoid::Attributes::Dynamic
+
+    field :name, type: String
+  end
 end

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

@@ -1447,6 +1447,42 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
+
+    context 'when using multiple criteria and symbol operators' do
+      context 'when using fields that meaningfully evolve values' do
+
+        let(:query) do
+          Dictionary.any_of({a: 1}, :published.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$or' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in local time,
+            # because we are querying on a Time field and dates are interpreted
+            # in local time when assigning to Time fields
+            {'published' => {'$gt' => Time.local(2020, 2, 3)}},
+          ]}
+        end
+      end
+
+      context 'when using fields that do not meaningfully evolve values' do
+
+        let(:query) do
+          Dictionary.any_of({a: 1}, :submitted_on.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$or' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in UTC,
+            # because we are querying on a Date field and dates are interpreted
+            # in UTC when persisted as dates by Mongoid
+            {'submitted_on' => {'$gt' => Time.utc(2020, 2, 3)}},
+          ]}
+        end
+      end
+    end
   end
 
   describe "#not" do

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

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
 
-    it "returns the fields with required _id minus type" do
-      expect(criteria.field_list).to eq([ "_id", "name" ])
+    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
+
+    context "when given an id" do
+      it "behaves as Findable" do
+        result = criteria.find(depeche.id)
+        expect(result).to eq(depeche)
+      end
     end
   end
 
@@ -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
@@ -3735,7 +3859,7 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#geo_spacial" do
+  describe "#geo_spatial" do
 
     context "when checking within a polygon" do
 
@@ -3748,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
@@ -3832,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