mongoid 9.0.11 → 9.1.1

data/spec/integration/matcher_operator_data/in.yml

@@ -114,16 +114,16 @@
   document:
     name: [Boris]
   query:
-    count:
+    name:
       $in:
         - !ruby/regexp /..ris/
-  matches: false
+  matches: true
 
 - name: array field - does not match native regexp as element value
   document:
     name: [Boris]
   query:
-    count:
+    name:
       $in:
         - !ruby/regexp /ri$/
   matches: false
@@ -132,18 +132,18 @@
   document:
     name: [Boris]
   query:
-    count:
+    name:
       $in:
         - !ruby/object:BSON::Regexp::Raw
           pattern: ..ris
           options: ''
-  matches: false
+  matches: true
 
 - name: array field - does not match bson regexp as element value
   document:
     name: [Boris]
   query:
-    count:
+    name:
       $in:
         - !ruby/object:BSON::Regexp::Raw
           pattern: ..ri$

data/spec/integration/matcher_operator_data/regex.yml

@@ -135,6 +135,27 @@
       $regex: bar
   matches: false
 
+# Object#=~ is gone as of Ruby 3.2, so an element that cannot be matched
+# against has to be skipped rather than passed to =~.
+- name: array field value - element that cannot be matched against
+  document:
+    title:
+      - 42
+      - foo
+  query:
+    title:
+      $regex: foo
+  matches: true
+
+- name: array field value - no element can be matched against
+  document:
+    title:
+      - 42
+  query:
+    title:
+      $regex: foo
+  matches: false
+
 - name: true field value
   document:
     title: true

data/spec/integration/matcher_operator_spec.rb

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'spec_helper'
 
 def mop_error?(spec, kind)
-  unless %w(matcher driver dsl).include?(kind)
-    raise ArgumentError, "Bogus kind: #{kind}"
-  end
+  raise ArgumentError, "Bogus kind: #{kind}" unless %w[matcher driver dsl].include?(kind)
 
   spec['error'] == true || spec['error'] == kind ||
-    spec['error'].is_a?(Array) && spec['error'].include?(kind)
+    (spec['error'].is_a?(Array) && spec['error'].include?(kind))
 end
 
 describe 'Matcher operators' do
@@ -42,7 +39,6 @@ describe 'Matcher operators' do
 
       specs.each do |spec|
         context spec['name'] do
-
           if spec['pending']
             before do
               # Cannot use `pending` here because some of the queries may work
@@ -51,9 +47,7 @@ describe 'Matcher operators' do
             end
           end
 
-          if spec['min_server_version']
-            min_server_version spec['min_server_version'].to_s
-          end
+          min_server_version spec['min_server_version'].to_s if spec['min_server_version']
 
           let(:query) { spec.fetch('query') }
           let(:result) { spec.fetch('matches') }
@@ -80,14 +74,12 @@ describe 'Matcher operators' do
             context 'via driver' do
               if mop_error?(spec, 'driver')
                 it 'produces an error' do
-                  begin
-                    Mop.collection.find(query).any?
-                  rescue Mongo::Error::OperationFailure
-                  rescue Mongo::Error::InvalidDocument
-                  rescue BSON::Error::UnserializableClass
-                  else
-                    fail "Expected an exception to be raised"
-                  end
+                  Mop.collection.find(query).any?
+                rescue Mongo::Error::OperationFailure
+                rescue Mongo::Error::InvalidDocument
+                rescue BSON::Error::UnserializableClass
+                else
+                  raise 'Expected an exception to be raised'
                 end
               else
                 it 'produces the correct result' do
@@ -99,15 +91,13 @@ describe 'Matcher operators' do
             context 'via Mongoid DSL' do
               if mop_error?(spec, 'dsl')
                 it 'produces an error' do
-                  begin
-                    Mop.where(query).any?
-                  rescue Mongo::Error::OperationFailure
-                  rescue BSON::Error::UnserializableClass
-                  rescue Mongoid::Errors::InvalidQuery
-                  rescue Mongoid::Errors::CriteriaArgumentRequired
-                  else
-                    fail "Expected the query to raise an error"
-                  end
+                  Mop.where(query).any?
+                rescue Mongo::Error::OperationFailure
+                rescue BSON::Error::UnserializableClass
+                rescue Mongoid::Errors::InvalidQuery
+                rescue Mongoid::Errors::CriteriaArgumentRequired
+                else
+                  raise 'Expected the query to raise an error'
                 end
               else
                 it 'produces the correct result' do

data/spec/integration/matcher_regexp_timeout_spec.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'spec_helper'
+
+describe 'in-memory regexp time limit' do
+  # See the comment in spec/mongoid/matcher/regexp_budget_spec.rb: costly to
+  # match but bounded on every supported Ruby. A pattern relying on nested
+  # quantifiers would hang before Ruby 3.2, where the examples that have no
+  # interrupt available could not stop it.
+  let(:slow_pattern) { "(?:#{(1..300).map { |i| "a#{i}" }.join('|')})Z" }
+  let(:slow_street) { 'a' * 5_000 }
+
+  let(:person) do
+    # Address derives its _id from the street, so the streets have to differ or
+    # the embedded association collapses to a single document.
+    Person.new(addresses: Array.new(30) { |i| Address.new(street: "#{slow_street}#{i}") })
+  end
+
+  let(:one_address) { Person.new(addresses: [ Address.new(street: slow_street) ]) }
+
+  # What one match of the fixture costs on the machine running the suite. It
+  # varies by more than an order of magnitude between implementations - around
+  # 6ms on MRI, 110ms on JRuby - so the examples below calibrate against a
+  # measurement instead of hard-coding a threshold that only holds on one.
+  let(:single_match_cost) do
+    regexp = Regexp.new(slow_pattern)
+    3.times { slow_street =~ regexp }
+    Benchmark.realtime { slow_street =~ regexp }
+  end
+
+  # Comfortably more than one match, comfortably less than twenty. The examples
+  # only need the ordering to hold, so the margin either side is wide.
+  let(:calibrated_limit) { single_match_cost * 5 }
+
+  context 'when the limit is disabled' do
+    config_override :in_memory_regexp_time_limit, nil
+
+    it 'evaluates the query without a bound' do
+      expect(person.addresses.where(street: { '$regex' => slow_pattern }).to_a).to eq([])
+    end
+  end
+
+  context 'when a limit is configured' do
+    config_override :in_memory_regexp_time_limit, nil
+
+    before { Mongoid::Config.in_memory_regexp_time_limit = calibrated_limit }
+
+    it 'leaves ordinary queries alone' do
+      person = Person.new(addresses: [ Address.new(street: 'Clarkson') ])
+      expect(person.addresses.where(street: { '$regex' => '\AClark' }).to_a.size).to eq(1)
+    end
+
+    it 'does not raise for a single document' do
+      # The counterpart to the example below, and what makes it meaningful: one
+      # document stays under the limit, so a scan that raises can only have got
+      # there by accumulating cost across documents.
+      expect do
+        one_address.addresses.where(street: { '$regex' => slow_pattern }).to_a
+      end.not_to raise_error
+    end
+
+    it 'raises for a scan over many documents under that same limit' do
+      expect do
+        person.addresses.where(street: { '$regex' => slow_pattern }).to_a
+      end.to raise_error(Mongoid::Errors::InMemoryRegexpTimeout)
+    end
+
+    it 'raises when $in multiplies the cost within a single document' do
+      conditions = Array.new(20) { BSON::Regexp::Raw.new(slow_pattern) }
+
+      expect do
+        one_address.addresses.where(street: { '$in' => conditions }).to_a
+      end.to raise_error(Mongoid::Errors::InMemoryRegexpTimeout)
+    end
+
+    it 'raises through the public _matches? API' do
+      # 20 conditions rather than one, because a single match is deliberately
+      # kept well under the limit by the calibration above.
+      conditions = Array.new(20) { BSON::Regexp::Raw.new(slow_pattern) }
+
+      expect do
+        person.addresses.first._matches?('street' => { '$in' => conditions })
+      end.to raise_error(Mongoid::Errors::InMemoryRegexpTimeout)
+    end
+  end
+
+  context 'when the pattern is pathological' do
+    config_override :in_memory_regexp_time_limit, 0.2
+
+    # The ticket's Case 1, verbatim. It backtracks exponentially and is the
+    # reason the guard exists, so every entry point that evaluates a selector
+    # in memory has to bound it. The subject is kept short enough that the
+    # match still finishes on its own in a few seconds, so an entry point that
+    # fails to bound it shows up as a failing example rather than a hung run.
+    let(:evil_pattern) { '^(a+)+\1?$' }
+    let(:evil_subject) { "#{'a' * 28}X" }
+
+    it 'bounds a scan over an embedded association' do
+      person = Person.new(addresses: [ Address.new(street: evil_subject) ])
+
+      expect do
+        person.addresses.where(street: { '$regex' => evil_pattern }).to_a
+      end.to raise_error(Mongoid::Errors::InMemoryRegexpTimeout)
+    end
+
+    it 'bounds the public _matches? API' do
+      expect do
+        Address.new(street: evil_subject)._matches?('street' => { '$regex' => evil_pattern })
+      end.to raise_error(Mongoid::Errors::InMemoryRegexpTimeout)
+    end
+
+    it 'bounds removal from a referenced association' do
+      owner = Person.create!
+      owner.posts.create!(title: evil_subject)
+
+      expect do
+        owner.posts.delete_all(title: { '$regex' => evil_pattern })
+      end.to raise_error(Mongoid::Errors::InMemoryRegexpTimeout)
+    end
+
+    it 'deletes nothing when removal is bounded' do
+      # The scan runs before the delete, so the error means what a caller would
+      # take it to mean: the documents are still there.
+      owner = Person.create!
+      owner.posts.create!(title: evil_subject)
+
+      expect do
+        owner.posts.delete_all(title: { '$regex' => evil_pattern })
+      end.to raise_error(Mongoid::Errors::InMemoryRegexpTimeout)
+
+      expect(Post.count).to eq(1)
+      expect(owner.reload.posts.size).to eq(1)
+    end
+  end
+
+  context 'when the association being removed from has not been loaded' do
+    config_override :in_memory_regexp_time_limit, 0.2
+
+    let!(:owner) do
+      person = Person.create!
+      person.posts.create!(title: 'Testing')
+      Person.find(person._id)
+    end
+
+    # The query that loads the association, which removal has to run before it
+    # has anything to match against.
+    let(:load_query) { owner.posts._target._unloaded }
+
+    # A stall standing in for a slow network. It is longer than the limit, and
+    # none of it is time spent on regular expressions.
+    before do
+      allow(load_query).to receive(:each).and_wrap_original do |original, *args, &block|
+        sleep(0.3)
+        original.call(*args, &block)
+      end
+    end
+
+    it 'does not load it, so no query can be counted against the limit' do
+      # On the Timeout path a deadline covering the fetch failed a slow query
+      # with an error about regular expressions, and the asynchronous exception
+      # could land inside the driver's socket read, leaving the connection with
+      # unconsumed bytes. Nothing is fetched now: the scan sees only what the
+      # association already holds.
+      stub_const('Mongoid::Matcher::RegexpBudget::PER_REGEXP_TIMEOUT', false)
+
+      expect do
+        owner.posts.delete_all(title: { '$regex' => '\Azzz' })
+      end.not_to raise_error
+
+      expect(load_query).not_to have_received(:each)
+    end
+
+    it 'runs no pattern against documents it never loaded' do
+      # The counterpart to the referenced-association examples below, where the
+      # documents are in memory and the pattern is run against every one of
+      # them. Here there is nothing to run it against, and the server applies
+      # the same selector for the delete, so nothing is missed by not looking.
+      expect(Mongoid::Matcher::RegexpBudget).not_to receive(:match?)
+
+      owner.posts.delete_all(title: { '$regex' => '\Azzz' })
+    end
+
+    it 'still removes the documents that match' do
+      expect(owner.posts.delete_all(title: { '$regex' => '\ATest' })).to eq(1)
+      expect(Post.count).to eq(0)
+      expect(owner.posts.size).to eq(0)
+    end
+  end
+
+  context 'when removing documents from a referenced association' do
+    config_override :in_memory_regexp_time_limit, nil
+
+    let!(:owner) { Person.create! }
+
+    before do
+      30.times { owner.posts.create!(title: slow_street) }
+      Mongoid::Config.in_memory_regexp_time_limit = calibrated_limit
+    end
+
+    it 'raises rather than scanning every loaded document' do
+      expect do
+        owner.posts.delete_all(title: { '$regex' => slow_pattern })
+      end.to raise_error(Mongoid::Errors::InMemoryRegexpTimeout)
+    end
+
+    it 'leaves the documents in place' do
+      expect do
+        owner.posts.delete_all(title: { '$regex' => slow_pattern })
+      end.to raise_error(Mongoid::Errors::InMemoryRegexpTimeout)
+
+      expect(Post.count).to eq(30)
+    end
+  end
+end

data/spec/integration/matcher_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'spec_helper'
 
@@ -15,30 +14,30 @@ describe 'Matcher operators' do
   end
 
   shared_examples 'is false' do
-    it 'is false 'do
+    it 'is false' do
       result.should be false
     end
   end
 
   context 'when comparing Time objects' do
-    let(:time) {Time.utc(2021, 10, 25, 10, 30, 30, 581345)}
+    let(:time) { Time.utc(2021, 10, 25, 10, 30, 30, 581_345) }
     let(:document) do
-      ConsumptionPeriod.new(:started_at => time)
+      ConsumptionPeriod.new(started_at: time)
     end
 
     context 'comparing millisecond precision' do
-      let(:time_millis) {Time.utc(2021, 10, 25, 10, 30, 30, 581774)}
+      let(:time_millis) { Time.utc(2021, 10, 25, 10, 30, 30, 581_774) }
 
       context 'with exact match' do
         let(:query) do
-          {'started_at' => time_millis}
+          { 'started_at' => time_millis }
         end
 
         it_behaves_like 'is true'
 
         context 'and query has different timezone' do
           let(:time_millis) do
-            Time.utc(2021, 10, 25, 10, 30, 30, 581345).in_time_zone("Stockholm")
+            Time.utc(2021, 10, 25, 10, 30, 30, 581_345).in_time_zone('Stockholm')
           end
 
           it_behaves_like 'is true'
@@ -47,7 +46,7 @@ describe 'Matcher operators' do
 
       context 'with $in' do
         let(:query) do
-          {'started_at' => {:$in => [time_millis]}}
+          { 'started_at' => { :$in => [ time_millis ] } }
         end
 
         it_behaves_like 'is true'
@@ -55,12 +54,12 @@ describe 'Matcher operators' do
 
       context 'when matching an element in an array' do
         let(:document) do
-          Mop.new(:array_field => [time])
+          Mop.new(array_field: [ time ])
         end
 
         context 'with equals match' do
           let(:query) do
-            {'array_field' => time_millis}
+            { 'array_field' => time_millis }
           end
 
           it_behaves_like 'is true'
@@ -73,14 +72,14 @@ describe 'Matcher operators' do
     context 'embeds_one' do
       let(:document) do
         Canvas.new(
-          writer: Writer.new(speed: 3),
+          writer: Writer.new(speed: 3)
         )
       end
 
       context 'implicit $eq' do
         context 'matches' do
           let(:query) do
-            {'writer.speed' => 3}
+            { 'writer.speed' => 3 }
           end
 
           it_behaves_like 'is true'
@@ -88,7 +87,7 @@ describe 'Matcher operators' do
 
         context 'does not match' do
           let(:query) do
-            {'speed' => 3}
+            { 'speed' => 3 }
           end
 
           it_behaves_like 'is false'
@@ -97,11 +96,11 @@ describe 'Matcher operators' do
 
       context 'field operator' do
         # Test string and symbol operators
-        ['$gt', :$gt].each do |op|
+        [ '$gt', :$gt ].each do |op|
           context op.inspect do
             context 'matches' do
               let(:query) do
-                {'writer.speed' => {op => 2}}
+                { 'writer.speed' => { op => 2 } }
               end
 
               it_behaves_like 'is true'
@@ -109,7 +108,7 @@ describe 'Matcher operators' do
 
             context 'does not match' do
               let(:query) do
-                {'writer.speed' => {op => 3}}
+                { 'writer.speed' => { op => 3 } }
               end
 
               it_behaves_like 'is false'
@@ -122,7 +121,7 @@ describe 'Matcher operators' do
         context 'scalar field in embedded document' do
           context 'matches' do
             let(:query) do
-              {writer: {speed: 3}}
+              { writer: { speed: 3 } }
             end
 
             it_behaves_like 'is true'
@@ -130,7 +129,7 @@ describe 'Matcher operators' do
 
           context 'does not match' do
             let(:query) do
-              {writer: {slow: 3}}
+              { writer: { slow: 3 } }
             end
 
             it_behaves_like 'is false'
@@ -140,13 +139,13 @@ describe 'Matcher operators' do
         context 'hash field' do
           let(:document) do
             Bar.new(
-              writer: {speed: 3},
+              writer: { speed: 3 }
             )
           end
 
           context 'matches' do
             let(:query) do
-              {writer: {speed: 3}}
+              { writer: { speed: 3 } }
             end
 
             it_behaves_like 'is true'
@@ -154,7 +153,7 @@ describe 'Matcher operators' do
 
           context 'does not match' do
             let(:query) do
-              {writer: {slow: 3}}
+              { writer: { slow: 3 } }
             end
 
             it_behaves_like 'is false'
@@ -166,19 +165,19 @@ describe 'Matcher operators' do
     context 'embeds_many' do
       let(:document) do
         Survey.new(
-          questions: [Question.new(
+          questions: [ Question.new(
             answers: [
               Answer.new(position: 3),
-              Answer.new(position: 4),
-            ],
-          )],
+              Answer.new(position: 4)
+            ]
+          ) ]
         )
       end
 
       context 'implicit $eq' do
         context 'matches' do
           let(:query) do
-            {'questions.answers.position' => 3}
+            { 'questions.answers.position' => 3 }
           end
 
           it_behaves_like 'is true'
@@ -186,7 +185,7 @@ describe 'Matcher operators' do
 
         context 'does not match' do
           let(:query) do
-            {'questions.answers.position' => 2}
+            { 'questions.answers.position' => 2 }
           end
 
           it_behaves_like 'is false'
@@ -195,11 +194,11 @@ describe 'Matcher operators' do
 
       context 'field operator' do
         # Test string and symbol operators
-        ['$gt', :$gt].each do |op|
+        [ '$gt', :$gt ].each do |op|
           context op.inspect do
             context 'matches' do
               let(:query) do
-                {'questions.answers.position' => {op => 2}}
+                { 'questions.answers.position' => { op => 2 } }
               end
 
               it_behaves_like 'is true'
@@ -207,7 +206,7 @@ describe 'Matcher operators' do
 
             context 'does not match' do
               let(:query) do
-                {'questions.answers.position' => {op => 4}}
+                { 'questions.answers.position' => { op => 4 } }
               end
 
               it_behaves_like 'is false'
@@ -219,7 +218,7 @@ describe 'Matcher operators' do
       context 'array index' do
         context 'matches' do
           let(:query) do
-            {'questions.answers.1' => {position: 4}}
+            { 'questions.answers.1' => { position: 4 } }
           end
 
           it_behaves_like 'is true'
@@ -227,7 +226,7 @@ describe 'Matcher operators' do
 
         context 'does not match' do
           let(:query) do
-            {'questions.answers.0' => {position: 4}}
+            { 'questions.answers.0' => { position: 4 } }
           end
 
           it_behaves_like 'is false'

data/spec/integration/persistence/collection_options_spec.rb

@@ -2,8 +2,6 @@
 
 require 'spec_helper'
 
-# rubocop:disable RSpec/LeakyConstantDeclaration
-# rubocop:disable Lint/ConstantDefinitionInBlock
 describe 'Collection options' do
   before(:all) do
     class CollectionOptionsCapped