mongoid 7.6.2 → 8.0.1

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

@@ -2239,10 +2239,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 +2256,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,150 +2287,10 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           it "returns the number of documents deleted" do
             expect(person.posts.send(method)).to eq(2)
           end
-        end
-
-        context 'when a document is appended with an id that is already loaded' do
-          # Iterating the association moves an appended document out of _added
-          # without adding it to _loaded, so the scan for matches and the
-          # removal that follows see different instances for the same id.
-          let(:person) { Person.create! }
-          let!(:post) { person.posts.create!(title: 'Testing') }
-          let(:reloaded) { Person.find(person._id) }
-
-          before do
-            reloaded.posts.to_a
-            reloaded.posts._target.push(
-              Post.new(_id: post._id, title: 'Testing', person_id: reloaded._id)
-            )
-          end
-
-          shared_examples 'removes the document once' do
-            it 'sets the association locally' do
-              reloaded.posts.send(method, conditions)
-              expect(reloaded.posts).to eq([])
-            end
-
-            it 'deletes the documents from the database' do
-              reloaded.posts.send(method, conditions)
-              expect(Post.count).to eq(0)
-            end
-          end
-
-          context 'when the conditions carry no regular expression' do
-            let(:conditions) { { title: 'Testing' } }
-
-            it_behaves_like 'removes the document once'
-          end
 
-          context 'when the conditions carry a regular expression' do
-            let(:conditions) { { title: /Testing/ } }
-
-            it_behaves_like 'removes the document once'
-          end
-        end
-
-        context 'when an appended document disagrees with the loaded one' do
-          # Only the appended instance matches, so the removal has to drop that
-          # id from both _loaded and _added. Removing by id and stopping at the
-          # first hash that has it would take the loaded instance instead and
-          # leave the unbound one behind.
-          let(:person) { Person.create! }
-          let!(:post) { person.posts.create!(title: 'Other') }
-          let(:reloaded) { Person.find(person._id) }
-
-          before do
-            reloaded.posts.to_a
-            reloaded.posts._target.push(
-              Post.new(_id: post._id, title: 'Testing', person_id: reloaded._id)
-            )
-          end
-
-          it 'deletes nothing from the database' do
-            expect(reloaded.posts.send(method, { title: /Testing/ })).to eq(0)
-            expect(Post.where(title: 'Other').count).to eq(1)
-          end
-
-          it 'leaves no unbound document in the association' do
-            reloaded.posts.send(method, { title: /Testing/ })
-            expect(reloaded.posts._target.in_memory.map(&:person_id)).not_to include(nil)
-          end
-        end
-
-        context 'when a nested selector is evaluated while the association loads' do
-          # Loading the association runs find callbacks, and application code in
-          # one of those can evaluate a selector of its own. A scope opened
-          # around the load would mark it as having nothing to bound, and that
-          # suppresses the decision for the nested selector too, leaving any
-          # pattern in it unguarded.
-          config_override :in_memory_regexp_time_limit, 5.0
-
-          let(:person) { Person.create! }
-          let(:reloaded) { Person.find(person._id) }
-
-          before do
-            person.posts.create!(title: 'Testing')
-            person.posts.create!(title: 'Keep')
-            reloaded
-          end
-
-          it 'leaves the nested scope free to establish its own budget' do
-            seen = []
-            allow(Mongoid::Factory).to receive(:from_db).and_wrap_original do |original, *args|
-              Mongoid::Matcher::RegexpBudget.open('title' => /Testing/) do
-                seen << Mongoid::Matcher::RegexpBudget.remaining
-              end
-              original.call(*args)
-            end
-
-            reloaded.posts.send(method, { title: 'Testing' })
-
-            expect(seen).not_to be_empty
-            expect(seen).not_to include(nil)
-          end
-        end
-
-        if method == :delete_all
-          context 'when the association has not been loaded' do
-            let(:person) { Person.create! }
-            let(:reloaded) { Person.find(person._id) }
-            let(:subscriber) { Mrss::EventSubscriber.new }
-
-            before do
-              person.posts.create!(title: 'Testing')
-              person.posts.create!(title: 'Test')
-              reloaded
-            end
-
-            def commands_for(conditions)
-              Person.collection.client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-              reloaded.posts.delete_all(conditions)
-              subscriber.started_events.map(&:command_name)
-            ensure
-              Person.collection.client.unsubscribe(Mongo::Monitoring::COMMAND, subscriber)
-            end
-
-            context 'when the conditions carry no regular expression' do
-              # Nothing to bound, so the scan for matches stays where it was,
-              # after the delete, where the association it loads comes back
-              # empty. Moving it ahead of the delete would transfer the whole
-              # association for an operation that need send nothing over the
-              # wire.
-              it 'deletes before loading the association' do
-                expect(commands_for(nil)).to eq(%w[ delete find ])
-              end
-            end
-
-            context 'when the conditions carry a regular expression' do
-              # The scan has to run under a budget, and before anything is
-              # deleted, so that a budget which runs out leaves the database
-              # untouched. What it scans is what is already in memory: loading
-              # would trade the matching cost the budget exists to bound for an
-              # unbounded amount of memory, since /.*/ is both cheap to supply
-              # and matches every document in the association.
-              it 'deletes without loading the association' do
-                expect(commands_for({ title: /Test/ })).to eq(%w[ delete ])
-              end
-            end
+          it "sets the association locally" do
+            person.posts.send(method)
+            expect(person.posts).to eq([])
           end
         end
       end
@@ -2440,10 +2303,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 })
@@ -2458,6 +2319,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
@@ -2484,6 +2350,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
@@ -2669,7 +2540,7 @@ 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
 
@@ -2684,7 +2555,7 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
             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
 
@@ -2733,7 +2604,7 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
             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
 
@@ -2797,7 +2668,7 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
             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
 
@@ -2854,7 +2725,7 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
             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
 
@@ -4235,6 +4106,39 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     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
 

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
 

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

@@ -133,7 +133,7 @@ describe Mongoid::Association::Referenced::HasOne::Proxy do
             it "detaches the previous relation" do
               expect {
                 game.reload
-              }.to raise_error(Mongoid::Errors::DocumentNotFound)
+              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Game with id\(s\)/)
             end
           end
         end
@@ -1139,4 +1139,110 @@ describe Mongoid::Association::Referenced::HasOne::Proxy do
       end
     end
   end
+
+  context "when there is a foreign key in the aliased associations" do
+    it "has the correct aliases" do
+      # Instances of Driver do not respond to vehicle_id.
+      expect(Driver.aliased_associations.key?("vehicle_id")).to be false
+      expect(Vehicle.aliased_associations.key?("driver_id")).to be false
+      expect(Vehicle.aliased_fields["driver"]).to eq("driver_id")
+    end
+  end
+
+  context "when the document is not persisted and the association is invalid" do
+
+    before do
+      class HomParent
+        include Mongoid::Document
+        has_one :child, class_name: "HomChild"
+        field :name
+        validates :name, presence: true
+      end
+
+      class HomChild; include Mongoid::Document; end
+
+      belongs_to
+      child.parent = parent
+      child.save
+    end
+
+    after do
+      Object.send(:remove_const, :HomParent)
+      Object.send(:remove_const, :HomChild)
+    end
+
+    let(:belongs_to) do
+      HomChild.belongs_to :parent, autosave: true, validate: false, optional: optional
+    end
+
+    let(:child) { HomChild.new }
+    let(:parent) { HomParent.new }
+
+
+    context "when belongs_to_required_by_default is true" do
+      config_override :belongs_to_required_by_default, true
+
+      context "when optional is true" do
+        let(:optional) { true }
+
+        it "persists the child with the parent_id" do
+          expect(HomChild.first.parent_id).to eq(parent._id)
+          expect(HomParent.count).to eq(0)
+        end
+      end
+
+      context "when optional is false" do
+        let(:optional) { false }
+
+        it "doesn't persist the parent or the child" do
+          expect(HomChild.count).to eq(0)
+          expect(HomParent.count).to eq(0)
+        end
+      end
+
+      context "when optional is not set" do
+        let(:belongs_to) do
+          HomChild.belongs_to :parent, autosave: true, validate: false
+        end
+
+        it "doesn't persist the parent or the child" do
+          expect(HomChild.count).to eq(0)
+          expect(HomParent.count).to eq(0)
+        end
+      end
+    end
+
+    context "when belongs_to_required_by_default is false" do
+      config_override :belongs_to_required_by_default, false
+
+      context "when optional is true" do
+        let(:optional) { true }
+
+        it "persists the child with the parent_id" do
+          expect(HomChild.first.parent_id).to eq(parent._id)
+          expect(HomParent.count).to eq(0)
+        end
+      end
+
+      context "when optional is false" do
+        let(:optional) { false }
+
+        it "doesn't persist the parent or the child" do
+          expect(HomChild.count).to eq(0)
+          expect(HomParent.count).to eq(0)
+        end
+      end
+
+      context "when optional is not set" do
+        let(:belongs_to) do
+          HomChild.belongs_to :parent, autosave: true, validate: false
+        end
+
+        it "persists the child with the parent_id" do
+          expect(HomChild.first.parent_id).to eq(parent._id)
+          expect(HomParent.count).to eq(0)
+        end
+      end
+    end
+  end
 end

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

@@ -95,3 +95,19 @@ class HomAnimal
 
   belongs_to :trainer, class_name: 'HomTrainer', scope: -> { where(name: 'Dave') }
 end
+
+class HomPost
+  include Mongoid::Document
+
+  field :title, type: String
+
+  has_one :comment, inverse_of: :post, class_name: 'HomComment'
+end
+
+class HomComment
+  include Mongoid::Document
+
+  field :content, type: String
+
+  belongs_to :post, inverse_of: :comment, optional: true, class_name: 'HomPost'
+end

data/spec/mongoid/association/syncable_spec.rb

@@ -496,4 +496,18 @@ describe "Syncable Association" do
       expect(dog.reload.breed_ids).to eq([ breed.id ])
     end
   end
+
+  context "when setting one document on unpersisted HABTM association" do
+    let!(:dog) { Dog.create! }
+    let!(:breed) { Breed.new }
+
+    before do
+      breed.dogs = Dog.all
+      breed.save!
+    end
+
+    it "sets the foreign key on the other side" do
+      expect(dog.reload.breed_ids).to eq([breed._id])
+    end
+  end
 end

data/spec/mongoid/atomic/paths_spec.rb

@@ -329,7 +329,6 @@ describe Mongoid::Atomic::Paths do
       context "assignment after saving" do
 
         it "correctly sets the association for the embedded class" do
-          pending 'MONGOID-5039'
 
           customer.home_address = CustomerAddress.new
           customer.work_address = CustomerAddress.new
@@ -346,19 +345,6 @@ describe Mongoid::Atomic::Paths do
           expect(customer.work_address.atomic_path).to eq("work_address")
         end
       end
-
-      context "inverse assignment" do
-
-        it "correctly returns the path for each embedded class" do
-          pending 'MONGOID-5039'
-
-          customer.work_address = CustomerAddress.new
-          customer.work_address.addressable = customer
-
-          expect(customer.home_address.atomic_path).to eq("home_address")
-          expect(customer.work_address.atomic_path).to eq("work_address")
-        end
-      end
     end
   end
 end