mongoid 7.5.1 → 8.1.2

data/spec/mongoid/association/embedded/embeds_many/proxy_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require_relative '../embeds_many_models.rb'
 
 describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
 
@@ -1861,51 +1862,56 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
     end
   end
 
-  describe "#delete" do
+  %i[ delete delete_one ].each do |method|
+    describe "\##{method}" do
+      let(:address_one) { Address.new(street: "first") }
+      let(:address_two) { Address.new(street: "second") }
 
-    let(:person) do
-      Person.new
-    end
-
-    let(:address_one) do
-      Address.new(street: "first")
-    end
+      before do
+        person.addresses << [ address_one, address_two ]
+      end
 
-    let(:address_two) do
-      Address.new(street: "second")
-    end
+      shared_examples_for 'deleting from the collection' do
+        context 'when the document exists in the relation' do
+          let!(:deleted) do
+            person.addresses.send(method, address_one)
+          end
 
-    before do
-      person.addresses << [ address_one, address_two ]
-    end
+          it 'deletes the document' do
+            expect(person.addresses).to eq([ address_two ])
+            expect(person.reload.addresses).to eq([ address_two ]) if person.persisted?
+          end
 
-    context "when the document exists in the relation" do
+          it 'deletes the document from the unscoped' do
+            expect(person.addresses.send(:_unscoped)).to eq([ address_two ])
+          end
 
-      let!(:deleted) do
-        person.addresses.delete(address_one)
-      end
+          it 'reindexes the relation' do
+            expect(address_two._index).to eq(0)
+          end
 
-      it "deletes the document" do
-        expect(person.addresses).to eq([ address_two ])
-      end
+          it 'returns the document' do
+            expect(deleted).to eq(address_one)
+          end
+        end
 
-      it "deletes the document from the unscoped" do
-        expect(person.addresses.send(:_unscoped)).to eq([ address_two ])
+        context 'when the document does not exist' do
+          it 'returns nil' do
+            expect(person.addresses.send(method, Address.new)).to be_nil
+          end
+        end
       end
 
-      it "reindexes the relation" do
-        expect(address_two._index).to eq(0)
-      end
+      context 'when the root document is unpersisted' do
+        let(:person) { Person.new }
 
-      it "returns the document" do
-        expect(deleted).to eq(address_one)
+        it_behaves_like 'deleting from the collection'
       end
-    end
 
-    context "when the document does not exist" do
+      context 'when the root document is persisted' do
+        let(:person) { Person.create }
 
-      it "returns nil" do
-        expect(person.addresses.delete(Address.new)).to be_nil
+        it_behaves_like 'deleting from the collection'
       end
     end
   end
@@ -2209,6 +2215,79 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
           end
         end
       end
+
+      context "when modifying the document beforehand" do
+        let(:parent) { EmmParent.new }
+
+        before do
+
+          parent.blocks << EmmBlock.new(name: 'test', children: [size: 1, order: 1])
+          parent.save!
+
+          parent.blocks[0].children[0].assign_attributes(size: 2)
+
+          parent.blocks.destroy_all(:name => 'test')
+        end
+
+        it "deletes the correct document in the database" do
+          expect(parent.reload.blocks.length).to eq(0)
+        end
+      end
+
+      context "when nil _id" do
+        let(:parent) { EmmParent.new }
+
+        before do
+          parent.blocks << EmmBlock.new(_id: nil, name: 'test', children: [size: 1, order: 1])
+          parent.blocks << EmmBlock.new(_id: nil, name: 'test2', children: [size: 1, order: 1])
+          parent.save!
+
+          parent.blocks.destroy_all(:name => 'test')
+        end
+
+        it "deletes only the matching documents in the database" do
+          expect(parent.reload.blocks.length).to eq(1)
+        end
+      end
+
+      # Since without an _id field we must us a $pullAll with the attributes of
+      # the embedded document, if you modify it beforehand, the query will not
+      # be able to find the correct document to pull.
+      context "when modifying the document with nil _id" do
+        let(:parent) { EmmParent.new }
+
+        before do
+          parent.blocks << EmmBlock.new(_id: nil, name: 'test', children: [size: 1, order: 1])
+          parent.blocks << EmmBlock.new(_id: nil, name: 'test2', children: [size: 1, order: 1])
+          parent.save!
+
+          parent.blocks[0].children[0].assign_attributes(size: 2)
+
+          parent.blocks.destroy_all(:name => 'test')
+        end
+
+        it "does not delete the correct documents" do
+          expect(parent.reload.blocks.length).to eq(2)
+        end
+      end
+
+      context "when documents with and without _id" do
+        let(:parent) { EmmParent.new }
+
+        before do
+          parent.blocks << EmmBlock.new(_id: nil, name: 'test', children: [size: 1, order: 1])
+          parent.blocks << EmmBlock.new(name: 'test', children: [size: 1, order: 1])
+          parent.save!
+
+          parent.blocks[1].children[0].assign_attributes(size: 2)
+
+          parent.blocks.destroy_all(:name => 'test')
+        end
+
+        it "does not delete the correct documents" do
+          expect(parent.reload.blocks.length).to eq(0)
+        end
+      end
     end
   end
 
@@ -2278,32 +2357,22 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
       context "when the id does not match" do
 
         context "when config set to raise error" do
-
-          before do
-            Mongoid.raise_not_found_error = true
-          end
+          config_override :raise_not_found_error, true
 
           it "raises an error" do
             expect {
               person.addresses.find(BSON::ObjectId.new)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Address with id\(s\)/)
           end
         end
 
         context "when config set not to raise error" do
+          config_override :raise_not_found_error, false
 
           let(:address) do
             person.addresses.find(BSON::ObjectId.new)
           end
 
-          before do
-            Mongoid.raise_not_found_error = false
-          end
-
-          after do
-            Mongoid.raise_not_found_error = true
-          end
-
           it "returns nil" do
             expect(address).to be_nil
           end
@@ -2327,32 +2396,22 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
       context "when the ids do not match" do
 
         context "when config set to raise error" do
-
-          before do
-            Mongoid.raise_not_found_error = true
-          end
+          config_override :raise_not_found_error, true
 
           it "raises an error" do
             expect {
               person.addresses.find([ BSON::ObjectId.new ])
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Address with id\(s\)/)
           end
         end
 
         context "when config set not to raise error" do
+          config_override :raise_not_found_error, false
 
           let(:addresses) do
             person.addresses.find([ BSON::ObjectId.new ])
           end
 
-          before do
-            Mongoid.raise_not_found_error = false
-          end
-
-          after do
-            Mongoid.raise_not_found_error = true
-          end
-
           it "returns an empty array" do
             expect(addresses).to be_empty
           end
@@ -3460,7 +3519,7 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
 
     describe "replacing the entire embedded list" do
 
-      context "when an embeds many relationship contains a nil as the first item" do
+      context "when an embeds many relationship contains nil as the first item" do
 
         let(:person) do
           Person.create!
@@ -3481,7 +3540,7 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
         end
       end
 
-      context "when an embeds many relationship contains a nil in the middle of the list" do
+      context "when an embeds many relationship contains nil in the middle of the list" do
 
         let(:person) do
           Person.create!
@@ -3502,7 +3561,7 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
         end
       end
 
-      context "when an embeds many relationship contains a nil at the end of the list" do
+      context "when an embeds many relationship contains nil at the end of the list" do
 
         let(:person) do
           Person.create!
@@ -3526,7 +3585,7 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
 
     describe "appending to the embedded list" do
 
-      context "when appending a nil to the first position in an embedded list" do
+      context "when appending nil to the first position in an embedded list" do
 
         let(:person) do
           Person.create! phone_numbers: []
@@ -3545,7 +3604,7 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
         end
       end
 
-      context "when appending a nil into the middle of an embedded list" do
+      context "when appending nil into the middle of an embedded list" do
 
         let(:person) do
           Person.create! phone_numbers: []
@@ -3564,7 +3623,7 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
         end
       end
 
-      context "when appending a nil to the end of an embedded list" do
+      context "when appending nil to the end of an embedded list" do
 
         let(:person) do
           Person.create! phone_numbers: []
@@ -3959,6 +4018,28 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
     end
   end
 
+  context "when destroying a document with multiple nil _ids" do
+    let(:congress) { EmmCongress.create! }
+
+    before do
+      congress.legislators << EmmLegislator.new(_id: nil, a: 1)
+      congress.legislators << EmmLegislator.new(_id: nil, a: 2)
+
+      congress.legislators[0].destroy
+    end
+
+    it "deletes the correct document locally" do
+      pending "MONGOID-5394"
+      expect(congress.legislators.length).to eq(1)
+      expect(congress.legislators.first.a).to eq(1)
+    end
+
+    it "only deletes the one document" do
+      pending "MONGOID-5394"
+      expect(congress.reload.legislators.length).to eq(1)
+    end
+  end
+
   context "when adding a document" do
 
     let(:person) do
@@ -4490,7 +4571,7 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
     before do
       band.collection.
           find(_id: band.id).
-          update_one("$set" => { records: [{ name: "Moderat" }]})
+          update_one("$set" => { records: [{ _id: BSON::ObjectId.new, name: "Moderat" }]})
     end
 
     context "when loading the documents" do
@@ -4649,4 +4730,134 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
       end
     end
   end
+
+  context "when trying to persist the empty list" do
+
+    context "in an embeds_many relation" do
+
+      let(:band) { Band.create! }
+
+      before do
+        band.labels = []
+        band.save!
+      end
+
+      let(:reloaded_band) { Band.collection.find(_id: band._id).first }
+
+      it "persists the empty list" do
+        expect(reloaded_band).to have_key(:labels)
+        expect(reloaded_band[:labels]).to eq []
+      end
+    end
+
+    context "in a nested embeds_many relation" do
+
+      let(:survey) { Survey.create!(questions: [Question.new]) }
+
+      before do
+        survey.questions.first.answers = []
+        survey.save!
+      end
+
+      let(:reloaded_survey) { Survey.collection.find(_id: survey._id).first }
+
+      it "persists the empty list" do
+        expect(reloaded_survey).to have_key(:questions)
+        expect(reloaded_survey[:questions][0]).to have_key(:answers)
+        expect(reloaded_survey[:questions][0][:answers]).to eq []
+      end
+    end
+
+    context "when not setting the embeds_many field" do
+
+      let(:band) { Band.create! }
+
+      let(:reloaded_band) { Band.collection.find(_id: band._id).first }
+
+      it "does not persist the empty list" do
+        expect(reloaded_band).to_not have_key(:labels)
+      end
+    end
+  end
+
+  context "when using assign_attributes with an already populated array" do
+    let(:post) { EmmPost.create! }
+
+    before do
+      post.assign_attributes(company_tags: [{id: BSON::ObjectId.new, title: 'a'}],
+        user_tags: [{id: BSON::ObjectId.new, title: 'b'}])
+      post.save!
+      post.reload
+      post.assign_attributes(company_tags: [{id: BSON::ObjectId.new, title: 'c'}],
+        user_tags: [])
+      post.save!
+      post.reload
+    end
+
+    it "has the correct embedded documents" do
+      expect(post.company_tags.length).to eq(1)
+      expect(post.company_tags.first.title).to eq("c")
+    end
+  end
+
+  context "when the parent fails validation" do
+    let(:school) { EmmSchool.new }
+    let(:student) { school.students.new }
+
+    before do
+      student.save
+    end
+
+    it "does not mark the parent as persisted" do
+      expect(school.persisted?).to be false
+    end
+
+    it "does not mark the child as persisted" do
+      expect(student.persisted?).to be false
+    end
+
+    it "does not persist the parent" do
+      expect(School.count).to eq(0)
+    end
+  end
+
+  context "when doing assign_attributes then assignment" do
+
+    let(:post) do
+      EmmPost.create!(
+        company_tags: [ EmmCompanyTag.new(title: "1"), EmmCompanyTag.new(title: "1") ],
+        user_tags: [ EmmUserTag.new(title: "1"), EmmUserTag.new(title: "1") ]
+      )
+    end
+
+    let(:from_db) { EmmPost.find(post.id) }
+
+    before do
+      post.assign_attributes(
+        company_tags: [ EmmCompanyTag.new(title: '3'), EmmCompanyTag.new(title: '4') ]
+      )
+      post.user_tags = [ EmmUserTag.new(title: '3'), EmmUserTag.new(title: '4') ]
+      post.save!
+    end
+
+    it "persists the associations correctly" do
+      expect(from_db.user_tags.size).to eq(2)
+      expect(from_db.company_tags.size).to eq(2)
+    end
+  end
+
+  context "when assigning hashes" do
+    let(:user) { EmmUser.create! }
+
+    before do
+      user.orders = [ { sku: 1 }, { sku: 2 } ]
+    end
+
+    it "creates the objects correctly" do
+      expect(user.orders.first).to be_a(EmmOrder)
+      expect(user.orders.last).to be_a(EmmOrder)
+
+      expect(user.orders.map(&:sku).sort).to eq([ 1, 2 ])
+    end
+  end
 end

data/spec/mongoid/association/embedded/embeds_many_models.rb

@@ -67,3 +67,161 @@ class EmmOuter
 
   field :level, :type => Integer
 end
+
+class EmmCustomerAddress
+  include Mongoid::Document
+
+  embedded_in :addressable, polymorphic: true, inverse_of: :work_address
+end
+
+class EmmFriend
+  include Mongoid::Document
+
+  embedded_in :befriendable, polymorphic: true
+end
+
+class EmmCustomer
+  include Mongoid::Document
+
+  embeds_one :home_address, class_name: 'EmmCustomerAddress', as: :addressable
+  embeds_one :work_address, class_name: 'EmmCustomerAddress', as: :addressable
+
+  embeds_many :close_friends, class_name: 'EmmFriend', as: :befriendable
+  embeds_many :acquaintances, class_name: 'EmmFriend', as: :befriendable
+end
+
+class EmmUser
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  embeds_many :orders, class_name: 'EmmOrder'
+end
+
+class EmmOrder
+  include Mongoid::Document
+
+  field :sku
+  field :amount, type: Integer
+
+  embedded_in :user, class_name: 'EmmUser'
+end
+
+module EmmSpec
+  # There is also a top-level Car class defined.
+  class Car
+    include Mongoid::Document
+
+    embeds_many :doors
+  end
+
+  class Door
+    include Mongoid::Document
+
+    embedded_in :car
+  end
+
+  class Tank
+    include Mongoid::Document
+
+    embeds_many :guns
+    embeds_many :emm_turrets
+    # This association references a model that is not in our module,
+    # and it does not define class_name hence Mongoid will not be able to
+    # figure out the inverse for this association.
+    embeds_many :emm_hatches
+
+    # class_name is intentionally unqualified, references a class in the
+    # same module. Rails permits class_name to be unqualified like this.
+    embeds_many :launchers, class_name: 'Launcher'
+  end
+
+  class Gun
+    include Mongoid::Document
+
+    embedded_in :tank
+  end
+
+  class Launcher
+    include Mongoid::Document
+
+    # class_name is intentionally unqualified.
+    embedded_in :tank, class_name: 'Tank'
+  end
+end
+
+# This is intentionally on top level.
+class EmmTurret
+  include Mongoid::Document
+
+  embedded_in :tank, class_name: 'EmmSpec::Tank'
+end
+
+# This is intentionally on top level.
+class EmmHatch
+  include Mongoid::Document
+
+  # No :class_name option on this association intentionally.
+  embedded_in :tank
+end
+
+class EmmPost
+  include Mongoid::Document
+
+  embeds_many :company_tags, class_name: "EmmCompanyTag"
+  embeds_many :user_tags, class_name: "EmmUserTag"
+end
+
+
+class EmmCompanyTag
+  include Mongoid::Document
+
+  field :title, type: String
+
+  embedded_in :post, class_name: "EmmPost"
+end
+
+
+class EmmUserTag
+  include Mongoid::Document
+
+  field :title, type: String
+
+  embedded_in :post, class_name: "EmmPost"
+end
+
+class EmmSchool
+  include Mongoid::Document
+
+  embeds_many :students, class_name: "EmmStudent"
+
+  field :name, type: :string
+
+  validates :name, presence: true
+end
+
+class EmmStudent
+  include Mongoid::Document
+
+  embedded_in :school, class_name: "EmmSchool"
+end
+
+class EmmParent
+  include Mongoid::Document
+  embeds_many :blocks, class_name: "EmmBlock"
+end
+
+class EmmBlock
+  include Mongoid::Document
+  field :name, type: String
+  embeds_many :children, class_name: "EmmChild"
+end
+
+class EmmChild
+  include Mongoid::Document
+  embedded_in :block, class_name: "EmmBlock"
+
+  field :size, type: Integer
+  field :order, type: Integer
+  field :t
+end
+

data/spec/mongoid/association/embedded/embeds_many_query_spec.rb

@@ -47,5 +47,17 @@ describe Mongoid::Association::Embedded::EmbedsMany do
         expect(patient.addresses.first.number).to eq(123)
       end
     end
+
+    context "when excluding the relation" do
+      let(:congress) do
+        EmmCongress.where(name: 'foo').only(:_id).first
+      end
+
+      it 'raises a MissingAttributeError' do
+        expect do
+          congress.legislators
+        end.to raise_error(ActiveModel::MissingAttributeError)
+      end
+    end
   end
 end