mongoid 9.0.0 → 9.0.2

data/spec/integration/persistence/collection_options_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# rubocop:disable RSpec/LeakyConstantDeclaration
+# rubocop:disable Lint/ConstantDefinitionInBlock
+describe 'Collection options' do
+  before(:all) do
+    class CollectionOptionsCapped
+      include Mongoid::Document
+
+      store_in collection_options: {
+        capped: true,
+        size: 25_600
+      }
+    end
+  end
+
+  after(:all) do
+    CollectionOptionsCapped.collection.drop
+    Mongoid.deregister_model(CollectionOptionsCapped)
+    Object.send(:remove_const, :CollectionOptionsCapped)
+  end
+
+  before do
+    CollectionOptionsCapped.collection.drop
+    # We should create the collection explicitly to apply collection options.
+    CollectionOptionsCapped.create_collection
+  end
+
+  it 'creates a document' do
+    expect { CollectionOptionsCapped.create! }.not_to raise_error
+  end
+end
+# rubocop:enable Lint/ConstantDefinitionInBlock
+# rubocop:enable RSpec/LeakyConstantDeclaration

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

@@ -28,6 +28,10 @@ describe Mongoid::Association::Embedded::EmbedsMany do
       expect(legislator.attributes.keys).to eq(['_id', 'a'])
     end
 
+    it 'allows accessing the parent' do
+      expect { legislator.congress }.not_to raise_error
+    end
+
     context 'when using only with $' do
       before do
         Patient.destroy_all

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

@@ -2,6 +2,7 @@
 # rubocop:todo all
 
 require "spec_helper"
+require 'support/models/canvas'
 require_relative '../belongs_to_models.rb'
 
 describe Mongoid::Association::Referenced::BelongsTo::Proxy do

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

@@ -4,6 +4,10 @@
 require "spec_helper"
 require_relative './has_one_models'
 
+BELONGS_TO_RESOLVER_ID__ = :__belongs_to_resolver_id
+BELONGS_TO_RESOLVER = Mongoid::ModelResolver.new
+Mongoid::ModelResolver.register_resolver BELONGS_TO_RESOLVER, BELONGS_TO_RESOLVER_ID__
+
 describe Mongoid::Association::Referenced::BelongsTo do
 
   before do
@@ -199,47 +203,76 @@ describe Mongoid::Association::Referenced::BelongsTo do
 
       context 'when the polymorphic option is provided' do
 
-        context 'when the polymorphic option is true' do
+        [ true, :default ].each do |opt|
+          context "when the polymorphic option is #{opt.inspect}" do
+            let(:options) { { polymorphic: opt } }
+            before { association }
 
-          let(:options) do
-            {
-              polymorphic: true
-            }
+            it 'set the polymorphic attribute on the owner class' do
+              expect(belonging_class.polymorphic).to be(true)
+            end
+
+            it 'sets up a field for the inverse type' do
+              expect(belonging_class.fields.keys).to include(association.inverse_type)
+            end
+
+            it 'uses the default resolver' do
+              expect(association.resolver).to be == Mongoid::ModelResolver.instance
+            end
           end
+        end
 
-          before do
-            association
+        [ false, nil ].each do |opt|
+          context "when the polymorphic option is #{opt.inspect}" do
+            let(:options) { { polymorphic: opt } }
+
+            it 'does not set the polymorphic attribute on the owner class' do
+              expect(belonging_class.polymorphic).to be(false)
+            end
+
+            it 'does not set up a field for the inverse type' do
+              expect(belonging_class.fields.keys).not_to include(association.inverse_type)
+            end
+
+            it 'does not use a resolver' do
+              expect(association.resolver).to be_nil
+            end
           end
+        end
 
-          it 'set the polymorphic attribute on the owner class' do
-            expect(belonging_class.polymorphic).to be(true)
+        context 'when the polymorphic option is set to an unregistered id' do
+          let(:options) { { polymorphic: :bogus } }
+
+          # This behavior is intentional, so that the resolver can be registered after the classes
+          # are loaded.
+          it 'does not immediately raise an exception' do
+            expect { association }.not_to raise_error
           end
 
-          it 'sets up a field for the inverse type' do
-            expect(belonging_class.fields.keys).to include(association.inverse_type)
+          it 'raises error when resolver is accessed' do
+            expect { association.resolver }.to raise_error(Mongoid::Errors::UnrecognizedResolver)
           end
         end
 
-        context 'when the polymorphic option is false' do
+        context 'when the polymorphic option is set to a registered id' do
+          let(:options) { { polymorphic: BELONGS_TO_RESOLVER_ID__ } }
+          before { association }
 
-          let(:options) do
-            {
-              polymorphic: false
-            }
+          it 'set the polymorphic attribute on the owner class' do
+            expect(belonging_class.polymorphic).to be(true)
           end
 
-          it 'does not set the polymorphic attribute on the owner class' do
-            expect(belonging_class.polymorphic).to be(false)
+          it 'sets up a field for the inverse type' do
+            expect(belonging_class.fields.keys).to include(association.inverse_type)
           end
 
-          it 'does not set up a field for the inverse type' do
-            expect(belonging_class.fields.keys).not_to include(association.inverse_type)
+          it 'connects the association to the corresponding resolver' do
+            expect(association.resolver).to be == BELONGS_TO_RESOLVER
           end
         end
       end
 
       context 'when the polymorphic option is not provided' do
-
         it 'does not set the polymorphic attribute on the owner class' do
           expect(belonging_class.polymorphic).to be(false)
         end
@@ -247,6 +280,10 @@ describe Mongoid::Association::Referenced::BelongsTo do
         it 'does not set up a field for the inverse type' do
           expect(belonging_class.fields.keys).not_to include(association.inverse_type)
         end
+
+        it 'does not use a resolver' do
+          expect(association.resolver).to be_nil
+        end
       end
     end
 

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

@@ -100,6 +100,10 @@ describe Mongoid::Association::Referenced::HasMany::Buildable do
         Post.where(association.foreign_key => object, 'ratable_type' => 'Rating')
       end
 
+      before do
+        Post.belongs_to :ratable, polymorphic: true
+      end
+
       it "adds the type to the criteria" do
         expect(documents).to eq(criteria)
       end

data/spec/mongoid/association_spec.rb

@@ -15,6 +15,20 @@ describe Mongoid::Association do
     )
   end
 
+  context "when class_name references an unknown class" do
+    context "when loading" do
+      it "does not raise an exception" do
+        expect do
+          class AssocationSpecModel
+            include Mongoid::Document
+
+            embedded_in :parent, class_name: 'SomethingBogusThatDoesNotExistYet'
+          end
+        end.not_to raise_exception
+      end
+    end
+  end
+
   describe "#embedded?" do
 
     let(:person) do

data/spec/mongoid/attributes/nested_spec.rb

@@ -2,6 +2,7 @@
 # rubocop:todo all
 
 require "spec_helper"
+require 'support/models/sandwich'
 require_relative '../association/referenced/has_many_models'
 require_relative '../association/referenced/has_and_belongs_to_many_models'
 require_relative './nested_spec_models'

data/spec/mongoid/attributes_spec.rb

@@ -289,6 +289,22 @@ describe Mongoid::Attributes do
         end
       end
 
+      context "when given nil" do
+
+        it "returns nil" do
+         expect(person[nil]).to be nil
+        end
+
+      end
+
+      context "when given an empty string" do
+
+        it "returns nil" do
+         expect(person[""]).to be nil
+        end
+
+      end
+
       context "when the field was not explicitly defined" do
 
         context "when excluding with only and the field was not excluded" do

data/spec/mongoid/clients/transactions_spec.rb

@@ -282,7 +282,7 @@ describe Mongoid::Clients::Sessions do
               end
             end
 
-            include_examples 'it aborts the transaction', Mongoid::Errors::InvalidTransactionNesting
+            include_examples 'it aborts the transaction', Mongoid::Errors::TransactionError
           end
         end
       end
@@ -591,7 +591,7 @@ describe Mongoid::Clients::Sessions do
             end
 
             it 'raises an error' do
-              expect(error).to be_a(Mongoid::Errors::InvalidTransactionNesting)
+              expect(error).to be_a(Mongoid::Errors::TransactionError)
             end
 
             it 'does not execute any operations' do

data/spec/mongoid/contextual/aggregable/memory_spec.rb

@@ -570,5 +570,16 @@ describe Mongoid::Contextual::Aggregable::Memory do
         expect(sum).to eq(1500)
       end
     end
+
+    context "when provided a block with initial value" do
+
+      let(:sum) do
+        context.sum(500, &:likes)
+      end
+
+      it "returns the sum for the provided block starting from initial value" do
+        expect(sum).to eq(2000)
+      end
+    end
   end
 end

data/spec/mongoid/contextual/aggregable/mongo_spec.rb

@@ -515,6 +515,17 @@ describe Mongoid::Contextual::Aggregable::Mongo do
           expect(sum).to eq(1500)
         end
       end
+
+      context "when provided a block with initial value" do
+
+        let(:sum) do
+          context.sum(500, &:likes)
+        end
+
+        it "returns the sum for the provided block starting from initial value" do
+          expect(sum).to eq(2000)
+        end
+      end
     end
   end
 

data/spec/mongoid/contextual/mongo_spec.rb

@@ -3640,6 +3640,75 @@ describe Mongoid::Contextual::Mongo do
               expect(new_order.reload.genres).to eq(["electronic"])
             end
           end
+
+          context "when operation is $pull" do
+            context "when pulling single element" do
+
+              before do
+                depeche_mode.update_attribute(:genres, ["electronic", "pop"])
+                new_order.update_attribute(:genres, ["electronic", "pop"])
+                context.update_all("$pull" => { genres: "electronic" })
+              end
+
+              it "updates the first matching document" do
+                expect(depeche_mode.reload.genres).to eq(["pop"])
+              end
+
+              it "updates the last matching document" do
+                expect(new_order.reload.genres).to eq(["pop"])
+              end
+            end
+
+            context "when pulling based on condition" do
+              before do
+                depeche_mode.update_attribute(:genres, ["electronic", "pop", "dance"])
+                new_order.update_attribute(:genres, ["electronic", "pop", "dance"])
+                context.update_all("$pull" => { genres: { '$in' => ["electronic", "pop"] } })
+              end
+
+              it "updates the first matching document" do
+                expect(depeche_mode.reload.genres).to eq(["dance"])
+              end
+
+              it "updates the last matching document" do
+                expect(new_order.reload.genres).to eq(["dance"])
+              end
+            end
+          end
+
+          context "when operation is $pop" do
+
+            before do
+              depeche_mode.update_attribute(:genres, ["pop", "electronic"])
+            end
+
+            it "removes first element in array" do
+              context.update_all("$pop" => { genres: -1 })
+              expect(depeche_mode.reload.genres).to eq(["electronic"])
+            end
+
+            it "removes last element in array" do
+              context.update_all("$pop" => { genres: 1 })
+              expect(depeche_mode.reload.genres).to eq(["pop"])
+            end
+          end
+
+          context "when operation is $pullAll" do
+
+            before do
+              depeche_mode.update_attribute(:genres, ["pop", "electronic", "dance", "pop" ])
+              new_order.update_attribute(:genres, ["electronic", "pop", "electronic", "dance"])
+              context.update_all("$pullAll" => { genres: ["pop", "electronic"] })
+            end
+
+            it "updates the first matching document" do
+              expect(depeche_mode.reload.genres).to eq(["dance"])
+            end
+
+            it "updates the last matching document" do
+              expect(new_order.reload.genres).to eq(["dance"])
+            end
+          end
         end
 
         context 'when using aliased field names' do
@@ -3659,15 +3728,15 @@ describe Mongoid::Contextual::Mongo do
         context "when the attributes must be mongoized" do
 
           before do
-            context.update_all("$set" => { member_count: "1" })
+            context.update_all("$set" => { location: LatLng.new(52.30, 13.25) })
           end
 
           it "updates the first matching document" do
-            expect(depeche_mode.reload.member_count).to eq(1)
+            expect(depeche_mode.reload.location).to eq(LatLng.new(52.30, 13.25))
           end
 
           it "updates the last matching document" do
-            expect(new_order.reload.member_count).to eq(1)
+            expect(new_order.reload.location).to eq(LatLng.new(52.30, 13.25))
           end
         end
       end

data/spec/mongoid/fields_spec.rb

@@ -1871,12 +1871,12 @@ describe Mongoid::Fields do
 
     context 'given nil' do
       subject { Person.database_field_name(nil) }
-      it { is_expected.to eq nil }
+      it { is_expected.to eq '' }
     end
 
     context 'given an empty String' do
       subject { Person.database_field_name('') }
-      it { is_expected.to eq nil }
+      it { is_expected.to eq '' }
     end
 
     context 'given a String' do

data/spec/mongoid/interceptable_spec.rb

@@ -2594,4 +2594,35 @@ describe Mongoid::Interceptable do
       end
     end
   end
+
+  context "when around callbacks for embedded children are enabled" do
+    config_override :around_callbacks_for_embeds, true
+
+    context "when around callback is defined without a yield" do
+      class Mother
+        include Mongoid::Document
+        embeds_many :daughters, cascade_callbacks: true
+      end
+
+      class Daughter
+        include Mongoid::Document
+        embedded_in :mother
+        around_save :log_callback
+
+        private
+
+        def log_callback
+          logger.debug('callback invoked')
+        end
+      end
+
+      let(:mom) { Mother.create(daughters: [ Daughter.new, Daughter.new ]) }
+
+      it "raises an InvalidAroundCallback error" do
+        expect do
+          mom.save
+        end.to raise_error(Mongoid::Errors::InvalidAroundCallback)
+      end
+    end
+  end
 end

data/spec/mongoid/model_resolver_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/feature_sandbox'
+
+MONGOID_MODEL_RESOLVER_KEY__ = :__separate_instance_spec_key
+Mongoid::ModelResolver.register_resolver Mongoid::ModelResolver.new, MONGOID_MODEL_RESOLVER_KEY__
+
+def quarantine(context, &block)
+  state = {}
+
+  context.before(:context) do
+    state[:quarantine] = FeatureSandbox.start_quarantine
+    block&.call
+  end
+
+  context.after(:context) do
+    FeatureSandbox.end_quarantine(state[:quarantine])
+  end
+end
+
+describe Mongoid::ModelResolver do
+  shared_examples 'a resolver' do |**kwargs|
+    it 'includes the class name when asked for all keys of the given model' do
+      expect(resolver.keys_for(model_class.new)).to include(model_class.name)
+    end
+
+    if kwargs[:with_aliases].nil?
+      it 'uses the class name as the default key for the given model' do
+        expect(resolver.default_key_for(model_class.new)).to eq model_class.name
+      end
+    elsif kwargs[:with_aliases].is_a?(Array)
+      it 'uses the first alias as the default key for the given model' do
+        expect(resolver.default_key_for(model_class.new)).to eq kwargs[:with_aliases].first
+      end
+    else
+      it 'uses the alias as the default key for the given model' do
+        expect(resolver.default_key_for(model_class.new)).to eq kwargs[:with_aliases]
+      end
+    end
+
+    it 'returns the model class when queried with the class name' do
+      expect(resolver.model_for(model_class.name)).to eq model_class
+    end
+
+    Array(kwargs[:with_aliases]).each do |model_alias|
+      it "includes the alias #{model_alias.inspect} when asked for all keys of the given model" do
+        expect(resolver.keys_for(model_class.new)).to include(model_alias)
+      end
+
+      it "returns the model class when queried with #{model_alias.inspect}" do
+        expect(resolver.model_for(model_alias)).to eq model_class
+      end
+    end
+  end
+
+  context 'when using the default instance' do
+    let(:resolver) { described_class.instance }
+
+    context 'when an alias is not specified' do
+      quarantine(self) do
+        Object.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          module Mongoid; module Specs; module DefaultInstance
+            class Vanilla; include Mongoid::Document; end
+          end; end; end
+        RUBY
+      end
+
+      let(:model_class) { Mongoid::Specs::DefaultInstance::Vanilla }
+
+      it_behaves_like 'a resolver'
+    end
+
+    context 'when one alias is specified' do
+      quarantine(self) do
+        Object.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          module Mongoid; module Specs; module DefaultInstance
+            class Aliased
+              include Mongoid::Document
+              identify_as 'aliased'
+            end
+          end; end; end
+        RUBY
+      end
+
+      let(:model_class) { Mongoid::Specs::DefaultInstance::Aliased }
+
+      it_behaves_like 'a resolver', with_aliases: 'aliased'
+    end
+
+    context 'when multiple aliases are specified' do
+      quarantine(self) do
+        Object.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          module Mongoid; module Specs; module DefaultInstance
+            class AliasedMultiple
+              include Mongoid::Document
+              identify_as 'aliased', 'alias2', 'alias3'
+            end
+          end; end; end
+        RUBY
+      end
+
+      let(:model_class) { Mongoid::Specs::DefaultInstance::AliasedMultiple }
+
+      it_behaves_like 'a resolver', with_aliases: %w[ aliased alias2 alias3 ]
+    end
+  end
+
+  context 'when using a separate instance' do
+    let(:resolver) { described_class.resolver(MONGOID_MODEL_RESOLVER_KEY__) }
+
+    it 'does not refer to the default instance' do
+      expect(resolver).not_to eq described_class.instance
+    end
+
+    context 'when an alias is not specified' do
+      quarantine(self) do
+        Object.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          module Mongoid; module Specs; module SeparateInstance
+            class Vanilla
+              include Mongoid::Document
+              identify_as resolver: MONGOID_MODEL_RESOLVER_KEY__
+            end
+          end; end; end
+        RUBY
+      end
+
+      let(:model_class) { Mongoid::Specs::SeparateInstance::Vanilla }
+
+      it_behaves_like 'a resolver'
+    end
+
+    context 'when one alias is specified' do
+      quarantine(self) do
+        Object.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          module Mongoid; module Specs; module SeparateInstance
+            class Aliased
+              include Mongoid::Document
+              identify_as 'aliased', resolver: MONGOID_MODEL_RESOLVER_KEY__
+            end
+          end; end; end
+        RUBY
+      end
+
+      let(:model_class) { Mongoid::Specs::SeparateInstance::Aliased }
+
+      it_behaves_like 'a resolver', with_aliases: 'aliased'
+    end
+
+    context 'when multiple aliases are specified' do
+      quarantine(self) do
+        Object.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          module Mongoid; module Specs; module SeparateInstance
+            class AliasedMultiple
+              include Mongoid::Document
+              identify_as 'aliased', 'alias2', 'alias3', resolver: MONGOID_MODEL_RESOLVER_KEY__
+            end
+          end; end; end
+        RUBY
+      end
+
+      let(:model_class) { Mongoid::Specs::SeparateInstance::AliasedMultiple }
+
+      it_behaves_like 'a resolver', with_aliases: %w[ aliased alias2 alias3 ]
+    end
+  end
+end

data/spec/mongoid/monkey_patches_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 # @note This test ensures that we do not inadvertently introduce new monkey patches
 # to Mongoid. Existing monkey patch methods which are marked with +Mongoid.deprecated+
 # are excluded from this test.
-RSpec.describe('Do not add monkey patches') do # rubocop:disable RSpec/DescribeClass
+RSpec.describe('Do not add monkey patches') do
   classes = [
     Object,
     Array,

data/spec/mongoid/persistence_context_spec.rb

@@ -206,12 +206,25 @@ describe Mongoid::PersistenceContext do
 
         context 'when the options are valid extra options' do
 
-          let(:options) do
-            { collection: 'other' }
+          context 'collection' do
+
+            let(:options) do
+              { collection: 'other' }
+            end
+
+            it 'sets the options on the persistence context object' do
+              expect(persistence_context.collection_name).to eq(options[:collection].to_sym)
+            end
           end
 
-          it 'sets the options on the persistence context object' do
-            expect(persistence_context.collection_name).to eq(options[:collection].to_sym)
+          context 'collection_options' do
+            let(:options) do
+              { collection_options: { capped: true } }
+            end
+
+            it 'does not propagate to client options' do
+              expect(persistence_context.send(:client_options).key?(:collection_options)).to eq(false)
+            end
           end
         end