mongoid 9.1.0 → 9.1.2

data/spec/mongoid/search_indexable_spec.rb

@@ -17,10 +17,10 @@ class SearchIndexHelper
 
   # Wait for all of the indexes with the given names to be ready; then return
   # the list of index definitions corresponding to those names.
-  def wait_for(*names, &condition)
+  def wait_for(*names, timeout: 300, &condition)
     names.flatten!
 
-    timeboxed_wait do
+    timeboxed_wait(max: timeout) do
       result = collection.search_indexes
       return filter_results(result, names) if names.all? { |name| ready?(result, name, &condition) }
     end
@@ -36,6 +36,14 @@ class SearchIndexHelper
     end
   end
 
+  # Atlas normalizes latestDefinition by adding "fields"=>{} inside mappings
+  # even when no fields were declared. Strip it before comparing against specs.
+  def normalize_definition(defn)
+    return defn unless defn.is_a?(Hash) && defn['mappings'].is_a?(Hash)
+
+    defn.merge('mappings' => defn['mappings'].reject { |k, v| k.to_s == 'fields' && v == {} })
+  end
+
   private
 
   def timeboxed_wait(step: 5, max: 300)
@@ -57,7 +65,7 @@ class SearchIndexHelper
   end
 
   def filter_results(result, names)
-    result.select { |index| names.include?(index['name']) }
+    names.filter_map { |name| result.find { |index| index['name'] == name } }
   end
 end
 
@@ -110,6 +118,32 @@ describe Mongoid::SearchIndexable do
     end
   end
 
+  describe '.wait_for_search_indexes' do
+    let(:model) do
+      Class.new do
+        include Mongoid::Document
+
+        store_in collection: BSON::ObjectId.new.to_s
+        search_index :idx, mappings: { dynamic: false }
+      end
+    end
+
+    it 'reads the index status inside collection management' do
+      managing = nil
+      search_indexes = [ { 'name' => 'idx', 'queryable' => true, 'status' => 'READY' } ]
+      collection = instance_double(Mongo::Collection)
+      allow(collection).to receive(:search_indexes) do
+        managing = Mongoid::Threaded.managing_collection?
+        search_indexes
+      end
+      allow(model).to receive(:collection).and_return(collection)
+
+      model.wait_for_search_indexes([ 'idx' ])
+
+      expect(managing).to be true
+    end
+  end
+
   describe '.vector_search_index' do
     let(:vector_model) do
       Class.new do
@@ -309,6 +343,276 @@ describe Mongoid::SearchIndexable do
     end
   end
 
+  describe '.vector_search_index with flat indexingMethod' do
+    it 'raises ArgumentError when flat index includes hnswOptions' do
+      expect do
+        Class.new do
+          include Mongoid::Document
+
+          store_in collection: BSON::ObjectId.new.to_s
+          vector_search_index fields: [
+            {
+              type: 'vector',
+              path: 'embedding',
+              numDimensions: 3,
+              similarity: 'cosine',
+              indexingMethod: 'flat',
+              hnswOptions: { m: 16, efConstruction: 150 }
+            }
+          ]
+        end
+      end.to raise_error(ArgumentError, /hnswOptions is only supported with indexingMethod: hnsw/)
+    end
+
+    it 'does not raise when flat index has no hnswOptions' do
+      expect do
+        Class.new do
+          include Mongoid::Document
+
+          store_in collection: BSON::ObjectId.new.to_s
+          vector_search_index fields: [
+            {
+              type: 'vector',
+              path: 'embedding',
+              numDimensions: 3,
+              similarity: 'cosine',
+              indexingMethod: 'flat'
+            }
+          ]
+        end
+      end.not_to raise_error
+    end
+
+    it 'does not raise when hnsw index has hnswOptions' do
+      expect do
+        Class.new do
+          include Mongoid::Document
+
+          store_in collection: BSON::ObjectId.new.to_s
+          vector_search_index fields: [
+            {
+              type: 'vector',
+              path: 'embedding',
+              numDimensions: 3,
+              similarity: 'cosine',
+              indexingMethod: 'hnsw',
+              hnswOptions: { m: 16, efConstruction: 150 }
+            }
+          ]
+        end
+      end.not_to raise_error
+    end
+  end
+
+  describe '.vector_search pipeline construction' do
+    let(:model) do
+      Class.new do
+        include Mongoid::Document
+
+        store_in collection: BSON::ObjectId.new.to_s
+        field :embedding, type: Array
+        vector_search_index fields: [ { type: 'vector', path: 'embedding', numDimensions: 3, similarity: 'cosine' } ]
+      end
+    end
+
+    let(:fake_collection) { instance_double(Mongo::Collection) }
+    let(:fake_cursor) { double(map: []) }
+
+    before do
+      allow(model).to receive(:collection).and_return(fake_collection)
+      allow(fake_collection).to receive(:aggregate).and_return(fake_cursor)
+    end
+
+    it 'includes numCandidates by default' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']).to have_key('numCandidates')
+        fake_cursor
+      end
+
+      model.vector_search([ 0.1, 0.2, 0.3 ], limit: 5)
+    end
+
+    it 'omits numCandidates and sends exact: true when exact: true' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']).not_to have_key('numCandidates')
+        expect(vs['$vectorSearch']['exact']).to be true
+        fake_cursor
+      end
+
+      model.vector_search([ 0.1, 0.2, 0.3 ], exact: true)
+    end
+
+    it 'uses limit * 10 as the default numCandidates' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']['numCandidates']).to eq(50)
+        fake_cursor
+      end
+
+      model.vector_search([ 0.1, 0.2, 0.3 ], limit: 5)
+    end
+  end
+
+  describe '#vector_search pipeline construction' do
+    let(:model) do
+      Class.new do
+        include Mongoid::Document
+
+        store_in collection: BSON::ObjectId.new.to_s
+        field :embedding, type: Array
+        vector_search_index fields: [ { type: 'vector', path: 'embedding', numDimensions: 3, similarity: 'cosine' } ]
+      end
+    end
+
+    let(:fake_collection) { instance_double(Mongo::Collection) }
+    let(:fake_cursor) { double(map: []) }
+    let(:doc) { model.new(embedding: [ 0.1, 0.2, 0.3 ]) }
+
+    before do
+      allow(model).to receive(:collection).and_return(fake_collection)
+      allow(fake_collection).to receive(:aggregate).and_return(fake_cursor)
+    end
+
+    it 'omits numCandidates and sends exact: true when exact: true' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']).not_to have_key('numCandidates')
+        expect(vs['$vectorSearch']['exact']).to be true
+        fake_cursor
+      end
+
+      doc.vector_search(exact: true)
+    end
+
+    it 'passes limit + 1 to $vectorSearch so the post-filter never short-counts' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']['limit']).to eq 6
+        fake_cursor
+      end
+
+      doc.vector_search(limit: 5)
+    end
+
+    it 'does not use filter in $vectorSearch for self-exclusion' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']).not_to have_key('filter')
+        fake_cursor
+      end
+
+      doc.vector_search(limit: 5)
+    end
+
+    it 'adds a $match stage after $vectorSearch to exclude self' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        match = pipeline.find { |s| s['$match'] }
+        expect(match).to eq({ '$match' => { '_id' => { '$ne' => doc.id } } })
+        fake_cursor
+      end
+
+      doc.vector_search(limit: 5)
+    end
+
+    it 'adds a $limit stage after $match to cap results at the requested limit' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        match_idx = pipeline.index { |s| s['$match'] }
+        limit_stage = pipeline[match_idx + 1]
+        expect(limit_stage).to eq({ '$limit' => 5 })
+        fake_cursor
+      end
+
+      doc.vector_search(limit: 5)
+    end
+
+    it 'passes a user-provided filter through to $vectorSearch' do
+      user_filter = { 'status' => 'published' }
+
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']['filter']).to eq user_filter
+        fake_cursor
+      end
+
+      doc.vector_search(limit: 5, filter: user_filter)
+    end
+  end
+
+  describe '#auto_embed_search pipeline construction' do
+    let(:model) do
+      Class.new do
+        include Mongoid::Document
+
+        store_in collection: BSON::ObjectId.new.to_s
+        auto_embed_field :description, model: 'voyage-4'
+      end
+    end
+
+    let(:fake_collection) { instance_double(Mongo::Collection) }
+    let(:fake_cursor) { double(map: []) }
+    let(:doc) { model.new(description: 'hello world') }
+
+    before do
+      allow(model).to receive(:collection).and_return(fake_collection)
+      allow(fake_collection).to receive(:aggregate).and_return(fake_cursor)
+    end
+
+    it 'passes limit + 1 to $vectorSearch so the post-filter never short-counts' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']['limit']).to eq 6
+        fake_cursor
+      end
+
+      doc.auto_embed_search(limit: 5)
+    end
+
+    it 'does not use filter in $vectorSearch for self-exclusion' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']).not_to have_key('filter')
+        fake_cursor
+      end
+
+      doc.auto_embed_search(limit: 5)
+    end
+
+    it 'adds a $match stage after $vectorSearch to exclude self' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        match = pipeline.find { |s| s['$match'] }
+        expect(match).to eq({ '$match' => { '_id' => { '$ne' => doc.id } } })
+        fake_cursor
+      end
+
+      doc.auto_embed_search(limit: 5)
+    end
+
+    it 'adds a $limit stage after $match to cap results at the requested limit' do
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        match_idx = pipeline.index { |s| s['$match'] }
+        limit_stage = pipeline[match_idx + 1]
+        expect(limit_stage).to eq({ '$limit' => 5 })
+        fake_cursor
+      end
+
+      doc.auto_embed_search(limit: 5)
+    end
+
+    it 'passes a user-provided filter through to $vectorSearch' do
+      user_filter = { 'status' => 'published' }
+
+      expect(fake_collection).to receive(:aggregate) do |pipeline|
+        vs = pipeline.find { |s| s['$vectorSearch'] }
+        expect(vs['$vectorSearch']['filter']).to eq user_filter
+        fake_cursor
+      end
+
+      doc.auto_embed_search(limit: 5, filter: user_filter)
+    end
+  end
+
   # Atlas integration tests — skipped when ATLAS_URI is not set.
 
   context 'Atlas integration' do
@@ -332,7 +636,7 @@ describe Mongoid::SearchIndexable do
       let(:requested_definitions) { model.search_index_specs.map { |spec| spec[:definition].with_indifferent_access } }
       let(:index_names) { model.create_search_indexes }
       let(:actual_indexes) { helper.wait_for(*index_names) }
-      let(:actual_definitions) { actual_indexes.map { |i| i['latestDefinition'] } }
+      let(:actual_definitions) { actual_indexes.map { |i| helper.normalize_definition(i['latestDefinition']) } }
 
       describe '.create_search_indexes' do
         it 'creates the indexes' do
@@ -343,10 +647,10 @@ describe Mongoid::SearchIndexable do
       describe '.search_indexes' do
         before { actual_indexes } # wait for the indices to be created
 
-        let(:queried_definitions) { model.search_indexes.map { |i| i['latestDefinition'] } }
+        let(:queried_definitions) { model.search_indexes.map { |i| helper.normalize_definition(i['latestDefinition']) } }
 
         it 'queries the available search indexes' do
-          expect(queried_definitions).to eq requested_definitions
+          expect(queried_definitions).to match_array(requested_definitions)
         end
       end
 
@@ -390,11 +694,19 @@ describe Mongoid::SearchIndexable do
       let(:vector_helper) { SearchIndexHelper.new(vector_model) }
 
       # Three orthogonal unit vectors as a minimal, predictable dataset.
-      let!(:doc_a) { vector_model.create!(embedding: [ 1.0, 0.0, 0.0 ]) }
-      let!(:doc_b) { vector_model.create!(embedding: [ 0.0, 1.0, 0.0 ]) }
-      let!(:doc_c) { vector_model.create!(embedding: [ 0.0, 0.0, 1.0 ]) }
+      let(:doc_a) { vector_model.create!(embedding: [ 1.0, 0.0, 0.0 ]) }
+      let(:doc_b) { vector_model.create!(embedding: [ 0.0, 1.0, 0.0 ]) }
+      let(:doc_c) { vector_model.create!(embedding: [ 0.0, 0.0, 1.0 ]) }
 
       before do
+        vector_helper # force collection to be dropped, created
+
+        # once the collection has been recreated, populate it with documents
+        doc_a
+        doc_b
+        doc_c
+
+        # prepare the search indexes
         names = vector_model.create_search_indexes
         vector_helper.wait_for(*names)
       end

data/spec/mongoid/tasks/database_spec.rb

@@ -69,6 +69,24 @@ describe Mongoid::Tasks::Database do
   end
 
   describe '.create_collections' do
+    # Creating a collection sends no document data, so it must not require a
+    # client that can encrypt, even for a model that declares encrypted
+    # fields. Otherwise this task cannot run without KMS credentials.
+    context 'when a model declares encrypted fields' do
+      before do
+        require 'support/crypt/models'
+      end
+
+      after do
+        Mongoid.default_client[Crypt::Patient.collection_name].drop
+      end
+
+      it 'creates the collection using a client without automatic encryption' do
+        expect { Mongoid::Tasks::Database.create_collections([ Crypt::Patient ]) }
+          .not_to raise_error
+      end
+    end
+
     context 'collection_options are specified' do
       let(:models) do
         [ DatabaseSpec::Measurement ]
@@ -236,6 +254,19 @@ describe Mongoid::Tasks::Database do
         described_class.create_search_indexes([ searchable_model_spy ], wait: false)
       end
     end
+
+    context 'when waiting for the indexes' do
+      it 'runs the wait inside collection management' do
+        managing = nil
+        allow(described_class).to receive(:wait_for_search_indexes) do
+          managing = Mongoid::Threaded.managing_collection?
+        end
+
+        described_class.create_search_indexes([ searchable_model_spy ], wait: true)
+
+        expect(managing).to be true
+      end
+    end
   end
 
   describe '.remove_search_indexes' do

data/spec/mongoid/timestamps/timeless_spec.rb

@@ -12,7 +12,7 @@ describe Mongoid::Timestamps::Timeless do
         before_save :lay_timeless_egg
 
         def lay_timeless_egg
-          Egg.timeless.create!
+          Egg.timeless { Egg.create! }
         end
       end
 
@@ -30,7 +30,7 @@ describe Mongoid::Timestamps::Timeless do
     context 'when timeless is used on one instance and then not used on another instance' do
       let!(:first_instance) do
         egg = Egg.create!
-        egg.timeless.save!
+        egg.timeless { egg.save! }
         egg
       end
 
@@ -60,7 +60,7 @@ describe Mongoid::Timestamps::Timeless do
 
       context 'when the root executes timeless' do
         let!(:chicken) do
-          Chicken.timeless.create!
+          Chicken.timeless { Chicken.create! }
         end
 
         it 'creates the parent with a timestamp' do
@@ -80,7 +80,7 @@ describe Mongoid::Timestamps::Timeless do
         end
 
         before do
-          document.timeless.save!
+          document.timeless { document.save! }
         end
 
         it 'does not set the created timestamp' do
@@ -108,7 +108,7 @@ describe Mongoid::Timestamps::Timeless do
 
       context 'when used on the class' do
         let!(:document) do
-          Dokument.timeless.create!
+          Dokument.timeless { Dokument.create! }
         end
 
         it 'does not set the created timestamp' do
@@ -135,4 +135,196 @@ describe Mongoid::Timestamps::Timeless do
       end
     end
   end
+
+  describe '#timeless with a block' do
+    before(:all) do
+      class TimelessOther
+        include Mongoid::Document
+        include Mongoid::Timestamps
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :TimelessOther)
+    end
+
+    context 'when called on an instance' do
+      let(:document) { Dokument.new }
+
+      it 'executes the block and persists the document' do
+        document.timeless { document.save! }
+        expect(document).to be_persisted
+      end
+
+      it 'does not set the created timestamp' do
+        document.timeless { document.save! }
+        expect(document.created_at).to be_nil
+      end
+
+      it 'does not set the updated timestamp' do
+        document.timeless { document.save! }
+        expect(document.updated_at).to be_nil
+      end
+
+      it 'returns the value of the block' do
+        expect(document.timeless { 42 }).to eq(42)
+      end
+
+      it 'resumes timestamping after the block' do
+        document.timeless { document.save! }
+        document.update_attribute(:title, 'Sir')
+        expect(document.updated_at).not_to be_nil
+      end
+
+      it 'is not timeless outside the block' do
+        document.timeless { document.save! }
+        expect(document).not_to be_timeless
+      end
+
+      it 'restores state even when the block raises' do
+        expect do
+          document.timeless { raise 'boom' }
+        end.to raise_error('boom')
+        expect(document).not_to be_timeless
+      end
+    end
+
+    context 'when called on the class' do
+      it 'does not set timestamps for documents created in the block' do
+        document = Dokument.timeless { Dokument.create! }
+        expect(document.created_at).to be_nil
+        expect(document.updated_at).to be_nil
+      end
+    end
+
+    context 'when nested' do
+      let(:document) { Dokument.new }
+
+      it 'remains timeless until the outermost block exits' do
+        Dokument.timeless do
+          Dokument.timeless { document.save! }
+          # inner block has exited, but we are still inside the outer block
+          expect(document).to be_timeless
+        end
+        expect(document).not_to be_timeless
+        expect(document.created_at).to be_nil
+      end
+    end
+
+    context 'when other documents are persisted in the block' do
+      it 'suppresses timestamps globally on the thread for the block duration' do
+        other = nil
+        Dokument.timeless { other = TimelessOther.create! }
+        expect(other.created_at).to be_nil
+      end
+    end
+  end
+
+  # Regression for MONGOID-5782: saving a parent timeless must not bump the
+  # updated_at of embedded children, at any nesting depth, when the
+  # associations cascade callbacks.
+  describe 'MONGOID-5782 cascaded embedded timestamps' do
+    before(:all) do
+      class TimelessBaz
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        embedded_in :timeless_bar
+        field :val, type: String
+      end
+
+      class TimelessBar
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        embedded_in :timeless_foo
+        embeds_many :timeless_bazs, cascade_callbacks: true
+        field :val, type: String
+      end
+
+      class TimelessFoo
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        embeds_many :timeless_bars, cascade_callbacks: true
+        field :val, type: String
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :TimelessBaz)
+      Object.send(:remove_const, :TimelessBar)
+      Object.send(:remove_const, :TimelessFoo)
+    end
+
+    let!(:start_time) { Timecop.freeze(Time.at(Time.now.to_i)) }
+
+    let!(:foo) do
+      TimelessFoo.create!(timeless_bars: [ { val: 'a', timeless_bazs: [ { val: 'x' } ] } ])
+    end
+
+    let(:bar) { foo.timeless_bars.first }
+    let(:baz) { bar.timeless_bazs.first }
+
+    after do
+      Timecop.return
+    end
+
+    it 'does not bump the embedded child updated_at' do
+      original = bar.updated_at
+      bar.val = 'b'
+      Timecop.freeze(Time.at(Time.now.to_i) + 2)
+      foo.timeless { foo.save! }
+      # the change was actually persisted (the block ran)...
+      expect(foo.reload.timeless_bars.first.val).to eq('b')
+      # ...but the timestamp was suppressed.
+      expect(bar.updated_at).to eq(original)
+    end
+
+    it 'does not bump the nested embedded child updated_at' do
+      original = baz.updated_at
+      baz.val = 'y'
+      Timecop.freeze(Time.at(Time.now.to_i) + 2)
+      foo.timeless { foo.save! }
+      expect(foo.reload.timeless_bars.first.timeless_bazs.first.val).to eq('y')
+      expect(baz.updated_at).to eq(original)
+    end
+
+    it 'still preserves the parent updated_at' do
+      original = foo.updated_at
+      foo.val = 'c'
+      Timecop.freeze(Time.at(Time.now.to_i) + 2)
+      foo.timeless { foo.save! }
+      expect(TimelessFoo.find(foo.id).val).to eq('c')
+      expect(foo.updated_at).to eq(original)
+    end
+  end
+
+  describe 'deprecation of the block-less form' do
+    before { Mongoid.reset_deprecation_warnings! }
+
+    let(:document) { Dokument.new }
+
+    it 'warns when called on an instance without a block' do
+      expect(Mongoid.logger).to receive(:warn).with(/timeless/)
+      document.timeless.save!
+    end
+
+    it 'warns when called on the class without a block' do
+      expect(Mongoid.logger).to receive(:warn).with(/timeless/)
+      Dokument.timeless.create!
+    end
+
+    it 'does not warn when called with a block' do
+      expect(Mongoid.logger).not_to receive(:warn)
+      document.timeless { document.save! }
+    end
+
+    it 'does not warn from the internal touch: false path' do
+      document.save!
+      document.title = 'changed'
+      expect(Mongoid.logger).not_to receive(:warn).with(/timeless/)
+      document.save!(touch: false)
+    end
+  end
 end