Merge pull request rails#54984 from rails/add-ability-to-opt-out-of-parallel-database-hooks

Implement ability to opt out of parallel database hooks

Author: eileencodes

activerecord/lib/active_record/test_databases.rb

@@ -5,11 +5,15 @@
 module ActiveRecord
   module TestDatabases # :nodoc:
     ActiveSupport::Testing::Parallelization.before_fork_hook do
-      ActiveRecord::Base.connection_handler.clear_all_connections!
+      if ActiveSupport.parallelize_test_databases
+        ActiveRecord::Base.connection_handler.clear_all_connections!
+      end
     end
 
     ActiveSupport::Testing::Parallelization.after_fork_hook do |i|
-      create_and_load_schema(i, env_name: ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
+      if ActiveSupport.parallelize_test_databases
+        create_and_load_schema(i, env_name: ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
+      end
     end
 
     def self.create_and_load_schema(i, env_name:)

activerecord/test/cases/test_databases_test.rb

@@ -53,6 +53,32 @@ def test_create_databases_after_fork
       ENV["RAILS_ENV"] = previous_env
     end
 
+    def test_create_databases_skipped_if_parallelize_test_databases_is_false
+      parallelize_databases = ActiveSupport.parallelize_test_databases
+      ActiveSupport.parallelize_test_databases = false
+
+      previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit"
+      prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, {
+        "arunit" => {
+          "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+        }
+      }
+
+      idx = 42
+      base_db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      expected_database = "#{base_db_config.database}"
+
+      ActiveSupport::Testing::Parallelization.after_fork_hooks.each { |cb| cb.call(idx) }
+
+      # In this case, there should be no updates
+      assert_equal expected_database, ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").database
+    ensure
+      ActiveSupport.parallelize_test_databases = parallelize_databases
+      ActiveRecord::Base.configurations = prev_configs
+      ActiveRecord::Base.establish_connection(:arunit)
+      ENV["RAILS_ENV"] = previous_env
+    end
+
     def test_order_of_configurations_isnt_changed_by_test_databases
       previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit"
       prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, {

activesupport/CHANGELOG.md

@@ -1,3 +1,24 @@
+*   Implement ability to skip creating parallel testing databases.
+
+    With parallel testing, Rails will create a database per process. If this isn't
+    desirable or you would like to implement databases handling on your own, you can
+    now turn off this default behavior.
+
+    To skip creating a database per process, you can change it via the
+    `parallelize` method:
+
+    ```ruby
+    parallelize(workers: 10, parallelize_databases: false)
+    ```
+
+    or via the application configuration:
+
+    ```ruby
+    config.active_support.parallelize_databases = false
+    ```
+
+    *Eileen M. Uchitelle*
+
 *   Allow to configure maximum cache key sizes
 
     When the key exceeds the configured limit (250 bytes by default), it will be truncated and

activesupport/lib/active_support.rb

@@ -104,6 +104,7 @@ def self.eager_load!
 
   cattr_accessor :test_order # :nodoc:
   cattr_accessor :test_parallelization_threshold, default: 50 # :nodoc:
+  cattr_accessor :parallelize_test_databases, default: true # :nodoc:
 
   @error_reporter = ActiveSupport::ErrorReporter.new
   singleton_class.attr_accessor :error_reporter # :nodoc:

activesupport/lib/active_support/test_case.rb

@@ -79,14 +79,27 @@ def test_order
       # Because parallelization presents an overhead, it is only enabled when the
       # number of tests to run is above the +threshold+ param. The default value is
       # 50, and it's configurable via +config.active_support.test_parallelization_threshold+.
-      def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold)
+      #
+      # If you want to skip Rails default creation of one database per process in favor of
+      # writing your own implementation, you can set +parallelize_databases+, or configure it
+      # via +config.active_support.parallelize_test_databases+.
+      #
+      #   parallelize(workers: :number_of_processes, parallelize_databases: false)
+      #
+      # Note that your test suite may deadlock if you attempt to use only one database
+      # with multiple processes.
+      def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold, parallelize_databases: ActiveSupport.parallelize_test_databases)
         case
         when ENV["PARALLEL_WORKERS"]
           workers = ENV["PARALLEL_WORKERS"].to_i
         when workers == :number_of_processors
           workers = (Concurrent.available_processor_count || Concurrent.processor_count).floor
         end
 
+        if with == :processes
+          ActiveSupport.parallelize_test_databases = parallelize_databases
+        end
+
         Minitest.parallel_executor = ActiveSupport::Testing::ParallelizeExecutor.new(size: workers, with: with, threshold: threshold)
       end
 

railties/test/application/configuration_test.rb

@@ -3204,6 +3204,20 @@ class Post < ActiveRecord::Base
       assert_equal 1234, ActiveSupport.test_parallelization_threshold
     end
 
+    test "ActiveSupport.parallelize_test_databases can be configured via config.active_support.parallelize_test_databases" do
+      remove_from_config '.*config\.load_defaults.*\n'
+
+      app_file "config/environments/test.rb", <<-RUBY
+        Rails.application.configure do
+          config.active_support.parallelize_test_databases = false
+        end
+      RUBY
+
+      app "test"
+
+      assert_not ActiveSupport.parallelize_test_databases
+    end
+
     test "custom serializers should be able to set via config.active_job.custom_serializers in an initializer" do
       class ::DummySerializer < ActiveJob::Serializers::ObjectSerializer; end