mongoid 9.0.2 → 9.0.4

data/lib/mongoid/validatable/associated.rb

@@ -70,13 +70,16 @@ module Mongoid
           # Now, treating the target as an array, look at each element
           # and see if it is valid, but only if it has already been
           # persisted, or changed, and hasn't been flagged for destroy.
-          list.all? do |value|
+          #
+          # use map.all? instead of just all?, because all? will do short-circuit
+          # evaluation and terminate on the first failed validation.
+          list.map do |value|
             if value && !value.flagged_for_destroy? && (!value.persisted? || value.changed?)
               value.validated? ? true : value.valid?
             else
               true
             end
-          end
+          end.all?
         end
 
         document.errors.add(attribute, :invalid) unless valid

data/lib/mongoid/version.rb

@@ -2,5 +2,5 @@
 # rubocop:todo all
 
 module Mongoid
-  VERSION = "9.0.2"
+  VERSION = "9.0.4"
 end

data/spec/integration/active_job_spec.rb

@@ -2,31 +2,35 @@
 # rubocop:todo all
 
 require 'spec_helper'
-require 'active_job'
-require 'mongoid/railties/bson_object_id_serializer'
+begin
+  require 'active_job'
+  require 'mongoid/railties/bson_object_id_serializer'
 
-describe 'ActiveJob Serialization' do
-  skip unless defined?(ActiveJob)
+  describe 'ActiveJob Serialization' do
+    skip unless defined?(ActiveJob)
 
-  class TestBsonObjectIdSerializerJob < ActiveJob::Base
-    def perform(*args)
-      args
+    class TestBsonObjectIdSerializerJob < ActiveJob::Base
+      def perform(*args)
+        args
+      end
     end
-  end
 
-  let(:band) do
-    Band.create!
-  end
+    let(:band) do
+      Band.create!
+    end
 
-  before do
-    ActiveJob::Serializers.add_serializers(
-      [::Mongoid::Railties::ActiveJobSerializers::BsonObjectIdSerializer]
-    )
-  end
+    before do
+      ActiveJob::Serializers.add_serializers(
+        [::Mongoid::Railties::ActiveJobSerializers::BsonObjectIdSerializer]
+      )
+    end
 
-  it 'serializes and deserializes BSON::ObjectId' do
-    expect do
-      TestBsonObjectIdSerializerJob.perform_later(band.id)
-    end.not_to raise_error
+    it 'serializes and deserializes BSON::ObjectId' do
+      expect do
+        TestBsonObjectIdSerializerJob.perform_later(band.id)
+      end.not_to raise_error
+    end
   end
+rescue LoadError
+  RSpec.context.skip 'This test requires active_job'
 end

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/mongoid/association/referenced/belongs_to/proxy_spec.rb

@@ -751,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/attributes/readonly_spec.rb

@@ -266,7 +266,26 @@ describe Mongoid::Attributes::Readonly do
           expect(child.mother).to be_nil
         end
       end
+    end
+
+    context "when a subclass inherits readonly fields" do
+      let(:attributes) do
+        [:title, :terms]
+      end
+
+      before do
+        class OldPerson < Person
+          attr_readonly :age
+        end
+      end
 
+      it "ensures subclass inherits the readonly attributes from parent" do
+        expect(OldPerson.readonly_attributes.to_a).to include("title","terms")
+      end
+
+      it "ensures subclass does not modify parent's readonly attributes" do
+        expect(Person.readonly_attributes.to_a).not_to include("age")
+      end
     end
   end
 end

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/criteria/queryable/selectable_spec.rb

@@ -1939,6 +1939,35 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
+  describe "#not" do
+    context "when negating a criterion" do
+      let(:selection) do
+        query.not(field: /value/)
+      end
+
+      it "adds the $not selector" do
+        expect(selection.selector).to eq({
+          "field" => { "$not" => /value/ }
+        })
+      end
+
+      it "returns a cloned query" do
+        expect(selection).to_not equal(query)
+      end
+
+      context "when toggling negation state" do
+        it "negates the negating value" do
+          expect(query.negating).to be_nil 
+          negated_query = query.not
+          expect(negated_query.negating).to be true
+          double_negated_query = negated_query.not
+          expect(double_negated_query.negating).to be false
+        end
+      end
+    end
+  end
+
+
   describe Symbol do
 
     describe "#all" do

data/spec/mongoid/equality_spec.rb

@@ -189,6 +189,12 @@ describe Mongoid::Equality do
     it "compares based on the document id" do
       expect(first <=> second).to eq(-1)
     end
+    
+    it "doesn't break if one isn't a document" do
+      expect do
+        first <=> "Foo"
+      end.to_not raise_error
+    end
   end
 
   describe "#eql?" 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
 

data/spec/mongoid/loadable_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongoid::Loadable do
+  let(:lib_dir) { Pathname.new('../../lib').realpath(__dir__) }
+
+  shared_context 'with ignore_patterns' do
+    around do |example|
+      saved = Mongoid.ignore_patterns
+      Mongoid.ignore_patterns = ignore_patterns
+      example.run
+    ensure
+      Mongoid.ignore_patterns = saved
+    end
+  end
+
+  describe '#ignore_patterns' do
+    context 'when not explicitly set' do
+      it 'equals the default list of ignore patterns' do
+        expect(Mongoid.ignore_patterns).to eq Mongoid::Loadable::DEFAULT_IGNORE_PATTERNS
+      end
+    end
+
+    context 'when explicitly set' do
+      include_context 'with ignore_patterns'
+
+      let(:ignore_patterns) { %w[ pattern1 pattern2 ] }
+
+      it 'equals the list of specified patterns' do
+        expect(Mongoid.ignore_patterns).to eq ignore_patterns
+      end
+    end
+  end
+
+  describe '#files_under_path' do
+    let(:results) { Mongoid.files_under_path(lib_dir) }
+
+    include_context 'with ignore_patterns'
+
+    context 'when ignore_patterns is empty' do
+      let(:ignore_patterns) { [] }
+
+      it 'returns all ruby files' do
+        expect(results.length).to be > 10 # should be a bunch of them
+        expect(results).to include('rails/mongoid')
+      end
+    end
+
+    context 'when ignore_patterns is not empty' do
+      let(:ignore_patterns) { %w[ */rails/* ] }
+
+      it 'omits the ignored paths' do
+        expect(results.length).to be > 10 # should be a bunch of them
+        expect(results).not_to include('rails/mongoid')
+      end
+    end
+  end
+
+  describe '#files_under_paths' do
+    let(:paths) { [ lib_dir.join('mongoid'), lib_dir.join('rails') ] }
+    let(:results) { Mongoid.files_under_paths(paths) }
+
+    include_context 'with ignore_patterns'
+
+    context 'when ignore_patterns is empty' do
+      let(:ignore_patterns) { [] }
+
+      it 'returns all ruby files' do
+        expect(results.length).to be > 10 # should be a bunch
+        expect(results).to include('generators/mongoid/model/model_generator')
+        expect(results).to include('fields/encrypted')
+      end
+    end
+
+    context 'when ignore_patterns is not empty' do
+      let(:ignore_patterns) { %w[ */model/* */fields/* ] }
+
+      it 'returns all ruby files' do
+        expect(results.length).to be > 10 # should be a bunch
+        expect(results).not_to include('generators/mongoid/model/model_generator')
+        expect(results).not_to include('fields/encrypted')
+      end
+    end
+  end
+end

data/spec/mongoid/persistence_context_spec.rb

@@ -536,6 +536,20 @@ describe Mongoid::PersistenceContext do
         end
       end
     end
+
+    context 'when the database is specified as a proc' do
+      let(:options) { { database: ->{ 'other' } } }
+
+      after { persistence_context.client.close }
+
+      it 'evaluates the proc' do
+        expect(persistence_context.database_name).to eq(:other)
+      end
+
+      it 'does not pass the proc to the client' do
+        expect(persistence_context.client.database.name).to eq('other')
+      end
+    end
   end
 
   describe '#client' do
@@ -570,6 +584,14 @@ describe Mongoid::PersistenceContext do
         expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
       end
 
+      context 'when the client option is a proc' do
+        let(:options) { { client: -> { :alternative } } }
+
+        it 'evaluates the proc' do
+          expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+        end
+      end
+
       context 'when there is a client override' do
         persistence_context_override :client, :other
 
@@ -608,6 +630,23 @@ describe Mongoid::PersistenceContext do
       end
     end
 
+    context 'when the client is set as a proc in the storage options' do
+      let(:options) { {} }
+
+      before do
+        Band.store_in client: ->{ :alternative }
+      end
+
+      after do
+        persistence_context.client.close
+        Band.store_in client: nil
+      end
+
+      it 'uses the client option' do
+        expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+      end
+    end
+
     context 'when there is no client option set' do
 
       let(:options) do

data/spec/mongoid/railties/bson_object_id_serializer_spec.rb

@@ -2,23 +2,29 @@
 # rubocop:todo all
 
 require 'spec_helper'
-require 'active_job'
-require 'mongoid/railties/bson_object_id_serializer'
 
-describe 'Mongoid::Railties::ActiveJobSerializers::BsonObjectIdSerializer' do
+begin
+  require 'active_job'
+  require 'mongoid/railties/bson_object_id_serializer'
 
-  let(:serializer) { Mongoid::Railties::ActiveJobSerializers::BsonObjectIdSerializer.instance }
-  let(:object_id) { BSON::ObjectId.new }
 
-  describe '#serialize' do
-    it 'serializes BSON::ObjectId' do
-      expect(serializer.serialize(object_id)).to be_a(String)
+  describe 'Mongoid::Railties::ActiveJobSerializers::BsonObjectIdSerializer' do
+
+    let(:serializer) { Mongoid::Railties::ActiveJobSerializers::BsonObjectIdSerializer.instance }
+    let(:object_id) { BSON::ObjectId.new }
+
+    describe '#serialize' do
+      it 'serializes BSON::ObjectId' do
+        expect(serializer.serialize(object_id)).to be_a(String)
+      end
     end
-  end
 
-  describe '#deserialize' do
-    it 'deserializes BSON::ObjectId' do
-      expect(serializer.deserialize(serializer.serialize(object_id))).to eq(object_id)
+    describe '#deserialize' do
+      it 'deserializes BSON::ObjectId' do
+        expect(serializer.deserialize(serializer.serialize(object_id))).to eq(object_id)
+      end
     end
   end
+rescue LoadError
+  RSpec.context.skip 'This test requires active_job'
 end

data/spec/mongoid/threaded_spec.rb

@@ -36,11 +36,11 @@ describe Mongoid::Threaded do
     context "when the stack has elements" do
 
       before do
-        Thread.current["[mongoid]:load-stack"] = [ true ]
+        described_class.stack('load').push(true)
       end
 
       after do
-        Thread.current["[mongoid]:load-stack"] = []
+        described_class.stack('load').clear
       end
 
       it "returns true" do
@@ -51,7 +51,7 @@ describe Mongoid::Threaded do
     context "when the stack has no elements" do
 
       before do
-        Thread.current["[mongoid]:load-stack"] = []
+        described_class.stack('load').clear
       end
 
       it "returns false" do
@@ -76,7 +76,7 @@ describe Mongoid::Threaded do
     context "when a stack has been initialized" do
 
       before do
-        Thread.current["[mongoid]:load-stack"] = [ true ]
+        described_class.stack('load').push(true)
       end
 
       let(:loading) do
@@ -84,7 +84,7 @@ describe Mongoid::Threaded do
       end
 
       after do
-        Thread.current["[mongoid]:load-stack"] = []
+        described_class.stack('load').clear
       end
 
       it "returns the stack" do
@@ -341,4 +341,23 @@ describe Mongoid::Threaded do
       end
     end
   end
+
+  describe '#clear_modified_documents' do
+    let(:session) do
+      double(Mongo::Session).tap do |session|
+        allow(session).to receive(:in_transaction?).and_return(true)
+      end
+    end
+
+    context 'when there are modified documents' do
+      before do
+        described_class.add_modified_document(session, Minim.new)
+        described_class.clear_modified_documents(session)
+      end
+
+      it 'removes the documents and keys' do
+        expect(described_class.modified_documents).to be_empty
+      end
+    end
+  end
 end