geneva_drive 0.7.0 → 0.9.0

data/test/generators/install_generator_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rails/generators/test_case"
+require "tmpdir"
+require "generators/geneva_drive/install/install_generator"
+
+class InstallGeneratorTest < Rails::Generators::TestCase
+  tests GenevaDrive::Generators::InstallGenerator
+
+  # One directory per test: parallel workers would otherwise wipe each other's
+  # output in prepare_destination.
+  setup do
+    self.destination_root = Dir.mktmpdir("geneva_drive_install")
+    prepare_destination
+  end
+
+  teardown do
+    FileUtils.rm_rf(destination_root)
+  end
+
+  test "writes the Sidekiq dispatcher when Active Job is set up for Sidekiq" do
+    skip "Sidekiq is only in the sidekiq_* appraisals" unless defined?(::Sidekiq)
+
+    with_active_job_adapter(:sidekiq) { run_generator }
+
+    assert_file "config/initializers/geneva_drive.rb" do |content|
+      assert_match(/^GenevaDrive\.dispatcher = :sidekiq$/, content)
+      assert RubyVM::InstructionSequence.compile(content)
+    end
+  end
+
+  test "leaves the dispatcher commented out for any other adapter" do
+    [nil, :solid_queue, :test].each do |adapter|
+      prepare_destination
+      with_active_job_adapter(adapter) { run_generator }
+
+      assert_file "config/initializers/geneva_drive.rb" do |content|
+        assert_match(/^# GenevaDrive\.dispatcher = :active_job$/, content)
+        refute_match(/^GenevaDrive\.dispatcher/, content, "with adapter #{adapter.inspect}")
+        assert RubyVM::InstructionSequence.compile(content)
+      end
+    end
+  end
+
+  private
+
+  def with_active_job_adapter(adapter)
+    config = Rails.application.config.active_job
+    previous = config.queue_adapter
+    config.queue_adapter = adapter
+    yield
+  ensure
+    config.queue_adapter = previous
+  end
+end

data/test/geneva_drive_test.rb

@@ -4,4 +4,14 @@ class GenevaDriveTest < ActiveSupport::TestCase
   test "it has a version number" do
     assert GenevaDrive::VERSION
   end
+
+  test "initializer template only documents settings that exist" do
+    template = File.expand_path("../lib/generators/geneva_drive/install/templates/initializer.rb.tt", __dir__)
+    settings = File.read(template).scan(/GenevaDrive\.(\w+)\s*=/).flatten
+    refute_empty settings
+
+    settings.each do |setting|
+      assert GenevaDrive.respond_to?("#{setting}="), "GenevaDrive.#{setting} in the initializer template is not a setting"
+    end
+  end
 end

data/test/migration_helpers_test.rb

@@ -62,6 +62,68 @@ class MigrationHelpersTest < ActiveSupport::TestCase
     assert_equal :bigint, build_migration(columns).geneva_drive_key_type
   end
 
+  test "keeps :bigint for the gem tables when the app uses string ids" do
+    columns = [
+      FakeColumn.new(name: "id", sql_type: "varchar", default_function: nil),
+      FakeColumn.new(name: "id", sql_type: "varchar", default_function: nil)
+    ]
+    assert_equal :bigint, build_migration(columns).geneva_drive_key_type
+  end
+
+  # --- geneva_drive_hero_key_type ---
+
+  test "hero key type is :bigint when there are no application tables" do
+    assert_equal :bigint, build_migration.geneva_drive_hero_key_type
+  end
+
+  test "hero key type is :bigint when most tables use integer ids" do
+    columns = [
+      FakeColumn.new(name: "id", sql_type: "bigint", default_function: nil),
+      FakeColumn.new(name: "id", sql_type: "integer", default_function: nil),
+      FakeColumn.new(name: "id", sql_type: "varchar", default_function: nil)
+    ]
+    assert_equal :bigint, build_migration(columns).geneva_drive_hero_key_type
+  end
+
+  test "hero key type is :uuid when most tables use uuid ids" do
+    columns = [
+      FakeColumn.new(name: "id", sql_type: "uuid", default_function: "gen_random_uuid()"),
+      FakeColumn.new(name: "id", sql_type: "char(36)", default_function: nil),
+      FakeColumn.new(name: "id", sql_type: "bigint", default_function: nil)
+    ]
+    assert_equal :uuid, build_migration(columns).geneva_drive_hero_key_type
+  end
+
+  test "hero key type is :string for string ids of any length" do
+    ["varchar", "varchar(255)", "character varying", "char(26)", "text"].each do |sql_type|
+      columns = [FakeColumn.new(name: "id", sql_type: sql_type, default_function: nil)]
+      assert_equal :string, build_migration(columns).geneva_drive_hero_key_type, "for #{sql_type}"
+    end
+  end
+
+  test "hero key type is :string when uuid and string ids together outnumber integer ids" do
+    columns = [
+      FakeColumn.new(name: "id", sql_type: "uuid", default_function: nil),
+      FakeColumn.new(name: "id", sql_type: "varchar", default_function: nil),
+      FakeColumn.new(name: "id", sql_type: "bigint", default_function: nil)
+    ]
+    assert_equal :string, build_migration(columns).geneva_drive_hero_key_type
+  end
+
+  test "hero key type is :string for an id: :string table on SQLite" do
+    connection = ActiveRecord::Base.connection
+    skip "SQLite only" unless connection.adapter_name.downcase.include?("sqlite")
+
+    begin
+      connection.create_table(:string_id_heroes, id: :string)
+      id_column = connection.columns(:string_id_heroes).find { |c| c.name == "id" }
+      assert_equal "varchar", id_column.sql_type # no length, which the uuid regex used to miss
+      assert_equal :string, build_migration([id_column]).geneva_drive_hero_key_type
+    ensure
+      connection.drop_table(:string_id_heroes, if_exists: true)
+    end
+  end
+
   # --- geneva_drive_table_options ---
 
   test "returns empty hash for bigint key type" do

data/test/sidekiq/sidekiq_dispatcher_test.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "minitest/mock"
+
+# Sidekiq is only in the sidekiq_* appraisals; run these with `rake test:sidekiq`
+return unless defined?(::Sidekiq)
+
+# Sidekiq 8 has a new testing API; 7 only has the old require, which also
+# switches fake mode on globally. Fake mode is toggled per test below.
+begin
+  require "sidekiq/test_api"
+rescue LoadError
+  require "sidekiq/testing"
+end
+Sidekiq::Testing.disable!
+Sidekiq.logger.level = Logger::WARN
+
+class SidekiqDispatcherTest < ActiveSupport::TestCase
+  include GenevaDrive::TestHelpers
+  include ActiveJob::TestHelper
+
+  class TwoStepWorkflow < GenevaDrive::Workflow
+    step :first do
+      Thread.current[:sidekiq_steps] << :first
+    end
+
+    step :second, wait: 2.hours do
+      Thread.current[:sidekiq_steps] << :second
+    end
+  end
+
+  class QueuedWorkflow < GenevaDrive::Workflow
+    set_step_job_options queue: :workflows
+    step(:only, job_options: {queue: :urgent}) {}
+  end
+
+  class FailingWorkflow < GenevaDrive::Workflow
+    step :explode do
+      raise ArgumentError, "kaboom"
+    end
+  end
+
+  class IteratingWorkflow < GenevaDrive::Workflow
+    resumable_step :crunch do |iter|
+      iter.iterate_over((1..5).to_a) do |n|
+        Thread.current[:sidekiq_steps] << n
+      end
+    end
+  end
+
+  # Stands in for Sidekiq::TransactionAwareClient: it records that it was
+  # asked to push, and pushes nothing.
+  class RecordingClient
+    class << self
+      attr_accessor :pushes
+    end
+
+    def initialize(**)
+    end
+
+    def push(item)
+      self.class.pushes << item
+      "recorded"
+    end
+  end
+
+  # Fake mode keeps pushed jobs in memory, per job class, so none of this needs Redis.
+  setup do
+    Sidekiq::Testing.fake!
+    @previous_dispatcher = GenevaDrive.dispatcher
+    GenevaDrive.dispatcher = :sidekiq
+    Sidekiq::Job.clear_all
+    Thread.current[:sidekiq_steps] = []
+    @user = create_user
+  end
+
+  teardown do
+    GenevaDrive.dispatcher = @previous_dispatcher
+    GenevaDrive.reset_exit_request!
+    Sidekiq::Job.clear_all
+    Sidekiq::Testing.disable!
+    Thread.current[:sidekiq_steps] = nil
+  end
+
+  test "dispatcher= maps symbols to the built-in dispatchers" do
+    GenevaDrive.dispatcher = :sidekiq
+    assert_kind_of GenevaDrive::SidekiqDispatcher, GenevaDrive.dispatcher
+
+    GenevaDrive.dispatcher = :active_job
+    assert_kind_of GenevaDrive::ActiveJobDispatcher, GenevaDrive.dispatcher
+  end
+
+  test "dispatcher= rejects anything that cannot enqueue steps" do
+    error = assert_raises(ArgumentError) { GenevaDrive.dispatcher = :resque }
+    assert_match(/:active_job, :sidekiq/, error.message)
+
+    assert_raises(ArgumentError) { GenevaDrive.dispatcher = Object.new }
+    assert_raises(ArgumentError) { GenevaDrive.dispatcher = nil }
+  end
+
+  test "creating a workflow pushes a native Sidekiq job for the first step" do
+    workflow = TwoStepWorkflow.create!(hero: @user)
+    execution = workflow.step_executions.sole
+
+    jobs = GenevaDrive::SidekiqPerformStepJob.jobs
+    assert_equal 1, jobs.size
+    job = jobs.first
+
+    assert_equal "GenevaDrive::SidekiqPerformStepJob", job["class"]
+    assert_equal [execution.id], job["args"]
+    assert_equal "default", job["queue"]
+    assert_equal false, job["retry"]
+    assert_nil job["at"], "an immediate step must not wait in the schedule set"
+    assert_equal ["geneva_drive", TwoStepWorkflow.name], job["tags"]
+
+    assert_equal job["jid"], execution.reload.job_id
+  end
+
+  test "nothing goes through Active Job" do
+    assert_no_enqueued_jobs do
+      TwoStepWorkflow.create!(hero: @user)
+    end
+  end
+
+  test "a step with wait: is pushed with an at timestamp" do
+    workflow = TwoStepWorkflow.create!(hero: @user)
+    GenevaDrive::SidekiqPerformStepJob.perform_one
+
+    second = workflow.step_executions.find_by!(step_name: "second")
+    job = GenevaDrive::SidekiqPerformStepJob.jobs.sole
+
+    assert_equal [second.id], job["args"]
+    assert_in_delta second.scheduled_for.to_f, job["at"], 1.0
+  end
+
+  test "queue options reach the pushed job, step options winning" do
+    QueuedWorkflow.create!(hero: @user)
+    assert_equal "urgent", GenevaDrive::SidekiqPerformStepJob.jobs.sole["queue"]
+  end
+
+  test "draining the queue runs the workflow to the end" do
+    workflow = TwoStepWorkflow.create!(hero: @user)
+
+    # The fake queue ignores "at", so the delayed step runs as soon as drained
+    GenevaDrive::SidekiqPerformStepJob.drain
+
+    assert_equal [:first, :second], Thread.current[:sidekiq_steps]
+    assert workflow.reload.finished?
+  end
+
+  test "a step's exception reaches Sidekiq after the executor has settled the step" do
+    workflow = FailingWorkflow.create!(hero: @user)
+
+    error = assert_raises(ArgumentError) { GenevaDrive::SidekiqPerformStepJob.perform_one }
+    assert_equal "kaboom", error.message
+
+    execution = workflow.step_executions.sole.reload
+    assert_equal "failed", execution.state
+    assert_empty GenevaDrive::SidekiqPerformStepJob.jobs, "no Sidekiq retry is queued"
+  end
+
+  test "a job for a vanished step execution is a no-op" do
+    job = GenevaDrive::SidekiqPerformStepJob.new
+    job.stub(:sleep, ->(_delay) {}) do
+      assert_nothing_raised { job.perform(999_999_999) }
+    end
+  end
+
+  test "pushes skip the client_class that perform_async would use" do
+    # Sidekiq.transactional_push! works by installing a client_class. We push
+    # through Sidekiq::Client directly, so it never sees our jobs.
+    RecordingClient.pushes = []
+    options = Sidekiq.default_job_options
+    previous = options["client_class"]
+    options["client_class"] = RecordingClient
+
+    begin
+      TwoStepWorkflow.create!(hero: @user)
+    ensure
+      previous ? options["client_class"] = previous : options.delete("client_class")
+    end
+
+    assert_empty RecordingClient.pushes
+    assert_equal 1, GenevaDrive::SidekiqPerformStepJob.jobs.size
+  end
+
+  test "a custom job class can be supplied" do
+    custom_job = Class.new(GenevaDrive::SidekiqPerformStepJob) do
+      sidekiq_options queue: "workflows", tags: ["billing"]
+    end
+    GenevaDrive.dispatcher = GenevaDrive::SidekiqDispatcher.new(job_class: custom_job)
+
+    RecordingClient.pushes = []
+    Sidekiq::Client.stub(:new, RecordingClient.new) do
+      TwoStepWorkflow.create!(hero: @user)
+    end
+
+    item = RecordingClient.pushes.sole
+    assert_equal custom_job, item["class"]
+    assert_equal ["billing", TwoStepWorkflow.name], item["tags"]
+    refute item.key?("queue"), "the class's own queue applies when no queue option is set"
+  end
+
+  test "priority is rejected under the Sidekiq dispatcher" do
+    error = assert_raises(GenevaDrive::StepConfigurationError) do
+      Class.new(GenevaDrive::Workflow) { set_step_job_options priority: 5 }
+    end
+    assert_match(/queues with weights/, error.message)
+
+    assert_raises(GenevaDrive::StepConfigurationError) do
+      Class.new(GenevaDrive::Workflow) { step(:s, job_options: {priority: 1}) {} }
+    end
+  end
+
+  test "priority stays allowed under the Active Job dispatcher" do
+    GenevaDrive.dispatcher = :active_job
+    assert_nothing_raised do
+      Class.new(GenevaDrive::Workflow) { set_step_job_options priority: 5 }
+    end
+  end
+
+  test "housekeeping runs as a Sidekiq job" do
+    result = GenevaDrive::SidekiqHousekeepingJob.new.perform
+    assert_kind_of Hash, result
+    assert result.key?(:stuck_scheduled_recovered)
+    assert_equal false, GenevaDrive::SidekiqHousekeepingJob.get_sidekiq_options["retry"]
+  end
+
+  test "a shutdown request hands a resumable step off to a successor" do
+    workflow = IteratingWorkflow.create!(hero: @user)
+    first = workflow.step_executions.sole
+
+    GenevaDrive.request_exit!
+    GenevaDrive::SidekiqPerformStepJob.perform_one
+
+    assert_operator Thread.current[:sidekiq_steps].size, :<, 5, "the step must stop early"
+    assert_equal "completed", first.reload.state
+
+    successor = workflow.step_executions.find_by!(continues_from_id: first.id)
+    assert_equal "scheduled", successor.state
+    assert_equal [successor.id], GenevaDrive::SidekiqPerformStepJob.jobs.sole["args"]
+
+    GenevaDrive.reset_exit_request!
+    GenevaDrive::SidekiqPerformStepJob.drain
+    assert_equal [1, 2, 3, 4, 5], Thread.current[:sidekiq_steps], "the successor picks up from the cursor"
+    assert workflow.reload.finished?
+  end
+
+  test "Sidekiq is recommended when Active Job is pointed at Sidekiq" do
+    sidekiq_adapter = Class.new { def self.name = "ActiveJob::QueueAdapters::SidekiqAdapter" }
+    [:sidekiq, "sidekiq", sidekiq_adapter.new].each do |adapter|
+      assert GenevaDrive::SidekiqDispatcher.recommended?(adapter), "with adapter #{adapter.inspect}"
+    end
+  end
+
+  test "Sidekiq is not recommended for any other adapter, or none" do
+    # Unset is the common case in development, where the generator runs, even
+    # for apps that use Solid Queue in production.
+    [nil, :async, :inline, :test, :solid_queue, :good_job, ActiveJob::QueueAdapters::AsyncAdapter.new].each do |adapter|
+      refute GenevaDrive::SidekiqDispatcher.recommended?(adapter), "with adapter #{adapter.inspect}"
+    end
+  end
+
+  test "an unset dispatcher is Active Job even where Sidekiq would be recommended" do
+    with_active_job_adapter(:sidekiq) do
+      GenevaDrive.instance_variable_set(:@dispatcher, nil)
+      assert_kind_of GenevaDrive::ActiveJobDispatcher, GenevaDrive.dispatcher
+    end
+  end
+
+  test "the supported Sidekiq versions are 7.3 up to, not including, 9" do
+    supported = GenevaDrive::SidekiqDispatcher::SUPPORTED_SIDEKIQ_VERSIONS
+    %w[7.3.0 7.3.10 8.0.0 8.1.7].each { |v| assert supported.satisfied_by?(Gem::Version.new(v)), v }
+    %w[6.5.12 7.2.4 9.0.0].each { |v| refute supported.satisfied_by?(Gem::Version.new(v)), v }
+    assert GenevaDrive::SidekiqDispatcher.supported_sidekiq_version?, "the bundled Sidekiq must be supported"
+  end
+
+  test "the Sidekiq dispatcher refuses an unsupported Sidekiq" do
+    GenevaDrive::SidekiqDispatcher.stub(:supported_sidekiq_version?, false) do
+      error = assert_raises(ArgumentError) { GenevaDrive::SidekiqDispatcher.new }
+      assert_match(Sidekiq::VERSION, error.message)
+      assert_match(/>= 7\.3/, error.message)
+    end
+  end
+
+  test "Sidekiq is not recommended when the loaded version is unsupported" do
+    GenevaDrive::SidekiqDispatcher.stub(:supported_sidekiq_version?, false) do
+      refute GenevaDrive::SidekiqDispatcher.recommended?(:sidekiq)
+    end
+  end
+
+  # Runs the initializer block against a stand-in config; a real `sidekiq`
+  # boot is not part of the suite.
+  test "the engine wires Sidekiq's quiet event to the shutdown request" do
+    initializer = GenevaDrive::Engine.instance.initializers.find { |i| i.name == "geneva_drive.sidekiq_lifecycle" }
+    assert initializer, "expected the lifecycle initializer to exist"
+
+    events = {}
+    fake_config = Object.new
+    fake_config.define_singleton_method(:on) { |event, &block| events[event] = block }
+
+    Sidekiq.stub(:configure_server, ->(&blk) { blk.call(fake_config) }) do
+      initializer.run(Rails.application)
+    end
+
+    refute GenevaDrive.exit_requested?
+    events.fetch(:quiet).call
+    assert GenevaDrive.exit_requested?
+  end
+
+  private
+
+  def with_active_job_adapter(adapter)
+    config = Rails.application.config.active_job
+    previous = config.queue_adapter
+    config.queue_adapter = adapter
+    yield
+  ensure
+    config.queue_adapter = previous
+  end
+end

data/test/sidekiq/sidekiq_redis_test.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Sidekiq is only in the sidekiq_* appraisals; run these with `rake test:sidekiq`
+return unless defined?(::Sidekiq)
+
+begin
+  require "sidekiq/test_api"
+rescue LoadError
+  require "sidekiq/testing"
+end
+require "sidekiq/api"
+
+# The Sidekiq dispatcher against a real Redis, end to end: real commits,
+# GenevaDrive's own after-commit deferral switched on, and Sidekiq's
+# transactional push installed - the combination the dispatcher exists to
+# get right. Runs only where GENEVA_DRIVE_SIDEKIQ_REDIS_URL is set, which the
+# Sidekiq CI workflow does; the main CI has no Redis and skips these.
+class SidekiqRedisTest < ActiveSupport::TestCase
+  REDIS_URL = ENV["GENEVA_DRIVE_SIDEKIQ_REDIS_URL"]
+
+  # after_all_transactions_commit never fires inside a test transaction
+  self.use_transactional_tests = false
+
+  class CheckoutWorkflow < GenevaDrive::Workflow
+    step :reserve_stock do
+      Thread.current[:sidekiq_redis_steps] << :reserve_stock
+    end
+
+    step :send_reminder, wait: 2.hours do
+      Thread.current[:sidekiq_redis_steps] << :send_reminder
+    end
+
+    # A queue of its own per test, so nothing else in this Redis is touched
+    private def merged_step_job_options(step_definition)
+      super.merge(queue: Thread.current[:sidekiq_redis_test_queue])
+    end
+  end
+
+  setup do
+    skip "Set GENEVA_DRIVE_SIDEKIQ_REDIS_URL to run these" unless REDIS_URL
+
+    Sidekiq.configure_client { |config| config.redis = {url: REDIS_URL} }
+    Sidekiq::Testing.disable!
+
+    @queue = Thread.current[:sidekiq_redis_test_queue] = "geneva_drive_test_#{SecureRandom.hex(6)}"
+    Thread.current[:sidekiq_redis_steps] = []
+    @previous_dispatcher = GenevaDrive.dispatcher
+    @previous_deferral = GenevaDrive.enqueue_after_commit
+    GenevaDrive.dispatcher = :sidekiq
+    GenevaDrive.enqueue_after_commit = true
+    @user = create_user
+  end
+
+  teardown do
+    next unless REDIS_URL
+
+    jids = GenevaDrive::StepExecution.where(workflow: @workflow).pluck(:job_id).compact if @workflow
+    Array(jids).each { |jid| Sidekiq::ScheduledSet.new.scan(jid).each(&:delete) }
+    Sidekiq::Queue.new(@queue).clear
+
+    @workflow&.step_executions&.delete_all
+    @workflow&.delete
+    @user&.delete
+
+    Sidekiq.default_job_options.delete("client_class")
+    GenevaDrive.dispatcher = @previous_dispatcher
+    GenevaDrive.enqueue_after_commit = @previous_deferral
+    Thread.current[:sidekiq_redis_test_queue] = nil
+    Thread.current[:sidekiq_redis_steps] = nil
+  end
+
+  test "a workflow created in a transaction lands in Redis once, after the commit" do
+    Sidekiq.transactional_push!
+
+    ActiveRecord::Base.transaction do
+      @workflow = CheckoutWorkflow.create!(hero: @user)
+      assert_equal 0, Sidekiq::Queue.new(@queue).size, "nothing may be pushed before the commit"
+    end
+
+    jobs = Sidekiq::Queue.new(@queue).to_a
+    assert_equal 1, jobs.size
+
+    execution = @workflow.step_executions.sole
+    assert_equal "GenevaDrive::SidekiqPerformStepJob", jobs.first.klass
+    assert_equal [execution.id], jobs.first.args
+    assert_equal jobs.first.jid, execution.reload.job_id
+  end
+
+  test "a step job taken off the queue runs the step and schedules the next one" do
+    @workflow = CheckoutWorkflow.create!(hero: @user)
+
+    perform(Sidekiq::Queue.new(@queue).first)
+    assert_equal [:reserve_stock], Thread.current[:sidekiq_redis_steps]
+
+    reminder = @workflow.step_executions.find_by!(step_name: "send_reminder")
+    scheduled = Sidekiq::ScheduledSet.new.scan(reminder.job_id).first
+    assert scheduled, "the delayed step must wait in the Scheduled set"
+    assert_in_delta reminder.scheduled_for.to_f, scheduled.score, 1.0
+
+    perform(scheduled)
+    assert_equal [:reserve_stock, :send_reminder], Thread.current[:sidekiq_redis_steps]
+    assert @workflow.reload.finished?
+  end
+
+  private
+
+  # What a Sidekiq processor does with a job, minus the fetching: delete it
+  # and run it with the arguments that went through Redis as JSON.
+  def perform(record)
+    record.delete
+    record.klass.constantize.new.perform(*record.args)
+  end
+end

data/test/test_helper.rb

@@ -7,29 +7,52 @@ require_relative "../test/dummy/config/environment"
 ActiveRecord::Migrator.migrations_paths = [File.expand_path("../test/dummy/db/migrate", __dir__)]
 ActiveRecord::Migrator.migrations_paths << File.expand_path("../db/migrate", __dir__)
 
-# Ensure GenevaDrive migrations exist and database is prepared.
-# The generator is the single source of truth for migrations.
+# Bring the dummy app's database in line with the migrations the install
+# generator produces, recreating it from scratch whenever it has drifted.
+#
+# Rebuilding rather than migrating forward is deliberate. The generated
+# migrations are gitignored and get fresh timestamps every time they are
+# regenerated, so a database left behind by an earlier generation records
+# versions that no longer exist on disk: every migration reads as pending, and
+# replaying them onto the existing tables just fails on "table already exists".
 unless defined?(GENEVA_DRIVE_TEST_DB_PREPARED)
   GENEVA_DRIVE_TEST_DB_PREPARED = true
 
   dummy_root = File.expand_path("../test/dummy", __dir__)
-  migrations = Dir.glob("#{dummy_root}/db/migrate/*geneva_drive*.rb")
-  tables_exist = begin
-    ActiveRecord::Base.connection.table_exists?("geneva_drive_workflows")
-  rescue
-    false
-  end
+  db_config = ActiveRecord::Base.connection_db_config
+  # Adapter-specific, and deliberately so - see the comment in the dummy app's
+  # config/database.yml. Ask Rails for the path rather than rebuilding it here.
+  schema_file = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(db_config)
 
-  if migrations.empty? && !tables_exist
+  # The generator is the single source of truth for migrations.
+  if Dir.glob("#{dummy_root}/db/migrate/*geneva_drive*.rb").empty?
     puts "Generating GenevaDrive migrations..."
     Dir.chdir(dummy_root) do
       system("bin/rails", "generate", "geneva_drive:install", "--skip") || abort("Failed to generate migrations")
-      system("bin/rails", "db:migrate") || abort("Failed to run migrations")
     end
-  elsif migrations.any? && !tables_exist
-    puts "Running pending migrations..."
+  end
+
+  on_disk = Dir.glob("#{dummy_root}/db/migrate/*.rb").map { |path| File.basename(path)[/\A\d+/] }
+  applied = begin
+    ActiveRecord::Base.connection.select_values("SELECT version FROM schema_migrations").map(&:to_s)
+  rescue
+    [] # No database, or no schema_migrations in it yet
+  end
+
+  if (on_disk - applied).any? || !File.exist?(schema_file)
+    puts "Recreating the #{db_config.adapter} test database..."
+    # db:migrate seeds an empty database from the schema dump before applying
+    # anything, so the outdated dump has to go first - otherwise it recreates
+    # exactly the tables the migrations are about to create.
+    File.delete(schema_file) if File.exist?(schema_file)
+    # bin/rails cannot drop a database this process still holds a connection to.
+    ActiveRecord::Base.connection_handler.clear_all_connections!
     Dir.chdir(dummy_root) do
-      system("bin/rails", "db:prepare") || abort("Failed to prepare database")
+      # One bin/rails per task, deliberately. Asking a single process to drop,
+      # recreate and migrate carries its column cache across the drop, and the
+      # schema it then dumps silently loses column defaults.
+      system("bin/rails", "db:drop") || abort("Failed to drop the test database")
+      system("bin/rails", "db:prepare") || abort("Failed to recreate the test database")
     end
   end
 end
@@ -44,6 +67,21 @@ if ActiveSupport::TestCase.respond_to?(:fixture_paths=)
   ActiveSupport::TestCase.fixtures :all
 end
 
+# Rails 8.1 clears Active Record's connections before forking the parallel test
+# workers. 7.2 and 8.0 fork with them still open, and a libpq connection
+# inherited across the fork takes the child down with a segfault in
+# PG::Connection#connect_start as it opens its own - a race, so it only bites
+# some of the time, which makes it maddening rather than merely broken. Where
+# upstream has no pre-fork hook to register on, wrap the fork point itself.
+unless ActiveSupport::Testing::Parallelization.respond_to?(:before_fork_hook)
+  ActiveSupport::Testing::Parallelization.prepend(Module.new do
+    def start
+      ActiveRecord::Base.connection_handler.clear_all_connections!
+      super
+    end
+  end)
+end
+
 # Test helper methods
 class ActiveSupport::TestCase
   # Run tests in parallel with specified workers

data/test/workflow/pause_resume_test.rb

@@ -284,6 +284,21 @@ class PauseResumeTest < ActiveSupport::TestCase
     end
   end
 
+  test "resume! records the re-enqueued job's id on the execution" do
+    workflow = WaitingWorkflow.create!(hero: @user)
+    perform_next_step(workflow)
+    execution = workflow.step_executions.find_by!(step_name: "step_two", state: "scheduled")
+    original_job_id = execution.job_id
+    assert original_job_id
+
+    workflow.pause!
+    workflow.resume!
+
+    assert_equal execution.id, workflow.current_execution.id
+    refute_equal original_job_id, execution.reload.job_id,
+      "the row must point at the job resume! pushed, not the one that may already have run"
+  end
+
   # Scenario: Resume with SCHEDULED execution now OVERDUE
   #
   # Workflow was paused, time passed, the scheduled time went by.