mongoid 7.4.0 → 8.0.1

data/spec/mongoid/indexable_spec.rb

@@ -191,7 +191,7 @@ describe Mongoid::Indexable do
       end
     end
 
-    context "when using a custom discriminator_key" do 
+    context "when using a custom discriminator_key" do
       context "when indexes have not been added" do
         let(:klass) do
           Class.new do
@@ -202,15 +202,15 @@ describe Mongoid::Indexable do
             end
           end
         end
-  
+
         before do
           klass.add_indexes
         end
-  
+
         let(:spec) do
           klass.index_specification(dkey: 1)
         end
-  
+
         it "adds the _type index" do
           expect(spec.options).to eq(unique: false, background: true)
         end
@@ -262,21 +262,6 @@ describe Mongoid::Indexable do
       end
     end
 
-    context "when providing a drop_dups option" do
-
-      before do
-        klass.index({ name: 1 }, drop_dups: true)
-      end
-
-      let(:options) do
-        klass.index_specification(name: 1).options
-      end
-
-      it "sets the index with drop_dups option" do
-        expect(options).to eq(drop_dups: true)
-      end
-    end
-
     context "when providing a sparse option" do
 
       before do
@@ -438,6 +423,18 @@ describe Mongoid::Indexable do
       end
     end
 
+    context "when providing a geo haystack index with a bucket_size" do
+
+      let(:message) do
+        'The geoHaystack type is deprecated.'
+      end
+
+      it "logs a deprecation warning" do
+        expect(Mongoid::Warnings).to receive(:warn_geo_haystack_deprecated)
+        klass.index({ location: "geoHaystack" }, { min: -200, max: 200, bucket_size: 0.5 })
+      end
+    end
+
     context "when providing a Spherical Geospatial index" do
 
       before do

data/spec/mongoid/interceptable_spec.rb

@@ -1746,8 +1746,12 @@ describe Mongoid::Interceptable do
         [InterceptableSpec::CbChild, :after_validation],
         [InterceptableSpec::CbParent, :after_validation],
         [InterceptableSpec::CbParent, :before_save],
+        [InterceptableSpec::CbParent, :around_save_open],
         [InterceptableSpec::CbParent, :before_create],
+        [InterceptableSpec::CbParent, :around_create_open],
+        [InterceptableSpec::CbParent, :around_create_close],
         [InterceptableSpec::CbParent, :after_create],
+        [InterceptableSpec::CbParent, :around_save_close],
         [InterceptableSpec::CbParent, :after_save],
       ]
     end
@@ -1769,26 +1773,601 @@ describe Mongoid::Interceptable do
 
     let(:expected) do
       [
+        [InterceptableSpec::CbCascadedChild, :before_validation],
+        [InterceptableSpec::CbCascadedChild, :after_validation],
         [InterceptableSpec::CbParent, :before_validation],
         [InterceptableSpec::CbCascadedChild, :before_validation],
         [InterceptableSpec::CbCascadedChild, :after_validation],
+
         [InterceptableSpec::CbParent, :after_validation],
         [InterceptableSpec::CbParent, :before_save],
-        [InterceptableSpec::CbCascadedChild, :before_save],
+        [InterceptableSpec::CbParent, :around_save_open],
         [InterceptableSpec::CbParent, :before_create],
+        [InterceptableSpec::CbParent, :around_create_open],
+
+        [InterceptableSpec::CbCascadedChild, :before_save],
+        [InterceptableSpec::CbCascadedChild, :around_save_open],
         [InterceptableSpec::CbCascadedChild, :before_create],
-        [InterceptableSpec::CbParent, :after_create],
+        [InterceptableSpec::CbCascadedChild, :around_create_open],
+
+        [InterceptableSpec::CbCascadedChild, :around_create_close],
         [InterceptableSpec::CbCascadedChild, :after_create],
-        [InterceptableSpec::CbParent, :after_save],
+        [InterceptableSpec::CbCascadedChild, :around_save_close],
         [InterceptableSpec::CbCascadedChild, :after_save],
+
+        [InterceptableSpec::CbParent, :around_create_close],
+        [InterceptableSpec::CbParent, :after_create],
+        [InterceptableSpec::CbParent, :around_save_close],
+        [InterceptableSpec::CbParent, :after_save]
       ]
     end
 
     it 'calls callbacks in the right order' do
-      pending 'MONGOID-3795'
-
       parent.save!
       expect(registry.calls).to eq expected
     end
   end
+
+  context "with associations" do
+    context "has_one" do
+      let(:registry) { InterceptableSpec::CallbackRegistry.new }
+
+      let(:parent) do
+        InterceptableSpec::CbHasOneParent.new(registry).tap do |parent|
+          parent.child = InterceptableSpec::CbHasOneChild.new(registry)
+        end
+      end
+
+      let(:expected) do
+        [
+          [InterceptableSpec::CbHasOneParent, :before_validation],
+          [InterceptableSpec::CbHasOneChild, :before_validation],
+          [InterceptableSpec::CbHasOneChild, :after_validation],
+          [InterceptableSpec::CbHasOneParent, :after_validation],
+          [InterceptableSpec::CbHasOneParent, :before_save],
+
+          [InterceptableSpec::CbHasOneParent, :around_save_open],
+          [InterceptableSpec::CbHasOneParent, :before_create],
+          [InterceptableSpec::CbHasOneParent, :around_create_open],
+
+          [InterceptableSpec::CbHasOneParent, :insert_into_database],
+
+          [InterceptableSpec::CbHasOneChild, :before_validation],
+          [InterceptableSpec::CbHasOneChild, :after_validation],
+          [InterceptableSpec::CbHasOneChild, :before_save],
+          [InterceptableSpec::CbHasOneChild, :around_save_open],
+          [InterceptableSpec::CbHasOneChild, :before_create],
+          [InterceptableSpec::CbHasOneChild, :around_create_open],
+
+          [InterceptableSpec::CbHasOneChild, :around_create_close],
+          [InterceptableSpec::CbHasOneChild, :after_create],
+          [InterceptableSpec::CbHasOneChild, :around_save_close],
+          [InterceptableSpec::CbHasOneChild, :after_save],
+
+          [InterceptableSpec::CbHasOneParent, :around_create_close],
+          [InterceptableSpec::CbHasOneParent, :after_create],
+          [InterceptableSpec::CbHasOneParent, :around_save_close],
+          [InterceptableSpec::CbHasOneParent, :after_save],
+        ]
+      end
+
+      it 'calls callbacks in the right order' do
+        parent.save!
+        expect(registry.calls).to eq expected
+      end
+    end
+
+    context "embeds_one" do
+      let(:registry) { InterceptableSpec::CallbackRegistry.new }
+
+      let(:parent) do
+        InterceptableSpec::CbEmbedsOneParent.new(registry).tap do |parent|
+          parent.child = InterceptableSpec::CbEmbedsOneChild.new(registry)
+        end
+      end
+
+      context "create" do
+        let(:expected) do
+          [
+            [InterceptableSpec::CbEmbedsOneChild, :before_validation],
+            [InterceptableSpec::CbEmbedsOneChild, :after_validation],
+            [InterceptableSpec::CbEmbedsOneParent, :before_validation],
+            [InterceptableSpec::CbEmbedsOneChild, :before_validation],
+            [InterceptableSpec::CbEmbedsOneChild, :after_validation],
+            [InterceptableSpec::CbEmbedsOneParent, :after_validation],
+
+            [InterceptableSpec::CbEmbedsOneParent, :before_save],
+            [InterceptableSpec::CbEmbedsOneParent, :around_save_open],
+            [InterceptableSpec::CbEmbedsOneParent, :before_create],
+            [InterceptableSpec::CbEmbedsOneParent, :around_create_open],
+
+            [InterceptableSpec::CbEmbedsOneChild, :before_save],
+            [InterceptableSpec::CbEmbedsOneChild, :around_save_open],
+            [InterceptableSpec::CbEmbedsOneChild, :before_create],
+            [InterceptableSpec::CbEmbedsOneChild, :around_create_open],
+
+            [InterceptableSpec::CbEmbedsOneParent, :insert_into_database],
+
+            [InterceptableSpec::CbEmbedsOneChild, :around_create_close],
+            [InterceptableSpec::CbEmbedsOneChild, :after_create],
+            [InterceptableSpec::CbEmbedsOneChild, :around_save_close],
+            [InterceptableSpec::CbEmbedsOneChild, :after_save],
+
+            [InterceptableSpec::CbEmbedsOneParent, :around_create_close],
+            [InterceptableSpec::CbEmbedsOneParent, :after_create],
+            [InterceptableSpec::CbEmbedsOneParent, :around_save_close],
+            [InterceptableSpec::CbEmbedsOneParent, :after_save]
+          ]
+        end
+
+        it 'calls callbacks in the right order' do
+          parent.save!
+          expect(registry.calls).to eq expected
+        end
+      end
+
+      context "update" do
+        let(:expected) do
+          [
+            [InterceptableSpec::CbEmbedsOneChild, :before_validation],
+            [InterceptableSpec::CbEmbedsOneChild, :after_validation],
+            [InterceptableSpec::CbEmbedsOneParent, :before_validation],
+            [InterceptableSpec::CbEmbedsOneChild, :before_validation],
+            [InterceptableSpec::CbEmbedsOneChild, :after_validation],
+            [InterceptableSpec::CbEmbedsOneParent, :after_validation],
+
+            [InterceptableSpec::CbEmbedsOneParent, :before_save],
+            [InterceptableSpec::CbEmbedsOneParent, :around_save_open],
+            [InterceptableSpec::CbEmbedsOneParent, :before_update],
+            [InterceptableSpec::CbEmbedsOneParent, :around_update_open],
+
+            [InterceptableSpec::CbEmbedsOneChild, :before_save],
+            [InterceptableSpec::CbEmbedsOneChild, :around_save_open],
+            [InterceptableSpec::CbEmbedsOneChild, :before_update],
+            [InterceptableSpec::CbEmbedsOneChild, :around_update_open],
+
+            [InterceptableSpec::CbEmbedsOneChild, :around_update_close],
+            [InterceptableSpec::CbEmbedsOneChild, :after_update],
+            [InterceptableSpec::CbEmbedsOneChild, :around_save_close],
+            [InterceptableSpec::CbEmbedsOneChild, :after_save],
+
+            [InterceptableSpec::CbEmbedsOneParent, :around_update_close],
+            [InterceptableSpec::CbEmbedsOneParent, :after_update],
+            [InterceptableSpec::CbEmbedsOneParent, :around_save_close],
+            [InterceptableSpec::CbEmbedsOneParent, :after_save]
+          ]
+        end
+
+        it 'calls callbacks in the right order' do
+          parent.callback_registry = nil
+          parent.child.callback_registry = nil
+          parent.save!
+
+          parent.callback_registry = registry
+          parent.child.callback_registry = registry
+          parent.name = "name"
+          parent.child.age = 10
+
+          parent.save!
+          expect(registry.calls).to eq expected
+        end
+      end
+    end
+
+    context "has_many" do
+      let(:registry) { InterceptableSpec::CallbackRegistry.new }
+
+      let(:parent) do
+        InterceptableSpec::CbHasManyParent.new(registry).tap do |parent|
+          parent.children = [
+            InterceptableSpec::CbHasManyChild.new(registry),
+            InterceptableSpec::CbHasManyChild.new(registry)
+          ]
+        end
+      end
+
+      let(:expected) do
+        [
+          [InterceptableSpec::CbHasManyParent, :before_validation],
+          [InterceptableSpec::CbHasManyChild, :before_validation],
+          [InterceptableSpec::CbHasManyChild, :after_validation],
+          [InterceptableSpec::CbHasManyChild, :before_validation],
+          [InterceptableSpec::CbHasManyChild, :after_validation],
+          [InterceptableSpec::CbHasManyParent, :after_validation],
+
+          [InterceptableSpec::CbHasManyParent, :before_save],
+          [InterceptableSpec::CbHasManyParent, :around_save_open],
+          [InterceptableSpec::CbHasManyParent, :before_create],
+          [InterceptableSpec::CbHasManyParent, :around_create_open],
+
+          [InterceptableSpec::CbHasManyParent, :insert_into_database],
+
+          [InterceptableSpec::CbHasManyChild, :before_validation],
+          [InterceptableSpec::CbHasManyChild, :after_validation],
+          [InterceptableSpec::CbHasManyChild, :before_save],
+          [InterceptableSpec::CbHasManyChild, :around_save_open],
+          [InterceptableSpec::CbHasManyChild, :before_create],
+          [InterceptableSpec::CbHasManyChild, :around_create_open],
+          [InterceptableSpec::CbHasManyChild, :around_create_close],
+          [InterceptableSpec::CbHasManyChild, :after_create],
+          [InterceptableSpec::CbHasManyChild, :around_save_close],
+          [InterceptableSpec::CbHasManyChild, :after_save],
+
+          [InterceptableSpec::CbHasManyChild, :before_validation],
+          [InterceptableSpec::CbHasManyChild, :after_validation],
+          [InterceptableSpec::CbHasManyChild, :before_save],
+          [InterceptableSpec::CbHasManyChild, :around_save_open],
+          [InterceptableSpec::CbHasManyChild, :before_create],
+          [InterceptableSpec::CbHasManyChild, :around_create_open],
+          [InterceptableSpec::CbHasManyChild, :around_create_close],
+          [InterceptableSpec::CbHasManyChild, :after_create],
+          [InterceptableSpec::CbHasManyChild, :around_save_close],
+          [InterceptableSpec::CbHasManyChild, :after_save],
+
+          [InterceptableSpec::CbHasManyParent, :around_create_close],
+          [InterceptableSpec::CbHasManyParent, :after_create],
+          [InterceptableSpec::CbHasManyParent, :around_save_close],
+          [InterceptableSpec::CbHasManyParent, :after_save]
+        ]
+      end
+
+      it 'calls callbacks in the right order' do
+        parent.save!
+        expect(registry.calls).to eq expected
+      end
+    end
+
+    context "embeds_many" do
+      let(:registry) { InterceptableSpec::CallbackRegistry.new }
+
+      let(:parent) do
+        InterceptableSpec::CbEmbedsManyParent.new(registry).tap do |parent|
+          parent.children = [
+            InterceptableSpec::CbEmbedsManyChild.new(registry),
+            InterceptableSpec::CbEmbedsManyChild.new(registry),
+          ]
+        end
+      end
+
+      let(:expected) do
+        [
+          [InterceptableSpec::CbEmbedsManyChild, :before_validation],
+          [InterceptableSpec::CbEmbedsManyChild, :after_validation],
+          [InterceptableSpec::CbEmbedsManyChild, :before_validation],
+          [InterceptableSpec::CbEmbedsManyChild, :after_validation],
+          [InterceptableSpec::CbEmbedsManyParent, :before_validation],
+          [InterceptableSpec::CbEmbedsManyChild, :before_validation],
+          [InterceptableSpec::CbEmbedsManyChild, :after_validation],
+          [InterceptableSpec::CbEmbedsManyChild, :before_validation],
+          [InterceptableSpec::CbEmbedsManyChild, :after_validation],
+          [InterceptableSpec::CbEmbedsManyParent, :after_validation],
+
+          [InterceptableSpec::CbEmbedsManyParent, :before_save],
+          [InterceptableSpec::CbEmbedsManyParent, :around_save_open],
+          [InterceptableSpec::CbEmbedsManyParent, :before_create],
+          [InterceptableSpec::CbEmbedsManyParent, :around_create_open],
+
+          [InterceptableSpec::CbEmbedsManyChild, :before_save],
+          [InterceptableSpec::CbEmbedsManyChild, :around_save_open],
+          [InterceptableSpec::CbEmbedsManyChild, :before_save],
+
+          [InterceptableSpec::CbEmbedsManyChild, :around_save_open],
+          [InterceptableSpec::CbEmbedsManyChild, :before_create],
+          [InterceptableSpec::CbEmbedsManyChild, :around_create_open],
+
+          [InterceptableSpec::CbEmbedsManyChild, :before_create],
+          [InterceptableSpec::CbEmbedsManyChild, :around_create_open],
+
+          [InterceptableSpec::CbEmbedsManyParent, :insert_into_database],
+
+          [InterceptableSpec::CbEmbedsManyChild, :around_create_close],
+          [InterceptableSpec::CbEmbedsManyChild, :after_create],
+
+          [InterceptableSpec::CbEmbedsManyChild, :around_create_close],
+          [InterceptableSpec::CbEmbedsManyChild, :after_create],
+
+          [InterceptableSpec::CbEmbedsManyChild, :around_save_close],
+          [InterceptableSpec::CbEmbedsManyChild, :after_save],
+
+          [InterceptableSpec::CbEmbedsManyChild, :around_save_close],
+          [InterceptableSpec::CbEmbedsManyChild, :after_save],
+
+          [InterceptableSpec::CbEmbedsManyParent, :around_create_close],
+          [InterceptableSpec::CbEmbedsManyParent, :after_create],
+          [InterceptableSpec::CbEmbedsManyParent, :around_save_close],
+          [InterceptableSpec::CbEmbedsManyParent, :after_save]
+        ]
+      end
+
+      it 'calls callbacks in the right order' do
+        parent.save!
+        expect(registry.calls).to eq expected
+      end
+    end
+  end
+
+  context "when accessing parent document from callbacks" do
+    shared_examples 'accesses the correct parent' do
+      it "accesses the correct parent in after_find" do
+        expect(from_db.after_find_player).to eq(player._id)
+      end
+
+      it "accesses the correct parent in after_initialize" do
+        expect(from_db.after_initialize_player).to eq(player._id)
+      end
+
+      it "accesses the correct parent in default" do
+        expect(from_db.after_default_player).to eq(player._id)
+      end
+
+      it "accesses the correct parent in unpersisted after_initialize" do
+        expect(unpersisted.after_initialize_player).to eq(player._id)
+      end
+    end
+
+    context "when using create methods" do
+
+      context "when the child is an embeds_many association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.implants.create!
+          end
+        end
+
+        let(:unpersisted) { player.implants.first }
+
+        before do
+          # The default is originally set when creating this document, and it is
+          # subsequently persisted to the database. Therefore when we retrieve
+          # this document from the database, this field is already set, and
+          # the default Proc is not called. This unset is needed to allow the
+          # default Proc to be called when the document is retrieved from the
+          # database.
+          Player.find(player.id).implants.first.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).implants.first
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+
+      context "when the child is an embeds_one association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.create_augmentation
+          end
+        end
+
+        let(:unpersisted) { player.augmentation }
+
+        before do
+          Player.find(player.id).augmentation.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).augmentation
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+
+      context "when the child is a has_many association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.weapons.create!
+          end
+        end
+
+        let(:unpersisted) { player.weapons.first }
+
+        before do
+          Player.find(player.id).weapons.first.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).weapons.first
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+
+      context "when the child is a has_one association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.create_powerup
+            player.save!
+          end
+        end
+
+        let(:unpersisted) { player.powerup }
+
+        before do
+          Player.find(player.id).powerup.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).powerup
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+
+      context "when the child is a has_and_belongs_to_many association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.shields.create!
+          end
+        end
+
+        let(:unpersisted) { player.shields.first }
+
+        before do
+          Player.find(player.id).shields.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).shields.first
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+    end
+
+    context "when using build methods" do
+
+      context "when the child is an embeds_many association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.implants.build
+            player.implants.first.save!
+          end
+        end
+
+        let(:unpersisted) { player.implants.first }
+
+        before do
+          Player.find(player.id).implants.first.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).implants.first
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+
+      context "when the child is an embeds_one association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.build_augmentation
+            player.save!
+          end
+        end
+
+        let(:unpersisted) { player.augmentation }
+
+        before do
+          Player.find(player.id).augmentation.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).augmentation
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+
+      context "when the child is a has_many association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.weapons.build
+            player.weapons.first.save!
+          end
+        end
+
+        let(:unpersisted) { player.weapons.first }
+
+        before do
+          Player.find(player.id).weapons.first.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).weapons.first
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+
+      context "when the child is a has_one association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.build_powerup
+            player.powerup.save!
+          end
+        end
+
+        let(:unpersisted) { player.powerup }
+
+        before do
+          Player.find(player.id).powerup.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).powerup
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+
+      context "when the child is a has_and_belongs_to_many association" do
+        let!(:player) do
+          Player.create!.tap do |player|
+            player.shields.build
+            player.shields.first.save!
+          end
+        end
+
+        let(:unpersisted) { player.shields.first }
+
+        before do
+          Player.find(player.id).shields.unset(:after_default_player)
+        end
+
+        let(:from_db) do
+          Player.find(player.id).shields.first
+        end
+
+        include_examples 'accesses the correct parent'
+      end
+    end
+  end
+
+  context "when accessing associations in defaults" do
+    context "when not using autobuilding" do
+      let(:band) { InterceptableBand.create(name: "Molejo") }
+      let(:song) { band.songs.create(name: "Cilada") }
+
+      it "assigns the default correctly" do
+        expect(song.band_name).to eq("Molejo")
+      end
+    end
+
+    context "when using autobuilding" do
+      before do
+        InterceptablePlane.create!.tap do |plane|
+          plane.wings.create!
+        end
+      end
+
+      let(:plane) { InterceptablePlane.first }
+      let(:wing) { InterceptableWing.first }
+      let(:engine) { wing.engine }
+
+      it "sets the defaults correctly" do
+        expect(wing._id).to eq("hello-wing")
+        expect(wing.p_id).to eq(plane._id.to_s)
+        expect(wing.e_id).to eq(engine._id.to_s)
+        expect(engine._id).to eq("hello-engine-#{wing.id}")
+      end
+    end
+  end
+
+  # This case is rather niche. The _ids method used to use the `.only` method
+  # to get only the _ids for an association, which was causing a
+  # MissingAttributeError to be raised when accessing another association. This
+  # 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
+      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
+  end
 end