mongoid 8.0.10 → 8.1.0

data/spec/mongoid/interceptable_spec_models.rb

@@ -1,19 +1,13 @@
 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
 
-    def reset!
-      @calls.clear
-    end
-
     attr_reader :calls
   end
 
@@ -21,8 +15,6 @@ module InterceptableSpec
     extend ActiveSupport::Concern
 
     included do
-      field :name, type: String
-
       %i(
         validation save create update
       ).each do |what|
@@ -42,128 +34,196 @@ module InterceptableSpec
         end
       end
     end
+  end
 
-    attr_accessor :callback_registry
+  class CbHasOneParent
+    include Mongoid::Document
 
-    def initialize(callback_registry, *args, **kwargs)
+    has_one :child, autosave: true, class_name: "CbHasOneChild", inverse_of: :parent
+
+    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/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
 

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
 

data/spec/mongoid/persistable/incrementable_spec.rb

@@ -237,5 +237,42 @@ describe Mongoid::Persistable::Incrementable do
         end
       end
     end
+
+    context "when executing on a readonly document" do
+
+      let(:person) do
+        Person.create!(age: 10, score: 100)
+      end
+
+      context "when legacy_readonly is true" do
+        config_override :legacy_readonly, true
+
+        before do
+          person.__selected_fields = { "age" => 1, "score" => 1 }
+        end
+
+        it "persists the changes" do
+          expect(person).to be_readonly
+          person.inc(age: 15, score: 2)
+          expect(person.age).to eq(25)
+          expect(person.score).to eq(102)
+        end
+      end
+
+      context "when legacy_readonly is false" do
+        config_override :legacy_readonly, false
+
+        before do
+          person.readonly!
+        end
+
+        it "raises a ReadonlyDocument error" do
+          expect(person).to be_readonly
+          expect do
+            person.inc(age: 15, score: 2)
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
+      end
+    end
   end
 end

data/spec/mongoid/persistable/logical_spec.rb

@@ -155,5 +155,42 @@ describe Mongoid::Persistable::Logical do
         end
       end
     end
+
+    context "when executing on a readonly document" do
+
+      let(:person) do
+        Person.create!(age: 10, score: 100)
+      end
+
+      context "when legacy_readonly is true" do
+        config_override :legacy_readonly, true
+
+        before do
+          person.__selected_fields = { "age" => 1, "score" => 1 }
+        end
+
+        it "persists the changes" do
+          expect(person).to be_readonly
+          person.bit(age: { and: 6 }, score: { or: 122 })
+          expect(person.age).to eq(2)
+          expect(person.score).to eq(126)
+        end
+      end
+
+      context "when legacy_readonly is false" do
+        config_override :legacy_readonly, false
+
+        before do
+          person.readonly!
+        end
+
+        it "raises a ReadonlyDocument error" do
+          expect(person).to be_readonly
+          expect do
+            person.bit(age: { and: 6 }, score: { or: 122 })
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
+      end
+    end
   end
 end

data/spec/mongoid/persistable/poppable_spec.rb

@@ -127,5 +127,41 @@ describe Mongoid::Persistable::Poppable do
         end
       end
     end
+
+    context "when executing on a readonly document" do
+
+      let(:person) do
+        Person.create!(test_array: [1, 2, 3])
+      end
+
+      context "when legacy_readonly is true" do
+        config_override :legacy_readonly, true
+
+        before do
+          person.__selected_fields = { "test_array" => 1 }
+        end
+
+        it "persists the changes" do
+          expect(person).to be_readonly
+          person.pop(test_array: 1)
+          expect(person.test_array).to eq([ 1, 2 ])
+        end
+      end
+
+      context "when legacy_readonly is false" do
+        config_override :legacy_readonly, false
+
+        before do
+          person.readonly!
+        end
+
+        it "raises a ReadonlyDocument error" do
+          expect(person).to be_readonly
+          expect do
+            person.pop(test_array: 1)
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
+      end
+    end
   end
 end

data/spec/mongoid/persistable/pullable_spec.rb

@@ -127,6 +127,42 @@ describe Mongoid::Persistable::Pullable do
         end
       end
     end
+
+    context "when executing on a readonly document" do
+
+      let(:person) do
+        Person.create!(test_array: [ 1, 1, 2, 3 ])
+      end
+
+      context "when legacy_readonly is true" do
+        config_override :legacy_readonly, true
+
+        before do
+          person.__selected_fields = { "test_array" => 1 }
+        end
+
+        it "persists the changes" do
+          expect(person).to be_readonly
+          person.pull(test_array: 1)
+          expect(person.test_array).to eq([ 2, 3 ])
+        end
+      end
+
+      context "when legacy_readonly is false" do
+        config_override :legacy_readonly, false
+
+        before do
+          person.readonly!
+        end
+
+        it "raises a ReadonlyDocument error" do
+          expect(person).to be_readonly
+          expect do
+            person.pull(test_array: 1)
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
+      end
+    end
   end
 
   describe "#pull_all" do
@@ -254,5 +290,41 @@ describe Mongoid::Persistable::Pullable do
         end
       end
     end
+
+    context "when executing on a readonly document" do
+
+      let(:person) do
+        Person.create!(test_array: [ 1, 1, 2, 3, 4 ])
+      end
+
+      context "when legacy_readonly is true" do
+        config_override :legacy_readonly, true
+
+        before do
+          person.__selected_fields = { "test_array" => 1 }
+        end
+
+        it "persists the changes" do
+          expect(person).to be_readonly
+          person.pull_all(test_array: [ 1, 2 ])
+          expect(person.test_array).to eq([ 3, 4 ])
+        end
+      end
+
+      context "when legacy_readonly is false" do
+        config_override :legacy_readonly, false
+
+        before do
+          person.readonly!
+        end
+
+        it "raises a ReadonlyDocument error" do
+          expect(person).to be_readonly
+          expect do
+            person.pull_all(test_array: [ 1, 2 ])
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
+      end
+    end
   end
 end

data/spec/mongoid/persistable/pushable_spec.rb

@@ -204,6 +204,42 @@ describe Mongoid::Persistable::Pushable do
         end
       end
     end
+
+    context "when executing on a readonly document" do
+
+      let(:person) do
+        Person.create!(test_array: [ 1, 2, 3 ])
+      end
+
+      context "when legacy_readonly is true" do
+        config_override :legacy_readonly, true
+
+        before do
+          person.__selected_fields = { "test_array" => 1 }
+        end
+
+        it "persists the changes" do
+          expect(person).to be_readonly
+          person.add_to_set(test_array: [ 1, 4 ])
+          expect(person.test_array).to eq([ 1, 2, 3, 4 ])
+        end
+      end
+
+      context "when legacy_readonly is false" do
+        config_override :legacy_readonly, false
+
+        before do
+          person.readonly!
+        end
+
+        it "raises a ReadonlyDocument error" do
+          expect(person).to be_readonly
+          expect do
+            person.add_to_set(test_array: [ 1, 4 ])
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
+      end
+    end
   end
 
   describe "#push" do
@@ -349,5 +385,41 @@ describe Mongoid::Persistable::Pushable do
         end
       end
     end
+
+    context "when executing on a readonly document" do
+
+      let(:person) do
+        Person.create!(test_array: [ 1, 2, 3 ])
+      end
+
+      context "when legacy_readonly is true" do
+        config_override :legacy_readonly, true
+
+        before do
+          person.__selected_fields = { "test_array" => 1 }
+        end
+
+        it "persists the changes" do
+          expect(person).to be_readonly
+          person.push(test_array: [ 1, 4 ])
+          expect(person.test_array).to eq([ 1, 2, 3, 1, 4 ])
+        end
+      end
+
+      context "when legacy_readonly is false" do
+        config_override :legacy_readonly, false
+
+        before do
+          person.readonly!
+        end
+
+        it "raises a ReadonlyDocument error" do
+          expect(person).to be_readonly
+          expect do
+            person.push(test_array: [ 1, 4 ])
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
+      end
+    end
   end
 end

data/spec/mongoid/persistable/renamable_spec.rb

@@ -147,5 +147,41 @@ describe Mongoid::Persistable::Renamable do
         end
       end
     end
+
+    context "when executing on a readonly document" do
+
+      let(:person) do
+        Person.create!(title: "sir")
+      end
+
+      context "when legacy_readonly is true" do
+        config_override :legacy_readonly, true
+
+        before do
+          person.__selected_fields = { "test_array" => 1 }
+        end
+
+        it "persists the changes" do
+          expect(person).to be_readonly
+          person.rename title: :salutation
+          expect(person.reload.salutation).to eq("sir")
+        end
+      end
+
+      context "when legacy_readonly is false" do
+        config_override :legacy_readonly, false
+
+        before do
+          person.readonly!
+        end
+
+        it "raises a ReadonlyDocument error" do
+          expect(person).to be_readonly
+          expect do
+            person.rename(title: :salutation)
+          end.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end
+      end
+    end
   end
 end