mongoid 7.5.4 → 8.1.9

data/spec/mongoid/interceptable_spec_models.rb

@@ -1,10 +1,12 @@
 module InterceptableSpec
   class CallbackRegistry
-    def initialize
+    def initialize(only: [])
       @calls = []
+      @only = only
     end
 
     def record_call(cls, cb)
+      return unless @only.empty? || @only.any? { |pat| pat == cb }
       @calls << [cls, cb]
     end
 
@@ -15,62 +17,227 @@ module InterceptableSpec
     extend ActiveSupport::Concern
 
     included do
+      field :name, type: String
+
       %i(
         validation save create update
       ).each do |what|
         %i(before after).each do |whn|
           send("#{whn}_#{what}", "#{whn}_#{what}_stub".to_sym)
           define_method("#{whn}_#{what}_stub") do
-            callback_registry.record_call(self.class, "#{whn}_#{what}".to_sym)
+            callback_registry&.record_call(self.class, "#{whn}_#{what}".to_sym)
+          end
+        end
+        unless what == :validation
+          send("around_#{what}", "around_#{what}_stub".to_sym)
+          define_method("around_#{what}_stub") do |&block|
+            callback_registry&.record_call(self.class, "around_#{what}_open".to_sym)
+            block.call
+            callback_registry&.record_call(self.class, "around_#{what}_close".to_sym)
           end
         end
       end
     end
-  end
 
-  class CbParent
-    include Mongoid::Document
+    attr_accessor :callback_registry
 
-    def initialize(callback_registry)
+    def initialize(callback_registry, *args, **kwargs)
       @callback_registry = callback_registry
-      super()
+      super(*args, **kwargs)
     end
+  end
 
-    attr_reader :callback_registry
+  module RootInsertable
+    def insert_as_root
+      @callback_registry&.record_call(self.class, :insert_into_database)
+      super
+    end
+  end
 
-    embeds_many :cb_children
-    embeds_many :cb_cascaded_children, cascade_callbacks: true
+  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
   end
 
-  class CbChild
+  class CbHasManyParent
     include Mongoid::Document
+    include CallbackTracking
+    include RootInsertable
 
-    embedded_in :cb_parent
+    has_many :children, autosave: true, class_name: "CbHasManyChild", inverse_of: :parent
+  end
 
-    def initialize(callback_registry, options)
-      @callback_registry = callback_registry
-      super(options)
-    end
+  class CbHasManyChild
+    include Mongoid::Document
+    include CallbackTracking
 
-    attr_reader :callback_registry
+    belongs_to :parent, class_name: "CbHasManyParent", inverse_of: :children
+  end
 
+  class CbEmbedsOneParent
+    include Mongoid::Document
     include CallbackTracking
+    include RootInsertable
+
+    field :name
+
+    embeds_one :child, cascade_callbacks: true, class_name: "CbEmbedsOneChild", inverse_of: :parent
+  end
+
+  class CbEmbedsOneChild
+    include Mongoid::Document
+    include CallbackTracking
+
+    field :age
+
+    embedded_in :parent, class_name: "CbEmbedsOneParent", inverse_of: :child
+  end
+
+  class CbEmbedsManyParent
+    include Mongoid::Document
+    include CallbackTracking
+    include RootInsertable
+
+    embeds_many :children, cascade_callbacks: true, class_name: "CbEmbedsManyChild", inverse_of: :parent
+  end
+
+  class CbEmbedsManyChild
+    include Mongoid::Document
+    include CallbackTracking
+
+    embedded_in :parent, class_name: "CbEmbedsManyParent", inverse_of: :children
+  end
+
+  class CbParent
+    include Mongoid::Document
+    include CallbackTracking
+
+    embeds_many :cb_children
+    embeds_many :cb_cascaded_children, cascade_callbacks: true
+    embeds_many :cb_cascaded_nodes, cascade_callbacks: true, as: :parent
+  end
+
+  class CbChild
+    include Mongoid::Document
+    include CallbackTracking
+
+    embedded_in :cb_parent
   end
 
   class CbCascadedChild
     include Mongoid::Document
+    include CallbackTracking
 
     embedded_in :cb_parent
 
-    def initialize(callback_registry, options)
-      @callback_registry = callback_registry
-      super(options)
-    end
+    before_save :test_mongoid_state
 
-    attr_reader :callback_registry
+    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
 
+  class CbCascadedNode
+    include Mongoid::Document
     include CallbackTracking
+
+    embedded_in :parent, polymorphic: true
+
+    embeds_many :cb_cascaded_nodes, cascade_callbacks: true, as: :parent
+  end
+end
+
+class InterceptableBand
+  include Mongoid::Document
+
+  has_many :songs, class_name: "InterceptableSong"
+  field :name
+end
+
+class InterceptableSong
+  include Mongoid::Document
+
+  belongs_to :band, class_name: "InterceptableBand"
+  field :band_name, default: -> { band.name }
+  field :name
+end
+
+class InterceptablePlane
+  include Mongoid::Document
+
+  has_many :wings, class_name: "InterceptableWing"
+end
+
+class InterceptableWing
+  include Mongoid::Document
+
+  belongs_to :plane, class_name: "InterceptablePlane"
+  has_one :engine, autobuild: true, class_name: "InterceptableEngine"
+
+  field :_id, type: String, default: -> { 'hello-wing' }
+
+  field :p_id, type: String, default: -> { plane&.id }
+  field :e_id, type: String, default: -> { engine&.id }
+end
+
+class InterceptableEngine
+  include Mongoid::Document
+
+  belongs_to :wing, class_name: "InterceptableWing"
+
+  field :_id, type: String, default: -> { "hello-engine-#{wing&.id}" }
+end
+
+class InterceptableCompany
+  include Mongoid::Document
+
+  has_many :users, class_name: "InterceptableUser"
+  has_many :shops, class_name: "InterceptableShop"
+end
+
+class InterceptableShop
+  include Mongoid::Document
+
+  embeds_one :address, class_name: "InterceptableAddress"
+  belongs_to :company, class_name: "InterceptableCompany"
+
+  after_initialize :build_address1
+
+  def build_address1
+    self.address ||= Address.new
   end
 end
+
+class InterceptableAddress
+  include Mongoid::Document
+  embedded_in :shop, class_name: "InterceptableShop"
+end
+
+class InterceptableUser
+  include Mongoid::Document
+
+  belongs_to :company, class_name: "InterceptableCompany"
+
+  validate :break_mongoid
+
+  def break_mongoid
+    company.shop_ids
+  end
+end
+

data/spec/mongoid/matcher/extract_attribute_spec.rb

@@ -5,11 +5,7 @@ require 'spec_helper'
 describe 'Matcher.extract_attribute' do
   Dir[File.join(File.dirname(__FILE__), 'extract_attribute_data', '*.yml')].sort.each do |path|
     context File.basename(path) do
-      specs = if RUBY_VERSION.start_with?("2.5")
-                YAML.safe_load(File.read(path), [], [], true)
-              else
-                YAML.safe_load(File.read(path), aliases: true)
-              end
+      specs = YAML.safe_load(File.read(path), aliases: true)
 
       specs.each do |spec|
         context spec['name'] do

data/spec/mongoid/mongoizable_spec.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# This file is for testing the functionality of uncastable values for all
+# mongoizable classes.
+describe "mongoize/demongoize/evolve methods" do
+
+  shared_examples "handles unmongoizable values" do
+
+    context "when passing an invalid value" do
+      context "to mongoize" do
+        it "returns nil" do
+          expect(klass.mongoize(invalid_value)).to be_nil
+        end
+      end
+
+      context "when assigning an invalid value to a field" do
+        let(:catalog) { Catalog.create!(field_name => invalid_value) }
+
+        it "returns nil" do
+          catalog.attributes[field_name].should be_nil
+        end
+
+        it "persists nil" do
+          Catalog.find(catalog._id).attributes[field_name].should be_nil
+        end
+      end
+    end
+  end
+
+  shared_examples "handles undemongoizable values" do
+
+    context "when passing an invalid value" do
+      context "to demongoize" do
+        it "returns nil" do
+          expect(klass.demongoize(invalid_value)).to be_nil
+        end
+      end
+
+      context "when retrieving an invalid value from the db" do
+
+        before do
+          Catalog.collection.insert_one(field_name => invalid_value)
+        end
+
+        let(:catalog) { Catalog.first }
+
+        it "returns nil" do
+          catalog.send(field_name).should be_nil
+        end
+      end
+    end
+  end
+
+  shared_examples "pushes through unmongoizable values" do
+
+    context "when passing an invalid value" do
+      context "to mongoize" do
+        it "returns that value" do
+          expect(klass.mongoize(invalid_value)).to eq(mongoized_value)
+        end
+      end
+    end
+
+    context "when assigning an invalid value to a field" do
+      let!(:catalog) { Catalog.create!(field_name => invalid_value) }
+      let(:from_db) { Catalog.find(catalog._id) }
+
+      it "returns the inputted value" do
+        catalog.attributes[field_name].should be_nil
+      end
+
+      it "persists the inputted value" do
+        from_db.attributes[field_name].should be_nil
+      end
+    end
+  end
+
+  shared_examples "pushes through undemongoizable values" do
+
+    context "when reading an invalid value from the db" do
+      before do
+        Catalog.collection.insert_one(field_name => invalid_value)
+      end
+
+      let(:from_db) { Catalog.first }
+
+      it "reads the inputted value" do
+        from_db.send(field_name).should eq(demongoized_value)
+      end
+    end
+  end
+
+  shared_examples "pushes through unevolvable values" do
+
+    context "when passing an uncastable value to evolve" do
+
+      it "pushes the value through" do
+        expect(klass.evolve(invalid_value)).to eq(mongoized_value)
+      end
+    end
+  end
+
+  shared_examples "pushes through uncastable values" do
+    include_examples "pushes through unmongoizable values"
+    include_examples "pushes through undemongoizable values"
+  end
+
+  shared_examples "handles uncastable values" do
+    include_examples "handles unmongoizable values"
+    include_examples "handles undemongoizable values"
+  end
+
+  let(:mongoized_value) { invalid_value }
+  let(:demongoized_value) { invalid_value }
+
+  describe Array do
+    let(:invalid_value) { 1 }
+    let(:klass) { Array }
+    let(:field_name) { :array_field }
+
+    include_examples "handles unmongoizable values"
+    include_examples "pushes through undemongoizable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe BigDecimal do
+    let(:invalid_value) { "bogus" }
+    let(:klass) { described_class }
+    let(:field_name) { :big_decimal_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Mongoid::Boolean do
+    let(:invalid_value) { "invalid_value" }
+    let(:klass) { described_class }
+    let(:field_name) { :boolean_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Date do
+    let(:invalid_value) { :hello }
+    let(:klass) { described_class }
+    let(:field_name) { :date_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe DateTime do
+    let(:invalid_value) { :hello }
+    let(:klass) { described_class }
+    let(:field_name) { :date_time_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Float do
+    let(:invalid_value) { [] }
+    let(:klass) { described_class }
+    let(:field_name) { :float_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Hash do
+    let(:invalid_value) { 1 }
+    let(:klass) { described_class }
+    let(:field_name) { :hash_field }
+
+    include_examples "handles unmongoizable values"
+    include_examples "pushes through undemongoizable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Integer do
+    let(:invalid_value) { [] }
+    let(:klass) { described_class }
+    let(:field_name) { :integer_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe BSON::ObjectId do
+    let(:invalid_value) { "invalid value" }
+    let(:klass) { described_class }
+    let(:field_name) { :object_id_field }
+
+    include_examples "pushes through uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe BSON::Binary do
+    let(:invalid_value) { true }
+    let(:klass) { described_class }
+    let(:field_name) { :binary_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Range do
+    let(:invalid_value) { "invalid value" }
+    let(:klass) { described_class }
+    let(:field_name) { :range_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Regexp do
+    let(:invalid_value) { 1 }
+    let(:klass) { described_class }
+    let(:field_name) { :regexp_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Set do
+    let(:invalid_value) { 1 }
+    let(:klass) { described_class }
+    let(:field_name) { :set_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe String do
+    let(:invalid_value) { 1 }
+    let(:mongoized_value) { "1" }
+    let(:demongoized_value) { "1" }
+    let(:klass) { described_class }
+    let(:field_name) { :string_field }
+
+    include_examples "pushes through uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Mongoid::StringifiedSymbol do
+    let(:invalid_value) { [] }
+    let(:mongoized_value) { "[]" }
+    let(:demongoized_value) { :[] }
+    let(:klass) { described_class }
+    let(:field_name) { :stringified_symbol_field }
+
+    include_examples "pushes through uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Symbol do
+    let(:invalid_value) { Time.new }
+    let(:klass) { described_class }
+    let(:field_name) { :symbol_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe Time do
+    let(:invalid_value) { "invalid value" }
+    let(:klass) { described_class }
+    let(:field_name) { :time_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+
+  describe ActiveSupport::TimeWithZone do
+    let(:invalid_value) { "invalid value" }
+    let(:klass) { described_class }
+    let(:field_name) { :time_with_zone_field }
+
+    include_examples "handles uncastable values"
+    include_examples "pushes through unevolvable values"
+  end
+end

data/spec/mongoid/persistable/creatable_spec.rb

@@ -234,11 +234,11 @@ describe Mongoid::Persistable::Creatable do
       end
 
       let(:attributes) do
-        collection.find({ name: "Testy"}).first
+        collection.find({ name: "Testy" }).first
       end
 
       before do
-        Browser.create(name: 'Safari', version: '4.0.0')
+        Browser.create(name: 'Safari', version: 4.0)
       end
 
       it "persists the versions" do

data/spec/mongoid/persistable/deletable_spec.rb

@@ -12,14 +12,34 @@ describe Mongoid::Persistable::Deletable do
 
     context "when deleting a readonly document" do
 
-      let(:from_db) do
-        Person.only(:_id).first
+      context "when legacy_attributes is true" do
+        config_override :legacy_readonly, true
+
+        let(:from_db) do
+          Person.only(:_id).first
+        end
+
+        it "raises an error" do
+          expect(from_db.readonly?).to be true
+          expect {
+            from_db.delete
+          }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
       end
 
-      it "raises an error" do
-        expect {
-          from_db.delete
-        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+      context "when legacy_attributes is false" do
+        config_override :legacy_readonly, false
+
+        let(:from_db) do
+          Person.first.tap(&:readonly!)
+        end
+
+        it "raises an error" do
+          expect(from_db.readonly?).to be true
+          expect {
+            from_db.delete
+          }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
       end
     end
 
@@ -33,7 +53,7 @@ describe Mongoid::Persistable::Deletable do
       it 'deletes the matching document from the database' do
         lambda do
           person.reload
-        end.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end.should raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
       end
     end
 
@@ -46,7 +66,7 @@ describe Mongoid::Persistable::Deletable do
       it "deletes the document from the collection" do
         expect {
           Person.find(person.id)
-        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
       end
 
       it "returns true" do

data/spec/mongoid/persistable/destroyable_spec.rb

@@ -12,14 +12,34 @@ describe Mongoid::Persistable::Destroyable do
 
     context "when destroying a readonly document" do
 
-      let(:from_db) do
-        Person.only(:_id).first
+      context "when legacy_attributes is true" do
+        config_override :legacy_readonly, true
+
+        let(:from_db) do
+          Person.only(:_id).first
+        end
+
+        it "raises an error" do
+          expect(from_db.readonly?).to be true
+          expect {
+            from_db.destroy
+          }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
       end
 
-      it "raises an error" do
-        expect {
-          from_db.destroy
-        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+      context "when legacy_attributes is false" do
+        config_override :legacy_readonly, false
+
+        let(:from_db) do
+          Person.first.tap(&:readonly!)
+        end
+
+        it "raises an error" do
+          expect(from_db.readonly?).to be true
+          expect {
+            from_db.destroy
+          }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
       end
     end
 
@@ -33,7 +53,7 @@ describe Mongoid::Persistable::Destroyable do
       it 'deletes the matching document from the database' do
         lambda do
           person.reload
-        end.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end.should raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
       end
     end
 
@@ -46,7 +66,7 @@ describe Mongoid::Persistable::Destroyable do
       it "destroys the document from the collection" do
         expect {
           Person.find(person.id)
-        }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
       end
 
       it "returns true" do