activerecord 7.0.0 → 7.2.1

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -3,8 +3,6 @@
 module ActiveRecord
   module Tasks # :nodoc:
     class SQLiteDatabaseTasks # :nodoc:
-      delegate :connection, :establish_connection, to: ActiveRecord::Base
-
       def self.using_database_configurations?
         true
       end
@@ -17,25 +15,26 @@ module ActiveRecord
       def create
         raise DatabaseAlreadyExists if File.exist?(db_config.database)
 
-        establish_connection(db_config)
+        establish_connection
         connection
       end
 
       def drop
-        require "pathname"
-        path = Pathname.new(db_config.database)
-        file = path.absolute? ? path.to_s : File.join(root, path)
-
+        db_path = db_config.database
+        file = File.absolute_path?(db_path) ? db_path : File.join(root, db_path)
         FileUtils.rm(file)
+        FileUtils.rm_f(["#{file}-shm", "#{file}-wal"])
       rescue Errno::ENOENT => error
         raise NoDatabaseError.new(error.message)
       end
 
       def purge
+        connection.disconnect!
         drop
       rescue NoDatabaseError
       ensure
         create
+        connection.reconnect!
       end
 
       def charset
@@ -49,6 +48,7 @@ module ActiveRecord
 
         ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
         if ignore_tables.any?
+          ignore_tables = connection.data_sources.select { |table| ignore_tables.any? { |pattern| pattern === table } }
           condition = ignore_tables.map { |table| connection.quote(table) }.join(", ")
           args << "SELECT sql FROM sqlite_master WHERE tbl_name NOT IN (#{condition}) ORDER BY tbl_name, type DESC, name"
         else
@@ -65,6 +65,15 @@ module ActiveRecord
       private
         attr_reader :db_config, :root
 
+        def connection
+          ActiveRecord::Base.lease_connection
+        end
+
+        def establish_connection(config = db_config)
+          ActiveRecord::Base.establish_connection(config)
+          connection.connect!
+        end
+
         def run_cmd(cmd, args, out)
           fail run_cmd_error(cmd, args) unless Kernel.system(cmd, *args, out: out)
         end

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
@@ -41,51 +55,36 @@ module ActiveRecord
 
       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
 
-        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
 
       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,
+      # to allow application logic transactions to be tested in a top-level
+      # (non-nested) context.
       def uses_transaction(*methods)
         @uses_transaction = [] unless defined?(@uses_transaction)
         @uses_transaction.concat methods.map(&:to_s)
@@ -97,95 +96,109 @@ module ActiveRecord
       end
     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
-      @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.
-      if run_in_transaction?
-        if @@already_loaded_fixtures[self.class]
-          @loaded_fixtures = @@already_loaded_fixtures[self.class]
+      def setup_fixtures(config = ActiveRecord::Base)
+        if pre_loaded_fixtures && !use_transactional_tests
+          raise RuntimeError, "pre_loaded_fixtures requires use_transactional_tests"
+        end
+
+        @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
 
+        # 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?
+          teardown_transactional_fixtures
+        else
+          ActiveRecord::FixtureSet.reset_cache
+          invalidate_already_loaded_fixtures
+        end
+
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+      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
         @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 spec_name
-            begin
-              connection = ActiveRecord::Base.connection_handler.retrieve_connection(spec_name, shard: shard)
-            rescue ConnectionNotEstablished
-              connection = nil
-            end
+          if connection_name
+            pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_name, shard: shard)
+            if pool
+              setup_shared_connection_pool
 
-            if connection && !@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.clear_active_connections!
-    end
-
-    def enlist_fixture_connections
-      setup_shared_connection_pool
-
-      ActiveRecord::Base.connection_handler.connection_pool_list.map(&:connection)
-    end
-
-    private
       # Shares the writing connection pool with connections on
       # other handlers.
       #
@@ -193,79 +206,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
@@ -283,5 +260,50 @@ module ActiveRecord
       def load_instances?
         use_instantiated_fixtures != :no_instances
       end
+
+      def method_missing(method, ...)
+        if fixture_sets.key?(method.name)
+          active_record_fixture(method, ...)
+        else
+          super
+        end
+      end
+
+      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
+
+        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/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