Extend all test tasks to run against every configured test database

When database.yml defines more than one top-level key starting with "test",
every standard test task (rails test, rails test:models, rails test:system,
rails test:controllers, …) is automatically rewritten at load time to run
the full suite against each configured database in turn.

Single-database setups are completely unaffected — the wrapping code
activates only when test_configs.size > 1, so existing behaviour is
preserved by default.

Convention: test: is the required primary; test_<name>: adds an adapter:
  test_sqlite:
    adapter: sqlite3
    database: db/fixinme_test.sqlite3
  test_pg:
    adapter: postgresql
    ...

Mechanism:
- lib/tasks/test_databases.rake loads after railties/testing.rake (which
  defines all test tasks). For each task in the wrapped set it calls
  Rake::Task[name].clear_actions and re-enhances with a block that loops
  over DB configs, writing a temporary database.yml per database and
  running "rails <task_name>" as a subprocess with RAILS_DATABASE_YML set.
- config/application.rb(.dist): reads RAILS_DATABASE_YML and overrides
  Rails' database config path before initialisation — no monkey-patching
  of the test runner required.
- Adapter gem availability is checked before each run; missing adapters are
  skipped with a hint on which bundle group to enable.
- A formatted summary (✓/✗ per database) is printed; exits non-zero on
  any failure.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

config/application.rb.dist

@@ -21,7 +21,7 @@ Bundler.require(*Rails.groups)
 module FixinMe
   class Application < Rails::Application
     # Allow RAILS_DATABASE_YML to override the database config file path.
-    # Used by `rails test:all_databases` to test against multiple DB adapters.
+    # Used by the multi-database test runner (lib/tasks/test_databases.rake).
     config.paths['config/database'] = [ENV['RAILS_DATABASE_YML']] if ENV['RAILS_DATABASE_YML']
 
     # Initialize configuration defaults for originally generated Rails version.

config/database.yml.dist

@@ -49,22 +49,20 @@ production:
 #  <<: *default
 #  database: fixinme_test
 
-# Multi-database testing — `bundle exec rails test:all_databases`
+# Multi-database testing
-# ---------------------------------------------------------------
+# ----------------------
-# Add any number of `test_<name>:` blocks to run the full test suite
+# Any key starting with "test" is treated as a test database.
-# against additional database adapters in a single command.
+# When more than one is present, EVERY test task (rails test, rails test:models,
-# Each adapter's gem must be available in the bundle:
+# rails test:system, …) automatically runs against all of them.
-#   bundle config --local with "mysql:sqlite"   # mysql + sqlite
-#   bundle config --local with "mysql:pg"       # mysql + postgresql
 #
-# Example — run tests against MySQL and SQLite:
+# The adapter gem must be available:
+#   bundle config --local with "mysql sqlite"   # mysql + sqlite
+#   bundle config --local with "mysql pg"       # mysql + postgresql
 #
 #test_sqlite:
 #  adapter: sqlite3
 #  database: db/fixinme_test.sqlite3
 #
-# Example — run tests against MySQL and PostgreSQL:
-#
 #test_pg:
 #  adapter: postgresql
 #  database: fixinme_test

lib/tasks/test_databases.rake

@@ -2,117 +2,157 @@ require 'yaml'
 require 'erb'
 require 'tmpdir'
 
-namespace :test do
+# Multi-database test runner
-  desc <<~DESC
+# ==========================
-    Run the full test suite against every test database configured in database.yml.
+# When database.yml contains more than one `test*` configuration, every
+# standard test task (test, test:models, test:system, …) is automatically
+# rewritten to run the full suite against EACH configured database in turn.
+#
+# Convention — any top-level key that starts with "test" and holds a Hash:
+#
+#   test:           ← required primary database
+#     adapter: mysql2
+#     database: fixinme_test
+#     ...
+#
+#   test_sqlite:    ← optional additional databases
+#     adapter: sqlite3
+#     database: db/fixinme_test.sqlite3
+#
+#   test_pg:
+#     adapter: postgresql
+#     ...
+#
+# A single-database setup is unchanged: every task behaves exactly as before.
+#
+# The mechanism uses RAILS_DATABASE_YML — an env var read by
+# config/application.rb(.dist) to override Rails' database config path before
+# initialisation, giving each subprocess a clean, isolated database config.
 
-    Any top-level key that starts with "test" and contains a Hash is treated as a
+module MultiDbTests
-    test database configuration:
+  ADAPTER_GEMS = {
-
-      test:           # always required — the primary test database
-        adapter: mysql2
-        database: fixinme_test
-        ...
-
-      test_sqlite:    # optional additional databases
-        adapter: sqlite3
-        database: db/fixinme_test.sqlite3
-
-      test_pg:
-        adapter: postgresql
-        database: fixinme_test
-        ...
-
-    For each database the task will:
-      1. Check that the required adapter gem is available (skip with warning if not).
-      2. Run `rails db:test:prepare` to create/migrate the database.
-      3. Run `rails test` and record pass/fail.
-
-    A summary is printed at the end. The task exits non-zero if any database fails.
-  DESC
-  task :all_databases do
-    db_file    = Rails.root.join('config', 'database.yml')
-    all        = YAML.safe_load(ERB.new(db_file.read).result, aliases: true) || {}
-    test_cfgs  = all.select { |k, v| k.to_s.start_with?('test') && v.is_a?(Hash) }
-    non_test   = all.reject { |k, _| k.to_s.start_with?('test') }
-
-    abort "No test database configurations found in #{db_file}." if test_cfgs.empty?
-
-    results = {}
-
-    test_cfgs.each do |name, config|
-      adapter = config['adapter'].to_s
-
-      puts "\n#{'─' * 64}"
-      puts "  #{name}  (adapter: #{adapter})"
-      puts '─' * 64
-
-      unless adapter_available?(adapter)
-        puts "  SKIPPED — gem for '#{adapter}' adapter not available in bundle."
-        puts "  Add it to Gemfile (e.g. `bundle config --local with #{adapter_group(adapter)}`)"
-        results[name] = :skipped
-        next
-      end
-
-      Dir.mktmpdir('rails_test_db_') do |tmpdir|
-        tmp_yml = File.join(tmpdir, 'database.yml')
-        # Write a standalone database.yml with just this config as `test:`
-        # (non-test configs are preserved so boot doesn't fail on `production:` lookup)
-        File.write(tmp_yml, non_test.merge('test' => config).to_yaml)
-
-        env = { 'RAILS_DATABASE_YML' => tmp_yml }
-
-        if system(env, 'bundle exec rails db:test:prepare')
-          results[name] = system(env, 'bundle exec rails test') ? :pass : :fail
-        else
-          results[name] = :prepare_failed
-        end
-      end
-    end
-
-    puts "\n#{'═' * 64}"
-    puts "  SUMMARY"
-    puts '═' * 64
-    results.each do |name, status|
-      adapter = test_cfgs[name]['adapter']
-      icon    = { pass: '✓', fail: '✗', prepare_failed: '✗', skipped: '–' }[status]
-      label   = { pass: 'PASS', fail: 'FAIL',
-                  prepare_failed: 'PREPARE FAILED', skipped: 'SKIPPED' }[status]
-      puts "  #{icon}  #{name.ljust(26)} (#{adapter.ljust(12)})  #{label}"
-    end
-    puts '═' * 64
-
-    failed = results.count { |_, s| s == :fail || s == :prepare_failed }
-    abort "\n  #{failed} database(s) failed." if failed > 0
-  end
-end
-
-private
-
-# Returns true if the gem required for this adapter is loadable.
-ADAPTER_GEMS = {
     'mysql2'      => 'mysql2',
     'sqlite3'     => 'sqlite3',
     'postgresql'  => 'pg',
     'pg'          => 'pg',
-}.freeze
+  }.freeze
 
-def adapter_available?(adapter)
+  ADAPTER_BUNDLE_GROUPS = {
-  gem_name = ADAPTER_GEMS.fetch(adapter, adapter)
-  require gem_name
-  true
-rescue LoadError
-  false
-end
-
-# Returns the Bundler group name that installs the adapter gem.
-ADAPTER_GROUPS = {
     'mysql2'      => 'mysql',
     'sqlite3'     => 'sqlite',
     'postgresql'  => 'postgresql',
     'pg'          => 'postgresql',
-}.freeze
+  }.freeze
 
-def adapter_group(adapter)
+  # Rake task names generated by railties/lib/rails/test_unit/testing.rake
-  ADAPTER_GROUPS.fetch(adapter, adapter)
+  # that use run_from_rake — these are the ones we rewrite.
+  WRAPPED_TASKS = (
+    ['test'] +
+    Rails::TestUnit::Runner::TEST_FOLDERS.map { |f| "test:#{f}" } +
+    %w[test:all test:system test:generators test:units test:functionals]
+  ).freeze
+
+  class << self
+    # Returns {name => config_hash} for every key starting with "test".
+    def test_configs
+      @test_configs ||= begin
+        db_file = Rails.root.join('config', 'database.yml')
+        all     = YAML.safe_load(ERB.new(db_file.read).result, aliases: true) || {}
+        all.select { |k, v| k.to_s.start_with?('test') && v.is_a?(Hash) }
+      end
+    end
+
+    def non_test_configs
+      @non_test_configs ||= begin
+        db_file = Rails.root.join('config', 'database.yml')
+        all     = YAML.safe_load(ERB.new(db_file.read).result, aliases: true) || {}
+        all.reject { |k, _| k.to_s.start_with?('test') }
+      end
+    end
+
+    # Run rails +task_name+ for every configured test database.
+    # Called from the rewritten rake task actions.
+    def run(task_name)
+      cfgs    = test_configs
+      results = {}
+
+      cfgs.each do |db_name, config|
+        adapter = config['adapter'].to_s
+        puts "\n#{'─' * 64}"
+        puts "  #{task_name}  ·  #{db_name}  (#{adapter})"
+        puts '─' * 64
+
+        unless adapter_available?(adapter)
+          warn "  SKIPPED — '#{adapter}' gem not in bundle.\n" \
+               "  Run: bundle config --local with \"#{current_with} #{adapter_group(adapter)}\""
+          results[db_name] = :skipped
+          next
+        end
+
+        Dir.mktmpdir('rails_test_') do |tmpdir|
+          tmp_yml = File.join(tmpdir, 'database.yml')
+          File.write(tmp_yml, non_test_configs.merge('test' => config).to_yaml)
+          env = { 'RAILS_DATABASE_YML' => tmp_yml }
+
+          if system(env, 'bundle exec rails db:test:prepare')
+            results[db_name] = system(env, 'rails', task_name) ? :pass : :fail
+          else
+            results[db_name] = :prepare_failed
+          end
+        end
+      end
+
+      print_summary(cfgs, results)
+
+      failed = results.count { |_, s| [:fail, :prepare_failed].include?(s) }
+      exit(false) if failed > 0
+    end
+
+    private
+
+    def adapter_available?(adapter)
+      require ADAPTER_GEMS.fetch(adapter, adapter)
+      true
+    rescue LoadError
+      false
+    end
+
+    def adapter_group(adapter)
+      ADAPTER_BUNDLE_GROUPS.fetch(adapter, adapter)
+    end
+
+    def current_with
+      (Bundler.settings[:with] || '').split(':').join(' ')
+    end
+
+    def print_summary(cfgs, results)
+      return if results.size <= 1  # no summary for single-DB runs
+
+      puts "\n#{'═' * 64}"
+      puts '  SUMMARY'
+      puts '═' * 64
+      results.each do |db_name, status|
+        adapter = cfgs.dig(db_name, 'adapter') || '?'
+        icon    = status == :pass ? '✓' : (status == :skipped ? '–' : '✗')
+        label   = { pass: 'PASS', fail: 'FAIL',
+                    prepare_failed: 'PREPARE FAILED', skipped: 'SKIPPED' }[status]
+        puts "  #{icon}  #{db_name.ljust(26)} (#{adapter.ljust(12)})  #{label}"
+      end
+      puts '═' * 64
+    end
+  end
+end
+
+# Rewrite every standard test task to run against all configured databases.
+# This file loads after railties/testing.rake, so all tasks already exist.
+# Single-database setups are completely unaffected.
+if MultiDbTests.test_configs.size > 1
+  MultiDbTests::WRAPPED_TASKS.each do |task_name|
+    next unless Rake::Task.task_defined?(task_name)
+
+    Rake::Task[task_name].clear_actions
+    Rake::Task[task_name].enhance do
+      MultiDbTests.run(task_name)
+    end
+  end
 end