mongoid 8.1.10 → 9.0.0

data/spec/mongoid/interceptable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 require_relative './interceptable_spec_models'
@@ -388,86 +389,6 @@ describe Mongoid::Interceptable do
         end
       end
     end
-
-    context 'with embedded grandchildren' do
-      IS = InterceptableSpec
-
-      config_override :prevent_multiple_calls_of_embedded_callbacks, true
-
-      context 'when creating' do
-        let(:registry) { IS::CallbackRegistry.new(only: %i[ before_save ]) }
-
-        let(:expected_calls) do
-          [
-            # the parent
-            [ IS::CbParent, :before_save ],
-
-            # the immediate child of the parent
-            [ IS::CbCascadedNode, :before_save ],
-
-            # the grandchild of the parent
-            [ IS::CbCascadedNode, :before_save ],
-          ]
-        end
-
-        let!(:parent) do
-          parent = IS::CbParent.new(registry)
-          child = IS::CbCascadedNode.new(registry)
-          grandchild = IS::CbCascadedNode.new(registry)
-
-          child.cb_cascaded_nodes = [ grandchild ]
-          parent.cb_cascaded_nodes = [ child ]
-
-          parent.tap(&:save)
-        end
-
-        it 'should cascade callbacks to grandchildren' do
-          expect(registry.calls).to be == expected_calls
-        end
-      end
-
-      context 'when updating' do
-        let(:registry) { IS::CallbackRegistry.new(only: %i[ before_update ]) }
-
-        let(:expected_calls) do
-          [
-            # the parent
-            [ IS::CbParent, :before_update ],
-
-            # the immediate child of the parent
-            [ IS::CbCascadedNode, :before_update ],
-
-            # the grandchild of the parent
-            [ IS::CbCascadedNode, :before_update ],
-          ]
-        end
-
-        let!(:parent) do
-          parent = IS::CbParent.new(nil)
-          child = IS::CbCascadedNode.new(nil)
-          grandchild = IS::CbCascadedNode.new(nil)
-
-          child.cb_cascaded_nodes = [ grandchild ]
-          parent.cb_cascaded_nodes = [ child ]
-
-          parent.save
-
-          parent.callback_registry = registry
-          child.callback_registry = registry
-          grandchild.callback_registry = registry
-
-          parent.name = 'updated'
-          child.name = 'updated'
-          grandchild.name = 'updated'
-
-          parent.tap(&:save)
-        end
-
-        it 'should cascade callbacks to grandchildren' do
-          expect(registry.calls).to be == expected_calls
-        end
-      end
-    end
   end
 
   describe ".before_destroy" do
@@ -2640,14 +2561,14 @@ describe Mongoid::Interceptable do
   # was fixed by using `.pluck` over `.only`. Look at MONGOID-5306 for a more
   # detailed explanation.
   context "when accessing _ids in validate and access an association in after_initialize" do
-    it "doesn't raise a MissingAttributeError" do
+    it "doesn't raise AttributeNotLoaded" do
       company = InterceptableCompany.create!
       shop = InterceptableShop.create!(company: company)
       user = InterceptableUser.new
       user.company = company
       expect do
         user.save!
-      end.to_not raise_error(ActiveModel::MissingAttributeError)
+      end.to_not raise_error(Mongoid::Errors::AttributeNotLoaded)
     end
   end
 

data/spec/mongoid/interceptable_spec_models.rb

@@ -1,12 +1,11 @@
+# rubocop:todo all
 module InterceptableSpec
   class CallbackRegistry
-    def initialize(only: [])
+    def initialize
       @calls = []
-      @only = only
     end
 
     def record_call(cls, cb)
-      return unless @only.empty? || @only.any? { |pat| pat == cb }
       @calls << [cls, cb]
     end
 
@@ -17,8 +16,6 @@ module InterceptableSpec
     extend ActiveSupport::Concern
 
     included do
-      field :name, type: String
-
       %i(
         validation save create update
       ).each do |what|
@@ -38,128 +35,196 @@ module InterceptableSpec
         end
       end
     end
+  end
 
-    attr_accessor :callback_registry
+  class CbHasOneParent
+    include Mongoid::Document
+
+    has_one :child, autosave: true, class_name: "CbHasOneChild", inverse_of: :parent
 
-    def initialize(callback_registry, *args, **kwargs)
+    def initialize(callback_registry)
       @callback_registry = callback_registry
-      super(*args, **kwargs)
+      super()
     end
-  end
 
-  module RootInsertable
+    attr_accessor :callback_registry
+
     def insert_as_root
       @callback_registry&.record_call(self.class, :insert_into_database)
       super
     end
-  end
 
-  class CbHasOneParent
-    include Mongoid::Document
     include CallbackTracking
-    include RootInsertable
-
-    has_one :child, autosave: true, class_name: "CbHasOneChild", inverse_of: :parent
   end
 
   class CbHasOneChild
     include Mongoid::Document
-    include CallbackTracking
 
     belongs_to :parent, class_name: "CbHasOneParent", inverse_of: :child
+
+    def initialize(callback_registry)
+      @callback_registry = callback_registry
+      super()
+    end
+
+    attr_accessor :callback_registry
+
+    include CallbackTracking
   end
 
   class CbHasManyParent
     include Mongoid::Document
-    include CallbackTracking
-    include RootInsertable
 
     has_many :children, autosave: true, class_name: "CbHasManyChild", inverse_of: :parent
+
+    def initialize(callback_registry)
+      @callback_registry = callback_registry
+      super()
+    end
+
+    attr_accessor :callback_registry
+
+    def insert_as_root
+      @callback_registry&.record_call(self.class, :insert_into_database)
+      super
+    end
+
+    include CallbackTracking
   end
 
   class CbHasManyChild
     include Mongoid::Document
-    include CallbackTracking
 
     belongs_to :parent, class_name: "CbHasManyParent", inverse_of: :children
+
+    def initialize(callback_registry)
+      @callback_registry = callback_registry
+      super()
+    end
+
+    attr_accessor :callback_registry
+
+    include CallbackTracking
   end
 
   class CbEmbedsOneParent
     include Mongoid::Document
-    include CallbackTracking
-    include RootInsertable
 
     field :name
 
     embeds_one :child, cascade_callbacks: true, class_name: "CbEmbedsOneChild", inverse_of: :parent
+
+    def initialize(callback_registry)
+      @callback_registry = callback_registry
+      super()
+    end
+
+    attr_accessor :callback_registry
+
+    def insert_as_root
+      @callback_registry&.record_call(self.class, :insert_into_database)
+      super
+    end
+
+    include CallbackTracking
   end
 
   class CbEmbedsOneChild
     include Mongoid::Document
-    include CallbackTracking
 
     field :age
 
     embedded_in :parent, class_name: "CbEmbedsOneParent", inverse_of: :child
+
+    def initialize(callback_registry)
+      @callback_registry = callback_registry
+      super()
+    end
+
+    attr_accessor :callback_registry
+
+    include CallbackTracking
   end
 
   class CbEmbedsManyParent
     include Mongoid::Document
-    include CallbackTracking
-    include RootInsertable
 
     embeds_many :children, cascade_callbacks: true, class_name: "CbEmbedsManyChild", inverse_of: :parent
+
+    def initialize(callback_registry)
+      @callback_registry = callback_registry
+      super()
+    end
+
+    attr_accessor :callback_registry
+
+    def insert_as_root
+      @callback_registry&.record_call(self.class, :insert_into_database)
+      super
+    end
+
+    include CallbackTracking
   end
 
   class CbEmbedsManyChild
     include Mongoid::Document
-    include CallbackTracking
 
     embedded_in :parent, class_name: "CbEmbedsManyParent", inverse_of: :children
+
+    def initialize(callback_registry)
+      @callback_registry = callback_registry
+      super()
+    end
+
+    attr_accessor :callback_registry
+
+    include CallbackTracking
   end
 
   class CbParent
     include Mongoid::Document
-    include CallbackTracking
+
+    def initialize(callback_registry)
+      @callback_registry = callback_registry
+      super()
+    end
+
+    attr_accessor :callback_registry
 
     embeds_many :cb_children
     embeds_many :cb_cascaded_children, cascade_callbacks: true
-    embeds_many :cb_cascaded_nodes, cascade_callbacks: true, as: :parent
+
+    include CallbackTracking
   end
 
   class CbChild
     include Mongoid::Document
-    include CallbackTracking
 
     embedded_in :cb_parent
+
+    def initialize(callback_registry, options)
+      @callback_registry = callback_registry
+      super(options)
+    end
+
+    attr_accessor :callback_registry
+
+    include CallbackTracking
   end
 
   class CbCascadedChild
     include Mongoid::Document
-    include CallbackTracking
 
     embedded_in :cb_parent
 
-    before_save :test_mongoid_state
-
-    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)
+    def initialize(callback_registry, options)
+      @callback_registry = callback_registry
+      super(options)
     end
-  end
 
-  class CbCascadedNode
-    include Mongoid::Document
-    include CallbackTracking
-
-    embedded_in :parent, polymorphic: true
+    attr_accessor :callback_registry
 
-    embeds_many :cb_cascaded_nodes, cascade_callbacks: true, as: :parent
+    include CallbackTracking
   end
 end
 

data/spec/mongoid/loading_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+require "ostruct"
+require "spec_helper"
+require "support/feature_sandbox"
+
+describe Mongoid::Loadable do
+  let(:model_root) do
+    File.absolute_path(
+      File.join(
+        File.dirname(__FILE__),
+        "../support/models/sandbox"
+      ))
+  end
+
+  let(:app_models_root) { File.join(model_root, "app/models") }
+  let(:lib_models_root) { File.join(model_root, "lib/models") }
+
+  describe "#model_paths" do
+    # reset model_paths to the default value
+    before { Mongoid.model_paths = nil }
+
+    context "when Rails is defined" do
+      around do |example|
+        FeatureSandbox.quarantine do
+          require "support/rails_mock"
+          require "rails/mongoid"
+          example.run
+        end
+      end
+
+      it "should return Rails' \"app/models\" paths" do
+        expect(Mongoid.model_paths).to be == %w( app/models )
+      end
+    end
+
+    context "when Rails is not defined" do
+      it "should return Mongoid's default model paths" do
+        expect(Mongoid.model_paths).to be == %w( ./app/models ./lib/models )
+      end
+    end
+
+    context "when explicitly set" do
+      before { Mongoid.model_paths = %w( /infra/models ) }
+      
+      it "should return the given value" do
+        expect(Mongoid.model_paths).to be == %w( /infra/models )
+      end
+    end
+  end
+
+  describe "#load_models" do
+    around :each do |example|
+      FeatureSandbox.quarantine do
+        Mongoid.model_paths = nil
+        example.run
+      end
+    end
+
+    context "when using default paths" do
+      around(:each) do |example|
+        $LOAD_PATH.concat [ app_models_root, lib_models_root ]
+
+        Dir.chdir(model_root) do
+          Mongoid.load_models
+          example.run
+        end
+      end
+
+      it "should find models in the default paths" do
+        expect(defined?(AppModelsMessage)).to be == "constant"
+        expect(defined?(LibModelsMessage)).to be == "constant"
+        expect(defined?(SandboxMessage)).to be_nil
+      end
+    end
+
+    context "when using custom model_paths" do
+      before do
+        Mongoid.model_paths = [ app_models_root ]
+        $LOAD_PATH.concat [ app_models_root ]
+        Mongoid.load_models
+      end
+
+      it "should find models in the specified paths" do
+        expect(defined?(AppModelsMessage)).to be == "constant"
+        expect(defined?(LibModelsMessage)).to be_nil
+        expect(defined?(SandboxMessage)).to be_nil
+      end
+    end
+
+    context "when passing paths directly" do
+      before do
+        $LOAD_PATH.concat [ model_root ]
+        Mongoid.load_models([ model_root ])
+      end
+
+      it "should find models in the specified paths" do
+        expect(defined?(AppModelsMessage)).to be == "constant"
+        expect(defined?(LibModelsMessage)).to be == "constant"
+        expect(defined?(SandboxMessage)).to be == "constant"
+        expect(defined?(SandboxComment)).to be == "constant"
+      end
+    end
+  end
+end
+
+module Mongoid::Loadable::RailsApplication
+  attr_accessor :application
+end

data/spec/mongoid/loggable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/matcher/extract_attribute_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/mongoid/mongoizable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/monkey_patches_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+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
+  classes = [
+    Object,
+    Array,
+    BigDecimal,
+    Date,
+    DateTime,
+    FalseClass,
+    Float,
+    Hash,
+    Integer,
+    Module,
+    NilClass,
+    Range,
+    Regexp,
+    Set,
+    String,
+    Symbol,
+    Time,
+    TrueClass,
+    ActiveSupport::TimeWithZone,
+    BSON::Binary,
+    BSON::Decimal128,
+    BSON::ObjectId,
+    BSON::Regexp,
+    BSON::Regexp::Raw
+  ]
+
+  expected_instance_methods = {
+    Object => %i[
+      __add__
+      __add_from_array__
+      __array__
+      __deep_copy__
+      __evolve_object_id__
+      __expand_complex__
+      __intersect__
+      __intersect_from_array__
+      __intersect_from_object__
+      __mongoize_object_id__
+      __union__
+      __union_from_object__
+      ivar
+      mongoize
+      numeric?
+      remove_ivar
+      resizable?
+      substitutable
+    ],
+    Array => %i[
+      __evolve_date__
+      __evolve_time__
+      __mongoize_time__
+      __sort_option__
+      __sort_pair__
+      delete_one
+    ],
+    Date => %i[
+      __evolve_date__
+      __evolve_time__
+      __mongoize_time__
+    ],
+    DateTime => %i[
+      __evolve_date__
+      __evolve_time__
+      __mongoize_time__
+    ],
+    FalseClass => %i[is_a?],
+    Float => %i[
+      __evolve_date__
+      __evolve_time__
+      __mongoize_time__
+    ],
+    Hash => %i[
+      __sort_option__
+    ],
+    Integer => %i[
+      __evolve_date__
+      __evolve_time__
+      __mongoize_time__
+    ],
+    Module => %i[
+      re_define_method
+    ],
+    NilClass => %i[
+      __evolve_date__
+      __evolve_time__
+      __expanded__
+      __override__
+      collectionize
+    ],
+    Range => %i[
+      __evolve_date__
+      __evolve_range__
+      __evolve_time__
+    ],
+    String => %i[
+      __evolve_date__
+      __evolve_time__
+      __expr_part__
+      __mongo_expression__
+      __mongoize_time__
+      __sort_option__
+      before_type_cast?
+      collectionize
+      reader
+      valid_method_name?
+      writer?
+    ],
+    Symbol => %i[
+      __expr_part__
+      add_to_set
+      all
+      asc
+      ascending
+      avg
+      desc
+      descending
+      elem_match
+      eq
+      exists
+      first
+      gt
+      gte
+      in
+      intersects_line
+      intersects_point
+      intersects_polygon
+      last
+      lt
+      lte
+      max
+      min
+      mod
+      ne
+      near
+      near_sphere
+      nin
+      not
+      push
+      sum
+      with_size
+      with_type
+      within_box
+      within_polygon
+    ],
+    TrueClass => %i[is_a?],
+    Time => %i[
+      __evolve_date__
+      __evolve_time__
+      __mongoize_time__
+    ],
+    ActiveSupport::TimeWithZone => %i[
+      __evolve_date__
+      __evolve_time__
+      __mongoize_time__
+      _bson_to_i
+    ],
+    BSON::Decimal128 => %i[
+      __evolve_decimal128__
+    ]
+  }.each_value(&:sort!)
+
+  expected_class_methods = {
+    Object => %i[
+      demongoize
+      evolve
+      re_define_method
+    ],
+    Float => %i[__numeric__],
+    Integer => %i[__numeric__],
+    String => %i[__expr_part__],
+    Symbol => %i[add_key]
+  }.each_value(&:sort!)
+
+  def mongoid_method?(method)
+    method.source_location&.first&.include?('/lib/mongoid/')
+  end
+
+  def added_instance_methods(klass)
+    methods = klass.instance_methods.select { |m| mongoid_method?(klass.instance_method(m)) }
+    methods -= added_instance_methods(Object) unless klass == Object
+    methods.sort
+  end
+
+  def added_class_methods(klass)
+    methods = klass.methods.select { |m| mongoid_method?(klass.method(m)) }
+    methods -= added_instance_methods(Object)
+    methods -= added_class_methods(Object) unless klass == Object
+    methods.sort
+  end
+
+  classes.each do |klass|
+    context klass.name do
+      it 'adds no unexpected instance methods' do
+        expect(added_instance_methods(klass)).to eq(expected_instance_methods[klass] || [])
+      end
+
+      it 'adds no unexpected class methods' do
+        expect(added_class_methods(klass)).to eq(expected_class_methods[klass] || [])
+      end
+    end
+  end
+end

data/spec/mongoid/persistable/creatable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"