mongoid 9.1.1 → 9.1.2

data/spec/mongoid/tasks/database_spec.rb

@@ -254,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/touchable_spec.rb

@@ -1400,6 +1400,46 @@ describe Mongoid::Touchable do
     end
   end
 
+  describe 'the parent chain touch paths' do
+    context 'on a root document' do
+      it 'contains the root updated_at path' do
+        expect(TouchableParent.new._touchable_chain_paths).to eq(%w[updated_at])
+      end
+    end
+
+    context 'on an embedded document with a touchable parent' do
+      let(:parent) do
+        parent = TouchableParent.create!
+        parent.child = TouchableChild.create!(parent: parent)
+        parent
+      end
+
+      it 'contains the paths of each node in the chain' do
+        expect(parent.child._touchable_chain_paths)
+          .to eq(%w[child.updated_at updated_at])
+      end
+    end
+
+    context 'with a custom touch field' do
+      it 'contains the custom field path of the anchor document' do
+        building = TouchableSpec::Embedded::Building.create!
+
+        expect(building._touchable_chain_paths(:last_used_at))
+          .to eq(%w[updated_at last_used_at])
+      end
+    end
+
+    context 'when the models use Timestamps::Short' do
+      it 'resolves the aliased timestamp fields' do
+        building = TouchableSpec::Short::Building.create!
+        building.floors.create!
+
+        expect(building.reload.floors.first._touchable_chain_paths)
+          .to eq(%w[floors.0.u_at u_at])
+      end
+    end
+  end
+
   describe 'touch merged with embedded insert' do
     context 'when pushing an embedded document with touch: true' do
       let(:building) do
@@ -1424,6 +1464,21 @@ describe Mongoid::Touchable do
         end
       end
 
+      it 'sends the merged touch updates rewritten to the positional operator' do
+        subscriber = Mrss::EventSubscriber.new
+        Mongoid.client(:default).subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        begin
+          floor.sofas.push(TouchableSpec::Embedded::Sofa.new)
+        ensure
+          Mongoid.client(:default).unsubscribe(Mongo::Monitoring::COMMAND, subscriber)
+        end
+
+        command = subscriber.single_command_started_event('update').command
+        sets = command['updates'].first['u']['$set']
+
+        expect(sets.keys).to contain_exactly('floors.$.updated_at', 'updated_at')
+      end
+
       it 'updates updated_at on the parent after push' do
         original_floor_updated_at = floor.updated_at
         original_building_updated_at = building.updated_at
@@ -1536,5 +1591,167 @@ describe Mongoid::Touchable do
         expect(building.updated_at).to be > original_updated_at
       end
     end
+
+    context 'when an existing child of the same array has a pending touch' do
+      let(:building) do
+        TouchableSpec::Embedded::Building.create!(title: 'Tower')
+      end
+
+      before do
+        floor = building.floors.create!(level: 1)
+        # Leave a pending touch on the existing sibling so merging it into
+        # the insert would target a path inside the pushed array.
+        floor.updated_at = Time.now + 60
+      end
+
+      it 'does not raise a conflict error when creating a sibling' do
+        expect { building.floors.create!(level: 2) }.not_to raise_error
+      end
+
+      it 'persists the new sibling' do
+        building.floors.create!(level: 2)
+        expect(building.reload.floors.length).to eq(2)
+      end
+
+      it 'touches the parent' do
+        building.floors.create!(level: 2)
+        building.reload
+        expect(building.updated_at).to be_within(5).of(Time.now)
+      end
+    end
+
+    context 'when a sibling in a parent array has a pending touch' do
+      let(:building) do
+        TouchableSpec::Embedded::Building.create!(title: 'Tower')
+      end
+
+      let(:first_floor) do
+        building.floors.create!(level: 1)
+      end
+
+      let(:second_floor) do
+        building.floors.create!(level: 2)
+      end
+
+      let(:pending_touch_time) do
+        Time.now + 60
+      end
+
+      before do
+        first_floor
+        # Leave a pending touch on the other floor, at a different index of
+        # the same array. Rewriting both that touch and the insert's own
+        # touch to the positional operator collapses them onto one path and
+        # touches the wrong floor.
+        second_floor.updated_at = pending_touch_time
+      end
+
+      it 'does not raise when creating a grandchild under the other floor' do
+        expect { first_floor.sofas.create! }.not_to raise_error
+      end
+
+      it 'touches the floor the grandchild was inserted under' do
+        first_floor.sofas.create!
+        building.reload
+        expect(building.floors[0].updated_at).to be_within(5).of(Time.now)
+      end
+
+      it 'preserves the pending touch on the sibling floor' do
+        first_floor.sofas.create!
+        building.reload
+        expect(building.floors[1].updated_at.to_f)
+          .to be_within(1).of(pending_touch_time.to_f)
+      end
+    end
+
+    context 'when the parent touch option names a custom field' do
+      let(:building) do
+        TouchableSpec::Embedded::Building.create!(title: 'Tower')
+      end
+
+      it 'writes the custom touch field when creating an embedded child' do
+        # Materialize the parent before the freeze so its updated_at differs
+        # from the touch time, forcing the touch updates to merge into the
+        # child's insert.
+        building
+        Timecop.freeze(Time.utc(2026, 1, 2, 3, 4, 5)) do
+          building.waiting_rooms.create!
+          building.reload
+          expect(building.last_used_at).not_to be_nil
+          expect(building.last_used_at.to_f)
+            .to be_within(1).of(Time.utc(2026, 1, 2, 3, 4, 5).to_f)
+        end
+      end
+    end
+
+    context 'when the models use Timestamps::Short' do
+      let(:building) do
+        TouchableSpec::Short::Building.create!
+      end
+
+      let(:floor) do
+        building.floors.create!
+      end
+
+      before do
+        building
+        floor
+      end
+
+      it 'merges the touch updates into the insert round-trip' do
+        expect_query(1) do
+          floor.gadgets.push(TouchableSpec::Short::Gadget.new)
+        end
+      end
+
+      it 'touches the parent chain through the aliased timestamp fields' do
+        original_building_updated_at = building.u_at
+        original_floor_updated_at = floor.u_at
+
+        Timecop.travel(Time.now + 10) do
+          floor.gadgets.push(TouchableSpec::Short::Gadget.new)
+        end
+
+        building.reload
+        expect(building.u_at).to be > original_building_updated_at
+        expect(building.floors.first.u_at).to be > original_floor_updated_at
+      end
+    end
+
+    context 'when a sibling has a pending touch and the touch callback does not run' do
+      let(:building) do
+        TouchableSpec::Embedded::Building.create!(title: 'Tower')
+      end
+
+      let(:first_floor) do
+        building.floors.create!(level: 1)
+      end
+
+      let(:second_floor) do
+        building.floors.create!(level: 2)
+      end
+
+      let(:pending_touch_time) do
+        Time.now + 60
+      end
+
+      before do
+        first_floor
+        # Leave a pending touch on the other floor: rewriting it and this
+        # chain's own touch would collapse both onto the same positional
+        # path, so the touch updates cannot be merged into the insert.
+        second_floor.updated_at = pending_touch_time
+      end
+
+      it 'persists the deferred touches at insert time' do
+        Mongoid::Touchable.suppress_touch_callbacks(TouchableSpec::Embedded::Sofa.name) do
+          first_floor.sofas.push(TouchableSpec::Embedded::Sofa.new)
+        end
+
+        building.reload
+        expect(building.floors[1].updated_at.to_f)
+          .to be_within(1).of(pending_touch_time.to_f)
+      end
+    end
   end
 end

data/spec/mongoid/touchable_spec_models.rb

@@ -7,10 +7,12 @@ module TouchableSpec
       include Mongoid::Timestamps
 
       field :title, type: String
+      field :last_used_at, type: Time
 
       embeds_many :entrances, class_name: 'TouchableSpec::Embedded::Entrance'
       embeds_many :floors, class_name: 'TouchableSpec::Embedded::Floor'
       embeds_one :lobby, class_name: 'TouchableSpec::Embedded::Lobby'
+      embeds_many :waiting_rooms, class_name: 'TouchableSpec::Embedded::WaitingRoom'
     end
 
     class Lobby
@@ -75,6 +77,41 @@ module TouchableSpec
 
       embedded_in :floor, touch: true, class_name: 'TouchableSpec::Embedded::Floor'
     end
+
+    class WaitingRoom
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      field :name, type: String
+
+      embedded_in :building, touch: :last_used_at,
+                             class_name: 'TouchableSpec::Embedded::Building'
+    end
+  end
+
+  module Short
+    class Building
+      include Mongoid::Document
+      include Mongoid::Timestamps::Short
+
+      embeds_many :floors, class_name: 'TouchableSpec::Short::Floor'
+    end
+
+    class Floor
+      include Mongoid::Document
+      include Mongoid::Timestamps::Short
+
+      embedded_in :building, touch: true, class_name: 'TouchableSpec::Short::Building'
+
+      embeds_many :gadgets, class_name: 'TouchableSpec::Short::Gadget'
+    end
+
+    class Gadget
+      include Mongoid::Document
+      include Mongoid::Timestamps::Short
+
+      embedded_in :floor, touch: true, class_name: 'TouchableSpec::Short::Floor'
+    end
   end
 
   module Referenced

data/spec/support/crypt/models.rb

@@ -203,4 +203,100 @@ module Crypt
 
     embeds_one :missing_note, class_name: 'Crypt::MissingNote'
   end
+
+  # Two unrelated models stored in one collection, each with its own encrypted
+  # field.
+  class Badge
+    include Mongoid::Document
+
+    store_in collection: 'crypt_badges'
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
+
+    field :serial, type: String, encrypt: true
+  end
+
+  class BadgeScan
+    include Mongoid::Document
+
+    store_in collection: 'crypt_badges'
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
+
+    field :holder, type: String, encrypt: true
+  end
+
+  # Single collection inheritance. Only Member is registered in
+  # Mongoid.models; the subclasses are not.
+  class Member
+    include Mongoid::Document
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
+
+    field :ssn, type: String, encrypt: true
+  end
+
+  class Employee < Member
+    field :salary, type: String, encrypt: true
+  end
+
+  class Contractor < Member
+    field :rate, type: String, encrypt: true
+  end
+
+  # Single collection inheritance where only the subclass is encrypted.
+  class Listing
+    include Mongoid::Document
+
+    field :title, type: String
+  end
+
+  class PrivateListing < Listing
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
+
+    field :owner_ssn, type: String, encrypt: true
+  end
+
+  # An embeds_one target whose subclass adds an encrypted field.
+  class Box
+    include Mongoid::Document
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
+
+    embeds_one :item, class_name: 'Crypt::Item'
+  end
+
+  class Item
+    include Mongoid::Document
+
+    field :label, type: String, encrypt: true
+
+    embedded_in :box, class_name: 'Crypt::Box'
+  end
+
+  class SealedItem < Item
+    field :seal, type: String, encrypt: true
+  end
+
+  # An embeds_one target with no encrypted field, whose subclass has one.
+  # Nothing on Locker or Content declares encryption.
+  class Locker
+    include Mongoid::Document
+
+    embeds_one :content, class_name: 'Crypt::Content'
+  end
+
+  class Content
+    include Mongoid::Document
+
+    field :label, type: String
+
+    embedded_in :locker, class_name: 'Crypt::Locker'
+  end
+
+  class SecretContent < Content
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
+
+    field :code, type: String, encrypt: true
+  end
 end

data/spec/support/models/modifier_models.rb

@@ -22,4 +22,69 @@ module ModifierModels
     embedded_in :book, class_name: 'ModifierModels::Book'
     field :text, type: String
   end
+
+  class Roster
+    include Mongoid::Document
+
+    embeds_many :players, class_name: 'ModifierModels::Player'
+    accepts_nested_attributes_for :players, allow_destroy: true
+  end
+
+  class Player
+    include Mongoid::Document
+
+    embedded_in :roster, class_name: 'ModifierModels::Roster'
+    embeds_one :medal, class_name: 'ModifierModels::Medal'
+    has_and_belongs_to_many :badges, inverse_of: nil, class_name: 'ModifierModels::Badge'
+    embeds_many :awards, class_name: 'ModifierModels::Award'
+    accepts_nested_attributes_for :awards, allow_destroy: true
+    field :nickname, type: String
+  end
+
+  class Award
+    include Mongoid::Document
+
+    embedded_in :player, class_name: 'ModifierModels::Player'
+    has_and_belongs_to_many :badges, inverse_of: nil, class_name: 'ModifierModels::Badge'
+    field :name, type: String
+  end
+
+  class Medal
+    include Mongoid::Document
+
+    embedded_in :player, class_name: 'ModifierModels::Player'
+  end
+
+  class Badge
+    include Mongoid::Document
+  end
+
+  class Cabinet
+    include Mongoid::Document
+
+    embeds_one :drawer, class_name: 'ModifierModels::Drawer', autobuild: true
+  end
+
+  class Drawer
+    include Mongoid::Document
+
+    field :matcher, type: String
+    embedded_in :cabinet, class_name: 'ModifierModels::Cabinet'
+    embeds_many :items, class_name: 'ModifierModels::Item'
+  end
+
+  class Item
+    include Mongoid::Document
+
+    field :name, type: String
+    embedded_in :drawer, class_name: 'ModifierModels::Drawer'
+    embeds_many :widgets, class_name: 'ModifierModels::Widget'
+  end
+
+  class Widget
+    include Mongoid::Document
+
+    field :label, type: String
+    embedded_in :item, class_name: 'ModifierModels::Item'
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid
 version: !ruby/object:Gem::Version
-  version: 9.1.1
+  version: 9.1.2
 platform: ruby
 authors:
 - The MongoDB Ruby Team
@@ -317,6 +317,7 @@ files:
 - lib/mongoid/errors/invalid_discriminator_key_target.rb
 - lib/mongoid/errors/invalid_dot_dollar_assignment.rb
 - lib/mongoid/errors/invalid_elem_match_operator.rb
+- lib/mongoid/errors/invalid_encryption_schema.rb
 - lib/mongoid/errors/invalid_estimated_count_criteria.rb
 - lib/mongoid/errors/invalid_estimated_count_scoping.rb
 - lib/mongoid/errors/invalid_expression_operator.rb
@@ -529,6 +530,7 @@ files:
 - spec/integration/active_job_spec.rb
 - spec/integration/app_spec.rb
 - spec/integration/associations/belongs_to_spec.rb
+- spec/integration/associations/embedded_delayed_atomic_sets_spec.rb
 - spec/integration/associations/embedded_dirty_spec.rb
 - spec/integration/associations/embedded_spec.rb
 - spec/integration/associations/embeds_many_spec.rb
@@ -1287,7 +1289,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 4.0.21
+rubygems_version: 4.0.24
 specification_version: 4
 summary: Elegant Persistence in Ruby for MongoDB.
 test_files:
@@ -1297,6 +1299,7 @@ test_files:
 - spec/integration/active_job_spec.rb
 - spec/integration/app_spec.rb
 - spec/integration/associations/belongs_to_spec.rb
+- spec/integration/associations/embedded_delayed_atomic_sets_spec.rb
 - spec/integration/associations/embedded_dirty_spec.rb
 - spec/integration/associations/embedded_spec.rb
 - spec/integration/associations/embeds_many_spec.rb