mongoid 7.5.1 → 8.1.2

data/spec/mongoid/association/referenced/has_and_belongs_to_many/proxy_spec.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require_relative "../has_and_belongs_to_many_models"
 
 describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
+  config_override :raise_not_found_error, true
 
   around(:each) do |example|
-    original_raise_not_found_error = Mongoid.raise_not_found_error
     original_preferences_association = Person.relations["preferences"]
-    Mongoid.raise_not_found_error = true
     Person.has_and_belongs_to_many :preferences, autosave: true
     example.run
-    Mongoid.raise_not_found_error = original_raise_not_found_error
     Person.relations["preferences"] = original_preferences_association
   end
 
@@ -2086,283 +2085,229 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
     end
   end
 
-  describe "#delete" do
+  %i[ delete delete_one ].each do |method|
+    describe "\##{method}" do
+      let(:person) { Person.create! }
+      let(:preference_one) { Preference.create!(name: "Testing") }
+      let(:preference_two) { Preference.create!(name: "Test") }
 
-    let(:person) do
-      Person.create!
-    end
-
-    let(:preference_one) do
-      Preference.create!(name: "Testing")
-    end
-
-    let(:preference_two) do
-      Preference.create!(name: "Test")
-    end
-
-    before do
-      person.preferences << [ preference_one, preference_two ]
-    end
-
-    context "when the document exists" do
-
-      let!(:deleted) do
-        person.preferences.delete(preference_one)
-      end
-
-      it "removes the document from the relation" do
-        expect(person.preferences).to eq([ preference_two ])
-      end
-
-      it "returns the document" do
-        expect(deleted).to eq(preference_one)
-      end
-
-      it "removes the document key from the foreign key" do
-        expect(person.preference_ids).to eq([ preference_two.id ])
-      end
-
-      it "removes the inverse reference" do
-        expect(deleted.reload.people).to be_empty
-      end
-
-      it "removes the base id from the inverse keys" do
-        expect(deleted.reload.person_ids).to be_empty
+      before do
+        person.preferences << [ preference_one, preference_two ]
       end
 
-      context "and person and preferences are reloaded" do
-
-        before do
-          person.reload
-          preference_one.reload
-          preference_two.reload
+      context 'when the document exists' do
+        let!(:deleted) do
+          person.preferences.send(method, preference_one)
         end
 
-        it "nullifies the deleted preference" do
+        it 'removes the document from the relation' do
           expect(person.preferences).to eq([ preference_two ])
         end
 
-        it "retains the ids for one preference" do
-          expect(person.preference_ids).to eq([ preference_two.id ])
+        it 'returns the document' do
+          expect(deleted).to eq(preference_one)
         end
-      end
-    end
-
-    context "when the document does not exist" do
-
-      let!(:deleted) do
-        person.preferences.delete(Preference.new)
-      end
-
-      it "returns nil" do
-        expect(deleted).to be_nil
-      end
-
-      it "does not modify the relation" do
-        expect(person.preferences).to eq([ preference_one, preference_two ])
-      end
-
-      it "does not modify the keys" do
-        expect(person.preference_ids).to eq([ preference_one.id, preference_two.id ])
-      end
-    end
-
-    context "when :dependent => :nullify is set" do
-
-      context "when :inverse_of is set" do
 
-        let(:event) do
-          Event.create!
+        it 'removes the document key from the foreign key' do
+          expect(person.preference_ids).to eq([ preference_two.id ])
         end
 
-        before do
-          person.administrated_events << [ event ]
+        it 'removes the inverse reference' do
+          expect(deleted.reload.people).to be_empty
         end
 
-        it "deletes the document" do
-          expect(event.delete).to be true
+        it 'removes the base id from the inverse keys' do
+          expect(deleted.reload.person_ids).to be_empty
         end
-      end
-    end
 
-    context "when the relationships are self referencing" do
-
-      let(:tag_one) do
-        Tag.create!(text: "one")
-      end
+        context 'and person and preferences are reloaded' do
+          before do
+            person.reload
+            preference_one.reload
+            preference_two.reload
+          end
 
-      let(:tag_two) do
-        Tag.create!(text: "two")
-      end
+          it 'nullifies the deleted preference' do
+            expect(person.preferences).to eq([ preference_two ])
+          end
 
-      before do
-        tag_one.related << tag_two
+          it 'retains the ids for one preference' do
+            expect(person.preference_ids).to eq([ preference_two.id ])
+          end
+        end
       end
 
-      context "when deleting without reloading" do
-
+      context 'when the document does not exist' do
         let!(:deleted) do
-          tag_one.related.delete(tag_two)
-        end
-
-        it "deletes the document from the relation" do
-          expect(tag_one.related).to be_empty
+          person.preferences.send(method, Preference.new)
         end
 
-        it "deletes the foreign key from the relation" do
-          expect(tag_one.related_ids).to be_empty
+        it 'returns nil' do
+          expect(deleted).to be_nil
         end
 
-        it "removes the reference from the inverse" do
-          expect(deleted.related).to be_empty
+        it 'does not modify the relation' do
+          expect(person.preferences).to eq([ preference_one, preference_two ])
         end
 
-        it "removes the foreign keys from the inverse" do
-          expect(deleted.related_ids).to be_empty
+        it 'does not modify the keys' do
+          expect(person.preference_ids).to eq([ preference_one.id, preference_two.id ])
         end
       end
 
-      context "when deleting with reloading" do
-
-        context "when deleting from the front side" do
-
-          let(:reloaded) do
-            tag_one.reload
-          end
-
-          let!(:deleted) do
-            reloaded.related.delete(tag_two)
-          end
+      context 'when :dependent => :nullify is set' do
+        context 'when :inverse_of is set' do
+          let(:event) { Event.create! }
 
-          it "deletes the document from the relation" do
-            expect(reloaded.related).to be_empty
+          before do
+            person.administrated_events << [ event ]
           end
 
-          it "deletes the foreign key from the relation" do
-            expect(reloaded.related_ids).to be_empty
+          it 'deletes the document' do
+            expect(event.delete).to be true
           end
+        end
+      end
 
-          it "removes the reference from the inverse" do
-            expect(deleted.related).to be_empty
-          end
+      context 'when the relationships are self referencing' do
+        let(:tag_one) { Tag.create!(text: "one") }
+        let(:tag_two) { Tag.create!(text: "two") }
 
-          it "removes the foreign keys from the inverse" do
-            expect(deleted.related_ids).to be_empty
-          end
+        before do
+          tag_one.related << tag_two
         end
 
-        context "when deleting from the inverse side" do
+        context 'when deleting without reloading' do
+          let!(:deleted) { tag_one.related.send(method, tag_two) }
 
-          let(:reloaded) do
-            tag_two.reload
+          it 'deletes the document from the relation' do
+            expect(tag_one.related).to be_empty
           end
 
-          let!(:deleted) do
-            reloaded.related.delete(tag_one)
+          it 'deletes the foreign key from the relation' do
+            expect(tag_one.related_ids).to be_empty
           end
 
-          it "deletes the document from the relation" do
-            expect(reloaded.related).to be_empty
-          end
-
-          it "deletes the foreign key from the relation" do
-            expect(reloaded.related_ids).to be_empty
+          it 'removes the reference from the inverse' do
+            expect(deleted.related).to be_empty
           end
 
-          it "removes the foreign keys from the inverse" do
+          it 'removes the foreign keys from the inverse' do
             expect(deleted.related_ids).to be_empty
           end
         end
-      end
-    end
 
-    context "when the association has callbacks" do
+        context 'when deleting with reloading' do
+          context "when deleting from the front side" do
+            let(:reloaded) { tag_one.reload }
+            let!(:deleted) { reloaded.related.send(method, tag_two) }
 
-      let(:post) do
-        Post.new
-      end
+            it 'deletes the document from the relation' do
+              expect(reloaded.related).to be_empty
+            end
 
-      let(:tag) do
-        Tag.new
-      end
+            it 'deletes the foreign key from the relation' do
+              expect(reloaded.related_ids).to be_empty
+            end
 
-      before do
-        post.tags << tag
-      end
+            it 'removes the reference from the inverse' do
+              expect(deleted.related).to be_empty
+            end
 
-      context "when the callback is a before_remove" do
+            it 'removes the foreign keys from the inverse' do
+              expect(deleted.related_ids).to be_empty
+            end
+          end
 
-        context "when there are no errors" do
+          context 'when deleting from the inverse side' do
+            let(:reloaded) { tag_two.reload }
+            let!(:deleted) { reloaded.related.send(method, tag_one) }
 
-          before do
-            post.tags.delete tag
-          end
+            it 'deletes the document from the relation' do
+              expect(reloaded.related).to be_empty
+            end
 
-          it "executes the callback" do
-            expect(post.before_remove_called).to be true
-          end
+            it 'deletes the foreign key from the relation' do
+              expect(reloaded.related_ids).to be_empty
+            end
 
-          it "removes the document from the relation" do
-            expect(post.tags).to be_empty
+            it 'removes the foreign keys from the inverse' do
+              expect(deleted.related_ids).to be_empty
+            end
           end
         end
+      end
 
-        context "when errors are raised" do
-
-          before do
-            expect(post).to receive(:before_remove_tag).and_raise
-            begin; post.tags.delete(tag); rescue; end
-          end
+      context 'when the association has callbacks' do
+        let(:post) { Post.new }
+        let(:tag) { Tag.new }
 
-          it "does not remove the document from the relation" do
-            expect(post.tags).to eq([ tag ])
-          end
+        before do
+          post.tags << tag
         end
-      end
 
-      context "when the callback is an after_remove" do
+        context 'when the callback is a before_remove' do
+          context 'when there are no errors' do
+            before do
+              post.tags.send(method, tag)
+            end
 
-        context "when no errors are raised" do
+            it 'executes the callback' do
+              expect(post.before_remove_called).to be true
+            end
 
-          before do
-            post.tags.delete(tag)
+            it 'removes the document from the relation' do
+              expect(post.tags).to be_empty
+            end
           end
 
-          it "executes the callback" do
-            expect(post.after_remove_called).to be true
-          end
+          context "when errors are raised" do
+            before do
+              expect(post).to receive(:before_remove_tag).and_raise
+              begin; post.tags.send(method, tag); rescue; end
+            end
 
-          it "removes the document from the relation" do
-            expect(post.tags).to be_empty
+            it 'does not remove the document from the relation' do
+              expect(post.tags).to eq([ tag ])
+            end
           end
         end
 
-        context "when errors are raised" do
+        context 'when the callback is an after_remove' do
+          context 'when no errors are raised' do
+            before do
+              post.tags.send(method, tag)
+            end
 
-          before do
-            expect(post).to receive(:after_remove_tag).and_raise
-            begin; post.tags.delete(tag); rescue; end
+            it 'executes the callback' do
+              expect(post.after_remove_called).to be true
+            end
+
+            it 'removes the document from the relation' do
+              expect(post.tags).to be_empty
+            end
           end
 
-          it "removes the document from the relation" do
-            expect(post.tags).to be_empty
+          context 'when errors are raised' do
+            before do
+              expect(post).to receive(:after_remove_tag).and_raise
+              begin; post.tags.send(method, tag); rescue; end
+            end
+
+            it 'removes the document from the relation' do
+              expect(post.tags).to be_empty
+            end
           end
         end
       end
     end
   end
 
-  [ :delete_all, :destroy_all ].each do |method|
-
-    describe "##{method}" do
-
-      context "when the relation is not polymorphic" do
-
-        context "when conditions are provided" do
-
-          let(:person) do
-            Person.create!
-          end
+  %i[ delete_all destroy_all ].each do |method|
+    describe "\##{method}" do
+      context 'when the relation is not polymorphic' do
+        context 'when conditions are provided' do
+          let(:person) { Person.create! }
 
           let!(:preference_one) do
             person.preferences.create!(name: "Testing")
@@ -2394,6 +2339,10 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
           it "removes the ids from the foreign key" do
             expect(person.preference_ids).to eq([ preference_two.id ])
           end
+
+          it "sets the association locally" do
+            expect(person.preferences).to eq([preference_two])
+          end
         end
 
         context "when conditions are not provided" do
@@ -2420,6 +2369,10 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
           it "returns the number of documents deleted" do
             expect(deleted).to eq(2)
           end
+
+          it "sets the association locally" do
+            expect(person.preferences).to eq([])
+          end
         end
       end
     end
@@ -2507,39 +2460,29 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
           it "raises an error" do
             expect {
               preference
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Preference with id\(s\)/)
           end
         end
 
         context "when the id does not match" do
 
           context "when config set to raise error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
+            config_override :raise_not_found_error, true
 
             it "raises an error" do
               expect {
                 person.preferences.find(BSON::ObjectId.new)
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Preference with id\(s\)/)
             end
           end
 
           context "when config set not to raise error" do
+            config_override :raise_not_found_error, false
 
             let(:preference) do
               person.preferences.find(BSON::ObjectId.new)
             end
 
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
             it "returns nil" do
               expect(preference).to be_nil
             end
@@ -2571,39 +2514,29 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
           it "raises an error" do
             expect {
               preferences
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Preference with id\(s\)/)
           end
         end
 
         context "when the ids do not match" do
 
           context "when config set to raise error" do
-
-            before do
-              Mongoid.raise_not_found_error = true
-            end
+            config_override :raise_not_found_error, true
 
             it "raises an error" do
               expect {
                 person.preferences.find([ BSON::ObjectId.new ])
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Preference with id\(s\)/)
             end
           end
 
           context "when config set not to raise error" do
+            config_override :raise_not_found_error, false
 
             let(:preferences) do
               person.preferences.find([ BSON::ObjectId.new ])
             end
 
-            before do
-              Mongoid.raise_not_found_error = false
-            end
-
-            after do
-              Mongoid.raise_not_found_error = true
-            end
-
             it "returns an empty array" do
               expect(preferences).to be_empty
             end
@@ -3770,4 +3703,58 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
       expect(p2.d_ids).to match_array([d2.id])
     end
   end
+
+  context "when accesing own _id from parent's foreign key in default" do
+    let!(:contract) { HabtmmContract.create! }
+    let!(:signature) { contract.signatures.create! }
+
+    it "is nil" do
+      expect(signature.favorite_signature).to be nil
+    end
+  end
+
+  context "when setting an association on a model that uses the class_name option" do
+    let!(:contract) { HabtmmContract.create! }
+    let!(:signature) { HabtmmSignature.create!(contracts: [contract]) }
+
+    it "populates the inverse foreign key" do
+      expect(signature.contracts.first.signature_ids).to eq([signature.id])
+    end
+  end
+
+  context "when there is a foreign key in the aliased associations" do
+    it "has the correct aliases" do
+      expect(Dog.aliased_associations["breed_ids"]).to eq("breeds")
+      expect(Breed.aliased_associations["dog_ids"]).to eq("dogs")
+    end
+  end
+
+  # This test is for MONGOID-5344 which tests that the initial call to
+  # signature_ids refers to the same array as subsequent calls to signature_ids.
+  # Prior to the change in that ticket, this test broke because the array
+  # returned from write_attribute (which is triggered the first time the
+  # foreign key array is referenced, to set the default), refers to a different
+  # array to the one stored in the attributes hash. This happened because,
+  # when retrieving a document from the database, the attributes hash is actually
+  # a BSON::Document, which applies a transformation to the array before
+  # storing it.
+  context "when executing concat on foreign key array from the db" do
+    config_override :legacy_attributes, false
+
+    before do
+      HabtmmContract.create!
+      HabtmmSignature.create!
+    end
+
+    let!(:contract) { HabtmmContract.first }
+    let!(:signature) { HabtmmSignature.first }
+
+    before do
+      contract.signature_ids.concat([signature.id])
+    end
+
+    it "works on the first attempt" do
+      expect(contract.signature_ids).to eq([signature.id])
+    end
+  end
 end

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

@@ -32,6 +32,8 @@ end
 class HabtmmSignature
   include Mongoid::Document
 
+  field :favorite_signature, default: ->{ contracts.first.signature_ids.first if contracts.first }
+
   has_and_belongs_to_many :contracts, class_name: 'HabtmmContract'
 
   field :name, type: String
@@ -65,3 +67,26 @@ class HabtmmAnimal
 
   has_and_belongs_to_many :trainers, inverse_of: :animals, class_name: 'HabtmmTrainer', scope: -> { where(name: 'Dave') }
 end
+
+class HabtmmSchool
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  has_and_belongs_to_many :students, class_name: 'HabtmmStudent'
+
+  field :after_destroy_triggered, default: false
+
+  accepts_nested_attributes_for :students, allow_destroy: true
+end
+
+class HabtmmStudent
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  has_and_belongs_to_many :schools, class_name: 'HabtmmSchool'
+
+  after_destroy do |doc|
+    schools.first.update_attributes!(after_destroy_triggered: true) unless schools.empty?
+  end
+end
+