mongoid 9.1.0 → 9.1.2

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
@@ -1511,5 +1566,192 @@ describe Mongoid::Touchable do
         expect(building.updated_at).to eq(original_building_updated_at)
       end
     end
+
+    context 'when creating an embeds_one document with touch: true (regression for #6128)' do
+      let(:building) do
+        TouchableSpec::Embedded::Building.create!(title: 'Tower')
+      end
+
+      it 'persists the embedded document fields after create_<assoc>' do
+        building.create_lobby(name: 'Main Lobby')
+
+        reloaded = TouchableSpec::Embedded::Building.find(building.id)
+        expect(reloaded.lobby).not_to be_nil
+        expect(reloaded.lobby.name).to eq('Main Lobby')
+      end
+
+      it 'updates the parent updated_at after create_<assoc>' do
+        original_updated_at = building.updated_at
+
+        Timecop.travel(Time.now + 10) do
+          building.create_lobby(name: 'Main Lobby')
+        end
+
+        building.reload
+        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,9 +7,21 @@ 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
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      field :name, type: String
+
+      embedded_in :building, touch: true, class_name: 'TouchableSpec::Embedded::Building'
     end
 
     class Entrance
@@ -65,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/mongoid/validatable/associated_spec.rb

@@ -82,6 +82,25 @@ describe Mongoid::Validatable::AssociatedValidator do
           expect(user).to be_valid
         end
       end
+
+      context 'when a child document has been destroyed' do
+        let(:user) do
+          User.new(name: 'test')
+        end
+
+        let(:description) do
+          Description.new
+        end
+
+        before do
+          user.descriptions << description
+          description.destroyed = true
+        end
+
+        it 'does not run validation on the destroyed child' do
+          expect(user).to be_valid
+        end
+      end
     end
   end
 

data/spec/spec_helper.rb

@@ -101,7 +101,11 @@ CONFIG = {
         heartbeat_frequency: 180,
         user: SpecConfig.instance.uri.client_options[:user] || MONGOID_ROOT_USER.name,
         password: SpecConfig.instance.uri.client_options[:password] || MONGOID_ROOT_USER.password,
-        auth_source: Mongo::Database::ADMIN
+        auth_source: Mongo::Database::ADMIN,
+
+        # so that we can run an Atlas cluster locally, and run tests with Atlas
+        # support enabled.
+        direct_connection: SpecConfig.instance.uri.uri_options[:direct_connection]
       )
     }
   },

data/spec/support/crypt/models.rb

@@ -46,4 +46,257 @@ module Crypt
     field :vin, type: String, encrypt: true
     field :make, type: String
   end
+
+  # An encrypted model whose database name is a callable resolving to a
+  # constant. The callable form of :database is supported by store_in, but the
+  # encryption schema map is keyed by namespace and built once, so this model's
+  # namespace is not known when the map is generated.
+  class DynamicCar
+    include Mongoid::Document
+
+    store_in database: -> { 'vehicles_dynamic' }
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
+
+    field :vin, type: String, encrypt: true
+  end
+
+  # An encrypted model using the documented multi-tenant idiom, where the
+  # database name is only known once a tenant is selected. There is no correct
+  # value to resolve at client construction time.
+  class TenantCar
+    include Mongoid::Document
+
+    # The fallback keeps this model usable by tasks that iterate every model,
+    # such as Mongoid::Tasks::Database.create_collections. Mongoid raises
+    # NoMethodError when a callable :database resolves to nil.
+    store_in database: -> { Thread.current[:tenant_database] || 'vehicles_no_tenant' }
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
+
+    field :vin, type: String, encrypt: true
+  end
+
+  # An encrypted model that is embedded by more than one parent, and more than
+  # once by the same parent.
+  class Token
+    include Mongoid::Document
+
+    field :value, type: String, encrypt: { deterministic: true }
+
+    embedded_in :tokenized, polymorphic: true
+  end
+
+  # A parent whose encrypted data lives entirely in an embedded model: it has
+  # no encrypted field of its own and no encrypt_with.
+  class Wallet
+    include Mongoid::Document
+
+    embeds_one :token, class_name: 'Crypt::Token', as: :tokenized
+  end
+
+  # Two parents embedding the same encrypted model.
+  class Vault
+    include Mongoid::Document
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
+
+    embeds_one :token, class_name: 'Crypt::Token', as: :tokenized
+  end
+
+  class Chest
+    include Mongoid::Document
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
+
+    embeds_one :token, class_name: 'Crypt::Token', as: :tokenized
+  end
+
+  # A parent embedding the same encrypted model through two relations.
+  class Ledger
+    include Mongoid::Document
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
+
+    embeds_one :primary_token, class_name: 'Crypt::Token', as: :tokenized
+    embeds_one :backup_token, class_name: 'Crypt::Token', as: :tokenized
+  end
+
+  # Three levels of nesting, where the middle level has no encrypted field of
+  # its own.
+  class Owner
+    include Mongoid::Document
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
+
+    embeds_one :account, class_name: 'Crypt::Account'
+  end
+
+  class Account
+    include Mongoid::Document
+
+    embedded_in :owner, class_name: 'Crypt::Owner'
+    embeds_one :credential, class_name: 'Crypt::Credential'
+  end
+
+  class Credential
+    include Mongoid::Document
+
+    field :secret, type: String, encrypt: { deterministic: true }
+
+    embedded_in :account, class_name: 'Crypt::Account'
+  end
+
+  # A model that embeds itself. The walk over embedded relations has to stop
+  # here, or generating the map never terminates.
+  class Comment
+    include Mongoid::Document
+
+    field :body, type: String, encrypt: { deterministic: true }
+
+    embedded_in :commentable, polymorphic: true
+    embeds_one :reply, class_name: 'Crypt::Comment', as: :commentable
+  end
+
+  class Article
+    include Mongoid::Document
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q=='
+
+    embeds_one :comment, class_name: 'Crypt::Comment', as: :commentable
+  end
+
+  # A parent with no encrypted field of its own: the encrypted field lives on
+  # the embedded model. Used by the integration specs, so the embedded model
+  # carries a key id.
+  class Folder
+    include Mongoid::Document
+
+    embeds_one :note, class_name: 'Crypt::Note'
+  end
+
+  class Note
+    include Mongoid::Document
+
+    encrypt_with key_id: 'grolrnFVSSW9Gq04Q87R9Q==', deterministic: true
+
+    field :text, type: String, encrypt: true
+
+    embedded_in :folder, class_name: 'Crypt::Folder'
+  end
+
+  # A model naming an embedded class that is never defined. The association
+  # cannot be used, so nothing is ever embedded through it, but every model in
+  # the application is walked when the schema map is generated.
+  class Drawer
+    include Mongoid::Document
+
+    embeds_one :missing_note, class_name: 'Crypt::MissingNote'
+  end
+
+  # The same, on a model that is encrypted itself, so the walk descends into
+  # its relations.
+  class Cabinet
+    include Mongoid::Document
+
+    field :label, type: String, encrypt: { deterministic: true }
+
+    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