mongoid 9.1.0 → 9.1.2

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/atomic/modifiers_spec.rb

@@ -74,6 +74,78 @@ describe Mongoid::Atomic::Modifiers do
         end
       end
     end
+
+    context 'when a conflicting modification exists' do
+      context 'when the conflicting modification is a set' do
+        let(:sets) do
+          { 'addresses.0.street' => 'Bond' }
+        end
+
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        before do
+          modifiers.set(sets)
+          modifiers.add_to_set(adds)
+        end
+
+        it 'adds the add to set modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$set' => { 'addresses.0.street' => 'Bond' },
+              conflicts: { '$addToSet' =>
+                { 'addresses.0.tags' => { '$each' => %w[tag] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a push' do
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        before do
+          modifiers.push(pushes)
+          modifiers.add_to_set(adds)
+        end
+
+        it 'adds the add to set modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$push' => { 'addresses' => { '$each' => [ { 'street' => 'Oxford St' } ] } },
+              conflicts: { '$addToSet' =>
+                { 'addresses.0.tags' => { '$each' => %w[tag] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a pull' do
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        before do
+          modifiers.pull(pulls)
+          modifiers.add_to_set(adds)
+        end
+
+        it 'does not split the operations, leaving MongoDB to reject the update' do
+          # A $pull shifts array elements, so applying the $addToSet in a
+          # separate write afterwards could target a different element.
+          expect(modifiers).to eq(
+            { '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } },
+              '$addToSet' => { 'addresses.0.tags' => { '$each' => %w[tag] } } }
+          )
+        end
+      end
+    end
   end
 
   describe '#pull' do
@@ -125,6 +197,98 @@ describe Mongoid::Atomic::Modifiers do
         end
       end
     end
+
+    context 'when a conflicting modification exists' do
+      # A $pull shifts the positions of the remaining elements, so it stays in
+      # the main update. MongoDB rejects the update if the paths overlap.
+      context 'when the conflicting modification is a set' do
+        let(:sets) do
+          { 'addresses.0.street' => 'Bond' }
+        end
+
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        before do
+          modifiers.set(sets)
+          modifiers.pull(pulls)
+        end
+
+        it 'keeps the pull modifiers in the main update' do
+          expect(modifiers).to eq(
+            { '$set' => { 'addresses.0.street' => 'Bond' },
+              '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a push' do
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        before do
+          modifiers.push(pushes)
+          modifiers.pull(pulls)
+        end
+
+        it 'keeps the pull modifiers in the main update' do
+          expect(modifiers).to eq(
+            { '$push' => { 'addresses' => { '$each' => [ { 'street' => 'Oxford St' } ] } },
+              '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is an add to set' do
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        before do
+          modifiers.add_to_set(adds)
+          modifiers.pull(pulls)
+        end
+
+        it 'keeps the pull modifiers in the main update' do
+          expect(modifiers).to eq(
+            { '$addToSet' => { 'addresses.0.tags' => { '$each' => %w[tag] } },
+              '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a pull all' do
+        let(:pull_alls) do
+          { 'addresses' => [ { '_id' => 'one' } ] }
+        end
+
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        before do
+          modifiers.pull_all(pull_alls)
+          modifiers.pull(pulls)
+        end
+
+        it 'keeps the pull modifiers in the main update' do
+          expect(modifiers).to eq(
+            { '$pullAll' => { 'addresses' => [ { '_id' => 'one' } ] },
+              '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } } }
+          )
+        end
+      end
+    end
   end
 
   describe '#pull_all' do
@@ -183,6 +347,54 @@ describe Mongoid::Atomic::Modifiers do
         end
       end
     end
+
+    context 'when a conflicting modification exists' do
+      context 'when the conflicting modification is a pull' do
+        let(:pulls) do
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        let(:pull_alls) do
+          { 'addresses' => [ { '_id' => 'one' } ] }
+        end
+
+        before do
+          modifiers.pull(pulls)
+          modifiers.pull_all(pull_alls)
+        end
+
+        it 'adds the pull all modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } },
+              conflicts: { '$pullAll' =>
+                { 'addresses' => [ { '_id' => 'one' } ] } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is a push' do
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        let(:pull_alls) do
+          { 'addresses' => [ { '_id' => 'one' } ] }
+        end
+
+        before do
+          modifiers.push(pushes)
+          modifiers.pull_all(pull_alls)
+        end
+
+        it 'adds the pull all modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$push' => { 'addresses' => { '$each' => [ { 'street' => 'Oxford St' } ] } },
+              conflicts: { '$pullAll' =>
+                { 'addresses' => [ { '_id' => 'one' } ] } } }
+          )
+        end
+      end
+    end
   end
 
   describe '#push' do
@@ -321,6 +533,56 @@ describe Mongoid::Atomic::Modifiers do
           )
         end
       end
+
+      context 'when the conflicting modification is an add to set' do
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        before do
+          modifiers.add_to_set(adds)
+          modifiers.push(pushes)
+        end
+
+        it 'adds the push modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$addToSet' => { 'addresses.0.tags' => { '$each' => %w[tag] } },
+              conflicts: { '$push' =>
+                { 'addresses' => { '$each' => [
+                  { 'street' => 'Oxford St' }
+                ] } } } }
+          )
+        end
+      end
+
+      context 'when the conflicting modification is an unset' do
+        let(:unsets) do
+          [ 'addresses.0.street' ]
+        end
+
+        let(:pushes) do
+          { 'addresses' => { 'street' => 'Oxford St' } }
+        end
+
+        before do
+          modifiers.unset(unsets)
+          modifiers.push(pushes)
+        end
+
+        it 'adds the push modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$unset' => { 'addresses.0.street' => true },
+              conflicts: { '$push' =>
+                { 'addresses' => { '$each' => [
+                  { 'street' => 'Oxford St' }
+                ] } } } }
+          )
+        end
+      end
     end
 
     context 'when there is another operation on a sibling of a key which is nested' do
@@ -419,6 +681,30 @@ describe Mongoid::Atomic::Modifiers do
           )
         end
       end
+
+      context 'when the conflicting modification is an add to set' do
+        let(:adds) do
+          { 'addresses.0.tags' => %w[tag] }
+        end
+
+        let(:sets) do
+          { 'addresses.0.title' => 'Sir' }
+        end
+
+        before do
+          modifiers.add_to_set(adds)
+          modifiers.set(sets)
+        end
+
+        it 'adds the set modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$addToSet' =>
+              { 'addresses.0.tags' => { '$each' => %w[tag] } },
+              conflicts:
+                { '$set' => { 'addresses.0.title' => 'Sir' } } }
+          )
+        end
+      end
     end
   end
 
@@ -488,6 +774,67 @@ describe Mongoid::Atomic::Modifiers do
           end
         end
       end
+
+      context 'when the unsets conflict with a prior push' do
+        # A $push appends to the array and does not shift existing element
+        # positions, so the $unset can be applied safely in a separate write.
+        let(:pushes) { { 'books' => { 'title' => '1984' } } }
+
+        let(:unsets) { [ 'books.0.title' ] }
+
+        before do
+          modifiers.push(pushes)
+          modifiers.unset(unsets)
+        end
+
+        it 'adds the unset modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$push' => { 'books' => { '$each' => [ { 'title' => '1984' } ] } },
+              conflicts: { '$unset' => { 'books.0.title' => true } } }
+          )
+        end
+      end
+
+      context 'when the unsets conflict with a prior add to set' do
+        let(:adds) { { 'books.0.tags' => %w[tag] } }
+
+        let(:unsets) { [ 'books.0.title' ] }
+
+        before do
+          modifiers.add_to_set(adds)
+          modifiers.unset(unsets)
+        end
+
+        it 'adds the unset modifiers to the conflicts hash' do
+          expect(modifiers).to eq(
+            { '$addToSet' => { 'books.0.tags' => { '$each' => %w[tag] } },
+              conflicts: { '$unset' => { 'books.0.title' => true } } }
+          )
+        end
+      end
+
+      context 'when there is a pending pull on the same field' do
+        # A $pull shifts array elements, so routing the $unset into a separate
+        # write could make it target a different element. The operations are
+        # left together so MongoDB rejects the update (code 40) atomically.
+        let(:pulls) do
+          { 'books' => { '_id' => { '$in' => [ 'one' ] } } }
+        end
+
+        let(:unsets) { [ 'books.0.title' ] }
+
+        before do
+          modifiers.pull(pulls)
+          modifiers.unset(unsets)
+        end
+
+        it 'does not split the operations' do
+          expect(modifiers).to eq(
+            { '$pull' => { 'books' => { '_id' => { '$in' => [ 'one' ] } } },
+              '$unset' => { 'books.0.title' => true } }
+          )
+        end
+      end
     end
   end
 end