mongoid 9.1.0 → 9.1.1

data/spec/mongoid/association/referenced/has_one_through/eager_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongoid::Association::Referenced::HasOneThrough::Eager do
+  before(:all) do
+    Object.const_set(:EgCustomer, Class.new do
+      include Mongoid::Document
+
+      store_in collection: 'eg_customers'
+      has_one :eg_franchise, class_name: 'EgFranchise', inverse_of: :eg_customer
+      has_one :eg_store, through: :eg_franchise, class_name: 'EgStore'
+    end)
+    Object.const_set(:EgFranchise, Class.new do
+      include Mongoid::Document
+
+      store_in collection: 'eg_franchises'
+      belongs_to :eg_customer, class_name: 'EgCustomer'
+      has_one :eg_store, class_name: 'EgStore', inverse_of: :eg_franchise
+    end)
+    Object.const_set(:EgStore, Class.new do
+      include Mongoid::Document
+
+      store_in collection: 'eg_stores'
+      belongs_to :eg_franchise, class_name: 'EgFranchise'
+    end)
+  end
+
+  after(:all) do
+    %w[EgCustomer EgFranchise EgStore].each { |c| Object.send(:remove_const, c) }
+  end
+
+  before { [ EgCustomer, EgFranchise, EgStore ].each(&:delete_all) }
+
+  it 'preloads the through association for multiple owners' do
+    c1 = EgCustomer.create!
+    c2 = EgCustomer.create!
+    f1 = EgFranchise.create!(eg_customer: c1)
+    f2 = EgFranchise.create!(eg_customer: c2)
+    s1 = EgStore.create!(eg_franchise: f1)
+    s2 = EgStore.create!(eg_franchise: f2)
+
+    customers = EgCustomer.includes(:eg_store).to_a
+    by_id = customers.index_by(&:id)
+
+    expect(by_id[c1.id].eg_store).to eq(s1)
+    expect(by_id[c2.id].eg_store).to eq(s2)
+  end
+
+  it 'sets nil on owners without a store' do
+    lone = EgCustomer.create!
+    EgFranchise.create!(eg_customer: lone) # franchise but no store
+
+    customers = EgCustomer.includes(:eg_store).to_a
+    loaded = customers.find { |c| c.id == lone.id }
+    expect(loaded.eg_store).to be_nil
+  end
+end

data/spec/mongoid/association/referenced/has_one_through/proxy_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongoid::Association::Referenced::HasOneThrough::Proxy do
+  before(:all) do
+    Object.const_set(:PxHotStore, Class.new { include Mongoid::Document })
+    Object.const_set(:PxHotFranchise, Class.new do
+      include Mongoid::Document
+
+      has_one :px_hot_store, class_name: 'PxHotStore', inverse_of: :px_hot_franchise
+    end)
+    Object.const_set(:PxHotCustomer, Class.new do
+      include Mongoid::Document
+
+      has_one :px_hot_franchise, class_name: 'PxHotFranchise',
+                                 inverse_of: :px_hot_customer
+      has_one :px_hot_store, through: :px_hot_franchise, class_name: 'PxHotStore',
+                             source: :px_hot_store
+    end)
+  end
+
+  after(:all) do
+    %w[PxHotCustomer PxHotFranchise PxHotStore].each { |c| Object.send(:remove_const, c) }
+  end
+
+  let(:customer) { PxHotCustomer.new }
+
+  describe 'setter' do
+    it 'raises ReadonlyAssociation' do
+      expect { customer.px_hot_store = PxHotStore.new }.to \
+        raise_error(Mongoid::Errors::ReadonlyAssociation)
+    end
+  end
+
+  describe '.eager_loader' do
+    it 'returns a HasOneThrough::Eager' do
+      assoc = PxHotCustomer.relations['px_hot_store']
+      result = described_class.eager_loader([ assoc ], [])
+      expect(result).to be_a(Mongoid::Association::Referenced::HasOneThrough::Eager)
+    end
+  end
+
+  describe '.embedded?' do
+    it 'returns false' do
+      expect(described_class.embedded?).to be false
+    end
+  end
+end

data/spec/mongoid/association/referenced/has_one_through_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongoid::Association::Referenced::HasOneThrough do
+  # Model setup:
+  #   HotCustomer  has_one :hot_franchise
+  #   HotCustomer  has_one :hot_store, through: :hot_franchise, source: :depot
+  #   HotFranchise has_one :depot (class HotStore)
+
+  before(:all) do
+    Object.const_set(:HotStore, Class.new do
+      include Mongoid::Document
+
+      field :hot_franchise_id, type: BSON::ObjectId
+    end)
+    Object.const_set(:HotFranchise, Class.new do
+      include Mongoid::Document
+
+      field :hot_customer_id, type: BSON::ObjectId
+      has_one :depot, class_name: 'HotStore', inverse_of: :hot_franchise
+    end)
+    Object.const_set(:HotCustomer, Class.new do
+      include Mongoid::Document
+
+      has_one :hot_franchise, class_name: 'HotFranchise', inverse_of: :hot_customer
+      has_one :hot_store, through: :hot_franchise,
+                          class_name: 'HotStore', source: :depot
+    end)
+  end
+
+  after(:all) do
+    %w[HotCustomer HotFranchise HotStore].each { |c| Object.send(:remove_const, c) }
+  end
+
+  let(:assoc) { HotCustomer.relations['hot_store'] }
+
+  describe '#through_association' do
+    it 'returns the intermediate association metadata' do
+      expect(assoc.through_association).to eq(HotCustomer.relations['hot_franchise'])
+    end
+  end
+
+  describe '#source_association' do
+    it 'returns the :depot association on HotFranchise' do
+      expect(assoc.source_association).to eq(HotFranchise.relations['depot'])
+    end
+  end
+
+  describe '#embedded?' do
+    it 'returns false' do
+      expect(assoc.embedded?).to be false
+    end
+  end
+
+  describe 'VALID_OPTIONS' do
+    it 'accepts :through' do
+      expect { HotCustomer.has_one(:foo, through: :hot_franchise) }.not_to raise_error
+    end
+
+    it 'accepts :source' do
+      expect { HotCustomer.has_one(:bar, through: :hot_franchise, source: :depot) }.not_to raise_error
+    end
+
+    it 'rejects unknown options at definition time' do
+      expect do
+        HotCustomer.has_one(:baz, through: :hot_franchise, bogus_option: true)
+      end.to raise_error(Mongoid::Errors::InvalidRelationOption)
+    end
+  end
+
+  describe '#criteria' do
+    it 'returns nil when the intermediate is nil' do
+      customer = HotCustomer.new
+      allow(customer).to receive(:hot_franchise).and_return(nil)
+      expect(assoc.criteria(customer)).to be_nil
+    end
+
+    it 'delegates to the source association on the intermediate' do
+      franchise = HotFranchise.new
+      store     = HotStore.new
+      customer  = HotCustomer.new
+      allow(customer).to receive(:hot_franchise).and_return(franchise)
+      allow(franchise).to receive(:depot).and_return(store)
+      expect(assoc.criteria(customer)).to eq(store)
+    end
+  end
+
+  describe ':through on an embedded association' do
+    it 'raises InvalidRelationOption when through association is embedded' do
+      embedded_owner = Class.new do
+        include Mongoid::Document
+
+        embeds_one :address
+      end
+      embedded_owner.has_one(:city, through: :address)
+      expect do
+        embedded_owner.relations['city'].through_association # triggers lazy validation
+      end.to raise_error(Mongoid::Errors::InvalidRelationOption)
+    end
+  end
+
+  context 'integration', :integration do
+    before(:all) do
+      Object.const_set(:IntCustomer, Class.new do
+        include Mongoid::Document
+
+        store_in collection: 'int_customers'
+        has_one :int_franchise, class_name: 'IntFranchise', inverse_of: :int_customer
+        # source: :depot exercises the :source option end-to-end
+        has_one :int_store, through: :int_franchise, class_name: 'IntStore', source: :depot
+      end)
+
+      Object.const_set(:IntFranchise, Class.new do
+        include Mongoid::Document
+
+        store_in collection: 'int_franchises'
+        field :int_customer_id, type: BSON::ObjectId
+        belongs_to :int_customer, class_name: 'IntCustomer'
+        has_one :depot, class_name: 'IntStore', inverse_of: :int_franchise
+      end)
+
+      Object.const_set(:IntStore, Class.new do
+        include Mongoid::Document
+
+        store_in collection: 'int_stores'
+        field :int_franchise_id, type: BSON::ObjectId
+        belongs_to :int_franchise, class_name: 'IntFranchise'
+      end)
+    end
+
+    after(:all) do
+      %w[IntCustomer IntFranchise IntStore].each { |c| Object.send(:remove_const, c) }
+    end
+
+    before { [ IntCustomer, IntFranchise, IntStore ].each(&:delete_all) }
+
+    let!(:customer)  { IntCustomer.create! }
+    let!(:franchise) { IntFranchise.create!(int_customer: customer) }
+    let!(:store)     { IntStore.create!(int_franchise: franchise) }
+
+    describe 'getter' do
+      it 'returns the store via the franchise' do
+        expect(customer.int_store).to eq(store)
+      end
+
+      it 'returns nil when the franchise is absent' do
+        lone = IntCustomer.create!
+        expect(lone.int_store).to be_nil
+      end
+
+      it 'returns cached value before reload and fresh value after' do
+        first_store = customer.int_store # prime cache
+        expect(first_store).to eq(store)
+
+        new_store = IntStore.create!
+        franchise.depot = new_store
+        franchise.save!
+
+        expect(customer.int_store).to eq(store) # cached — still old
+        expect(customer.int_store(true)).to eq(new_store) # reloaded
+      end
+    end
+
+    describe 'setter' do
+      it 'raises ReadonlyAssociation' do
+        expect { customer.int_store = IntStore.new }.to \
+          raise_error(Mongoid::Errors::ReadonlyAssociation)
+      end
+    end
+  end
+
+  context 'with :source option resolving a differently-named association', :integration do
+    before(:all) do
+      Object.const_set(:SrcOrg, Class.new do
+        include Mongoid::Document
+
+        store_in collection: 'src_orgs'
+        has_one :src_location, class_name: 'SrcLocation', inverse_of: :src_org
+        has_one :src_hq, through: :src_location,
+                         class_name: 'SrcBuilding', source: :src_main_building
+      end)
+      Object.const_set(:SrcLocation, Class.new do
+        include Mongoid::Document
+
+        store_in collection: 'src_locations'
+        belongs_to :src_org, class_name: 'SrcOrg'
+        has_one :src_main_building, class_name: 'SrcBuilding', inverse_of: :src_location
+      end)
+      Object.const_set(:SrcBuilding, Class.new do
+        include Mongoid::Document
+
+        store_in collection: 'src_buildings'
+        belongs_to :src_location, class_name: 'SrcLocation'
+      end)
+    end
+
+    after(:all) do
+      %w[SrcOrg SrcLocation SrcBuilding].each { |c| Object.send(:remove_const, c) }
+    end
+
+    before { [ SrcOrg, SrcLocation, SrcBuilding ].each(&:delete_all) }
+
+    it 'resolves the :source association on the intermediate' do
+      org      = SrcOrg.create!
+      location = SrcLocation.create!(src_org: org)
+      building = SrcBuilding.create!(src_location: location)
+      expect(org.src_hq).to eq(building)
+    end
+  end
+end

data/spec/mongoid/attributes/nested_spec.rb

@@ -7,6 +7,33 @@ require_relative '../association/referenced/has_and_belongs_to_many_models'
 require_relative 'nested_spec_models'
 
 describe Mongoid::Attributes::Nested do
+  # Expects the enclosing context to define `build_with_id`, taking an id
+  # value and returning the document built with it in nested attributes.
+  shared_examples 'rejects non-scalar ids' do |klass_name|
+    not_found = /not found for class #{klass_name}/
+
+    context 'when the id is an operator hash' do
+      it 'raises a document not found error' do
+        expect { build_with_id({ '$ne' => nil }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound, not_found)
+      end
+    end
+
+    context 'when the id is an array' do
+      it 'raises a document not found error' do
+        expect { build_with_id([ BSON::ObjectId.new ]) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound, not_found)
+      end
+    end
+
+    context 'when the id is a malformed object id hash' do
+      it 'raises a document not found error' do
+        expect { build_with_id({ '$oid' => 'junk' }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound, not_found)
+      end
+    end
+  end
+
   describe '.accepts_nested_attributes_for' do
     context 'when the autosave option is not defined' do
       let(:person) do
@@ -188,6 +215,77 @@ describe Mongoid::Attributes::Nested do
           it 'sets the nested attributes' do
             expect(person2.posts.map(&:title)).to eq([ 'Reparented!' ])
           end
+
+          context 'when the id does not correspond to an existing document' do
+            let(:person2) do
+              Person.create!(posts_attributes: { '0' => { id: BSON::ObjectId.new, title: 'Ghost' } })
+            end
+
+            context 'when raise_not_found_error is true' do
+              config_override :raise_not_found_error, true
+
+              it 'raises a document not found error' do
+                expect { person2 }.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                                  /Document\(s\) not found for class Post/)
+              end
+            end
+
+            context 'when raise_not_found_error is false' do
+              config_override :raise_not_found_error, false
+
+              it 'raises a document not found error' do
+                expect { person2 }.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                                  /Document\(s\) not found for class Post/)
+              end
+            end
+          end
+        end
+
+        context 'when _destroy is true for a document not in the relation' do
+          config_override :allow_reparenting_via_nested_attributes, true
+
+          before do
+            Person.send(:undef_method, :posts_attributes=)
+            Person.accepts_nested_attributes_for :posts, allow_destroy: true
+          end
+
+          let(:person3) do
+            Person.create!(
+              posts_attributes: { '0' => { id: post.id, _destroy: '1' } }
+            )
+          end
+
+          it 'does not raise UnknownAttribute' do
+            expect { person3 }.not_to raise_error
+          end
+
+          it 'does not add the document to the relation' do
+            expect(person3.posts).to be_empty
+          end
+        end
+      end
+
+      context 'when the id in the attributes is not a scalar' do
+        let(:person) { Person.create! }
+
+        def build_with_id(id)
+          person.update!(posts_attributes: { '0' => { id: id, title: 'Crafted' } })
+        end
+
+        context 'when the association is empty' do
+          include_examples 'rejects non-scalar ids', 'Post'
+        end
+
+        context 'when the association is not empty' do
+          before { person.posts.create!(title: 'Existing') }
+
+          include_examples 'rejects non-scalar ids', 'Post'
+        end
+
+        context 'when allow_reparenting_via_nested_attributes is true' do
+          config_override :allow_reparenting_via_nested_attributes, true
+
+          include_examples 'rejects non-scalar ids', 'Post'
         end
       end
     end
@@ -214,16 +312,100 @@ describe Mongoid::Attributes::Nested do
           )
         end
 
-        it 'sets the nested attributes' do
-          expect(person.preferences.map(&:name)).to eq([ preference.name ])
+        context 'when allow_reparenting_via_nested_attributes is false' do
+          config_override :allow_reparenting_via_nested_attributes, false
+
+          it 'raises a document not found error' do
+            expect { person }.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                             /Document\(s\) not found for class Preference/)
+          end
         end
 
-        it 'updates attributes of existing document which is added to relation' do
-          preference_name = 'updated preference'
-          person = Person.new(
-            preferences_attributes: { 0 => { id: preference.id, name: preference_name } }
-          )
-          expect(person.preferences.map(&:name)).to eq([ preference_name ])
+        context 'when allow_reparenting_via_nested_attributes is true' do
+          config_override :allow_reparenting_via_nested_attributes, true
+
+          it 'sets the nested attributes' do
+            expect(person.preferences.map(&:name)).to eq([ preference.name ])
+          end
+
+          it 'updates attributes of existing document which is added to relation' do
+            preference_name = 'updated preference'
+            person = Person.new(
+              preferences_attributes: { 0 => { id: preference.id, name: preference_name } }
+            )
+            expect(person.preferences.map(&:name)).to eq([ preference_name ])
+          end
+
+          context 'when the id does not correspond to an existing document' do
+            let(:person) do
+              Person.new(
+                preferences_attributes: { 0 => { id: BSON::ObjectId.new, name: 'Ghost' } }
+              )
+            end
+
+            context 'when raise_not_found_error is true' do
+              config_override :raise_not_found_error, true
+
+              it 'raises a document not found error' do
+                expect { person }.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                                 /Document\(s\) not found for class Preference/)
+              end
+            end
+
+            context 'when raise_not_found_error is false' do
+              config_override :raise_not_found_error, false
+
+              it 'raises a document not found error' do
+                expect { person }.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                                 /Document\(s\) not found for class Preference/)
+              end
+            end
+          end
+        end
+
+        context 'when _destroy is true for a document not in the relation' do
+          before do
+            Person.send(:undef_method, :preferences_attributes=)
+            Person.accepts_nested_attributes_for :preferences, allow_destroy: true
+          end
+
+          let(:person) do
+            Person.new(
+              preferences_attributes: { 0 => { id: preference.id, _destroy: '1' } }
+            )
+          end
+
+          it 'does not raise UnknownAttribute' do
+            expect { person }.not_to raise_error
+          end
+
+          it 'does not add the document to the relation' do
+            expect(person.preferences).to be_empty
+          end
+        end
+      end
+
+      context 'when the id in the attributes is not a scalar' do
+        let(:target) { Person.create! }
+
+        def build_with_id(id)
+          target.update!(preferences_attributes: { 0 => { id: id, name: 'Crafted' } })
+        end
+
+        context 'when the association is empty' do
+          include_examples 'rejects non-scalar ids', 'Preference'
+        end
+
+        context 'when the association is not empty' do
+          before { target.preferences.create!(name: 'Existing') }
+
+          include_examples 'rejects non-scalar ids', 'Preference'
+        end
+
+        context 'when allow_reparenting_via_nested_attributes is true' do
+          config_override :allow_reparenting_via_nested_attributes, true
+
+          include_examples 'rejects non-scalar ids', 'Preference'
         end
       end
     end
@@ -4552,4 +4734,63 @@ describe Mongoid::Attributes::Nested do
       end
     end
   end
+
+  context 'when an id in nested attributes belongs to another parent' do
+    let(:victim) { Person.create! }
+    let(:attacker) { Person.create! }
+
+    context 'when the association is a has-many' do
+      before do
+        Person.send(:undef_method, :posts_attributes=)
+        Person.accepts_nested_attributes_for :posts
+      end
+
+      let!(:victim_post) { victim.posts.create!(title: 'Private') }
+
+      it 'does not update the other parent\'s document' do
+        expect { attacker.update!(posts_attributes: { '0' => { id: victim_post.id, title: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(victim_post.reload.title).to eq('Private')
+      end
+
+      it 'does not add the other parent\'s document to the association' do
+        expect { attacker.update!(posts_attributes: { '0' => { id: victim_post.id, title: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(attacker.reload.posts).to be_empty
+      end
+
+      it 'does not update via a direct association assignment' do
+        expect { attacker.update!(posts: { '0' => { id: victim_post.id, title: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(victim_post.reload.title).to eq('Private')
+      end
+    end
+
+    context 'when the association is a has-and-belongs-to-many' do
+      before do
+        Person.send(:undef_method, :preferences_attributes=)
+        Person.accepts_nested_attributes_for :preferences
+      end
+
+      let!(:victim_preference) { victim.preferences.create!(name: 'Private') }
+
+      it 'does not update the other parent\'s document' do
+        expect { attacker.update!(preferences_attributes: { '0' => { id: victim_preference.id, name: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(victim_preference.reload.name).to eq('Private')
+      end
+
+      it 'does not add the other parent\'s document to the association' do
+        expect { attacker.update!(preferences_attributes: { '0' => { id: victim_preference.id, name: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(attacker.reload.preferences).to be_empty
+      end
+
+      it 'does not update via a direct association assignment' do
+        expect { attacker.update!(preferences: { '0' => { id: victim_preference.id, name: 'Overwritten' } }) }
+          .to raise_error(Mongoid::Errors::DocumentNotFound)
+        expect(victim_preference.reload.name).to eq('Private')
+      end
+    end
+  end
 end

data/spec/mongoid/config/defaults_spec.rb

@@ -38,6 +38,24 @@ describe Mongoid::Config::Defaults do
       end
     end
 
+    shared_examples 'uses settings for 9.0' do
+      it 'uses settings for 9.0' do
+        expect(Mongoid.autosave_saves_unchanged_documents).to be true
+      end
+    end
+
+    shared_examples 'does not use settings for 9.0' do
+      it 'does not use settings for 9.0' do
+        expect(Mongoid.autosave_saves_unchanged_documents).to be false
+      end
+    end
+
+    shared_examples 'never allows reparenting via nested attributes' do
+      it 'leaves allow_reparenting_via_nested_attributes false' do
+        expect(Mongoid.allow_reparenting_via_nested_attributes).to be false
+      end
+    end
+
     context 'when giving a valid version' do
       before do
         config.load_defaults(version)
@@ -52,6 +70,8 @@ describe Mongoid::Config::Defaults do
 
         it_behaves_like 'uses settings for 8.0'
         it_behaves_like 'uses settings for 8.1'
+        it_behaves_like 'uses settings for 9.0'
+        it_behaves_like 'never allows reparenting via nested attributes'
       end
 
       context 'when the given version is 8.1' do
@@ -59,6 +79,8 @@ describe Mongoid::Config::Defaults do
 
         it_behaves_like 'does not use settings for 8.0'
         it_behaves_like 'uses settings for 8.1'
+        it_behaves_like 'uses settings for 9.0'
+        it_behaves_like 'never allows reparenting via nested attributes'
       end
 
       context 'when the given version is 9.0' do
@@ -66,6 +88,17 @@ describe Mongoid::Config::Defaults do
 
         it_behaves_like 'does not use settings for 8.0'
         it_behaves_like 'does not use settings for 8.1'
+        it_behaves_like 'uses settings for 9.0'
+        it_behaves_like 'never allows reparenting via nested attributes'
+      end
+
+      context 'when the given version is 9.1' do
+        let(:version) { 9.1 }
+
+        it_behaves_like 'does not use settings for 8.0'
+        it_behaves_like 'does not use settings for 8.1'
+        it_behaves_like 'does not use settings for 9.0'
+        it_behaves_like 'never allows reparenting via nested attributes'
       end
     end