mongoid 9.0.1 → 9.0.3

data/spec/integration/app_spec.rb

@@ -36,6 +36,8 @@ describe 'Mongoid application tests' do
   context 'demo application' do
     context 'sinatra' do
       it 'runs' do
+        skip 'https://jira.mongodb.org/browse/MONGOID-5826'
+
         clone_application(
           'https://github.com/mongoid/mongoid-demo',
           subdir: 'sinatra-minimal',
@@ -55,6 +57,8 @@ describe 'Mongoid application tests' do
 
     context 'rails-api' do
       it 'runs' do
+        skip 'https://jira.mongodb.org/browse/MONGOID-5826'
+
         clone_application(
           'https://github.com/mongoid/mongoid-demo',
           subdir: 'rails-api',
@@ -172,7 +176,7 @@ describe 'Mongoid application tests' do
     if (rails_version = SpecConfig.instance.rails_version) == 'master'
     else
       check_call(%w(gem list))
-      check_call(%w(gem install rails --no-document -v) + ["~> #{rails_version}.0"])
+      check_call(%w(gem install rails --no-document --force -v) + ["~> #{rails_version}.0"])
     end
   end
 
@@ -319,6 +323,10 @@ describe 'Mongoid application tests' do
   end
 
   def adjust_rails_defaults(rails_version: SpecConfig.instance.rails_version)
+    if !rails_version.match?(/^\d+\.\d+$/)
+      # This must be pre-release version, we trim it
+      rails_version = rails_version.split('.')[0..1].join('.')
+    end
     if File.exist?('config/application.rb')
       lines = IO.readlines('config/application.rb')
       lines.each do |line|

data/spec/integration/associations/belongs_to_spec.rb

@@ -2,8 +2,40 @@
 # rubocop:todo all
 
 require 'spec_helper'
+require 'support/feature_sandbox'
+
 require_relative '../../mongoid/association/referenced/has_one_models'
 
+def quarantine(context, polymorphic:, dept_aliases:, team_aliases:)
+  state = {}
+
+  context.before(:context) do
+    state[:quarantine] = FeatureSandbox.start_quarantine
+
+    # Have to eval this, because otherwise we get syntax errors when defining a class
+    # inside a method.
+    #
+    # I know the scissors are sharp! But I want to run with them anwyay!
+    Object.class_eval <<-RUBY
+      class SandboxManager; include Mongoid::Document; end
+      class SandboxDepartment; include Mongoid::Document; end
+      class SandboxTeam; include Mongoid::Document; end
+    RUBY
+
+    SandboxManager.belongs_to :unit, polymorphic: polymorphic
+
+    SandboxDepartment.identify_as *dept_aliases, resolver: polymorphic
+    SandboxDepartment.has_many :sandbox_managers, as: :unit
+
+    SandboxTeam.identify_as *team_aliases, resolver: polymorphic
+    SandboxTeam.has_one :sandbox_manager, as: :unit
+  end
+
+  context.after(:context) do
+    FeatureSandbox.end_quarantine(state[:quarantine])
+  end
+end
+
 describe 'belongs_to associations' do
   context 'referencing top level classes when source class is namespaced' do
     let(:college) { HomCollege.create! }
@@ -31,4 +63,101 @@ describe 'belongs_to associations' do
       expect(instance.movie).to eq movie
     end
   end
+
+  context 'when the association is polymorphic' do
+    let(:dept_manager) { SandboxManager.create(unit: department) }
+    let(:team_manager) { SandboxManager.create(unit: team) }
+    let(:department) { SandboxDepartment.create }
+    let(:team) { SandboxTeam.create }
+
+    shared_context 'it finds the associated records' do
+      it 'successfully finds the manager\'s unit' do
+        expect(dept_manager.reload.unit).to be == department
+        expect(team_manager.reload.unit).to be == team
+      end
+
+      it 'successfully finds the unit\'s manager' do
+        dept_manager; team_manager # make sure these are created first...
+
+        expect(department.reload.sandbox_managers).to be == [ dept_manager ]
+        expect(team.reload.sandbox_manager).to be == team_manager
+      end
+    end
+
+    shared_context 'it searches for alternative aliases' do
+      it 'successfully finds the corresponding unit when unit_type is a different alias' do
+        dept_manager.update unit_type: 'sandbox_dept'
+        dept_manager.reload
+
+        team_manager.update unit_type: 'group'
+        team_manager.reload
+
+        expect(dept_manager.reload.unit_type).to be == 'sandbox_dept'
+        expect(dept_manager.unit).to be == department
+
+        expect(team_manager.reload.unit_type).to be == 'group'
+        expect(team_manager.unit).to be == team
+      end
+    end
+
+    context 'when the association uses the default resolver' do
+      context 'when there are no aliases given' do
+        quarantine(self, polymorphic: true, dept_aliases: [], team_aliases: [])
+
+        it 'populates the unit_type with the class name' do
+          expect(dept_manager.unit_type).to be == 'SandboxDepartment'
+          expect(team_manager.unit_type).to be == 'SandboxTeam'
+        end
+
+        it_behaves_like 'it finds the associated records'
+      end
+
+      context 'when there are multiple aliases given' do
+        quarantine(self, polymorphic: true, dept_aliases: %w[ dept sandbox_dept ], team_aliases: %w[ team group ])
+
+        it 'populates the unit_type with the first alias' do
+          expect(dept_manager.unit_type).to be == 'dept'
+          expect(team_manager.unit_type).to be == 'team'
+        end
+
+        it_behaves_like 'it finds the associated records'
+        it_behaves_like 'it searches for alternative aliases'
+      end
+    end
+
+    context 'when the association uses a registered resolver' do
+      before(:context) { Mongoid::ModelResolver.register_resolver Mongoid::ModelResolver.new, :sandbox }
+      quarantine(self, polymorphic: :sandbox, dept_aliases: %w[ dept sandbox_dept ], team_aliases: %w[ team group ])
+
+      it 'does not include the aliases in the default resolver' do
+        expect(Mongoid::ModelResolver.instance.keys_for(SandboxDepartment.new)).not_to include('dept')
+      end
+
+      it 'populates the unit_type with the first alias' do
+        expect(dept_manager.unit_type).to be == 'dept'
+        expect(team_manager.unit_type).to be == 'team'
+      end
+
+      it_behaves_like 'it finds the associated records'
+      it_behaves_like 'it searches for alternative aliases'
+    end
+
+    context 'when the association uses an unregistered resolver' do
+      quarantine(self, polymorphic: Mongoid::ModelResolver.new,
+        dept_aliases: %w[ dept sandbox_dept ],
+        team_aliases: %w[ team group ])
+
+      it 'does not include the aliases in the default resolver' do
+        expect(Mongoid::ModelResolver.instance.keys_for(SandboxDepartment.new)).not_to include('dept')
+      end
+
+      it 'populates the unit_type with the first alias' do
+        expect(dept_manager.unit_type).to be == 'dept'
+        expect(team_manager.unit_type).to be == 'team'
+      end
+
+      it_behaves_like 'it finds the associated records'
+      it_behaves_like 'it searches for alternative aliases'
+    end
+  end
 end

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
@@ -750,6 +751,10 @@ describe Mongoid::Association::Referenced::BelongsTo::Proxy do
           person.save!
         end
 
+        # NOTE: there as a bad interdependency here, with the auto_save_spec.rb
+        # file. If auto_save_spec.rb runs before this, the following specs fail
+        # with "undefined method `nullify' for an instance of Person".
+
         context "when parent exists" do
 
           context "when child is destroyed" 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/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/clients/options_spec.rb

@@ -27,7 +27,7 @@ describe Mongoid::Clients::Options, retry: 3 do
       let(:options) { { database: 'other' } }
 
       it 'sets the options on the client' do
-        expect(persistence_context.client.options['database']).to eq(options[:database])
+        expect(persistence_context.client.options['database'].to_s).to eq(options[:database].to_s)
       end
 
       it 'does not set the options on class level' do
@@ -319,7 +319,7 @@ describe Mongoid::Clients::Options, retry: 3 do
       end
 
       it 'sets the options on the client' do
-        expect(persistence_context.client.options['database']).to eq(options[:database])
+        expect(persistence_context.client.options['database'].to_s).to eq(options[:database].to_s)
       end
 
       it 'does not set the options on instance level' do
@@ -522,4 +522,129 @@ describe Mongoid::Clients::Options, retry: 3 do
       end
     end
   end
+
+  context 'with global overrides' do
+    let(:default_subscriber) do
+      Mrss::EventSubscriber.new
+    end
+
+    let(:override_subscriber) do
+      Mrss::EventSubscriber.new
+    end
+
+    context 'when global client is overridden' do
+      before do
+        Mongoid.clients['override_client'] = { hosts: SpecConfig.instance.addresses, database: 'default_override_database' }
+        Mongoid.override_client('override_client')
+        Mongoid.client(:default).subscribe(Mongo::Monitoring::COMMAND, default_subscriber)
+        Mongoid.client('override_client').subscribe(Mongo::Monitoring::COMMAND, override_subscriber)
+      end
+
+      after do
+        Mongoid.client(:default).unsubscribe(Mongo::Monitoring::COMMAND, default_subscriber)
+        Mongoid.client('override_client').unsubscribe(Mongo::Monitoring::COMMAND, override_subscriber)
+        Mongoid.override_client(nil)
+        Mongoid.clients['override_client'] = nil
+      end
+
+      it 'uses the overridden client for create' do
+        Minim.create!
+
+        expect(override_subscriber.single_command_started_event('insert').database_name).to eq('default_override_database')
+        expect(default_subscriber.command_started_events('insert')).to be_empty
+      end
+
+      it 'uses the overridden client for queries' do
+        Minim.where(name: 'Dmitry').to_a
+
+        expect(override_subscriber.single_command_started_event('find').database_name).to eq('default_override_database')
+        expect(default_subscriber.command_started_events('find')).to be_empty
+      end
+
+      context 'when the client is set on the model level' do
+        let(:model_level_subscriber) do
+          Mrss::EventSubscriber.new
+        end
+
+        around(:example) do |example|
+          opts = Minim.storage_options
+          Minim.storage_options = Minim.storage_options.merge( { client: 'model_level_client' } )
+          Mongoid.clients['model_level_client'] = { hosts: SpecConfig.instance.addresses, database: 'model_level_database' }
+          Mongoid.client('model_level_client').subscribe(Mongo::Monitoring::COMMAND, override_subscriber)
+          example.run
+          Mongoid.client('model_level_client').unsubscribe(Mongo::Monitoring::COMMAND, override_subscriber)
+          Mongoid.clients['model_level_client'] = nil
+          Minim.storage_options = opts
+        end
+
+        # This behaviour is consistent with 8.x
+        it 'uses the overridden client for create' do
+          Minim.create!
+
+          expect(override_subscriber.single_command_started_event('insert').database_name).to eq('default_override_database')
+          expect(default_subscriber.command_started_events('insert')).to be_empty
+          expect(model_level_subscriber.command_started_events('insert')).to be_empty
+        end
+
+        # This behaviour is consistent with 8.x
+        it 'uses the overridden client for queries' do
+          Minim.where(name: 'Dmitry').to_a
+
+          expect(override_subscriber.single_command_started_event('find').database_name).to eq('default_override_database')
+          expect(default_subscriber.command_started_events('find')).to be_empty
+          expect(model_level_subscriber.command_started_events('find')).to be_empty
+        end
+      end
+    end
+
+    context 'when global database is overridden' do
+      before do
+        Mongoid.override_database('override_database')
+        Mongoid.client(:default).subscribe(Mongo::Monitoring::COMMAND, default_subscriber)
+      end
+
+      after do
+        Mongoid.client(:default).unsubscribe(Mongo::Monitoring::COMMAND, default_subscriber)
+        Mongoid.override_database(nil)
+      end
+
+      it 'uses the overridden database for create' do
+        Minim.create!
+
+        expect(default_subscriber.single_command_started_event('insert').database_name).to eq('override_database')
+      end
+
+      it 'uses the overridden database for queries' do
+        Minim.where(name: 'Dmitry').to_a
+
+        expect(default_subscriber.single_command_started_event('find').database_name).to eq('override_database')
+      end
+
+      context 'when the database is set on the model level' do
+        around(:example) do |example|
+          opts = Minim.storage_options
+          Minim.storage_options = Minim.storage_options.merge( { database: 'model_level_database' } )
+          Mongoid.clients['model_level_client'] = { hosts: SpecConfig.instance.addresses, database: 'model_level_database' }
+          Mongoid.client(:default).subscribe(Mongo::Monitoring::COMMAND, default_subscriber)
+          example.run
+          Mongoid.client(:default).unsubscribe(Mongo::Monitoring::COMMAND, default_subscriber)
+          Mongoid.clients['model_level_client'] = nil
+          Minim.storage_options = opts
+        end
+
+        # This behaviour is consistent with 8.x
+        it 'uses the overridden database for create' do
+          Minim.create!
+
+          expect(default_subscriber.single_command_started_event('insert').database_name).to eq('override_database')
+        end
+
+        it 'uses the overridden database for queries' do
+          Minim.where(name: 'Dmitry').to_a
+
+          expect(default_subscriber.single_command_started_event('find').database_name).to eq('override_database')
+        end
+      end
+    end
+  end
 end

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/interceptable_spec.rb

@@ -1789,6 +1789,12 @@ describe Mongoid::Interceptable do
     context 'with around callbacks' do
       config_override :around_callbacks_for_embeds, true
 
+      after do
+        Mongoid::Threaded.stack('interceptable').clear
+      end
+
+      let(:stack) { Mongoid::Threaded.stack('interceptable') }
+
       let(:expected) do
         [
           [InterceptableSpec::CbCascadedChild, :before_validation],
@@ -1824,6 +1830,12 @@ describe Mongoid::Interceptable do
         parent.save!
         expect(registry.calls).to eq expected
       end
+
+      it 'shows that cascaded callbacks can access Mongoid state' do
+        expect(stack).to be_empty
+        parent.save!
+        expect(stack).not_to be_empty
+      end
     end
 
     context 'without around callbacks' do

data/spec/mongoid/interceptable_spec_models.rb

@@ -224,7 +224,19 @@ module InterceptableSpec
 
     attr_accessor :callback_registry
 
+    before_save :test_mongoid_state
+
     include CallbackTracking
+
+    private
+
+    # Helps test that cascading child callbacks have access to the Mongoid
+    # state objects; if the implementation uses fiber-local (instead of truly
+    # thread-local) variables, the related tests will fail because the
+    # cascading child callbacks use fibers to linearize the recursion.
+    def test_mongoid_state
+      Mongoid::Threaded.stack('interceptable').push(self)
+    end
   end
 end