activerecord 7.1.5.1 → 8.0.2

data/lib/active_record/test_fixtures.rb

@@ -53,20 +53,6 @@ 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_paths`." if fixture_paths.blank?
@@ -79,7 +65,7 @@ module ActiveRecord
           fixture_set_names = fixture_set_names.flatten.map(&:to_s)
         end
 
-        self.fixture_table_names |= fixture_set_names
+        self.fixture_table_names = (fixture_table_names | fixture_set_names).sort
         setup_fixture_accessors(fixture_set_names)
       end
 
@@ -110,45 +96,87 @@ 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)
+    # Generic fixture accessor for fixture names that may conflict with other methods.
+    #
+    #   assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
+    #   assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+    def fixture(fixture_set_name, *fixture_names)
+      active_record_fixture(fixture_set_name, *fixture_names)
     end
 
-    def setup_fixtures(config = ActiveRecord::Base)
-      if pre_loaded_fixtures && !use_transactional_tests
-        raise RuntimeError, "pre_loaded_fixtures requires use_transactional_tests"
+    private
+      def run_in_transaction?
+        use_transactional_tests &&
+          !self.class.uses_transaction?(name)
       end
 
-      @fixture_cache = {}
-      @fixture_connections = []
-      @@already_loaded_fixtures ||= {}
-      @connection_subscriber = nil
-      @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
+      def setup_fixtures(config = ActiveRecord::Base)
+        if pre_loaded_fixtures && !use_transactional_tests
+          raise RuntimeError, "pre_loaded_fixtures requires use_transactional_tests"
+        end
 
-      # Load fixtures once and begin transaction.
-      if run_in_transaction?
-        if @@already_loaded_fixtures[self.class]
-          @loaded_fixtures = @@already_loaded_fixtures[self.class]
+        @fixture_cache = {}
+        @fixture_cache_key = [self.class.fixture_table_names.dup, self.class.fixture_paths.dup, self.class.fixture_class_names.dup]
+        @fixture_connection_pools = []
+        @@already_loaded_fixtures ||= {}
+        @connection_subscriber = nil
+        @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
+
+        if run_in_transaction?
+          # Load fixtures once and begin transaction.
+          @loaded_fixtures = @@already_loaded_fixtures[@fixture_cache_key]
+          unless @loaded_fixtures
+            @@already_loaded_fixtures.clear
+            @loaded_fixtures = @@already_loaded_fixtures[@fixture_cache_key] = load_fixtures(config)
+          end
+
+          setup_transactional_fixtures
         else
+          # Load fixtures for every test.
+          ActiveRecord::FixtureSet.reset_cache
+          invalidate_already_loaded_fixtures
           @loaded_fixtures = load_fixtures(config)
-          @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
+        setup_asynchronous_queries_session
+
+        # Instantiate fixtures for every test if requested.
+        instantiate_fixtures if use_instantiated_fixtures
+      end
+
+      def teardown_fixtures
+        teardown_asynchronous_queries_session
+
+        # Rollback changes if a transaction is active.
+        if run_in_transaction?
+          teardown_transactional_fixtures
+        else
+          ActiveRecord::FixtureSet.reset_cache
+          invalidate_already_loaded_fixtures
+        end
+
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+      end
+
+      def setup_asynchronous_queries_session
+        @_async_queries_session = ActiveRecord::Base.asynchronous_queries_tracker.start_session
+      end
+
+      def teardown_asynchronous_queries_session
+        ActiveRecord::Base.asynchronous_queries_tracker.finalize_session(true) if @_async_queries_session
+      end
+
+      def invalidate_already_loaded_fixtures
+        @@already_loaded_fixtures.clear
+      end
+
+      def setup_transactional_fixtures
+        setup_shared_connection_pool
 
         # Begin transactions for connections already established
-        @fixture_connections = enlist_fixture_connections
-        @fixture_connections.each do |connection|
-          connection.begin_transaction joinable: false, _lazy: false
-          connection.pool.lock_thread = true if lock_threads
+        @fixture_connection_pools = ActiveRecord::Base.connection_handler.connection_pool_list(:writing)
+        @fixture_connection_pools.each do |pool|
+          pool.pin_connection!(lock_threads)
+          pool.lease_connection
         end
 
         # When connections are established in the future, begin a transaction too
@@ -157,59 +185,32 @@ module ActiveRecord
           shard = payload[:shard] if payload.key?(:shard)
 
           if connection_name
-            begin
-              connection = ActiveRecord::Base.connection_handler.retrieve_connection(connection_name, shard: shard)
-            rescue ConnectionNotEstablished
-              connection = nil
-            end
-
-            if connection
+            pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_name, shard: shard)
+            if pool
               setup_shared_connection_pool
 
-              if !@fixture_connections.include?(connection)
-                connection.begin_transaction joinable: false, _lazy: false
-                connection.pool.lock_thread = true if lock_threads
-                @fixture_connections << connection
+              unless @fixture_connection_pools.include?(pool)
+                pool.pin_connection!(lock_threads)
+                pool.lease_connection
+                @fixture_connection_pools << pool
               end
             end
           end
         end
-
-      # Load fixtures for every test.
-      else
-        ActiveRecord::FixtureSet.reset_cache
-        @@already_loaded_fixtures[self.class] = nil
-        @loaded_fixtures = load_fixtures(config)
       end
 
-      # Instantiate fixtures for every test if requested.
-      instantiate_fixtures if use_instantiated_fixtures
-    end
-
-    def teardown_fixtures
-      # Rollback changes if a transaction is active.
-      if run_in_transaction?
+      def teardown_transactional_fixtures
         ActiveSupport::Notifications.unsubscribe(@connection_subscriber) if @connection_subscriber
-        @fixture_connections.each do |connection|
-          connection.rollback_transaction if connection.transaction_open?
-          connection.pool.lock_thread = false
+
+        unless @fixture_connection_pools.map(&:unpin_connection!).all?
+          # Something caused the transaction to be committed or rolled back
+          # We can no longer trust the database is in a clean state.
+          @@already_loaded_fixtures.clear
         end
-        @fixture_connections.clear
+        @fixture_connection_pools.clear
         teardown_shared_connection_pool
-      else
-        ActiveRecord::FixtureSet.reset_cache
       end
 
-      ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
-    end
-
-    def enlist_fixture_connections
-      setup_shared_connection_pool
-
-      ActiveRecord::Base.connection_handler.connection_pool_list(:writing).map(&:connection)
-    end
-
-    private
       # Shares the writing connection pool with connections on
       # other handlers.
       #
@@ -272,22 +273,30 @@ module ActiveRecord
         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)
+      def method_missing(method, ...)
+        if fixture_sets.key?(method.name)
+          active_record_fixture(method, ...)
         else
           super
         end
       end
 
-      def respond_to_missing?(name, include_private = false)
-        if include_private && fixture_sets.key?(name.to_s)
+      def respond_to_missing?(method, include_private = false)
+        if include_private && fixture_sets.key?(method.name)
           true
         else
           super
         end
       end
 
+      def active_record_fixture(fixture_set_name, *fixture_names)
+        if fs_name = fixture_sets[fixture_set_name.name]
+          access_fixture(fs_name, *fixture_names)
+        else
+          raise StandardError, "No fixture set named '#{fixture_set_name.inspect}'"
+        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

data/lib/active_record/testing/query_assertions.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Assertions
+    module QueryAssertions
+      # Asserts that the number of SQL queries executed in the given block matches the expected count.
+      #
+      #   # Check for exact number of queries
+      #   assert_queries_count(1) { Post.first }
+      #
+      #   # Check for any number of queries
+      #   assert_queries_count { Post.first }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related) are counted.
+      #
+      #   assert_queries_count(1, include_schema: true) { Post.columns }
+      #
+      def assert_queries_count(count = nil, include_schema: false, &block)
+        ActiveRecord::Base.lease_connection.materialize_transactions
+
+        counter = SQLCounter.new
+        ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+          result = _assert_nothing_raised_or_warn("assert_queries_count", &block)
+          queries = include_schema ? counter.log_all : counter.log
+          if count
+            assert_equal count, queries.size, "#{queries.size} instead of #{count} queries were executed. Queries: #{queries.join("\n\n")}"
+          else
+            assert_operator queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          end
+          result
+        end
+      end
+
+      # Asserts that no SQL queries are executed in the given block.
+      #
+      #   assert_no_queries { post.comments }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related) are counted.
+      #
+      #   assert_no_queries(include_schema: true) { Post.columns }
+      #
+      def assert_no_queries(include_schema: false, &block)
+        assert_queries_count(0, include_schema: include_schema, &block)
+      end
+
+      # Asserts that the SQL queries executed in the given block match expected pattern.
+      #
+      #   # Check for exact number of queries
+      #   assert_queries_match(/LIMIT \?/, count: 1) { Post.first }
+      #
+      #   # Check for any number of queries
+      #   assert_queries_match(/LIMIT \?/) { Post.first }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related)
+      # that match the matcher are considered.
+      #
+      #   assert_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
+      #
+      def assert_queries_match(match, count: nil, include_schema: false, &block)
+        ActiveRecord::Base.lease_connection.materialize_transactions
+
+        counter = SQLCounter.new
+        ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+          result = _assert_nothing_raised_or_warn("assert_queries_match", &block)
+          queries = include_schema ? counter.log_all : counter.log
+          matched_queries = queries.select { |query| match === query }
+
+          if count
+            assert_equal count, matched_queries.size, "#{matched_queries.size} instead of #{count} queries were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          else
+            assert_operator matched_queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          end
+
+          result
+        end
+      end
+
+      # Asserts that no SQL queries matching the pattern are executed in the given block.
+      #
+      #   assert_no_queries_match(/SELECT/i) { post.comments }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related)
+      # that match the matcher are counted.
+      #
+      #   assert_no_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
+      #
+      def assert_no_queries_match(match, include_schema: false, &block)
+        assert_queries_match(match, count: 0, include_schema: include_schema, &block)
+      end
+
+      class SQLCounter # :nodoc:
+        attr_reader :log_full, :log_all
+
+        def initialize
+          @log_full = []
+          @log_all = []
+        end
+
+        def log
+          @log_full.map(&:first)
+        end
+
+        def call(*, payload)
+          return if payload[:cached]
+
+          sql = payload[:sql]
+          @log_all << sql
+
+          unless payload[:name] == "SCHEMA"
+            bound_values = (payload[:binds] || []).map do |value|
+              value = value.value_for_database if value.respond_to?(:value_for_database)
+              value
+            end
+
+            @log_full << [sql, bound_values]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/timestamp.rb

@@ -77,7 +77,7 @@ module ActiveRecord
       end
 
       def current_time_from_proper_timezone
-        connection.default_timezone == :utc ? Time.now.utc : Time.now
+        with_connection { |c| c.default_timezone == :utc ? Time.now.utc : Time.now }
       end
 
       protected
@@ -162,7 +162,7 @@ module ActiveRecord
 
     def max_updated_column_timestamp
       timestamp_attributes_for_update_in_model
-        .filter_map { |attr| self[attr]&.to_time }
+        .filter_map { |attr| (v = self[attr]) && (v.is_a?(::Time) ? v : v.to_time) }
         .max
     end
 

data/lib/active_record/token_for.rb

@@ -35,6 +35,24 @@ module ActiveRecord
       end
     end
 
+    module RelationMethods
+      # 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 model.primary_key
+        model.token_definitions.fetch(purpose).resolve_token(token) { |id| find_by(model.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)
+        model.token_definitions.fetch(purpose).resolve_token(token) { |id| find(id) } ||
+          (raise ActiveSupport::MessageVerifier::InvalidSignature)
+      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
@@ -85,20 +103,12 @@ module ActiveRecord
         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) }
+      def find_by_token_for(purpose, token) # :nodoc:
+        all.find_by_token_for(purpose, token)
       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)
+      def find_by_token_for!(purpose, token) # :nodoc:
+        all.find_by_token_for!(purpose, token)
       end
     end
 

data/lib/active_record/touch_later.rb

@@ -64,7 +64,7 @@ module ActiveRecord
       end
 
       def has_defer_touch_attrs?
-        defined?(@_defer_touch_attrs) && @_defer_touch_attrs.present?
+        @_defer_touch_attrs.present?
       end
   end
 end

data/lib/active_record/transaction.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/digest"
+
+module ActiveRecord
+  # Class specifies the interface to interact with the current transaction state.
+  #
+  # It can either map to an actual transaction/savepoint, or represent the
+  # absence of a transaction.
+  #
+  # == State
+  #
+  # We say that a transaction is _finalized_ when it wraps a real transaction
+  # that has been either committed or rolled back.
+  #
+  # A transaction is _open_ if it wraps a real transaction that is not finalized.
+  #
+  # On the other hand, a transaction is _closed_ when it is not open. That is,
+  # when it represents absence of transaction, or it wraps a real but finalized
+  # one.
+  #
+  # You can check whether a transaction is open or closed with the +open?+ and
+  # +closed?+ predicates:
+  #
+  #  if Article.current_transaction.open?
+  #    # We are inside a real and not finalized transaction.
+  #  end
+  #
+  # Closed transactions are `blank?` too.
+  #
+  # == Callbacks
+  #
+  # After updating the database state, you may sometimes need to perform some extra work, or reflect these
+  # changes in a remote system like clearing or updating a cache:
+  #
+  #   def publish_article(article)
+  #     article.update!(published: true)
+  #     NotificationService.article_published(article)
+  #   end
+  #
+  # The above code works but has one important flaw, which is that it no longer works properly if called inside
+  # a transaction, as it will interact with the remote system before the changes are persisted:
+  #
+  #   Article.transaction do
+  #     article = create_article(article)
+  #     publish_article(article)
+  #   end
+  #
+  # The callbacks offered by ActiveRecord::Transaction allow to rewriting this method in a way that is compatible
+  # with transactions:
+  #
+  #   def publish_article(article)
+  #     article.update!(published: true)
+  #     Article.current_transaction.after_commit do
+  #       NotificationService.article_published(article)
+  #     end
+  #   end
+  #
+  # In the above example, if +publish_article+ is called inside a transaction, the callback will be invoked
+  # after the transaction is successfully committed, and if called outside a transaction, the callback will be invoked
+  # immediately.
+  #
+  # == Caveats
+  #
+  # When using after_commit callbacks, it is important to note that if the callback raises an error, the transaction
+  # won't be rolled back as it was already committed. Relying solely on these to synchronize state between multiple
+  # systems may lead to consistency issues.
+  class Transaction
+    def initialize(internal_transaction) # :nodoc:
+      @internal_transaction = internal_transaction
+      @uuid = nil
+    end
+
+    # Registers a block to be called after the transaction is fully committed.
+    #
+    # If there is no currently open transactions, the block is called
+    # immediately, unless the transaction is finalized, in which case attempting
+    # to register the callback raises ActiveRecord::ActiveRecordError.
+    #
+    # If the transaction has a parent transaction, the callback is transferred to
+    # the parent when the current transaction commits, or dropped when the current transaction
+    # is rolled back. This operation is repeated until the outermost transaction is reached.
+    #
+    # If the callback raises an error, the transaction remains committed.
+    def after_commit(&block)
+      if @internal_transaction.nil?
+        yield
+      else
+        @internal_transaction.after_commit(&block)
+      end
+    end
+
+    # Registers a block to be called after the transaction is rolled back.
+    #
+    # If there is no currently open transactions, the block is not called. But
+    # if the transaction is finalized, attempting to register the callback
+    # raises ActiveRecord::ActiveRecordError.
+    #
+    # If the transaction is successfully committed but has a parent
+    # transaction, the callback is automatically added to the parent transaction.
+    #
+    # If the entire chain of nested transactions are all successfully committed,
+    # the block is never called.
+    #
+    # If the transaction is already finalized, attempting to register a callback
+    # will raise ActiveRecord::ActiveRecordError.
+    def after_rollback(&block)
+      @internal_transaction&.after_rollback(&block)
+    end
+
+    # Returns true if the transaction exists and isn't finalized yet.
+    def open?
+      !closed?
+    end
+
+    # Returns true if the transaction doesn't exist or is finalized.
+    def closed?
+      @internal_transaction.nil? || @internal_transaction.state.finalized?
+    end
+
+    alias_method :blank?, :closed?
+
+    # Returns a UUID for this transaction or +nil+ if no transaction is open.
+    def uuid
+      if @internal_transaction
+        @uuid ||= Digest::UUID.uuid_v4
+      end
+    end
+
+    NULL_TRANSACTION = new(nil).freeze
+  end
+end