mongoid 7.5.1 → 8.1.2

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

@@ -2,11 +2,30 @@
 
 require "spec_helper"
 
+module RefHasManySpec
+  module OverrideInitialize
+    class Parent
+      include Mongoid::Document
+      has_many :children, inverse_of: :parent
+    end
+
+    class Child
+      include Mongoid::Document
+      belongs_to :parent
+      field :name, type: String
+
+      def initialize(*args)
+        super
+        self.name ||= "default"
+      end
+    end
+  end
+end
+
 describe Mongoid::Association::Referenced::HasMany::Proxy do
+  config_override :raise_not_found_error, true
 
   before :all do
-    Mongoid.raise_not_found_error = true
-
     Drug.belongs_to :person, primary_key: :username
     Person.has_many :drugs, validate: false, primary_key: :username
   end
@@ -877,6 +896,14 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
   [ :build, :new ].each do |method|
 
     describe "##{method}" do
+      context 'when model has #initialize' do
+        let(:parent) { RefHasManySpec::OverrideInitialize::Parent.create }
+        let(:child)  { parent.children.send(method) }
+
+        it 'should call #initialize' do
+          expect(child.name).to be == "default"
+        end
+      end
 
       context "when the association is not polymorphic" do
 
@@ -2077,154 +2104,114 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  describe "#delete" do
-
-    let!(:person) do
-      Person.create!(username: 'arthurnn')
-    end
+  %i[ delete delete_one ].each do |method|
+    describe "##{method}" do
+      let!(:person) { Person.create!(username: 'arthurnn') }
 
-    context "when the document is found" do
+      context 'when the document is found' do
+        context 'when no dependent option is set' do
+          context 'when we are assigning attributes' do
+            let!(:drug) { person.drugs.create! }
+            let(:deleted) { person.drugs.send(method, drug) }
 
-      context "when no dependent option is set" do
+            before do
+              Mongoid::Threaded.begin_execution(:assign)
+            end
 
-        context "when we are assigning attributes" do
+            after do
+              Mongoid::Threaded.exit_execution(:assign)
+            end
 
-          let!(:drug) do
-            person.drugs.create!
+            it 'does not cascade' do
+              expect(deleted.changes.keys).to eq([ 'person_id' ])
+            end
           end
 
-          before do
-            Mongoid::Threaded.begin_execution(:assign)
-          end
+          context 'when the document is loaded' do
+            let!(:drug) { person.drugs.create! }
+            let!(:deleted) { person.drugs.send(method, drug) }
 
-          after do
-            Mongoid::Threaded.exit_execution(:assign)
-          end
+            it 'returns the document' do
+              expect(deleted).to eq(drug)
+            end
 
-          let(:deleted) do
-            person.drugs.delete(drug)
-          end
+            it 'deletes the foreign key' do
+              expect(drug.person_id).to be_nil
+            end
 
-          it "does not cascade" do
-            expect(deleted.changes.keys).to eq([ "person_id" ])
+            it 'removes the document from the association' do
+              expect(person.drugs).not_to include(drug)
+            end
           end
-        end
 
-        context "when the document is loaded" do
+          context 'when the document is not loaded' do
+            let!(:drug) { Drug.create!(person_id: person.username) }
+            let!(:deleted) { person.drugs.send(method, drug) }
 
-          let!(:drug) do
-            person.drugs.create!
-          end
+            it 'returns the document' do
+              expect(deleted).to eq(drug)
+            end
 
-          let!(:deleted) do
-            person.drugs.delete(drug)
-          end
+            it 'deletes the foreign key' do
+              expect(drug.person_id).to be_nil
+            end
 
-          it "returns the document" do
-            expect(deleted).to eq(drug)
+            it 'removes the document from the association' do
+              expect(person.drugs).not_to include(drug)
+            end
           end
+        end
 
-          it "deletes the foreign key" do
-            expect(drug.person_id).to be_nil
-          end
+        context 'when dependent is delete' do
+          context 'when the document is loaded' do
+            let!(:post) { person.posts.create!(title: 'test') }
+            let!(:deleted) { person.posts.send(method, post) }
 
-          it "removes the document from the association" do
-            expect(person.drugs).to_not include(drug)
-          end
-        end
+            it 'returns the document' do
+              expect(deleted).to eq(post)
+            end
 
-        context "when the document is not loaded" do
+            it 'deletes the document' do
+              expect(post).to be_destroyed
+            end
 
-          let!(:drug) do
-            Drug.create!(person_id: person.username)
+            it 'removes the document from the association' do
+              expect(person.posts).not_to include(post)
+            end
           end
 
-          let!(:deleted) do
-            person.drugs.delete(drug)
-          end
+          context 'when the document is not loaded' do
+            let!(:post) { Post.create!(title: 'foo', person_id: person.id) }
+            let!(:deleted) { person.posts.send(method, post) }
 
-          it "returns the document" do
-            expect(deleted).to eq(drug)
-          end
+            it 'returns the document' do
+              expect(deleted).to eq(post)
+            end
 
-          it "deletes the foreign key" do
-            expect(drug.person_id).to be_nil
-          end
+            it 'deletes the document' do
+              expect(post).to be_destroyed
+            end
 
-          it "removes the document from the association" do
-            expect(person.drugs).to_not include(drug)
+            it 'removes the document from the association' do
+              expect(person.posts).not_to include(post)
+            end
           end
         end
       end
 
-      context "when dependent is delete" do
-
-        context "when the document is loaded" do
+      context 'when the document is not found' do
+        let!(:post) { Post.create!(title: 'foo') }
+        let!(:deleted) { person.posts.send(method, post) }
 
-          let!(:post) do
-            person.posts.create!(title: "test")
-          end
-
-          let!(:deleted) do
-            person.posts.delete(post)
-          end
-
-          it "returns the document" do
-            expect(deleted).to eq(post)
-          end
-
-          it "deletes the document" do
-            expect(post).to be_destroyed
-          end
-
-          it "removes the document from the association" do
-            expect(person.posts).to_not include(post)
-          end
+        it 'returns nil' do
+          expect(deleted).to be_nil
         end
 
-        context "when the document is not loaded" do
-
-          let!(:post) do
-            Post.create!(title: "foo", person_id: person.id)
-          end
-
-          let!(:deleted) do
-            person.posts.delete(post)
-          end
-
-          it "returns the document" do
-            expect(deleted).to eq(post)
-          end
-
-          it "deletes the document" do
-            expect(post).to be_destroyed
-          end
-
-          it "removes the document from the association" do
-            expect(person.posts).to_not include(post)
-          end
+        it 'does not delete the document' do
+          expect(post).to be_persisted
         end
       end
     end
-
-    context "when the document is not found" do
-
-      let!(:post) do
-        Post.create!(title: "foo")
-      end
-
-      let!(:deleted) do
-        person.posts.delete(post)
-      end
-
-      it "returns nil" do
-        expect(deleted).to be_nil
-      end
-
-      it "does not delete the document" do
-        expect(post).to be_persisted
-      end
-    end
   end
 
   [ :delete_all, :destroy_all ].each do |method|
@@ -2239,10 +2226,8 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
             Person.create!(username: 'durran')
           end
 
-          before do
-            person.posts.create!(title: "Testing")
-            person.posts.create!(title: "Test")
-          end
+          let!(:post1) { person.posts.create!(title: "Testing") }
+          let!(:post2) { person.posts.create!(title: "Test") }
 
           it "removes the correct posts" do
             person.posts.send(method, { title: "Testing" })
@@ -2258,6 +2243,11 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           it "returns the number of documents deleted" do
             expect(person.posts.send(method, { title: "Testing" })).to eq(1)
           end
+
+          it "sets the association locally" do
+            person.posts.send(method, { title: "Testing" })
+            expect(person.posts).to eq([post2])
+          end
         end
 
         context "when conditions are not provided" do
@@ -2284,6 +2274,11 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           it "returns the number of documents deleted" do
             expect(person.posts.send(method)).to eq(2)
           end
+
+          it "sets the association locally" do
+            person.posts.send(method)
+            expect(person.posts).to eq([])
+          end
         end
       end
 
@@ -2295,10 +2290,8 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
             Movie.create!(title: "Bladerunner")
           end
 
-          before do
-            movie.ratings.create!(value: 1)
-            movie.ratings.create!(value: 2)
-          end
+          let!(:rating1) { movie.ratings.create!(value: 1) }
+          let!(:rating2) { movie.ratings.create!(value: 2) }
 
           it "removes the correct ratings" do
             movie.ratings.send(method, { value: 1 })
@@ -2313,6 +2306,11 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           it "returns the number of documents deleted" do
             expect(movie.ratings.send(method, { value: 1 })).to eq(1)
           end
+
+          it "sets the association locally" do
+            movie.ratings.send(method, { value: 1 })
+            expect(movie.ratings).to eq([rating2])
+          end
         end
 
         context "when conditions are not provided" do
@@ -2339,6 +2337,11 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           it "returns the number of documents deleted" do
             expect(movie.ratings.send(method)).to eq(2)
           end
+
+          it "sets the association locally" do
+            movie.ratings.send(method)
+            expect(movie.ratings).to eq([])
+          end
         end
       end
     end
@@ -2524,39 +2527,29 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           it "raises an error" do
             expect {
               person.posts.find(post.id)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound)
+            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post 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.posts.find(BSON::ObjectId.new)
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
             end
           end
 
           context "when config set not to raise error" do
+            config_override :raise_not_found_error, false
 
             let(:post) do
               person.posts.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(post).to be_nil
             end
@@ -2580,32 +2573,22 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
         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.posts.find([ BSON::ObjectId.new ])
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
             end
           end
 
           context "when config set not to raise error" do
+            config_override :raise_not_found_error, false
 
             let(:posts) do
               person.posts.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(posts).to be_empty
             end
@@ -2644,32 +2627,22 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
         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 {
                 movie.ratings.find(BSON::ObjectId.new)
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Rating with id\(s\)/)
             end
           end
 
           context "when config set not to raise error" do
+            config_override :raise_not_found_error, false
 
             let(:rating) do
               movie.ratings.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(rating).to be_nil
             end
@@ -2701,32 +2674,22 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
         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 {
                 movie.ratings.find([ BSON::ObjectId.new ])
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Rating with id\(s\)/)
             end
           end
 
           context "when config set not to raise error" do
+            config_override :raise_not_found_error, false
 
             let(:ratings) do
               movie.ratings.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(ratings).to be_empty
             end
@@ -4089,4 +4052,57 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
       expect(band.same_name).to eq([agent])
     end
   end
+
+  context "when removing a document with counter_cache on" do
+    let(:post) { Post.create! }
+    let(:person1) { Person.create! }
+    let(:person2) { Person.create! }
+
+    before do
+      post.update_attribute(:person, person1)
+      expect(person1.posts_count).to eq 1
+
+      person2
+      post.update_attribute(:person, person2)
+      person1.reload
+      expect(person1.posts_count).to eq 0
+      expect(person2.posts_count).to eq 1
+
+      post.update_attribute(:person, nil)
+      person1.reload
+      person2.reload
+    end
+
+    it "the count field is updated" do
+      expect(person2.posts_count).to eq 0
+    end
+  end
+
+  context "when there is a foreign key in the aliased associations" do
+    it "has the correct aliases" do
+      expect(Band.aliased_associations["artist_ids"]).to eq("artists")
+      expect(Artist.aliased_associations.key?("band_id")).to be false
+      expect(Artist.aliased_fields["band"]).to eq("band_id")
+    end
+  end
+
+  context "when executing concat on foreign key array from the db" do
+    config_override :legacy_attributes, false
+
+    before do
+      Agent.create!
+      Basic.create!
+    end
+
+    let!(:agent) { Agent.first }
+    let!(:basic) { Basic.first }
+
+    before do
+      agent.basic_ids.concat([basic.id])
+    end
+
+    it "works on the first attempt" do
+      expect(agent.basic_ids).to eq([basic.id])
+    end
+  end
 end

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

@@ -42,6 +42,7 @@ end
 
 class HmmSchool
   include Mongoid::Document
+  include Mongoid::Timestamps
 
   has_many :students, class_name: 'HmmStudent'
 
@@ -51,8 +52,9 @@ end
 
 class HmmStudent
   include Mongoid::Document
+  include Mongoid::Timestamps
 
-  belongs_to :school, class_name: 'HmmSchool'
+  belongs_to :school, class_name: 'HmmSchool', touch: true
 
   field :name, type: String
   field :grade, type: Integer, default: 3

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require_relative './has_many_models'
 
 describe Mongoid::Association::Referenced::HasMany do
 
@@ -1245,4 +1246,28 @@ describe Mongoid::Association::Referenced::HasMany do
       expect(association.create_relation(owner, target)).to be_a(Array)
     end
   end
+
+  context "when adding an object to the association" do
+    let!(:start_time) { Timecop.freeze(Time.at(Time.now.to_i)) }
+
+    let(:update_time) do
+      Timecop.freeze(Time.at(Time.now.to_i) + 2)
+    end
+
+    after do
+      Timecop.return
+    end
+
+    let!(:school) { HmmSchool.create! }
+    let!(:student) { HmmStudent.create! }
+
+    before do
+      update_time
+      student.update(school: school)
+    end
+
+    it "updates the updated_at" do
+      expect(student.updated_at).to eq(update_time)
+    end
+  end
 end

data/spec/mongoid/association/referenced/has_one/buildable_spec.rb

@@ -91,7 +91,7 @@ describe Mongoid::Association::Referenced::HasOne::Buildable do
         expect(document).to eq(object)
       end
 
-      context 'when the object is already related to another object' do
+      context 'when the object is already associated with another object' do
 
         let(:original_person) do
           Person.new
@@ -105,7 +105,7 @@ describe Mongoid::Association::Referenced::HasOne::Buildable do
           association.build(Person.new, object)
         end
 
-        it 'clears the object of its previous relation' do
+        it 'clears the object of its previous association' do
           expect(original_person.account).to be_nil
         end