rspec-multicore-rails 0.2.0.pre1 → 0.2.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d79cf584351309d480685d78f5a6d75a6883f1dbc7567f0711723eb631222dd3
-  data.tar.gz: 43a198971e8fef686be3f859658f10c3038bc897053fc0252782dc2d71c46736
+  metadata.gz: 3c3050617c4ec5b96ff57ac77a08a685e24c0a056d9c029464ec4f950d894369
+  data.tar.gz: f87be93f0ba0d16fd7b55200bd8a955ff9f334d06a327c2970701204998694ba
 SHA512:
-  metadata.gz: ece0c46dc96d6fc0d716512a7db10b96bad1216dd8f8b1cc47aadb6e5ab0a48756efd244ce1491dca91d55e91cf3d54ce4866f917c9c7b9e0c4716f186c2ff8f
-  data.tar.gz: b01482a80460f2e5b5e3532fc210ee6c5c3c5d0e16311403934a33d1067747484f09239b92efb920da9c8585c849051e7b4eb6ce5d149613e3c314c52782cb86
+  metadata.gz: d01bc7b6b71ee1e1d6287f5b66ff075f10df202bd2abb69b566d91d89915a5c43c6e1645f7b55edeaa34808330b089689e08cc2cc4d85e31efad2abdbecfc61b
+  data.tar.gz: c423d5130794d5b5feef994b6b82a4a1aac9dea321352fe44106b6135a8c44cda8a5ebaa688f78c0689190bc0584a7a322146caaf93685daa2b5f1e2433a87d8

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.2.0.pre3
+
+- (#11) Fix Rails database lifecycle and parallel coverage for pre3
+
+## 0.2.0.pre2
+
+- Uses Rails' standard database tasks to manage worker test databases and
+  removes the prerelease custom task namespace.
+- Supports multiple writable test configurations while leaving replicas and
+  `database_tasks: false` configurations unmanaged.
+- Improves release validation and retry safety.
+
 ## 0.2.0.pre1
 
 - Uses the core worker count as the single concurrency source.

data/README.md

@@ -2,14 +2,35 @@
 
 `rspec-multicore-rails` loads `rspec-multicore` and automatically isolates ActiveRecord connections for Rails test workers.
 
-Worker 1 uses the base test database. Later workers use `_2`, `_3`, and so on; SQLite suffixes are placed before the extension. The adapter refuses non-test environments and clears inherited connections before connecting.
+## Installation
+
+```ruby
+group :test do
+  gem "rspec-multicore-rails", "0.2.0.pre3"
+end
+```
+
+Normal `Bundler.require` loading requires no `require: false`, initializer, or
+manual require. The adapter loads the matching core gem automatically.
+
+Worker 1 uses the base test database. Later workers use `_2`, `_3`, and so on;
+SQLite suffixes are placed before the extension. The adapter refuses to connect
+workers outside test and clears inherited connections before connecting.
+
+Use Rails' standard database tasks to manage the base and worker databases:
 
 ```bash
-bundle exec rake db:test:multicore:prepare
-bundle exec rake db:test:multicore:drop
-bundle exec rake db:test:multicore:recreate
+bin/rails db:prepare
+bin/rails db:test:prepare
+bin/rails db:reset
 ```
 
+Create, schema-load, prepare, purge, and drop operations extend to the extra
+worker databases whenever the Rails task includes test. Multiple writable test
+configurations are supported; replicas and configurations with
+`database_tasks: false` are not managed. No worker entries are needed in
+`database.yml`, and running RSpec never mutates the database lifecycle.
+
 The adapter does not manage Redis, Sidekiq, caches, loggers, SimpleCov, or profilers. Configure those with `RSpec::Multicore.on_worker_fork` and `on_worker_shutdown`.
 
 Requires Ruby 3.2+, Rails/ActiveRecord 7.1–8.x, and exactly the matching `rspec-multicore` version.

data/lib/rspec/multicore/rails/database_manager.rb

@@ -6,71 +6,121 @@ require "active_record/tasks/database_tasks"
 module RSpec
   module Multicore
     module Rails
-      # Names, prepares, and connects worker-owned ActiveRecord databases.
+      # Manages and connects worker-owned ActiveRecord test databases.
       class DatabaseManager
+        TEST_ENV = "test"
+
         def initialize
-          ensure_test_environment!
-          @base_config = ActiveRecord::Base.connection_db_config
+          @original_config = ActiveRecord::Base.connection_db_config
+          @configs = test_configs
+          @primary_config = canonical_config(@original_config) || @configs.first || @original_config
+          @configs << @primary_config unless @configs.include?(@primary_config)
+          @base_databases = {}.compare_by_identity
+          @configs.each { @base_databases[_1] = _1.database }
         end
 
         def connect_worker(slot)
+          ensure_test_environment!
           ActiveRecord::Base.connection_handler.clear_all_connections!
-          ActiveRecord::Base.establish_connection(config_for(slot))
+          @configs.each { _1._database = database_for(slot, _1) }
+          ActiveRecord::Base.establish_connection(@primary_config)
         end
 
-        def prepare_all
-          worker_slots.each do |slot|
-            purge(slot)
-            ActiveRecord::Tasks::DatabaseTasks.load_schema(hash_config_for(slot))
+        def create_workers(name: nil) = preserve_connection { each_worker_config(name:) { database_tasks.create(_1) } }
+
+        def purge_workers(name: nil)
+          preserve_connection do
+            each_worker_config(name:) do |config|
+              database_tasks.purge(config)
+            rescue ActiveRecord::NoDatabaseError
+              database_tasks.create(config)
+            end
           end
         end
 
-        def drop_workers = worker_slots.drop(1).each { drop(_1) }
+        def load_schema_workers(name: nil)
+          preserve_connection do
+            each_worker_config(name:) do |config|
+              establish_connection(config)
+              database_tasks.load_schema(config, schema_format(config))
+            end
+          end
+        end
+
+        def prepare_workers(name: nil)
+          purge_workers(name:)
+          load_schema_workers(name:)
+        end
+
+        def drop_workers(name: nil) = preserve_connection { each_worker_config(name:) { database_tasks.drop(_1) } }
 
         def workers = RSpec::Multicore.workers
-        def database_for(slot) = slot == 1 ? base_database : suffixed_database(slot)
+
+        def database_for(slot, config = @primary_config)
+          return base_database(config) if slot == 1
+
+          database = base_database(config)
+          return "#{database}_#{slot}" unless config.adapter == "sqlite3"
+
+          extension = File.extname(database)
+          "#{database.delete_suffix(extension)}_#{slot}#{extension}"
+        end
 
         private
 
-        def worker_slots = (1..workers)
-        def base_database = @base_config.database
+        def test_configs
+          configurations = ActiveRecord::Base.configurations
+          Array(configurations.configs_for(env_name: TEST_ENV, include_hidden: true))
+        end
+
+        def canonical_config(config) = @configs.find { _1.env_name == config.env_name && _1.name == config.name }
 
-        def suffixed_database(slot)
-          if sqlite?
-            extension = File.extname(base_database)
-            return "#{base_database.delete_suffix(extension)}_#{slot}#{extension}"
+        def task_configs(name: nil)
+          @configs.select do |config|
+            config.env_name == TEST_ENV && config.database_tasks? && (!name || config.name == name)
           end
-
-          "#{base_database}_#{slot}"
         end
 
-        def sqlite? = @base_config.adapter == "sqlite3"
+        def each_worker_config(name:)
+          return enum_for(__method__, name:) unless block_given?
 
-        def config_for(slot) = @base_config.configuration_hash.merge(database: database_for(slot))
+          task_configs(name:).each do |config|
+            2.upto(workers) { yield derived_config(config, _1) }
+          end
+        end
 
-        def hash_config_for(slot)
+        def derived_config(config, slot)
           ActiveRecord::DatabaseConfigurations::HashConfig.new(
-            @base_config.env_name,
-            @base_config.name,
-            config_for(slot)
+            config.env_name,
+            config.name,
+            config.configuration_hash.merge(database: database_for(slot, config))
           )
         end
 
-        def purge(slot)
-          drop(slot)
-          ActiveRecord::Tasks::DatabaseTasks.create(config_for(slot))
+        def base_database(config) = @base_databases.fetch(config)
+        def database_tasks = ActiveRecord::Tasks::DatabaseTasks
+
+        def preserve_connection
+          yield
+        ensure
+          establish_connection(@original_config)
         end
 
-        def drop(slot)
-          ActiveRecord::Tasks::DatabaseTasks.drop(config_for(slot))
-        rescue ActiveRecord::NoDatabaseError
-          nil
+        def establish_connection(config)
+          handler = ActiveRecord::Base.connection_handler
+          handler.establish_connection(config, clobber: true)
+        end
+
+        def schema_format(config)
+          return config.schema_format if config.respond_to?(:schema_format)
+
+          config.configuration_hash.fetch(:schema_format, ActiveRecord.schema_format)
         end
 
         def ensure_test_environment!
           return if ::Rails.env.test?
 
-          raise RSpec::Multicore::Error, "Parallel databases can only be managed in the Rails test environment"
+          raise RSpec::Multicore::Error, "Parallel databases can only be connected in the Rails test environment"
         end
       end
     end

data/lib/rspec/multicore/rails/version.rb

@@ -3,7 +3,7 @@
 module RSpec
   module Multicore
     module Rails
-      VERSION = "0.2.0.pre1"
+      VERSION = "0.2.0.pre3"
     end
   end
 end

data/lib/tasks/multicore.rake

@@ -2,27 +2,46 @@
 
 require "rspec/multicore/rails"
 
-namespace :db do
-  namespace :test do
-    namespace :multicore do
-      desc "Prepare all parallel test databases (create and load schema)"
-      task prepare: :environment do
-        manager = RSpec::Multicore::Rails::DatabaseManager.new
-        puts "Preparing parallel test databases..."
-        manager.prepare_all
-        puts "Parallel test databases ready (#{manager.workers} workers)"
-      end
+manager = -> { RSpec::Multicore::Rails::DatabaseManager.new }
+test_in_scope = lambda do
+  Rails.env.test? || (Rails.env.development? && !ENV["DATABASE_URL"] && !ENV["SKIP_TEST_DATABASE"])
+end
+allowed = lambda do |scope|
+  scope == :all || (scope == :test ? Rails.env.test? : test_in_scope.call)
+end
+
+enhance = lambda do |task_name, operation, name: nil, scope: :current|
+  next unless Rake::Task.task_defined?(task_name)
+
+  Rake::Task[task_name].enhance do
+    next unless allowed.call(scope)
+
+    manager.call.public_send(operation, name:)
+  end
+end
 
-      desc "Drop all parallel test databases (except base test database)"
-      task drop: :environment do
-        manager = RSpec::Multicore::Rails::DatabaseManager.new
-        puts "Dropping parallel test databases..."
-        manager.drop_workers
-        puts "Parallel test databases dropped"
-      end
+enhance.call("db:create", :create_workers)
+enhance.call("db:create:all", :create_workers, scope: :all)
+enhance.call("db:prepare", :prepare_workers)
+enhance.call("db:schema:load", :load_schema_workers)
+enhance.call("db:test:purge", :purge_workers, scope: :all)
+enhance.call("db:test:load_schema", :load_schema_workers, scope: :all)
+enhance.call("db:purge", :purge_workers)
+enhance.call("db:purge:all", :purge_workers, scope: :all)
+enhance.call("db:drop", :drop_workers)
+enhance.call("db:drop:all", :drop_workers, scope: :all)
 
-      desc "Recreate all parallel test databases"
-      task recreate: :prepare
-    end
+Rake::Task.tasks.map(&:name).each do |task_name|
+  case task_name
+  when /\Adb:test:purge:(.+)\z/
+    enhance.call(task_name, :purge_workers, name: Regexp.last_match(1), scope: :all)
+  when /\Adb:test:load_schema:(.+)\z/
+    enhance.call(task_name, :load_schema_workers, name: Regexp.last_match(1), scope: :all)
+  when /\Adb:create:(?!all\z)(.+)\z/
+    enhance.call(task_name, :create_workers, name: Regexp.last_match(1), scope: :test)
+  when /\Adb:schema:load:(.+)\z/
+    enhance.call(task_name, :load_schema_workers, name: Regexp.last_match(1), scope: :test)
+  when /\Adb:drop:(?!all\z|_unsafe\z)(.+)\z/
+    enhance.call(task_name, :drop_workers, name: Regexp.last_match(1), scope: :test)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-multicore-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre1
+  version: 0.2.0.pre3
 platform: ruby
 authors:
 - Sveta Markovic
@@ -55,14 +55,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.0.pre1
+        version: 0.2.0.pre3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.2.0.pre1
+        version: 0.2.0.pre3
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -120,7 +120,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 description: Rails adapter for rspec-multicore that assigns each worker an isolated
-  ActiveRecord test database and provides focused prepare, drop, and recreate tasks.
+  ActiveRecord test database through the standard Rails database-task lifecycle.
 email:
 - svetam.sd@pm.me
 executables: []