mongoid 7.5.0 → 8.0.1

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require_relative '../embeds_many_models'
 
 describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
 
@@ -507,7 +508,7 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     end
   end
 
-  context "when the same class is embedded multiple times" do
+  context "when the same class is embedded multiple times; embeds_one" do
 
     let(:customer) do
       Customer.new
@@ -516,7 +517,6 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     context "assignment after saving" do
 
       it "correctly sets the association for the embedded class" do
-        pending 'MONGOID-5039'
 
         customer.home_address = CustomerAddress.new
         customer.work_address = CustomerAddress.new
@@ -537,22 +537,82 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
 
         expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
         expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+
+        expect(customer.home_address.addressable).to eq(customer)
+        expect(customer.work_address.addressable).to eq(customer)
       end
     end
 
     context "inverse assignment" do
 
+      it "raises an error when trying to set the association" do
+        customer.work_address = CustomerAddress.new
+
+        expect do
+          customer.work_address.addressable = customer
+        end.to raise_error(Mongoid::Errors::InvalidSetPolymorphicRelation)
+      end
+    end
+
+    context "when there is an explicit inverse_of" do
+
+      let(:customer) { EmmCustomer.new }
+
       it "correctly sets the association for the embedded class" do
-        pending 'MONGOID-5039'
+        customer.work_address = EmmCustomerAddress.new
 
-        customer.work_address = CustomerAddress.new
-        customer.work_address.addressable = customer
+        expect do
+          customer.work_address.addressable = customer
+        end.to_not raise_error
 
-        expect(customer.home_address._association.store_as).to eq("home_address")
-        expect(customer.work_address._association.store_as).to eq("work_address")
+        expect(customer.work_address.addressable).to eq(customer)
+      end
+    end
+  end
 
-        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
-        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+  context "when the same class is embedded multiple times; embeds_many" do
+
+    let(:customer) do
+      EmmCustomer.new
+    end
+
+    context "assignment after saving" do
+
+      it "correctly sets the association for the embedded class" do
+
+        customer.close_friends = [EmmFriend.new]
+        customer.acquaintances = [EmmFriend.new]
+
+        expect(customer.close_friends._association.store_as).to eq("close_friends")
+        expect(customer.acquaintances._association.store_as).to eq("acquaintances")
+
+        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq("close_friends")
+        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq("acquaintances")
+
+        customer.save!
+
+        customer.close_friends = [EmmFriend.new]
+        customer.acquaintances = [EmmFriend.new]
+
+        expect(customer.close_friends._association.store_as).to eq("close_friends")
+        expect(customer.acquaintances._association.store_as).to eq("acquaintances")
+
+        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq("close_friends")
+        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq("acquaintances")
+
+        expect(customer.close_friends[0].befriendable).to eq(customer)
+        expect(customer.acquaintances[0].befriendable).to eq(customer)
+      end
+    end
+
+    context "inverse assignment" do
+
+      it "raises an error when trying to set the association" do
+        customer.acquaintances = [EmmFriend.new]
+
+        expect do
+          customer.acquaintances[0].befriendable = customer
+        end.to raise_error(Mongoid::Errors::InvalidSetPolymorphicRelation)
       end
     end
   end

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

@@ -103,4 +103,116 @@ describe Mongoid::Association::Embedded::EmbedsMany::Buildable do
       end
     end
   end
+
+  context 'when the object is already associated with another object' do
+
+    context "when using <<" do
+
+      let(:person1) do
+        Person.new
+      end
+
+      let(:person2) do
+        Person.new
+      end
+
+      let(:appointment) do
+        Appointment.new
+      end
+
+      before do
+        person1.appointments << appointment
+        person2.appointments << appointment
+      end
+
+      it 'clears the object of its previous association' do
+        expect(person1.appointments).to eq([])
+        expect(person2.appointments).to eq([appointment])
+      end
+    end
+
+    context "when using concat" do
+
+      let(:person1) do
+        Person.new
+      end
+
+      let(:person2) do
+        Person.new
+      end
+
+      let(:appointment) do
+        Appointment.new
+      end
+
+      before do
+        person1.appointments.concat([appointment])
+        person2.appointments.concat([appointment])
+      end
+
+      it 'clears the object of its previous association' do
+        expect(person1.appointments).to eq([])
+        expect(person2.appointments).to eq([appointment])
+      end
+    end
+
+    context "when using =" do
+
+      let(:person1) do
+        Person.new
+      end
+
+      let(:person2) do
+        Person.new
+      end
+
+      let(:appointment) do
+        Appointment.new
+      end
+
+      let(:apts) { [ appointment ] }
+
+      before do
+        person1.appointments = apts
+        person2.appointments = apts
+        expect(apts).to eq([ appointment ])
+      end
+
+      it 'clears the object of its previous association' do
+        expect(person1.appointments).to eq([])
+        expect(person2.appointments).to eq([appointment])
+      end
+    end
+
+    context "when using = on the same document twice" do
+
+      let(:person1) do
+        Person.new
+      end
+
+      let(:person2) do
+        Person.new
+      end
+
+      let(:appointment1) do
+        Appointment.new
+      end
+
+      let(:appointment2) do
+        Appointment.new
+      end
+
+      let(:apts) { [ appointment1, appointment2 ] }
+
+      before do
+        person1.appointments = apts
+        person1.appointments = person1.appointments.reverse
+        expect(apts).to eq([ appointment1, appointment2  ])
+      end
+
+      it 'clears the object of its previous association' do
+        expect(person1.appointments).to eq([ appointment2, appointment1 ])
+      end
+    end
+  end
 end

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
 
@@ -2209,6 +2210,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
 
@@ -2286,7 +2360,7 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
           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
 
@@ -2335,7 +2409,7 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
           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
 
@@ -3460,7 +3534,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 +3555,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 +3576,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 +3600,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 +3619,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 +3638,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 +4033,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
@@ -4649,4 +4745,119 @@ 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
 end

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

@@ -67,3 +67,160 @@ 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 :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