mongoid 7.0.1 → 7.0.2

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Mongoid
-  VERSION = "7.0.1"
+  VERSION = "7.0.2"
 end

data/spec/app/models/array_field.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ArrayField
+  include Mongoid::Document
+
+  field :af, type: Array
+end

data/spec/app/models/updatable.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Updatable
+  include Mongoid::Document
+
+  field :updated_at, type: BSON::Timestamp
+end

data/spec/mongoid/association/accessors_spec.rb

@@ -687,6 +687,45 @@ describe Mongoid::Association::Accessors do
     end
   end
 
+  context 'when setting associations to nil values' do
+    context 'when the document embeds one' do
+      let(:definitions) do
+        class AccessorEmbedding
+          include Mongoid::Document
+
+          embeds_one :accessor_embedded
+        end
+
+        class AccessorEmbedded
+          include Mongoid::Document
+
+          embedded_in :accessor_embedding
+        end
+
+        define_embedded
+      end
+
+      let(:embedding) do
+        AccessorEmbedding.create!
+      end
+
+      let(:define_embedded) do
+        AccessorEmbedded.create!(accessor_embedding: embedding)
+      end
+
+      it 'successfully removes the embedded document' do
+        definitions
+
+        expect(embedding.accessor_embedded).not_to be_nil
+
+        embedding.accessor_embedded = nil
+        embedding.save!
+
+        expect(embedding.reload.accessor_embedded).to be_nil
+      end
+    end
+  end
+
   context "when setting association foreign keys" do
 
     let(:game) do

data/spec/mongoid/association/depending_spec.rb

@@ -2,6 +2,259 @@ require "spec_helper"
 
 describe Mongoid::Association::Depending do
 
+  describe '#self.included' do
+
+    context 'when a destroy dependent is defined' do
+
+      context 'when the model is a subclass' do
+
+        context 'when transitive dependents are defined' do
+
+          let(:define_classes) do
+            class DependentReportCard
+              include Mongoid::Document
+
+              belongs_to :dependent_student
+            end
+
+            class DependentUser
+              include Mongoid::Document
+            end
+
+            class DependentStudent < DependentUser
+              belongs_to :dependent_teacher
+              has_many :dependent_report_cards, dependent: :destroy
+            end
+
+            class DependentDerivedStudent < DependentStudent; end
+
+            class DependentTeacher
+              include Mongoid::Document
+
+              has_many :dependent_students, dependent: :destroy
+            end
+
+            class DependentCollegeUser < DependentUser; end
+          end
+
+          it "does not add the dependent to superclass" do
+            define_classes
+
+            expect(DependentUser.dependents).to be_empty
+
+            u = DependentUser.create!
+            expect(u.dependents).to be_empty
+          end
+
+          it 'does not impede destroying the superclass' do
+            define_classes
+
+            u = DependentUser.create!
+            expect { u.destroy! }.not_to raise_error
+          end
+
+          it 'adds the dependent' do
+            define_classes
+
+            expect(DependentStudent.dependents.length).to be(1)
+            expect(DependentStudent.dependents.first.name).to be(:dependent_report_cards)
+
+            s = DependentStudent.create!
+            expect(s.dependents.length).to be(1)
+            expect(s.dependents.first.name).to be(:dependent_report_cards)
+          end
+
+          it 'facilitates proper destroying of the object' do
+            define_classes
+
+            s = DependentStudent.create!
+            r = DependentReportCard.create!(dependent_student: s)
+            s.destroy!
+
+            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+
+          it 'facilitates proper transitive destroying of the object' do
+            define_classes
+
+            t = DependentTeacher.create!
+            s = DependentStudent.create!(dependent_teacher: t)
+            r = DependentReportCard.create!(dependent_student: s)
+            s.destroy!
+
+            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+
+          it 'adds the dependent to subclasses' do
+            define_classes
+
+            expect(DependentDerivedStudent.dependents.length).to be(1)
+            expect(DependentDerivedStudent.dependents.first.name).to be(:dependent_report_cards)
+
+            s = DependentDerivedStudent.create!
+            expect(s.dependents.length).to be(1)
+            expect(s.dependents.first.name).to be(:dependent_report_cards)
+          end
+
+          it 'facilitates proper destroying of the object from subclasses' do
+            define_classes
+
+            s = DependentDerivedStudent.create!
+            r = DependentReportCard.create!(dependent_student: s)
+            s.destroy!
+
+            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+
+          it "doesn't add the dependent to sibling classes" do
+            define_classes
+
+            expect(DependentCollegeUser.dependents).to be_empty
+
+            c = DependentCollegeUser.create!
+            expect(c.dependents).to be_empty
+          end
+
+          it 'does not impede destroying the sibling class' do
+            define_classes
+
+            c = DependentCollegeUser.create!
+            expect { c.destroy! }.not_to raise_error
+          end
+        end
+
+        context 'when a superclass is reopened and a new dependent is added' do
+          let(:define_classes) do
+            class DependentOwnedOne
+              include Mongoid::Document
+
+              belongs_to :dependent_superclass
+            end
+
+            class DependentOwnedTwo
+              include Mongoid::Document
+
+              belongs_to :dependent_superclass
+            end
+
+            class DependentSuperclass
+              include Mongoid::Document
+              has_one :dependent_owned_one
+              has_one :dependent_owned_two
+            end
+
+            class DependentSubclass < DependentSuperclass
+              has_one :dependent_owned_two, dependent: :nullify
+            end
+
+            class DependentSuperclass
+              has_one :dependent_owned_one, dependent: :destroy
+            end
+          end
+
+          it 'defines the dependent from the reopened superclass on the subclass' do
+            define_classes
+
+            DependentSubclass.create!.destroy!
+
+            expect(DependentSubclass.dependents.length).to be(1)
+            expect(DependentSubclass.dependents.last.name).to be(:dependent_owned_two)
+            expect(DependentSubclass.dependents.last.options[:dependent]).to be(:nullify)
+
+            subclass = DependentSubclass.create!
+            expect(subclass.dependents.last.name).to be(:dependent_owned_two)
+            expect(subclass.dependents.last.options[:dependent]).to be(:nullify)
+          end
+
+          it 'causes the destruction of the inherited destroy dependent' do
+            define_classes
+
+            subclass = DependentSubclass.create!
+            owned = DependentOwnedOne.create!(dependent_superclass: subclass)
+            subclass.destroy!
+
+            expect {
+              DependentOwnedOne.find(owned.id)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+
+        context 'when a separate subclass overrides the destroy dependent' do
+          let(:define_classes) do
+            class Dep
+              include Mongoid::Document
+
+              belongs_to :double_assoc
+            end
+
+            class DoubleAssoc
+              include Mongoid::Document
+
+              has_many :deps, dependent: :destroy
+            end
+
+            class DoubleAssocOne < DoubleAssoc
+              has_many :deps, dependent: :nullify, inverse_of: :double_assoc
+            end
+
+            class DoubleAssocTwo < DoubleAssocOne
+              has_many :deps, dependent: :destroy, inverse_of: :double_assoc
+            end
+
+            class DoubleAssocThree < DoubleAssoc; end
+          end
+
+          it 'adds the non-destroy dependent correctly to the subclass with the override' do
+            define_classes
+
+            expect(DoubleAssocOne.dependents.length).to be(1)
+            expect(DoubleAssocOne.dependents.first.name).to be(:deps)
+            expect(DoubleAssocOne.dependents.first.options[:dependent]).to be(:nullify)
+
+            one = DoubleAssocOne.create!
+            expect(one.dependents.length).to be(1)
+            expect(one.dependents.first.name).to be(:deps)
+            expect(one.dependents.first.options[:dependent]).to be(:nullify)
+          end
+
+          it 'does not cause the destruction of the non-destroy dependent' do
+            define_classes
+
+            one = DoubleAssocOne.create!
+            dep = Dep.create!(double_assoc: one)
+            one.destroy!
+
+            expect { Dep.find(dep.id) }.not_to raise_error
+            expect(dep.double_assoc).to be_nil
+          end
+
+          it 'adds the destroy dependent correctly to the subclass without the override' do
+            define_classes
+
+            expect(DoubleAssocTwo.dependents.length).to be(1)
+            expect(DoubleAssocTwo.dependents.first.name).to be(:deps)
+            expect(DoubleAssocTwo.dependents.first.options[:dependent]).to be(:destroy)
+
+            two = DoubleAssocTwo.create!
+            expect(two.dependents.length).to be(1)
+            expect(two.dependents.first.name).to be(:deps)
+            expect(two.dependents.first.options[:dependent]).to be(:destroy)
+          end
+
+          it 'causes the destruction of the destroy dependent' do
+            define_classes
+
+            two = DoubleAssocTwo.create!
+            dep = Dep.create!(double_assoc: two)
+            two.destroy!
+
+            expect { Dep.find(dep.id) }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          end
+        end
+      end
+    end
+  end
+
   around(:each) do |example|
     relations_before = Person.relations
     example.run

data/spec/mongoid/association/polymorphic_spec.rb

@@ -98,4 +98,63 @@ describe "Polymorphic Associations" do
       end
     end
   end
+
+  context 'when the relation is touchable' do
+
+    context 'when the relation is embedded' do
+
+      let(:define_classes) do
+
+        class FirstOwner
+          include Mongoid::Document
+
+          embeds_one :owned, class_name: 'Owned', as: :embedded_relation_polymorphic_touch_owner
+        end
+
+        class SecondOwner
+          include Mongoid::Document
+
+          embeds_one :owned, class_name: 'Owned', as: :embedded_relation_polymorphic_touch_owner
+        end
+
+        class Owned
+          include Mongoid::Document
+
+          embedded_in :embedded_relation_polymorphic_touch_owner, polymorphic: true, touch: true
+        end
+      end
+
+      it 'successfully defines the touch method' do
+       expect { define_classes }.not_to raise_error
+      end
+    end
+
+    context 'when the relation is not embedded' do
+
+      let(:define_classes) do
+
+        class FirstOwner
+          include Mongoid::Document
+
+          has_one :owned, class_name: 'Owned', as: :belongs_relation_polymorphic_touch_owner
+        end
+
+        class SecondOwner
+          include Mongoid::Document
+
+          has_one :owned, class_name: 'Owned', as: :belongs_relation_polymorphic_touch_owner
+        end
+
+        class Owned
+          include Mongoid::Document
+
+          belongs_to :belongs_relation_polymorphic_touch_owner, polymorphic: true, touch: true
+        end
+      end
+
+      it 'successfully defines the touch method' do
+       expect { define_classes }.not_to raise_error
+      end
+    end
+  end
 end

data/spec/mongoid/association/referenced/belongs_to_spec.rb

@@ -449,7 +449,7 @@ describe Mongoid::Association::Referenced::BelongsTo do
         end
 
         it 'sets up touch' do
-          expect(Mongoid:: Association::Touchable).to receive(:define_touchable!).with(association)
+          expect(Mongoid::Touchable).to receive(:define_touchable!).with(association)
           association.setup!
         end
       end
@@ -463,7 +463,7 @@ describe Mongoid::Association::Referenced::BelongsTo do
         end
 
         it 'does not set up touch' do
-          expect(Mongoid:: Association::Touchable).not_to receive(:define_touchable!).with(association)
+          expect(Mongoid::Touchable).not_to receive(:define_touchable!).with(association)
           association.setup!
         end
       end
@@ -477,7 +477,7 @@ describe Mongoid::Association::Referenced::BelongsTo do
         end
 
         it 'does not set up touch' do
-          expect(Mongoid:: Association::Touchable).not_to receive(:define_touchable!).with(association)
+          expect(Mongoid::Touchable).not_to receive(:define_touchable!).with(association)
           association.setup!
         end
       end

data/spec/mongoid/association/referenced/has_one_spec.rb

@@ -890,6 +890,33 @@ describe Mongoid::Association::Referenced::HasOne do
 
   describe '#relation_class_name' do
 
+    context 'when the classes are defined in a module' do
+
+      let(:define_classes) do
+        module HasOneAssociationClassName
+          class OwnedClass
+            include Mongoid::Document
+
+            belongs_to :owner_class
+          end
+
+          class OwnerClass
+            include Mongoid::Document
+
+            has_one :owned_class
+          end
+        end
+      end
+
+      it 'returns the proper namespaced class name' do
+        define_classes
+
+        expect(
+            HasOneAssociationClassName::OwnedClass.relations['owner_class'].relation_class_name
+        ).to eq('HasOneAssociationClassName::OwnerClass')
+      end
+    end
+
     context 'when the :class_name option is specified' do
 
       let(:options) do
@@ -1200,6 +1227,38 @@ describe Mongoid::Association::Referenced::HasOne do
     end
   end
 
+  context 'when the classes are defined in a module' do
+
+    let(:define_classes) do
+      module HasOneAssociationModuleDefinitions
+        class OwnedClass
+          include Mongoid::Document
+
+          belongs_to :owner_class
+        end
+
+        class OwnerClass
+          include Mongoid::Document
+
+          has_one :owned_class
+        end
+      end
+    end
+
+    let(:owner) do
+      HasOneAssociationModuleDefinitions::OwnerClass.create!
+    end
+
+    let(:owned) do
+      define_classes
+      HasOneAssociationModuleDefinitions::OwnedClass.create!(owner_class: owner)
+    end
+
+    it 'successfully creates the owned document' do
+      expect { owned }.not_to raise_error
+    end
+  end
+
   describe '#nested_builder' do
 
     it 'returns an instance of Association::Nested::One' do