good_pipeline 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 350a7e051f704db8ee906a90bb8f641f1373be815aceb9adccc8cd17b2d38640
-  data.tar.gz: f0cebfb8f77d35e043df87e71e5698b4e6ec08a468d95702a5a3a489eb1debf9
+  metadata.gz: 38ec7eb9fb3cec2b9109b9695b0084aff2fa111440cd8fb76dbe53be59bd8e06
+  data.tar.gz: 71094436abc0d2c393b3d188510608bf714867201f2fc13eac4cc218d6b8a420
 SHA512:
-  metadata.gz: 682725126bc0643cd8ec88d249ef7e93b760d646a4aac30cbb693c1bde6d1c0b3d30494623eb5ffed8cc2845f62dc3642501648bf65cbf3adc43577f13734270
-  data.tar.gz: 5e2aae2df9e5b8997b85a4aff15d0989fa24f27b6e607332d82421c5e5b33d0a4171e455ddc04eab71f790657fe9f71d59b412b7ffa054b7f15c60148b1a1536
+  metadata.gz: c3520cff350de86f2d2820d7a4406f2b81407079c1d00ee8ecfc4dff02e23f54dcedb1ae61d3a32594a4680b111b4b127fe2808ecf08c4705c4e0732e04643b9
+  data.tar.gz: 2a91e6a2b050392b6e5e8c1af31bd93a8e05fe5d23f1f940d0bbe97df59c381b7286bf10a8f3590789b342d079d66b9e1c1433e00a03eaa42d31c277e8e6218f

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [Unreleased]
 
+## [0.4.0] - 2026-04-02
+
+### Performance
+
+- **Bulk root step enqueuing** — pipelines with multiple root steps now enqueue all of them via `GoodJob::Batch.enqueue_all` in a fixed number of queries instead of ~9 queries per step. Both `Runner#enqueue_root_steps` and `ChainCoordinator#start_pipeline` use the new `Coordinator.bulk_enqueue_steps` method.
+
+### Added
+
+- **Configurable queue names for internal jobs** — new `coordination_queue_name` and `callback_queue_name` settings control which queues `StepFinishedJob`, `PipelineReconciliationJob`, and `PipelineCallbackJob` run on. Configurable globally (`GoodPipeline.coordination_queue_name = "x"`) and per-pipeline via the class DSL. Defaults to `"good_pipeline_coordination"` and `"good_pipeline_callbacks"`.
+- **`Coordinator.bulk_enqueue_steps`** — public method that loads pending steps, partitions branch steps for individual handling, and bulk-enqueues the rest via `Batch.enqueue_all`. Invalid job classes are failed individually without blocking valid steps.
+
+### Changed
+
+- **Minimum GoodJob version** — bumped from `>= 3.10` to `>= 4.14` (required for `Batch.enqueue_all`).
+- **`run_pipeline_to_completion` test helper** — extracted from 3 integration test files into `test_helper.rb`.
+
+## [0.3.1] - 2026-03-26
+
+### Added
+
+- **`halt_pipeline!`** — call from any job to stop the pipeline early with a `succeeded` status. The halting step is marked `halted`, remaining pending steps are `skipped`, and the `on_success` callback fires. The GoodJob record completes as succeeded (no error, no discard). Available in all jobs via `GoodPipeline::Haltable`, included automatically by the Engine.
+- **`halted` coordination status** — new terminal step status for steps that called `halt_pipeline!`. Treated as satisfied for downstream dependency resolution.
+- **`halt_requested` column** — boolean column on steps table, set by `halt_pipeline!` and checked by the coordinator on step completion.
+- **`good_job_id` index** — partial unique index on `good_job_id` for fast step lookup from within jobs.
+
 ## [0.3.0] - 2026-03-25
 
 ### Performance

data/README.md

@@ -2,7 +2,7 @@
 
 DAG-based job pipeline orchestration for Rails, built on [GoodJob](https://github.com/bensheldon/good_job).
 
-Define multi-step workflows as directed acyclic graphs, where each step is a GoodJob job. GoodPipeline handles dependency resolution, parallel execution, failure strategies, pipeline chaining, and lifecycle callbacks. It also ships with a web dashboard.
+Define multi-step workflows as directed acyclic graphs — not linear chains. Steps run in parallel when they can and wait for dependencies when they must. GoodPipeline handles dependency resolution, parallel execution, failure strategies, conditional branching, pipeline chaining, and lifecycle callbacks. It also ships with a web dashboard.
 
 ## Requirements
 

data/app/helpers/good_pipeline/mermaid_diagram_builder.rb

@@ -15,6 +15,7 @@ module GoodPipeline
       "  classDef failed fill:#f44336,color:#fff",
       "  classDef skipped fill:#bdbdbd,color:#333",
       "  classDef skipped_by_branch fill:#bdbdbd,color:#333",
+      "  classDef halted fill:#8bc34a,color:#fff",
       "  classDef branch fill:#ff9800,color:#fff,stroke:#f57c00",
       "  classDef terminal fill:#1a1a2e,color:#fff,stroke:#1a1a2e"
     ].freeze

data/app/models/good_pipeline/step_record.rb

@@ -7,11 +7,11 @@ module GoodPipeline
   class StepRecord < ActiveRecord::Base
     self.table_name = "good_pipeline_steps"
 
-    TERMINAL_COORDINATION_STATUSES = %w[succeeded failed skipped skipped_by_branch].freeze
+    TERMINAL_COORDINATION_STATUSES = %w[succeeded failed skipped skipped_by_branch halted].freeze
 
     VALID_COORDINATION_TRANSITIONS = {
-      "pending" => %w[enqueued skipped skipped_by_branch succeeded failed],
-      "enqueued" => %w[succeeded failed]
+      "pending" => %w[enqueued skipped skipped_by_branch succeeded failed halted],
+      "enqueued" => %w[succeeded failed halted]
     }.freeze
 
     enum :coordination_status, {
@@ -20,7 +20,8 @@ module GoodPipeline
       succeeded: "succeeded",
       failed: "failed",
       skipped: "skipped",
-      skipped_by_branch: "skipped_by_branch"
+      skipped_by_branch: "skipped_by_branch",
+      halted: "halted"
     }
 
     enum :on_failure_strategy, { halt: "halt", continue: "continue", ignore: "ignore" }

data/demo/app/jobs/halt_execution_job.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class HaltExecutionJob < ApplicationJob
+  def perform(**)
+    halt_pipeline!
+  end
+end

data/demo/db/migrate/20260319205326_create_good_pipeline_tables.rb

@@ -31,6 +31,7 @@ class CreateGoodPipelineTables < ActiveRecord::Migration[8.1]
       t.uuid :good_job_batch_id
       t.uuid :good_job_id
       t.integer :pending_upstream_count, null: false, default: 0
+      t.boolean :halt_requested, null: false, default: false
       t.integer :attempts
       t.string :error_class
       t.text :error_message
@@ -40,6 +41,7 @@ class CreateGoodPipelineTables < ActiveRecord::Migration[8.1]
 
     add_index :good_pipeline_steps, %i[pipeline_id key], unique: true
     add_index :good_pipeline_steps, :coordination_status
+    add_index :good_pipeline_steps, :good_job_id, unique: true, where: "good_job_id IS NOT NULL"
 
     create_table :good_pipeline_dependencies do |t|
       t.references :pipeline, null: false, foreign_key: { to_table: :good_pipeline_pipelines }, type: :uuid

data/demo/test/good_pipeline/test_bulk_enqueue.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestBulkEnqueue < ActiveSupport::TestCase
+  # --- basic enqueuing ---
+
+  def test_enqueues_multiple_steps
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "step_a", job_class: "DownloadJob")
+    step_b = build_step(pipeline, key: "step_b", job_class: "TranscodeJob")
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step_a.id, step_b.id])
+
+    step_a.reload
+    step_b.reload
+
+    assert_equal "enqueued", step_a.coordination_status
+    assert_equal "enqueued", step_b.coordination_status
+    refute_nil step_a.good_job_batch_id
+    refute_nil step_b.good_job_batch_id
+    refute_nil step_a.good_job_id
+    refute_nil step_b.good_job_id
+  end
+
+  def test_each_step_gets_its_own_batch
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "step_a", job_class: "DownloadJob")
+    step_b = build_step(pipeline, key: "step_b", job_class: "TranscodeJob")
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step_a.id, step_b.id])
+
+    refute_equal step_a.reload.good_job_batch_id, step_b.reload.good_job_batch_id
+  end
+
+  def test_good_job_id_points_to_real_job_record
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step = build_step(pipeline, key: "step_a", job_class: "DownloadJob")
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step.id])
+
+    step.reload
+    good_job = GoodJob::Job.find_by(id: step.good_job_id)
+
+    refute_nil good_job, "good_job_id should point to a real GoodJob::Job record"
+    assert_equal step.good_job_batch_id, good_job.batch_id
+  end
+
+  # --- batch callback setup ---
+
+  def test_batch_has_step_finished_callback
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step = build_step(pipeline, key: "step_a", job_class: "DownloadJob")
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step.id])
+
+    batch_record = GoodJob::BatchRecord.find(step.reload.good_job_batch_id)
+
+    assert_equal "GoodPipeline::StepFinishedJob", batch_record.on_finish
+    assert_equal({ step_id: step.id }, batch_record.properties)
+  end
+
+  # --- enqueue_options ---
+
+  def test_respects_queue_and_priority_options
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step = build_step(pipeline, key: "step_a", job_class: "DownloadJob",
+                      enqueue_options: { "queue" => "critical", "priority" => 3 })
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step.id])
+
+    good_job = GoodJob::Job.find_by(id: step.reload.good_job_id)
+
+    assert_equal "critical", good_job.queue_name
+    assert_equal 3, good_job.priority
+  end
+
+  def test_respects_wait_option
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step = build_step(pipeline, key: "step_a", job_class: "DownloadJob",
+                      enqueue_options: { "wait" => 300 })
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step.id])
+
+    good_job = GoodJob::Job.find_by(id: step.reload.good_job_id)
+
+    refute_nil good_job.scheduled_at
+    assert_in_delta 300, good_job.scheduled_at - good_job.created_at, 5
+  end
+
+  def test_passes_step_params_to_job
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step = build_step(pipeline, key: "step_a", job_class: "DownloadJob",
+                      params: { "video_id" => 42 })
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step.id])
+
+    good_job = GoodJob::Job.find_by(id: step.reload.good_job_id)
+    arguments = good_job.serialized_params["arguments"]
+
+    assert_equal 42, arguments.first["video_id"]
+  end
+
+  def test_handles_empty_params
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step = build_step(pipeline, key: "step_a", job_class: "DownloadJob", params: {})
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step.id])
+
+    assert_equal "enqueued", step.reload.coordination_status
+  end
+
+  # --- guard clauses ---
+
+  def test_skips_non_pending_steps
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "step_a", job_class: "DownloadJob")
+    step_a.update_columns(coordination_status: "enqueued")
+    step_b = build_step(pipeline, key: "step_b", job_class: "TranscodeJob")
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step_a.id, step_b.id])
+
+    assert_equal "enqueued", step_b.reload.coordination_status
+    refute_nil step_b.good_job_id
+    assert_nil step_a.reload.good_job_id, "Non-pending step should not have been re-enqueued"
+  end
+
+  def test_skips_steps_with_good_job_id
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "step_a", job_class: "DownloadJob")
+    existing_job_id = SecureRandom.uuid
+    step_a.update_columns(good_job_id: existing_job_id)
+    step_b = build_step(pipeline, key: "step_b", job_class: "TranscodeJob")
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([step_a.id, step_b.id])
+
+    assert_equal "enqueued", step_b.reload.coordination_status
+    assert_equal existing_job_id, step_a.reload.good_job_id, "Step with good_job_id should be left alone"
+  end
+
+  def test_handles_empty_array
+    # Should not raise
+    result = GoodPipeline::Coordinator.bulk_enqueue_steps([])
+    assert_nil result
+  end
+
+  # --- branch step fallback ---
+
+  def test_falls_back_to_try_enqueue_step_for_branch_steps
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    branch_step = build_step(pipeline, key: "format_check",
+                             job_class: GoodPipeline::BRANCH_JOB_CLASS)
+    branch_step.update_columns(branch: { "decides" => "pick_format", "empty_arms" => %w[hd sd] })
+    normal_step = build_step(pipeline, key: "step_a", job_class: "DownloadJob")
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([branch_step.id, normal_step.id])
+
+    assert_equal "enqueued", normal_step.reload.coordination_status
+    refute_nil normal_step.good_job_id
+
+    branch_step.reload
+    refute_equal "pending", branch_step.coordination_status,
+                 "Branch step should have been processed by try_enqueue_step fallback"
+  end
+
+  # --- error handling ---
+
+  def test_invalid_job_class_fails_step_without_blocking_others
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    bad_step = build_step(pipeline, key: "bad_step", job_class: "NonExistentJob")
+    good_step = build_step(pipeline, key: "good_step", job_class: "DownloadJob")
+
+    GoodPipeline::Coordinator.bulk_enqueue_steps([bad_step.id, good_step.id])
+
+    assert_equal "enqueued", good_step.reload.coordination_status
+    refute_nil good_step.good_job_id
+
+    assert_equal "failed", bad_step.reload.coordination_status
+    assert_equal "GoodPipeline::ConfigurationError", bad_step.error_class
+  end
+end

data/demo/test/good_pipeline/test_queue_configuration.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestQueueConfiguration < ActiveSupport::TestCase
+  teardown do
+    GoodPipeline.coordination_queue_name = nil
+    GoodPipeline.callback_queue_name = nil
+  end
+
+  # --- global defaults ---
+
+  def test_default_coordination_queue_name
+    assert_equal "good_pipeline_coordination", GoodPipeline.coordination_queue_name
+  end
+
+  def test_default_callback_queue_name
+    assert_equal "good_pipeline_callbacks", GoodPipeline.callback_queue_name
+  end
+
+  # --- global override ---
+
+  def test_global_coordination_queue_override
+    GoodPipeline.coordination_queue_name = "custom_coordination"
+
+    assert_equal "custom_coordination", GoodPipeline.coordination_queue_name
+  end
+
+  def test_global_callback_queue_override
+    GoodPipeline.callback_queue_name = "custom_callbacks"
+
+    assert_equal "custom_callbacks", GoodPipeline.callback_queue_name
+  end
+
+  # --- pipeline DSL ---
+
+  def test_pipeline_dsl_coordination_queue
+    klass = Class.new(GoodPipeline::Pipeline) do
+      coordination_queue_name "pipeline_coordination"
+      def configure(**) = run(:a, DownloadJob)
+    end
+
+    assert_equal "pipeline_coordination", klass.coordination_queue_name
+  end
+
+  def test_pipeline_dsl_callback_queue
+    klass = Class.new(GoodPipeline::Pipeline) do
+      callback_queue_name "pipeline_callbacks"
+      def configure(**) = run(:a, DownloadJob)
+    end
+
+    assert_equal "pipeline_callbacks", klass.callback_queue_name
+  end
+
+  # --- pipeline DSL fallback to global ---
+
+  def test_pipeline_without_dsl_uses_global_config
+    GoodPipeline.coordination_queue_name = "global_coordination"
+
+    klass = Class.new(GoodPipeline::Pipeline) do
+      def configure(**) = run(:a, DownloadJob)
+    end
+
+    assert_equal "global_coordination", klass.coordination_queue_name
+  end
+
+  def test_pipeline_without_dsl_or_global_uses_default
+    klass = Class.new(GoodPipeline::Pipeline) do
+      def configure(**) = run(:a, DownloadJob)
+    end
+
+    assert_equal "good_pipeline_coordination", klass.coordination_queue_name
+  end
+
+  # --- pipeline DSL overrides global ---
+
+  def test_pipeline_dsl_overrides_global
+    GoodPipeline.coordination_queue_name = "global_coordination"
+
+    klass = Class.new(GoodPipeline::Pipeline) do
+      coordination_queue_name "pipeline_coordination"
+      def configure(**) = run(:a, DownloadJob)
+    end
+
+    assert_equal "pipeline_coordination", klass.coordination_queue_name
+  end
+
+  # --- inheritance ---
+
+  def test_pipeline_inherits_queue_from_parent
+    parent = Class.new(GoodPipeline::Pipeline) do
+      coordination_queue_name "parent_coordination"
+      callback_queue_name "parent_callbacks"
+    end
+
+    child = Class.new(parent) do
+      def configure(**) = run(:a, DownloadJob)
+    end
+
+    assert_equal "parent_coordination", child.coordination_queue_name
+    assert_equal "parent_callbacks", child.callback_queue_name
+  end
+
+  # --- step batch gets coordination queue ---
+
+  def test_step_batch_gets_coordination_queue
+    klass = Class.new(GoodPipeline::Pipeline) do
+      coordination_queue_name "step_coordination"
+      def configure(**) = run(:a, DownloadJob)
+    end
+    klass.define_singleton_method(:name) { "StepBatchQueueTestPipeline" }
+    Object.const_set(:StepBatchQueueTestPipeline, klass) unless defined?(::StepBatchQueueTestPipeline)
+
+    pipeline_record = StepBatchQueueTestPipeline.run
+
+    step = pipeline_record.steps.first
+    batch_record = GoodJob::BatchRecord.find(step.good_job_batch_id)
+
+    assert_equal "step_coordination", batch_record.callback_queue_name
+  end
+
+  # --- pipeline batch gets coordination queue ---
+
+  def test_pipeline_batch_gets_coordination_queue
+    klass = Class.new(GoodPipeline::Pipeline) do
+      coordination_queue_name "pipeline_coordination"
+      def configure(**) = run(:a, DownloadJob)
+    end
+    klass.define_singleton_method(:name) { "PipelineBatchQueueTestPipeline" }
+    Object.const_set(:PipelineBatchQueueTestPipeline, klass) unless defined?(::PipelineBatchQueueTestPipeline)
+
+    pipeline_record = PipelineBatchQueueTestPipeline.run
+
+    actual_record = GoodPipeline::PipelineRecord.find(pipeline_record.id)
+    batch_record = GoodJob::BatchRecord.find(actual_record.good_job_batch_id)
+
+    assert_equal "pipeline_coordination", batch_record.callback_queue_name
+  end
+
+  # --- PipelineCallbackJob gets callback queue ---
+
+  def test_callback_job_gets_callback_queue
+    klass = Class.new(GoodPipeline::Pipeline) do
+      callback_queue_name "my_callbacks"
+      def configure(**) = run(:a, DownloadJob)
+    end
+    klass.define_singleton_method(:name) { "CallbackQueueTestPipeline" }
+    Object.const_set(:CallbackQueueTestPipeline, klass) unless defined?(::CallbackQueueTestPipeline)
+
+    pipeline_record = CallbackQueueTestPipeline.run
+    run_pipeline_to_completion(pipeline_record)
+
+    callback_job = GoodJob::Job.where(job_class: "GoodPipeline::PipelineCallbackJob").last
+
+    assert_equal "my_callbacks", callback_job.queue_name
+  end
+end

data/demo/test/integration/test_bulk_enqueue_end_to_end.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestBulkEnqueueEndToEnd < ActiveSupport::TestCase
+  def test_fan_in_pipeline_with_multiple_root_steps_succeeds
+    pipeline_class = Class.new(GoodPipeline::Pipeline) do
+      failure_strategy :halt
+
+      define_method(:configure) do |**_kwargs|
+        run :root_a, DownloadJob
+        run :root_b, TranscodeJob
+        run :root_c, ThumbnailJob
+        run :collector, PublishJob, after: %i[root_a root_b root_c]
+      end
+    end
+    Object.const_set(:FanInBulkTestPipeline, pipeline_class) unless defined?(::FanInBulkTestPipeline)
+
+    pipeline_record = FanInBulkTestPipeline.run
+
+    # All 3 root steps should have been enqueued with distinct batches
+    root_steps = pipeline_record.steps.where(key: %w[root_a root_b root_c])
+    root_steps.each do |step|
+      refute_equal "pending", step.coordination_status,
+                   "Root step #{step.key} should have been enqueued"
+      refute_nil step.good_job_batch_id
+      refute_nil step.good_job_id
+    end
+
+    batch_ids = root_steps.pluck(:good_job_batch_id).uniq
+    assert_equal 3, batch_ids.size, "Each root step should have a unique batch"
+
+    result = run_pipeline_to_completion(pipeline_record)
+
+    assert_equal "succeeded", result.status
+    assert(result.steps.all? { |step| step.coordination_status == "succeeded" })
+  end
+
+  def test_all_root_steps_pipeline_succeeds
+    pipeline_class = Class.new(GoodPipeline::Pipeline) do
+      failure_strategy :continue
+
+      define_method(:configure) do |**_kwargs|
+        run :step_a, DownloadJob
+        run :step_b, TranscodeJob
+        run :step_c, ThumbnailJob
+        run :step_d, PublishJob
+        run :step_e, CleanupJob
+      end
+    end
+    Object.const_set(:AllRootsBulkTestPipeline, pipeline_class) unless defined?(::AllRootsBulkTestPipeline)
+
+    pipeline_record = AllRootsBulkTestPipeline.run
+    result = run_pipeline_to_completion(pipeline_record)
+
+    assert_equal "succeeded", result.status
+
+    result.steps.each do |step|
+      assert_equal "succeeded", step.coordination_status
+      refute_nil step.good_job_batch_id
+      refute_nil step.good_job_id
+    end
+  end
+
+  def test_fan_in_with_failing_root_step_halts
+    pipeline_class = Class.new(GoodPipeline::Pipeline) do
+      failure_strategy :halt
+
+      define_method(:configure) do |**_kwargs|
+        run :root_a, DownloadJob
+        run :root_b, FailingJob
+        run :root_c, ThumbnailJob
+        run :collector, PublishJob, after: %i[root_a root_b root_c]
+      end
+    end
+    Object.const_set(:FanInFailBulkTestPipeline, pipeline_class) unless defined?(::FanInFailBulkTestPipeline)
+
+    pipeline_record = FanInFailBulkTestPipeline.run
+    result = run_pipeline_to_completion(pipeline_record)
+
+    assert_equal "halted", result.status
+    assert_equal "failed", result.steps.find_by(key: "root_b").coordination_status
+  end
+
+  def test_enqueue_options_forwarded_to_good_job
+    pipeline_class = Class.new(GoodPipeline::Pipeline) do
+      failure_strategy :halt
+
+      define_method(:configure) do |**_kwargs|
+        run :step_a, DownloadJob, enqueue: { queue: "critical", priority: 1 }
+        run :step_b, TranscodeJob, enqueue: { queue: "low", priority: 10 }
+      end
+    end
+    Object.const_set(:EnqueueOptionsBulkTestPipeline, pipeline_class) unless defined?(::EnqueueOptionsBulkTestPipeline)
+
+    pipeline_record = EnqueueOptionsBulkTestPipeline.run
+
+    step_a = pipeline_record.steps.find_by(key: "step_a")
+    step_b = pipeline_record.steps.find_by(key: "step_b")
+
+    good_job_a = GoodJob::Job.find_by(id: step_a.good_job_id)
+    good_job_b = GoodJob::Job.find_by(id: step_b.good_job_id)
+
+    assert_equal "critical", good_job_a.queue_name
+    assert_equal 1, good_job_a.priority
+    assert_equal "low", good_job_b.queue_name
+    assert_equal 10, good_job_b.priority
+  end
+end

data/demo/test/integration/test_end_to_end.rb

@@ -3,21 +3,6 @@
 require "test_helper"
 
 class TestEndToEnd < ActiveSupport::TestCase
-  def run_pipeline_to_completion(pipeline_record, timeout: 15)
-    deadline = Time.current + timeout
-    loop do
-      perform_enqueued_jobs_inline
-      pipeline_record.reload
-      return pipeline_record if pipeline_record.terminal?
-
-      if Time.current > deadline
-        raise "Pipeline did not reach terminal state within #{timeout}s (status: #{pipeline_record.status})"
-      end
-
-      sleep 0.05
-    end
-  end
-
   def test_full_pipeline_succeeds
     pipeline_record = VideoProcessingPipeline.run(video_id: 123)