activerecord 7.0.8.7 → 7.1.5.1

data/lib/active_record/test_fixtures.rb

@@ -13,17 +13,31 @@ module ActiveRecord
 
     def after_teardown # :nodoc:
       super
+    ensure
       teardown_fixtures
     end
 
     included do
-      class_attribute :fixture_path, instance_writer: false
+      ##
+      # :singleton-method: fixture_paths
+      #
+      # Returns the ActiveRecord::FixtureSet collection
+
+      ##
+      # :singleton-method: fixture_paths=
+      #
+      # :call-seq:
+      #   fixture_paths=(fixture_paths)
+      class_attribute :fixture_paths, instance_writer: false, default: []
       class_attribute :fixture_table_names, default: []
       class_attribute :fixture_class_names, default: {}
       class_attribute :use_transactional_tests, default: true
       class_attribute :use_instantiated_fixtures, default: false # true, false, or :no_instances
       class_attribute :pre_loaded_fixtures, default: false
       class_attribute :lock_threads, default: true
+      class_attribute :fixture_sets, default: {}
+
+      ActiveSupport.run_load_hooks(:active_record_fixtures, self)
     end
 
     module ClassMethods
@@ -39,12 +53,28 @@ module ActiveRecord
         self.fixture_class_names = fixture_class_names.merge(class_names.stringify_keys)
       end
 
+      def fixture_path # :nodoc:
+        ActiveRecord.deprecator.warn(<<~WARNING)
+          TestFixtures.fixture_path is deprecated and will be removed in Rails 7.2. Use .fixture_paths instead.
+          If multiple fixture paths have been configured with .fixture_paths, then .fixture_path will just return
+          the first path.
+        WARNING
+        fixture_paths.first
+      end
+
+      def fixture_path=(path) # :nodoc:
+        ActiveRecord.deprecator.warn("TestFixtures.fixture_path= is deprecated and will be removed in Rails 7.2. Use .fixture_paths= instead.")
+        self.fixture_paths = Array(path)
+      end
+
       def fixtures(*fixture_set_names)
         if fixture_set_names.first == :all
-          raise StandardError, "No fixture path found. Please set `#{self}.fixture_path`." if fixture_path.blank?
-          fixture_set_names = Dir[::File.join(fixture_path, "{**,*}/*.{yml}")].uniq
-          fixture_set_names.reject! { |f| f.start_with?(file_fixture_path.to_s) } if defined?(file_fixture_path) && file_fixture_path
-          fixture_set_names.map! { |f| f[fixture_path.to_s.size..-5].delete_prefix("/") }
+          raise StandardError, "No fixture path found. Please set `#{self}.fixture_paths`." if fixture_paths.blank?
+          fixture_set_names = fixture_paths.flat_map do |path|
+            names = Dir[::File.join(path, "{**,*}/*.{yml}")].uniq
+            names.reject! { |f| f.start_with?(file_fixture_path.to_s) } if defined?(file_fixture_path) && file_fixture_path
+            names.map! { |f| f[path.to_s.size..-5].delete_prefix("/") }
+          end.uniq
         else
           fixture_set_names = fixture_set_names.flatten.map(&:to_s)
         end
@@ -55,35 +85,15 @@ module ActiveRecord
 
       def setup_fixture_accessors(fixture_set_names = nil)
         fixture_set_names = Array(fixture_set_names || fixture_table_names)
-        methods = Module.new do
+        unless fixture_set_names.empty?
+          self.fixture_sets = fixture_sets.dup
           fixture_set_names.each do |fs_name|
-            fs_name = fs_name.to_s
-            accessor_name = fs_name.tr("/", "_").to_sym
-
-            define_method(accessor_name) do |*fixture_names|
-              force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
-              return_single_record = fixture_names.size == 1
-              fixture_names = @loaded_fixtures[fs_name].fixtures.keys if fixture_names.empty?
-
-              @fixture_cache[fs_name] ||= {}
-
-              instances = fixture_names.map do |f_name|
-                f_name = f_name.to_s if f_name.is_a?(Symbol)
-                @fixture_cache[fs_name].delete(f_name) if force_reload
-
-                if @loaded_fixtures[fs_name][f_name]
-                  @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
-                else
-                  raise StandardError, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'"
-                end
-              end
-
-              return_single_record ? instances.first : instances
-            end
-            private accessor_name
+            key = fs_name.to_s.include?("/") ? -fs_name.to_s.tr("/", "_") : fs_name
+            key = -key.to_s if key.is_a?(Symbol)
+            fs_name = -fs_name.to_s if fs_name.is_a?(Symbol)
+            fixture_sets[key] = fs_name
           end
         end
-        include methods
       end
 
       # Prevents automatically wrapping each specified test in a transaction,
@@ -100,6 +110,15 @@ module ActiveRecord
       end
     end
 
+    def fixture_path # :nodoc:
+      ActiveRecord.deprecator.warn(<<~WARNING)
+        TestFixtures#fixture_path is deprecated and will be removed in Rails 7.2. Use #fixture_paths instead.
+        If multiple fixture paths have been configured with #fixture_paths, then #fixture_path will just return
+        the first path.
+      WARNING
+      fixture_paths.first
+    end
+
     def run_in_transaction?
       use_transactional_tests &&
         !self.class.uses_transaction?(name)
@@ -114,7 +133,6 @@ module ActiveRecord
       @fixture_connections = []
       @@already_loaded_fixtures ||= {}
       @connection_subscriber = nil
-      @legacy_saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
       @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
 
       # Load fixtures once and begin transaction.
@@ -135,19 +153,18 @@ module ActiveRecord
 
         # When connections are established in the future, begin a transaction too
         @connection_subscriber = ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
-          spec_name = payload[:spec_name] if payload.key?(:spec_name)
+          connection_name = payload[:connection_name] if payload.key?(:connection_name)
           shard = payload[:shard] if payload.key?(:shard)
-          setup_shared_connection_pool if ActiveRecord.legacy_connection_handling
 
-          if spec_name
+          if connection_name
             begin
-              connection = ActiveRecord::Base.connection_handler.retrieve_connection(spec_name, shard: shard)
+              connection = ActiveRecord::Base.connection_handler.retrieve_connection(connection_name, shard: shard)
             rescue ConnectionNotEstablished
               connection = nil
             end
 
             if connection
-              setup_shared_connection_pool unless ActiveRecord.legacy_connection_handling
+              setup_shared_connection_pool
 
               if !@fixture_connections.include?(connection)
                 connection.begin_transaction joinable: false, _lazy: false
@@ -183,13 +200,13 @@ module ActiveRecord
         ActiveRecord::FixtureSet.reset_cache
       end
 
-      ActiveRecord::Base.clear_active_connections!
+      ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
     end
 
     def enlist_fixture_connections
       setup_shared_connection_pool
 
-      ActiveRecord::Base.connection_handler.connection_pool_list.map(&:connection)
+      ActiveRecord::Base.connection_handler.connection_pool_list(:writing).map(&:connection)
     end
 
     private
@@ -200,79 +217,43 @@ module ActiveRecord
       # need to share a connection pool so that the reading connection
       # can see data in the open transaction on the writing connection.
       def setup_shared_connection_pool
-        if ActiveRecord.legacy_connection_handling
-          writing_handler = ActiveRecord::Base.connection_handlers[ActiveRecord.writing_role]
-
-          ActiveRecord::Base.connection_handlers.values.each do |handler|
-            if handler != writing_handler
-              handler.connection_pool_names.each do |name|
-                writing_pool_manager = writing_handler.send(:owner_to_pool_manager)[name]
-                return unless writing_pool_manager
-
-                pool_manager = handler.send(:owner_to_pool_manager)[name]
-                @legacy_saved_pool_configs[handler][name] ||= {}
-                pool_manager.shard_names.each do |shard_name|
-                  writing_pool_config = writing_pool_manager.get_pool_config(nil, shard_name)
-                  pool_config = pool_manager.get_pool_config(nil, shard_name)
-                  next if pool_config == writing_pool_config
-
-                  @legacy_saved_pool_configs[handler][name][shard_name] = pool_config
-                  pool_manager.set_pool_config(nil, shard_name, writing_pool_config)
-                end
-              end
-            end
-          end
-        else
-          handler = ActiveRecord::Base.connection_handler
-
-          handler.connection_pool_names.each do |name|
-            pool_manager = handler.send(:owner_to_pool_manager)[name]
-            pool_manager.shard_names.each do |shard_name|
-              writing_pool_config = pool_manager.get_pool_config(ActiveRecord.writing_role, shard_name)
-              @saved_pool_configs[name][shard_name] ||= {}
-              pool_manager.role_names.each do |role|
-                next unless pool_config = pool_manager.get_pool_config(role, shard_name)
-                next if pool_config == writing_pool_config
-
-                @saved_pool_configs[name][shard_name][role] = pool_config
-                pool_manager.set_pool_config(role, shard_name, writing_pool_config)
-              end
+        handler = ActiveRecord::Base.connection_handler
+
+        handler.connection_pool_names.each do |name|
+          pool_manager = handler.send(:connection_name_to_pool_manager)[name]
+          pool_manager.shard_names.each do |shard_name|
+            writing_pool_config = pool_manager.get_pool_config(ActiveRecord.writing_role, shard_name)
+            @saved_pool_configs[name][shard_name] ||= {}
+            pool_manager.role_names.each do |role|
+              next unless pool_config = pool_manager.get_pool_config(role, shard_name)
+              next if pool_config == writing_pool_config
+
+              @saved_pool_configs[name][shard_name][role] = pool_config
+              pool_manager.set_pool_config(role, shard_name, writing_pool_config)
             end
           end
         end
       end
 
       def teardown_shared_connection_pool
-        if ActiveRecord.legacy_connection_handling
-          @legacy_saved_pool_configs.each_pair do |handler, names|
-            names.each_pair do |name, shards|
-              shards.each_pair do |shard_name, pool_config|
-                pool_manager = handler.send(:owner_to_pool_manager)[name]
-                pool_manager.set_pool_config(nil, shard_name, pool_config)
-              end
-            end
-          end
-        else
-          handler = ActiveRecord::Base.connection_handler
+        handler = ActiveRecord::Base.connection_handler
 
-          @saved_pool_configs.each_pair do |name, shards|
-            pool_manager = handler.send(:owner_to_pool_manager)[name]
-            shards.each_pair do |shard_name, roles|
-              roles.each_pair do |role, pool_config|
-                next unless pool_manager.get_pool_config(role, shard_name)
+        @saved_pool_configs.each_pair do |name, shards|
+          pool_manager = handler.send(:connection_name_to_pool_manager)[name]
+          shards.each_pair do |shard_name, roles|
+            roles.each_pair do |role, pool_config|
+              next unless pool_manager.get_pool_config(role, shard_name)
 
-                pool_manager.set_pool_config(role, shard_name, pool_config)
-              end
+              pool_manager.set_pool_config(role, shard_name, pool_config)
             end
           end
         end
 
-        @legacy_saved_pool_configs.clear
         @saved_pool_configs.clear
       end
 
       def load_fixtures(config)
-        ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names, config).index_by(&:name)
+        ActiveRecord::FixtureSet.create_fixtures(fixture_paths, fixture_table_names, fixture_class_names, config).index_by(&:name)
       end
 
       def instantiate_fixtures
@@ -290,5 +271,42 @@ module ActiveRecord
       def load_instances?
         use_instantiated_fixtures != :no_instances
       end
+
+      def method_missing(name, *args, **kwargs, &block)
+        if fs_name = fixture_sets[name.to_s]
+          access_fixture(fs_name, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        if include_private && fixture_sets.key?(name.to_s)
+          true
+        else
+          super
+        end
+      end
+
+      def access_fixture(fs_name, *fixture_names)
+        force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
+        return_single_record = fixture_names.size == 1
+
+        fixture_names = @loaded_fixtures[fs_name].fixtures.keys if fixture_names.empty?
+        @fixture_cache[fs_name] ||= {}
+
+        instances = fixture_names.map do |f_name|
+          f_name = f_name.to_s if f_name.is_a?(Symbol)
+          @fixture_cache[fs_name].delete(f_name) if force_reload
+
+          if @loaded_fixtures[fs_name][f_name]
+            @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
+          else
+            raise StandardError, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'"
+          end
+        end
+
+        return_single_record ? instances.first : instances
+      end
   end
 end

data/lib/active_record/timestamp.rb

@@ -30,7 +30,7 @@ module ActiveRecord
   #
   #   ActiveRecord::Base.time_zone_aware_types = [:datetime]
   #
-  # You can also add database specific timezone aware types. For example, for PostgreSQL:
+  # You can also add database-specific timezone aware types. For example, for PostgreSQL:
   #
   #   ActiveRecord::Base.time_zone_aware_types += [:tsrange, :tstzrange]
   #
@@ -54,8 +54,10 @@ module ActiveRecord
 
     module ClassMethods # :nodoc:
       def touch_attributes_with_time(*names, time: nil)
+        names = names.map(&:to_s)
+        names = names.map { |name| attribute_aliases[name] || name }
         attribute_names = timestamp_attributes_for_update_in_model
-        attribute_names |= names.map(&:to_s)
+        attribute_names |= names
         attribute_names.index_with(time || current_time_from_proper_timezone)
       end
 
@@ -75,9 +77,17 @@ module ActiveRecord
       end
 
       def current_time_from_proper_timezone
-        ActiveRecord.default_timezone == :utc ? Time.now.utc : Time.now
+        connection.default_timezone == :utc ? Time.now.utc : Time.now
       end
 
+      protected
+        def reload_schema_from_cache(recursive = true)
+          @timestamp_attributes_for_create_in_model = nil
+          @timestamp_attributes_for_update_in_model = nil
+          @all_timestamp_attributes_in_model = nil
+          super
+        end
+
       private
         def timestamp_attributes_for_create
           ["created_at", "created_on"].map! { |name| attribute_aliases[name] || name }
@@ -86,16 +96,14 @@ module ActiveRecord
         def timestamp_attributes_for_update
           ["updated_at", "updated_on"].map! { |name| attribute_aliases[name] || name }
         end
-
-        def reload_schema_from_cache
-          @timestamp_attributes_for_create_in_model = nil
-          @timestamp_attributes_for_update_in_model = nil
-          @all_timestamp_attributes_in_model = nil
-          super
-        end
     end
 
   private
+    def init_internals
+      super
+      @_touch_record = nil
+    end
+
     def _create_record
       if record_timestamps
         current_time = current_time_from_proper_timezone
@@ -109,6 +117,17 @@ module ActiveRecord
     end
 
     def _update_record
+      record_update_timestamps
+
+      super
+    end
+
+    def create_or_update(touch: true, **)
+      @_touch_record = touch
+      super
+    end
+
+    def record_update_timestamps
       if @_touch_record && should_record_timestamps?
         current_time = current_time_from_proper_timezone
 
@@ -118,12 +137,7 @@ module ActiveRecord
         end
       end
 
-      super
-    end
-
-    def create_or_update(touch: true, **)
-      @_touch_record = touch
-      super
+      yield if block_given?
     end
 
     def should_record_timestamps?

data/lib/active_record/token_for.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/json"
+
+module ActiveRecord
+  module TokenFor
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :token_definitions, instance_accessor: false, instance_predicate: false, default: {}
+      class_attribute :generated_token_verifier, instance_accessor: false, instance_predicate: false
+    end
+
+    TokenDefinition = Struct.new(:defining_class, :purpose, :expires_in, :block) do # :nodoc:
+      def full_purpose
+        @full_purpose ||= [defining_class.name, purpose, expires_in].join("\n")
+      end
+
+      def message_verifier
+        defining_class.generated_token_verifier
+      end
+
+      def payload_for(model)
+        block ? [model.id, model.instance_eval(&block).as_json] : [model.id]
+      end
+
+      def generate_token(model)
+        message_verifier.generate(payload_for(model), expires_in: expires_in, purpose: full_purpose)
+      end
+
+      def resolve_token(token)
+        payload = message_verifier.verified(token, purpose: full_purpose)
+        model = yield(payload[0]) if payload
+        model if model && payload_for(model) == payload
+      end
+    end
+
+    module ClassMethods
+      # Defines the behavior of tokens generated for a specific +purpose+.
+      # A token can be generated by calling TokenFor#generate_token_for on a
+      # record. Later, that record can be fetched by calling #find_by_token_for
+      # (or #find_by_token_for!) with the same purpose and token.
+      #
+      # Tokens are signed so that they are tamper-proof. Thus they can be
+      # exposed to outside world as, for example, password reset tokens.
+      #
+      # By default, tokens do not expire. They can be configured to expire by
+      # specifying a duration via the +expires_in+ option. The duration becomes
+      # part of the token's signature, so changing the value of +expires_in+
+      # will automatically invalidate previously generated tokens.
+      #
+      # A block may also be specified. When generating a token with
+      # TokenFor#generate_token_for, the block will be evaluated in the context
+      # of the record, and its return value will be embedded in the token as
+      # JSON. Later, when fetching the record with #find_by_token_for, the block
+      # will be evaluated again in the context of the fetched record. If the two
+      # JSON values do not match, the token will be treated as invalid. Note
+      # that the value returned by the block <b>should not contain sensitive
+      # information</b> because it will be embedded in the token as
+      # <b>human-readable plaintext JSON</b>.
+      #
+      # ==== Examples
+      #
+      #   class User < ActiveRecord::Base
+      #     has_secure_password
+      #
+      #     generates_token_for :password_reset, expires_in: 15.minutes do
+      #       # Last 10 characters of password salt, which changes when password is updated:
+      #       password_salt&.last(10)
+      #     end
+      #   end
+      #
+      #   user = User.first
+      #
+      #   token = user.generate_token_for(:password_reset)
+      #   User.find_by_token_for(:password_reset, token) # => user
+      #   # 16 minutes later...
+      #   User.find_by_token_for(:password_reset, token) # => nil
+      #
+      #   token = user.generate_token_for(:password_reset)
+      #   User.find_by_token_for(:password_reset, token) # => user
+      #   user.update!(password: "new password")
+      #   User.find_by_token_for(:password_reset, token) # => nil
+      def generates_token_for(purpose, expires_in: nil, &block)
+        self.token_definitions = token_definitions.merge(purpose => TokenDefinition.new(self, purpose, expires_in, block))
+      end
+
+      # Finds a record using a given +token+ for a predefined +purpose+. Returns
+      # +nil+ if the token is invalid or the record was not found.
+      def find_by_token_for(purpose, token)
+        raise UnknownPrimaryKey.new(self) unless primary_key
+        token_definitions.fetch(purpose).resolve_token(token) { |id| find_by(primary_key => id) }
+      end
+
+      # Finds a record using a given +token+ for a predefined +purpose+. Raises
+      # ActiveSupport::MessageVerifier::InvalidSignature if the token is invalid
+      # (e.g. expired, bad format, etc). Raises ActiveRecord::RecordNotFound if
+      # the token is valid but the record was not found.
+      def find_by_token_for!(purpose, token)
+        token_definitions.fetch(purpose).resolve_token(token) { |id| find(id) } ||
+          (raise ActiveSupport::MessageVerifier::InvalidSignature)
+      end
+    end
+
+    # Generates a token for a predefined +purpose+.
+    #
+    # Use ClassMethods#generates_token_for to define a token purpose and
+    # behavior.
+    def generate_token_for(purpose)
+      self.class.token_definitions.fetch(purpose).generate_token(self)
+    end
+  end
+end

data/lib/active_record/touch_later.rb

@@ -24,9 +24,13 @@ module ActiveRecord
       @_new_record_before_last_commit ||= false
 
       # touch the parents as we are not calling the after_save callbacks
-      self.class.reflect_on_all_associations(:belongs_to).each do |r|
+      self.class.reflect_on_all_associations.each do |r|
         if touch = r.options[:touch]
-          ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, changes_to_save, r.foreign_key, r.name, touch, :touch_later)
+          if r.macro == :belongs_to
+            ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, changes_to_save, r.foreign_key, r.name, touch)
+          elsif r.macro == :has_one
+            ActiveRecord::Associations::Builder::HasOne.touch_record(self, r.name, touch)
+          end
         end
       end
     end
@@ -42,6 +46,11 @@ module ActiveRecord
     end
 
     private
+      def init_internals
+        super
+        @_defer_touch_attrs = nil
+      end
+
       def surreptitiously_touch(attr_names)
         attr_names.each do |attr_name|
           _write_attribute(attr_name, @_touch_time)
@@ -57,9 +66,5 @@ module ActiveRecord
       def has_defer_touch_attrs?
         defined?(@_defer_touch_attrs) && @_defer_touch_attrs.present?
       end
-
-      def belongs_to_touch_method
-        :touch_later
-      end
   end
 end

data/lib/active_record/transactions.rb

@@ -13,7 +13,9 @@ module ActiveRecord
                        scope: [:kind, :name]
     end
 
-    # = Active Record Transactions
+    attr_accessor :_new_record_before_last_commit # :nodoc:
+
+    # = Active Record \Transactions
     #
     # \Transactions are protective blocks where SQL statements are only permanent
     # if they can all succeed as one atomic action. The classic example is a
@@ -98,7 +100,8 @@ module ActiveRecord
     # catch those in your application code.
     #
     # One exception is the ActiveRecord::Rollback exception, which will trigger
-    # a ROLLBACK when raised, but not be re-raised by the transaction block.
+    # a ROLLBACK when raised, but not be re-raised by the transaction block. Any
+    # other exception will be re-raised.
     #
     # *Warning*: one should not catch ActiveRecord::StatementInvalid exceptions
     # inside a transaction block. ActiveRecord::StatementInvalid exceptions indicate that an
@@ -227,31 +230,31 @@ module ActiveRecord
       #   after_commit :do_bar_baz, on: [:update, :destroy]
       #
       def after_commit(*args, &block)
-        set_options_for_callbacks!(args)
+        set_options_for_callbacks!(args, prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: [ :create, :update ]</tt>.
       def after_save_commit(*args, &block)
-        set_options_for_callbacks!(args, on: [ :create, :update ])
+        set_options_for_callbacks!(args, on: [ :create, :update ], **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: :create</tt>.
       def after_create_commit(*args, &block)
-        set_options_for_callbacks!(args, on: :create)
+        set_options_for_callbacks!(args, on: :create, **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: :update</tt>.
       def after_update_commit(*args, &block)
-        set_options_for_callbacks!(args, on: :update)
+        set_options_for_callbacks!(args, on: :update, **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: :destroy</tt>.
       def after_destroy_commit(*args, &block)
-        set_options_for_callbacks!(args, on: :destroy)
+        set_options_for_callbacks!(args, on: :destroy, **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
@@ -259,11 +262,19 @@ module ActiveRecord
       #
       # Please check the documentation of #after_commit for options.
       def after_rollback(*args, &block)
-        set_options_for_callbacks!(args)
+        set_options_for_callbacks!(args, prepend_option)
         set_callback(:rollback, :after, *args, &block)
       end
 
       private
+        def prepend_option
+          if ActiveRecord.run_after_transaction_callbacks_in_order_defined
+            { prepend: true }
+          else
+            {}
+          end
+        end
+
         def set_options_for_callbacks!(args, enforced_options = {})
           options = args.extract_options!.merge!(enforced_options)
           args << options
@@ -365,6 +376,13 @@ module ActiveRecord
     private
       attr_reader :_committed_already_called, :_trigger_update_callback, :_trigger_destroy_callback
 
+      def init_internals
+        super
+        @_start_transaction_state = nil
+        @_committed_already_called = nil
+        @_new_record_before_last_commit = nil
+      end
+
       # Save the new record state and id of a record so it can be restored later if a transaction fails.
       def remember_transaction_record_state
         @_start_transaction_state ||= {
@@ -406,8 +424,16 @@ module ActiveRecord
             end
             @mutations_from_database = nil
             @mutations_before_last_save = nil
-            if @attributes.fetch_value(@primary_key) != restore_state[:id]
-              @attributes.write_from_user(@primary_key, restore_state[:id])
+            if self.class.composite_primary_key?
+              if restore_state[:id] != @primary_key.map { |col| @attributes.fetch_value(col) }
+                @primary_key.zip(restore_state[:id]).each do |col, val|
+                  @attributes.write_from_user(col, val)
+                end
+              end
+            else
+              if @attributes.fetch_value(@primary_key) != restore_state[:id]
+                @attributes.write_from_user(@primary_key, restore_state[:id])
+              end
             end
             freeze if restore_state[:frozen?]
           end