mongoid 9.0.11 → 9.1.1

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 require_relative '../has_many_models'
 
 describe Mongoid::Association::Referenced::HasMany::Proxy do

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

@@ -6,11 +6,13 @@ 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
 
@@ -735,7 +737,7 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
         let(:child)  { parent.children.send(method) }
 
         it 'calls #initialize' do
-          expect(child.name).to be == 'default'
+          expect(child.name).to eq 'default'
         end
       end
 
@@ -1322,6 +1324,22 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     context 'when appending to an association in a transaction' do
       require_transaction_support
 
+      # for some reason this test fails intermittently on any sharded
+      # topology (sharded or load-balanced). The error is:
+      #
+      #   [13388:StaleConfig]: Transaction <id>...eats is not currently
+      #   known and needs to be recovered
+      #
+      # It will fail on one run, succeed on the next, fail on the next,
+      # etc. Tested on both db versions 7 and 8, with both sharded and
+      # load-balanced topologies. For now, we'll just test this on a
+      # replica set.
+      require_topology :replica_set
+
+      # this also fails on server version 4.0, even with replica set,
+      # so we'll just skip it
+      min_server_version '5.0'
+
       let!(:movie) { Movie.create! }
 
       def with_transaction_via(model, &block)
@@ -1832,6 +1850,151 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
             expect(person.posts).to eq([])
           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
+          end
+        end
       end
 
       context 'when the association is polymorphic' do
@@ -2228,6 +2391,23 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           end
         ).to be_nil
       end
+
+      context 'when the parent is not persisted (MONGOID-5759)' do
+        let(:person) { Person.new }
+        let!(:post) { person.posts.build(title: 'unpersisted post') }
+
+        it 'yields unpersisted built documents' do
+          expect(
+            person.posts.find { |p| p.title == 'unpersisted post' }
+          ).to eq(post)
+        end
+
+        it 'returns nil when no match among unpersisted documents' do
+          expect(
+            person.posts.find { |p| p.title == 'other' }
+          ).to be_nil
+        end
+      end
     end
   end
 
@@ -2530,13 +2710,9 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     let(:post_one) { Post.create!(rating: 5) }
     let(:post_two) { Post.create!(rating: 10) }
 
-    # rubocop:disable Performance/CompareWithBlock
     let(:max) do
-      person.posts.max do |a, b|
-        a.rating <=> b.rating
-      end
+      person.posts.max_by(&:rating)
     end
-    # rubocop:enable Performance/CompareWithBlock
 
     before do
       person.posts.push(post_one, post_two)
@@ -2619,13 +2795,9 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     let(:post_one) { Post.create!(rating: 5) }
     let(:post_two) { Post.create!(rating: 10) }
 
-    # rubocop:disable Performance/CompareWithBlock
     let(:min) do
-      person.posts.min do |a, b|
-        a.rating <=> b.rating
-      end
+      person.posts.min_by(&:rating)
     end
-    # rubocop:enable Performance/CompareWithBlock
 
     before do
       person.posts.push(post_one, post_two)
@@ -3230,4 +3402,139 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
       expect(agent.basic_ids).to eq [ basic.id ]
     end
   end
+
+  describe '#cache_version' do
+    context 'when the model does not have an updated_at column' do
+      let(:root_model) { Person.create! }
+      let(:root) { Person.find(root_model.id) }
+
+      let(:prepopulated_root) do
+        root_model.posts << Post.new(title: 'Post #1')
+        root_model.posts << Post.new(title: 'Post #2')
+        Person.find(root_model.id)
+      end
+
+      shared_examples_for 'a cache_version generator' do
+        it 'produces a trivial cache_version' do
+          expect(posts.cache_version).to eq "#{posts.length}"
+        end
+      end
+
+      context 'when the relation is already loaded' do
+        let(:posts) { root.posts.tap { |r| r.to_a } }
+
+        context 'when the relation is empty' do
+          it_behaves_like 'a cache_version generator'
+        end
+
+        context 'when the relation is not empty' do
+          let(:root) { prepopulated_root }
+
+          it_behaves_like 'a cache_version generator'
+        end
+      end
+
+      context 'when the relation is not already loaded' do
+        let(:posts) { root.posts }
+
+        context 'when the relation is empty' do
+          it_behaves_like 'a cache_version generator'
+        end
+
+        context 'when the relation is not empty' do
+          let(:root) { prepopulated_root }
+
+          it_behaves_like 'a cache_version generator'
+        end
+      end
+    end
+
+    context 'when the model has an updated_at column' do
+      let(:root_model) { WikiPage.create(title: 'Root') }
+      let(:root) { WikiPage.find(root_model.id) }
+
+      let(:child_page) { root_model.child_pages.first }
+      let(:original_cache_version) { root.child_pages.cache_version }
+
+      let(:prepopulated_root) do
+        root_model.child_pages << WikiPage.new(title: 'Child #1')
+        root_model.child_pages << WikiPage.new(title: 'Child #2')
+        WikiPage.find(root_model.id)
+      end
+
+      shared_examples_for 'a cache_version generator' do
+        it 'produces a consistent cache_version' do
+          expect(child_pages.cache_version).not_to be_nil
+          expect(child_pages.cache_version).to eq child_pages.cache_version
+        end
+      end
+
+      context 'when the relation is already loaded' do
+        let(:child_pages) { root.child_pages.tap { |r| r.to_a } }
+
+        context 'when the relation is empty' do
+          it_behaves_like 'a cache_version generator'
+        end
+
+        context 'when the relation is not empty' do
+          let(:root) { prepopulated_root }
+
+          it_behaves_like 'a cache_version generator'
+        end
+      end
+
+      context 'when the relation is not yet loaded' do
+        let(:child_pages) { root.child_pages }
+
+        context 'when the relation is empty' do
+          it_behaves_like 'a cache_version generator'
+        end
+
+        context 'when the relation is not empty' do
+          let(:root) { prepopulated_root }
+
+          it_behaves_like 'a cache_version generator'
+        end
+      end
+
+      context 'when an element is updated' do
+        let(:updated_cache_version) do
+          child_page.update description: 'modified'
+          root.reload.child_pages.cache_version
+        end
+
+        let(:root) { prepopulated_root }
+
+        it 'changes the cache_version' do
+          expect(original_cache_version).not_to eq updated_cache_version
+        end
+      end
+
+      context 'when an element is added' do
+        let(:updated_cache_version) do
+          root.child_pages << WikiPage.new(title: 'Another Child')
+          root.reload.child_pages.cache_version
+        end
+
+        let(:root) { prepopulated_root }
+
+        it 'changes the cache_version' do
+          expect(original_cache_version).not_to eq updated_cache_version
+        end
+      end
+
+      context 'when an element is removed' do
+        let(:updated_cache_version) do
+          child_page.destroy
+          root.reload.child_pages.cache_version
+        end
+
+        let(:root) { prepopulated_root }
+
+        it 'changes the cache_version' do
+          expect(original_cache_version).not_to eq updated_cache_version
+        end
+      end
+    end
+  end
 end

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 class HmmCompany
   include Mongoid::Document
@@ -8,7 +7,7 @@ class HmmCompany
   has_many :emails, primary_key: :p, foreign_key: :f, class_name: 'HmmEmail'
 
   # The addresses are added with different dependency mechanisms in tests:
-  #has_many :addresses, class_name: 'HmmAddress', dependent: :destroy
+  # has_many :addresses, class_name: 'HmmAddress', dependent: :destroy
 end
 
 class HmmEmail

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

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
-require_relative './has_many_models'
+require 'spec_helper'
+require_relative 'has_many_models'
 
 describe Mongoid::Association::Referenced::HasMany do
   context 'when projecting with #only' do
@@ -25,7 +24,7 @@ describe Mongoid::Association::Referenced::HasMany do
       expect do
         student.grade
       end.to raise_error(Mongoid::Errors::AttributeNotLoaded)
-      expect(student.attributes.keys).to eq(['_id', 'name'])
+      expect(student.attributes.keys).to eq(%w[_id name])
     end
 
     # Delete this test when https://jira.mongodb.org/browse/MONGOID-4704 is