mongoid 8.0.13 → 8.1.0

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

@@ -4,14 +4,12 @@ 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
 
@@ -1757,6 +1755,43 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
       end
     end
 
+    describe "#any?" do
+
+      let(:person) do
+        Person.create!
+      end
+
+      context "when nothing exists on the relation" do
+
+        context "when no document is added" do
+
+          let!(:sandwich) do
+            Sandwich.create!
+          end
+
+          it "returns false" do
+            expect(sandwich.meats.any?).to be false
+          end
+        end
+
+        context "when the document is destroyed" do
+
+          before do
+            Meat.create!
+          end
+
+          let!(:sandwich) do
+            Sandwich.create!
+          end
+
+          it "returns false" do
+            sandwich.destroy
+            expect(sandwich.meats.any?).to be false
+          end
+        end
+      end
+    end
+
     context "when documents have been persisted" do
 
       let!(:preference) do
@@ -2268,13 +2303,6 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
     end
   end
 
-  # Whether the conditions carry a pattern decides which branch of remove_all
-  # runs, so anything that has to behave the same on both is exercised twice.
-  conditions_variants = [
-    [ 'no regular expression', nil ],
-    [ 'a regular expression', { name: /Test/ } ]
-  ].freeze
-
   %i[ delete_all destroy_all ].each do |method|
     describe "\##{method}" do
       context 'when the relation is not polymorphic' do
@@ -2346,47 +2374,6 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
             expect(person.preferences).to eq([])
           end
         end
-
-        context 'when the base holds the foreign keys' do
-          # unbind_one pulls ids out of the base's foreign key array and marks
-          # the base dirty, so which documents get unbound is visible here.
-          # Only what the association already held is unbound, and that has to
-          # hold whether or not the conditions carry a regular expression:
-          # scanning under a regexp budget loads the association first, and
-          # that load must not turn into an unbind of its own. See the note in
-          # HasMany::Proxy#remove_all_bounded.
-          let!(:person) do
-            Person.create!.tap do |base|
-              base.preferences.create!(name: 'Testing')
-              base.preferences.create!(name: 'Test')
-            end
-          end
-
-          let(:ids) { person.preference_ids.dup }
-
-          conditions_variants.each do |description, conditions|
-            context "when the conditions carry #{description}" do
-              context 'when the association is already in memory' do
-                it 'unbinds the deleted documents' do
-                  person.preferences.send(method, conditions)
-                  expect(person.preference_ids).to eq([])
-                  expect(person).to be_changed
-                end
-              end
-
-              context 'when the association has not been loaded' do
-                let(:cold) { Person.find(person._id) }
-
-                it 'leaves the foreign keys alone' do
-                  expect(ids.length).to eq(2)
-                  cold.preferences.send(method, conditions)
-                  expect(cold.preference_ids).to eq(ids)
-                  expect(cold).not_to be_changed
-                end
-              end
-            end
-          end
-        end
       end
     end
   end
@@ -2480,10 +2467,7 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::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 {
@@ -2493,19 +2477,12 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
           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
@@ -2544,10 +2521,7 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::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 {
@@ -2557,19 +2531,12 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
           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
@@ -3074,34 +3041,6 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
         end
       end
 
-      # MONGOID-5844
-      #
-      # Specifically, this tests the case where the association is
-      # initialized with a single element (so that Proxy#push does not take
-      # the `concat` route), which causes `reset_unloaded` to be called, which
-      # sets the `_unloaded` Criteria object to match only the specific element
-      # that was given.
-      #
-      # The issue now is that when the events list is updated to be both events,
-      # _unloaded matches one of them already, and the other has previously been
-      # persisted so `new_record?` won't match it. We need to make sure the
-      # `#size` logic properly accounts for this case.
-      context 'when documents have been previously persisted' do
-        let(:person1) { Person.create! }
-        let(:person2) { Person.create! }
-        let(:event1) { Event.create!(administrators: [ person1 ]) }
-        let(:event2) { Event.create!(administrators: [ person2 ]) }
-
-        before do
-          person1.administrated_events = [ event1, event2 ]
-        end
-
-        it 'returns the number of associated documents [MONGOID-5844]' do
-          expect(person1.administrated_events.to_a.size).to eq(2)
-          expect(person1.administrated_events.size).to eq(2)
-        end
-      end
-
       context "when documents have not been persisted" do
 
         before do

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

@@ -23,10 +23,9 @@ module RefHasManySpec
 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
@@ -2281,151 +2280,6 @@ 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
@@ -2680,10 +2534,7 @@ 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 {
@@ -2693,19 +2544,12 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           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
@@ -2729,10 +2573,7 @@ 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 {
@@ -2742,19 +2583,12 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           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
@@ -2793,10 +2627,7 @@ 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 {
@@ -2806,19 +2637,12 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           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
@@ -2850,10 +2674,7 @@ 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 {
@@ -2863,19 +2684,12 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
           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

data/spec/mongoid/association/syncable_spec.rb

@@ -3,9 +3,9 @@
 require "spec_helper"
 
 describe "Syncable Association" do
+  config_override :raise_not_found_error, true
 
   before(:all) do
-    Mongoid.raise_not_found_error = true
     Person._synced(Person.relations["preferences"])
     Person.has_and_belongs_to_many :preferences
     Preference.has_and_belongs_to_many :people