mongoid 9.1.0 → 9.1.1

data/spec/mongoid/association/fallback_spec.rb

@@ -0,0 +1,425 @@
+require 'spec_helper'
+
+describe 'associations with the :fallback option' do
+  before(:all) do
+    class Anonymous
+      def attribution
+        'Composer unknown'
+      end
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :Anonymous)
+  end
+
+  context 'belongs_to' do
+    before(:all) do
+      class Composer
+        include Mongoid::Document
+
+        field :name
+
+        def attribution
+          "Composed by #{name}"
+        end
+      end
+
+      class Symphony
+        include Mongoid::Document
+
+        belongs_to :composer, fallback: -> { Anonymous.new }
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Symphony)
+      Object.send(:remove_const, :Composer)
+    end
+
+    it 'returns a fresh null object instance on every access when the association is nil' do
+      symphony = Symphony.create!
+
+      expect(symphony.composer.attribution).to eq('Composer unknown')
+      expect(symphony.composer).not_to equal(symphony.composer)
+    end
+
+    it 'returns the real associated document when the FK is set' do
+      symphony = Symphony.create!(composer: Composer.create!(name: 'Mahler'))
+
+      expect(Symphony.find(symphony.id).composer.attribution).to eq('Composed by Mahler')
+    end
+
+    it 'treats a direct null object assignment as nil' do
+      symphony = Symphony.create!
+
+      symphony.composer = Anonymous.new
+      symphony.save!
+
+      expect(Symphony.find(symphony.id).composer_id).to be_nil
+    end
+
+    it 'treats a null object passed via the constructor as nil' do
+      symphony = Symphony.create!(composer: Anonymous.new)
+
+      expect(Symphony.find(symphony.id).composer_id).to be_nil
+    end
+  end
+
+  context 'has_one' do
+    before(:all) do
+      class Composer
+        include Mongoid::Document
+
+        field :name
+
+        belongs_to :symphony
+
+        def attribution
+          "Composed by #{name}"
+        end
+      end
+
+      class Symphony
+        include Mongoid::Document
+
+        has_one :composer, fallback: -> { Anonymous.new }
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Symphony)
+      Object.send(:remove_const, :Composer)
+    end
+
+    it 'returns a fresh null object instance on every access when the association is nil' do
+      symphony = Symphony.create!
+
+      expect(symphony.composer.attribution).to eq('Composer unknown')
+      expect(symphony.composer).not_to equal(symphony.composer)
+    end
+
+    it 'returns the real associated document when one exists' do
+      symphony = Symphony.create!
+      Composer.create!(symphony: symphony, name: 'Mahler')
+
+      expect(Symphony.find(symphony.id).composer.attribution).to eq('Composed by Mahler')
+    end
+
+    it 'treats a direct null object assignment as nil' do
+      symphony = Symphony.create!
+
+      symphony.composer = Anonymous.new
+      symphony.save!
+
+      expect(Composer.where(symphony_id: symphony.id).first).to be_nil
+    end
+
+    it 'treats a null object passed via the constructor as nil' do
+      symphony = Symphony.create!(composer: Anonymous.new)
+
+      expect(Composer.where(symphony_id: symphony.id).first).to be_nil
+    end
+  end
+
+  context 'embeds_one' do
+    before(:all) do
+      class Composer
+        include Mongoid::Document
+
+        field :name
+
+        embedded_in :symphony
+
+        def attribution
+          "Composed by #{name}"
+        end
+      end
+
+      class Symphony
+        include Mongoid::Document
+
+        embeds_one :composer, fallback: -> { Anonymous.new }
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Symphony)
+      Object.send(:remove_const, :Composer)
+    end
+
+    it 'returns a fresh null object instance on every access when the association is nil' do
+      symphony = Symphony.create!
+
+      expect(symphony.composer.attribution).to eq('Composer unknown')
+      expect(symphony.composer).not_to equal(symphony.composer)
+    end
+
+    it 'returns the real embedded document when one exists' do
+      symphony = Symphony.create!(composer: Composer.new(name: 'Mahler'))
+
+      expect(Symphony.find(symphony.id).composer.attribution).to eq('Composed by Mahler')
+    end
+
+    it 'treats a direct null object assignment as nil' do
+      symphony = Symphony.create!
+
+      symphony.composer = Anonymous.new
+      symphony.save!
+
+      expect(Symphony.collection.find(_id: symphony.id).first['composer']).to be_nil
+    end
+
+    it 'treats a null object passed via the constructor as nil' do
+      symphony = Symphony.create!(composer: Anonymous.new)
+
+      expect(Symphony.collection.find(_id: symphony.id).first['composer']).to be_nil
+    end
+  end
+
+  context 'with a dependent strategy and no real associated document' do
+    before(:all) do
+      class Composer
+        include Mongoid::Document
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Composer)
+    end
+
+    context 'when the strategy is :destroy' do
+      before(:all) do
+        class Symphony
+          include Mongoid::Document
+
+          has_one :composer, dependent: :destroy, fallback: -> { Anonymous.new }
+        end
+      end
+
+      after(:all) do
+        Object.send(:remove_const, :Symphony)
+      end
+
+      it 'does not apply the strategy to the fallback when destroying the owner' do
+        symphony = Symphony.create!
+
+        expect { symphony.destroy }.not_to raise_error
+      end
+    end
+
+    context 'when the strategy is :nullify' do
+      before(:all) do
+        class Symphony
+          include Mongoid::Document
+
+          has_one :composer, dependent: :nullify, fallback: -> { Anonymous.new }
+        end
+      end
+
+      after(:all) do
+        Object.send(:remove_const, :Symphony)
+      end
+
+      it 'does not apply the strategy to the fallback when destroying the owner' do
+        symphony = Symphony.create!
+
+        expect { symphony.destroy }.not_to raise_error
+      end
+    end
+
+    context 'when the strategy is :delete_all' do
+      before(:all) do
+        class Symphony
+          include Mongoid::Document
+
+          has_one :composer, dependent: :delete_all, fallback: -> { Anonymous.new }
+        end
+      end
+
+      after(:all) do
+        Object.send(:remove_const, :Symphony)
+      end
+
+      it 'does not apply the strategy to the fallback when destroying the owner' do
+        symphony = Symphony.create!
+
+        expect { symphony.destroy }.not_to raise_error
+      end
+    end
+
+    context 'when the strategy is :restrict_with_exception' do
+      before(:all) do
+        class Symphony
+          include Mongoid::Document
+
+          has_one :composer, dependent: :restrict_with_exception, fallback: -> { Anonymous.new }
+        end
+      end
+
+      after(:all) do
+        Object.send(:remove_const, :Symphony)
+      end
+
+      it 'does not apply the strategy to the fallback when destroying the owner' do
+        symphony = Symphony.create!
+
+        expect { symphony.destroy }.not_to raise_error
+      end
+    end
+
+    context 'when the strategy is :restrict_with_error' do
+      before(:all) do
+        class Symphony
+          include Mongoid::Document
+
+          has_one :composer, dependent: :restrict_with_error, fallback: -> { Anonymous.new }
+        end
+      end
+
+      after(:all) do
+        Object.send(:remove_const, :Symphony)
+      end
+
+      it 'does not block destroying the owner because of the fallback' do
+        symphony = Symphony.create!
+
+        expect(symphony.destroy).to be_truthy
+      end
+    end
+  end
+
+  context 'on a polymorphic belongs_to' do
+    before(:all) do
+      class Composer
+        include Mongoid::Document
+      end
+
+      class Symphony
+        include Mongoid::Document
+
+        belongs_to :author, polymorphic: true, fallback: -> { Anonymous.new }
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Symphony)
+      Object.send(:remove_const, :Composer)
+    end
+
+    it 'does not raise when assigning a real document' do
+      symphony = Symphony.new
+
+      expect { symphony.author = Composer.new }.not_to raise_error
+    end
+
+    it 'treats a null object assignment as nil' do
+      symphony = Symphony.new
+
+      expect { symphony.author = Anonymous.new }.not_to raise_error
+      expect(symphony.author_id).to be_nil
+    end
+  end
+
+  context 'with nested attributes' do
+    before(:all) do
+      class Composer
+        include Mongoid::Document
+
+        field :name
+
+        embedded_in :symphony
+      end
+
+      class Symphony
+        include Mongoid::Document
+
+        embeds_one :composer, fallback: -> { Anonymous.new }
+        accepts_nested_attributes_for :composer
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Symphony)
+      Object.send(:remove_const, :Composer)
+    end
+
+    it 'builds the nested document instead of operating on the fallback' do
+      symphony = Symphony.new
+
+      expect { symphony.composer_attributes = { name: 'Mahler' } }.not_to raise_error
+      expect(symphony.composer.name).to eq('Mahler')
+    end
+  end
+
+  context 'when serialized with an included association' do
+    before(:all) do
+      class Composer
+        include Mongoid::Document
+      end
+
+      class Symphony
+        include Mongoid::Document
+
+        belongs_to :composer, fallback: -> { Anonymous.new }
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Symphony)
+      Object.send(:remove_const, :Composer)
+    end
+
+    it 'omits the fallback when the real association is nil' do
+      symphony = Symphony.new
+
+      expect { symphony.serializable_hash(include: :composer) }.not_to raise_error
+      expect(symphony.serializable_hash(include: :composer)).not_to have_key('composer')
+    end
+  end
+
+  context 'with a counter cache' do
+    before(:all) do
+      class Composer
+        include Mongoid::Document
+      end
+
+      class Symphony
+        include Mongoid::Document
+
+        belongs_to :composer, counter_cache: true, fallback: -> { Anonymous.new }
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Symphony)
+      Object.send(:remove_const, :Composer)
+    end
+
+    it 'does not update the counter on the fallback' do
+      expect { Symphony.create! }.not_to raise_error
+    end
+  end
+
+  context 'validation of the :fallback option' do
+    it 'rejects a declaration that combines :fallback with :autobuild' do
+      expect do
+        Class.new do
+          include Mongoid::Document
+
+          belongs_to :composer, fallback: -> { Object.new }, autobuild: true
+        end
+      end.to raise_error(ArgumentError, /cannot be combined with :autobuild/)
+    end
+
+    it 'rejects a non-callable :fallback value' do
+      expect do
+        Class.new do
+          include Mongoid::Document
+
+          belongs_to :composer, fallback: Object.new
+        end
+      end.to raise_error(ArgumentError, /must be a Proc or lambda/)
+    end
+  end
+end

data/spec/mongoid/association/macros_spec.rb

@@ -1027,4 +1027,30 @@ describe Mongoid::Association::Macros do
       end
     end
   end
+
+  context 'with :through option' do
+    let(:klass) do
+      Class.new do
+        include Mongoid::Document
+      end
+    end
+
+    it 'creates a HasManyThrough for has_many with :through' do
+      klass.has_many(:patients, through: :appointments)
+      assoc = klass.relations['patients']
+      expect(assoc).to be_a(Mongoid::Association::Referenced::HasManyThrough)
+    end
+
+    it 'creates a HasOneThrough for has_one with :through' do
+      klass.has_one(:store, through: :franchise)
+      assoc = klass.relations['store']
+      expect(assoc).to be_a(Mongoid::Association::Referenced::HasOneThrough)
+    end
+
+    it 'raises when :through is used with belongs_to' do
+      expect do
+        klass.belongs_to(:something, through: :other)
+      end.to raise_error(Mongoid::Errors::InvalidRelationOption)
+    end
+  end
 end

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

@@ -325,6 +325,23 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
           eager.map(&:reviewer).should eq [ nil ]
         end
       end
+
+      context 'when the *_type field has not been registered with the resolver' do
+        before do
+          Publication::Review.collection.insert_one(
+            _id: BSON::ObjectId.new,
+            summary: 'tampered',
+            reviewer_id: BSON::ObjectId.new,
+            reviewer_type: 'Kernel'
+          )
+        end
+
+        it 'raises UnrecognizedModelAlias' do
+          expect do
+            Publication::Review.includes(:reviewer).entries
+          end.to raise_error(Mongoid::Errors::UnrecognizedModelAlias)
+        end
+      end
     end
 
     context 'when the association has scope' do

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

@@ -2161,6 +2161,13 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
     end
   end
 
+  # Whether the conditions carry a pattern decides which branch of remove_all
+  # runs, so anything that has to behave the same on both is exercised twice.
+  conditions_variants = [
+    [ 'no regular expression', nil ],
+    [ 'a regular expression', { name: /Test/ } ]
+  ].freeze
+
   %i[ delete_all destroy_all ].each do |method|
     describe "##{method}" do
       context 'when the relation is not polymorphic' do
@@ -2231,6 +2238,47 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
             expect(person.preferences).to eq([])
           end
         end
+
+        context 'when the base holds the foreign keys' do
+          # unbind_one pulls ids out of the base's foreign key array and marks
+          # the base dirty, so which documents get unbound is visible here.
+          # Only what the association already held is unbound, and that has to
+          # hold whether or not the conditions carry a regular expression:
+          # scanning under a regexp budget loads the association first, and
+          # that load must not turn into an unbind of its own. See the note in
+          # HasMany::Proxy#remove_all_bounded.
+          let!(:person) do
+            Person.create!.tap do |base|
+              base.preferences.create!(name: 'Testing')
+              base.preferences.create!(name: 'Test')
+            end
+          end
+
+          let(:ids) { person.preference_ids.dup }
+
+          conditions_variants.each do |description, conditions|
+            context "when the conditions carry #{description}" do
+              context 'when the association is already in memory' do
+                it 'unbinds the deleted documents' do
+                  person.preferences.send(method, conditions)
+                  expect(person.preference_ids).to eq([])
+                  expect(person).to be_changed
+                end
+              end
+
+              context 'when the association has not been loaded' do
+                let(:cold) { Person.find(person._id) }
+
+                it 'leaves the foreign keys alone' do
+                  expect(ids.length).to eq(2)
+                  cold.preferences.send(method, conditions)
+                  expect(cold.preference_ids).to eq(ids)
+                  expect(cold).not_to be_changed
+                end
+              end
+            end
+          end
+        end
       end
     end
   end

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

@@ -984,4 +984,54 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany do
       expect(school.updated_at).to eq(update_time)
     end
   end
+
+  context 'when the stored foreign key array contains nil', :integration do
+    # Associating a target whose custom primary key is unset stores a literal
+    # nil in the foreign key array. A nil in an $in matches every document
+    # whose primary key field is null or absent, returning documents that were
+    # never associated.
+
+    before(:all) do
+      Object.const_set(:NkPost, Class.new do
+        include Mongoid::Document
+
+        store_in collection: 'nk_posts'
+        has_and_belongs_to_many :nk_tags, class_name: 'NkTag',
+                                          primary_key: :slug, inverse_of: nil
+      end)
+      Object.const_set(:NkTag, Class.new do
+        include Mongoid::Document
+
+        store_in collection: 'nk_tags'
+        field :slug, type: String
+        field :name, type: String
+      end)
+    end
+
+    after(:all) do
+      %w[NkPost NkTag].each { |c| Object.send(:remove_const, c) }
+    end
+
+    before { [ NkPost, NkTag ].each(&:delete_all) }
+
+    let!(:tag)         { NkTag.create!(slug: 'ruby', name: 'tagged') }
+    let!(:keyless_tag) { NkTag.create!(name: 'never associated') }
+    let!(:post)        { NkPost.create!(nk_tags: [ tag, NkTag.create!(name: 'no slug') ]) }
+
+    it 'does not return tags that were never associated' do
+      expect(post.reload.nk_tags.to_a).to eq([ tag ])
+    end
+
+    it 'does not put nil in the membership query' do
+      expect(post.reload.nk_tags.criteria.selector['slug']['$in']).not_to include(nil)
+    end
+
+    context 'when every stored key is nil' do
+      let!(:post) { NkPost.create!(nk_tags: [ NkTag.create!(name: 'no slug') ]) }
+
+      it 'returns nothing rather than everything' do
+        expect(post.reload.nk_tags.to_a).to eq([])
+      end
+    end
+  end
 end

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

@@ -323,6 +323,39 @@ describe Mongoid::Association::Referenced::HasMany::Eager do
           expect(eager.ordered_posts.max(:rating)).to eq(30)
         end
       end
+
+      context 'when the field name is a method name' do
+        it 'does not call the method for sum' do
+          eager.ordered_posts.each { |post| expect(post).not_to receive(:destroy) }
+          expect(eager.ordered_posts.sum(:destroy)).to eq(0)
+        end
+
+        it 'returns zero from sum' do
+          expect(eager.ordered_posts.sum(:object_id)).to eq(0)
+        end
+
+        it 'returns nil from avg' do
+          expect(eager.ordered_posts.avg(:object_id)).to be_nil
+        end
+
+        it 'returns nil from min' do
+          expect(eager.ordered_posts.min(:object_id)).to be_nil
+        end
+
+        it 'returns nil from max' do
+          expect(eager.ordered_posts.max(:object_id)).to be_nil
+        end
+      end
+
+      context 'when the field is not defined' do
+        it 'returns zero from sum' do
+          expect(eager.ordered_posts.sum(:not_a_field)).to eq(0)
+        end
+
+        it 'returns nil from avg' do
+          expect(eager.ordered_posts.avg(:not_a_field)).to be_nil
+        end
+      end
     end
   end
 end