good_pipeline 0.1.0

data/demo/test/good_pipeline/test_coordinator.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestCoordinator < ActiveSupport::TestCase
+  # --- Helper to create a GoodJob::Job record for failure metadata ---
+
+  def create_good_job_for_step(step, error: "RuntimeError: something broke", executions_count: 3)
+    good_job = GoodJob::Job.create!(
+      id: SecureRandom.uuid,
+      active_job_id: SecureRandom.uuid,
+      job_class: step.job_class,
+      error: error,
+      executions_count: executions_count,
+      finished_at: Time.current
+    )
+    step.update_column(:good_job_id, good_job.id)
+    good_job
+  end
+
+  # --- complete_step: idempotency ---
+
+  def test_complete_step_idempotent_on_terminal_step
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    step = build_step(pipeline, key: "a")
+    step.update_columns(coordination_status: "succeeded")
+    step.reload
+
+    GoodPipeline::Coordinator.complete_step(step, succeeded: true)
+
+    assert_equal "succeeded", step.reload.coordination_status
+  end
+
+  # --- complete_step: succeeded ---
+
+  def test_complete_step_succeeded_transitions
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step = build_step(pipeline, key: "a")
+    step.update_columns(coordination_status: "enqueued")
+    step.reload
+
+    GoodPipeline::Coordinator.complete_step(step, succeeded: true)
+
+    assert_equal "succeeded", step.reload.coordination_status
+  end
+
+  # --- complete_step: failed ---
+
+  def test_complete_step_failed_transitions_and_sets_metadata
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step = build_step(pipeline, key: "a")
+    step.update_columns(coordination_status: "enqueued")
+    create_good_job_for_step(step, error: "RuntimeError: something broke", executions_count: 3)
+    step.reload
+
+    GoodPipeline::Coordinator.complete_step(step, succeeded: false)
+
+    step.reload
+
+    assert_equal "failed", step.coordination_status
+    assert_equal "RuntimeError", step.error_class
+    assert_equal "something broke", step.error_message
+    assert_equal 3, step.attempts
+  end
+
+  # --- recompute_pipeline_status: derivation ---
+
+  def test_recompute_returns_early_when_steps_not_all_terminal
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    build_step(pipeline, key: "a")
+    build_step(pipeline, key: "b")
+
+    GoodPipeline::Coordinator.recompute_pipeline_status(pipeline)
+
+    assert_equal "running", pipeline.reload.status
+  end
+
+  def test_recompute_derives_succeeded_when_all_steps_succeeded
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "a")
+    step_b = build_step(pipeline, key: "b")
+    step_a.update_columns(coordination_status: "succeeded")
+    step_b.update_columns(coordination_status: "succeeded")
+
+    GoodPipeline::Coordinator.recompute_pipeline_status(pipeline.reload)
+
+    assert_equal "succeeded", pipeline.reload.status
+  end
+
+  def test_recompute_derives_halted_when_halt_triggered
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running", halt_triggered: true)
+    step_a = build_step(pipeline, key: "a")
+    step_b = build_step(pipeline, key: "b")
+    step_a.update_columns(coordination_status: "failed")
+    step_b.update_columns(coordination_status: "skipped")
+
+    GoodPipeline::Coordinator.recompute_pipeline_status(pipeline.reload)
+
+    assert_equal "halted", pipeline.reload.status
+  end
+
+  def test_recompute_derives_failed_when_no_halt_triggered
+    pipeline = create_pipeline(on_failure_strategy: "continue")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "a")
+    step_b = build_step(pipeline, key: "b")
+    step_a.update_columns(coordination_status: "failed")
+    step_b.update_columns(coordination_status: "succeeded")
+
+    GoodPipeline::Coordinator.recompute_pipeline_status(pipeline.reload)
+
+    assert_equal "failed", pipeline.reload.status
+  end
+
+  def test_recompute_is_idempotent_on_terminal_pipeline
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "succeeded", callbacks_dispatched_at: Time.current)
+    build_step(pipeline, key: "a").update_columns(coordination_status: "succeeded")
+
+    GoodPipeline::Coordinator.recompute_pipeline_status(pipeline.reload)
+
+    assert_equal "succeeded", pipeline.reload.status
+  end
+
+  # --- dispatch_callbacks_once ---
+
+  def test_dispatch_callbacks_sets_callbacks_dispatched_at
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    build_step(pipeline, key: "a").update_columns(coordination_status: "succeeded")
+
+    GoodPipeline::Coordinator.recompute_pipeline_status(pipeline.reload)
+
+    pipeline.reload
+
+    assert_equal "succeeded", pipeline.status
+    refute_nil pipeline.callbacks_dispatched_at
+  end
+
+  def test_dispatch_callbacks_exactly_once
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    build_step(pipeline, key: "a").update_columns(coordination_status: "succeeded")
+
+    GoodPipeline::Coordinator.recompute_pipeline_status(pipeline.reload)
+    first_dispatched_at = pipeline.reload.callbacks_dispatched_at
+
+    # Call again — should not change anything
+    GoodPipeline::Coordinator.recompute_pipeline_status(pipeline.reload)
+
+    assert_equal first_dispatched_at, pipeline.reload.callbacks_dispatched_at
+  end
+
+  # --- Halt propagation ---
+
+  def test_halt_skips_all_pending_steps
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "a")
+    step_b = build_step(pipeline, key: "b", dependencies: [step_a])
+    step_c = build_step(pipeline, key: "c", dependencies: [step_a])
+    step_a.update_columns(coordination_status: "enqueued")
+
+    GoodPipeline::Coordinator.complete_step(step_a.reload, succeeded: false)
+
+    assert_equal "failed", step_a.reload.coordination_status
+    assert_equal "skipped", step_b.reload.coordination_status
+    assert_equal "skipped", step_c.reload.coordination_status
+    assert_predicate pipeline.reload, :halt_triggered?
+    assert_equal "halted", pipeline.status
+  end
+
+  def test_halt_with_step_ignore_exempts_dependents
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "a", on_failure_strategy: "ignore")
+    step_b = build_step(pipeline, key: "b", dependencies: [step_a])
+    step_c = build_step(pipeline, key: "c")
+    step_a.update_columns(coordination_status: "enqueued")
+
+    GoodPipeline::Coordinator.complete_step(step_a.reload, succeeded: false)
+
+    assert_equal "failed", step_a.reload.coordination_status
+    # step_b is a direct dependent of step_a (which has failure_strategy: :ignore) — should NOT be skipped
+    refute_equal "skipped", step_b.reload.coordination_status
+    # step_c is unrelated — should be skipped under :halt
+    assert_equal "skipped", step_c.reload.coordination_status
+    assert_predicate pipeline.reload, :halt_triggered?
+  end
+
+  # --- Continue strategy ---
+
+  def test_continue_skips_only_unsatisfied_descendants
+    pipeline = create_pipeline(on_failure_strategy: "continue")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "a")
+    step_b = build_step(pipeline, key: "b")
+    step_c = build_step(pipeline, key: "c", dependencies: [step_a])
+    step_a.update_columns(coordination_status: "enqueued")
+    step_b.update_columns(coordination_status: "succeeded")
+
+    GoodPipeline::Coordinator.complete_step(step_a.reload, succeeded: false)
+
+    assert_equal "failed", step_a.reload.coordination_status
+    assert_equal "skipped", step_c.reload.coordination_status
+    assert_equal "succeeded", step_b.reload.coordination_status
+    refute_predicate pipeline.reload, :halt_triggered?
+    assert_equal "failed", pipeline.reload.status
+  end
+
+  # --- Ignore strategy ---
+
+  def test_ignore_nothing_skipped
+    pipeline = create_pipeline(on_failure_strategy: "ignore")
+    pipeline.update_columns(status: "running")
+    step_a = build_step(pipeline, key: "a")
+    build_step(pipeline, key: "b", dependencies: [step_a])
+    step_a.update_columns(coordination_status: "enqueued")
+
+    GoodPipeline::Coordinator.complete_step(step_a.reload, succeeded: false)
+
+    assert_equal "failed", step_a.reload.coordination_status
+    refute_predicate pipeline.reload, :halt_triggered?
+  end
+
+  # --- Single-step pipeline reaches terminal ---
+
+  def test_single_step_pipeline_succeeds
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    step = build_step(pipeline, key: "a")
+    step.update_columns(coordination_status: "enqueued")
+
+    GoodPipeline::Coordinator.complete_step(step.reload, succeeded: true)
+
+    assert_equal "succeeded", pipeline.reload.status
+  end
+
+  # --- try_enqueue_step ---
+
+  def test_try_enqueue_bails_on_non_pending_step
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    step = build_step(pipeline, key: "a")
+    step.update_columns(coordination_status: "enqueued")
+
+    GoodPipeline::Coordinator.try_enqueue_step(step.id)
+
+    assert_equal "enqueued", step.reload.coordination_status
+  end
+
+  def test_try_enqueue_bails_when_good_job_id_present
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    step = build_step(pipeline, key: "a")
+    step.update_columns(good_job_id: SecureRandom.uuid)
+
+    GoodPipeline::Coordinator.try_enqueue_step(step.id)
+
+    assert_equal "pending", step.reload.coordination_status
+  end
+
+  def test_try_enqueue_bails_when_upstreams_not_satisfied
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    step_a = build_step(pipeline, key: "a")
+    step_b = build_step(pipeline, key: "b", dependencies: [step_a])
+
+    GoodPipeline::Coordinator.try_enqueue_step(step_b.id)
+
+    assert_equal "pending", step_b.reload.coordination_status
+  end
+
+  def test_try_enqueue_skips_permanently_unsatisfied_step
+    pipeline = create_pipeline(on_failure_strategy: "continue")
+    step_a = build_step(pipeline, key: "a")
+    step_b = build_step(pipeline, key: "b", dependencies: [step_a])
+    step_a.update_columns(coordination_status: "failed")
+
+    GoodPipeline::Coordinator.try_enqueue_step(step_b.id)
+
+    assert_equal "skipped", step_b.reload.coordination_status
+  end
+end

data/demo/test/good_pipeline/test_dependency_record.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestDependencyRecord < ActiveSupport::TestCase
+  # --- Diamond DAG graph navigation ---
+  #
+  #   A
+  #  / \
+  # B   C
+  #  \ /
+  #   D
+
+  def test_diamond_dag_navigation
+    pipeline = create_pipeline
+    step_a = create_step(pipeline, key: "a")
+    step_b = create_step(pipeline, key: "b")
+    step_c = create_step(pipeline, key: "c")
+    step_d = create_step(pipeline, key: "d")
+
+    # B depends on A, C depends on A
+    GoodPipeline::DependencyRecord.create!(pipeline: pipeline, step: step_b, depends_on_step: step_a)
+    GoodPipeline::DependencyRecord.create!(pipeline: pipeline, step: step_c, depends_on_step: step_a)
+    # D depends on B and C
+    GoodPipeline::DependencyRecord.create!(pipeline: pipeline, step: step_d, depends_on_step: step_b)
+    GoodPipeline::DependencyRecord.create!(pipeline: pipeline, step: step_d, depends_on_step: step_c)
+
+    # A has no upstream steps
+    assert_empty step_a.upstream_steps
+
+    # A's downstream: B and C
+    assert_equal %w[b c], step_a.downstream_steps.map(&:key).sort
+
+    # B's upstream: A
+    assert_equal ["a"], step_b.upstream_steps.map(&:key)
+
+    # B's downstream: D
+    assert_equal ["d"], step_b.downstream_steps.map(&:key)
+
+    # D's upstream: B and C
+    assert_equal %w[b c], step_d.upstream_steps.map(&:key).sort
+
+    # D has no downstream
+    assert_empty step_d.downstream_steps
+  end
+end

data/demo/test/good_pipeline/test_failure_metadata.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestFailureMetadata < ActiveSupport::TestCase
+  def test_extract_returns_empty_result_when_no_good_job_record
+    pipeline = create_pipeline
+    step = build_step(pipeline, key: "a")
+
+    result = GoodPipeline::FailureMetadata.extract(step)
+
+    assert_nil result.error_class
+    assert_nil result.error_message
+    assert_equal 0, result.attempts
+  end
+
+  def test_extract_parses_error_from_good_job_record
+    pipeline = create_pipeline
+    step = build_step(pipeline, key: "a")
+
+    good_job = GoodJob::Job.create!(
+      id: SecureRandom.uuid,
+      active_job_id: SecureRandom.uuid,
+      job_class: "DownloadJob",
+      error: "RuntimeError: something went wrong",
+      executions_count: 3,
+      finished_at: Time.current
+    )
+    step.update_column(:good_job_id, good_job.id)
+
+    result = GoodPipeline::FailureMetadata.extract(step.reload)
+
+    assert_equal "RuntimeError", result.error_class
+    assert_equal "something went wrong", result.error_message
+    assert_equal 3, result.attempts
+  end
+
+  def test_extract_handles_error_message_with_colon
+    pipeline = create_pipeline
+    step = build_step(pipeline, key: "a")
+
+    good_job = GoodJob::Job.create!(
+      id: SecureRandom.uuid,
+      active_job_id: SecureRandom.uuid,
+      job_class: "DownloadJob",
+      error: "Net::HTTPError: 404: Not Found",
+      executions_count: 1,
+      finished_at: Time.current
+    )
+    step.update_column(:good_job_id, good_job.id)
+
+    result = GoodPipeline::FailureMetadata.extract(step.reload)
+
+    assert_equal "Net::HTTPError", result.error_class
+    assert_equal "404: Not Found", result.error_message
+  end
+
+  def test_extract_handles_nil_error
+    pipeline = create_pipeline
+    step = build_step(pipeline, key: "a")
+
+    good_job = GoodJob::Job.create!(
+      id: SecureRandom.uuid,
+      active_job_id: SecureRandom.uuid,
+      job_class: "DownloadJob",
+      error: nil,
+      executions_count: 1,
+      finished_at: Time.current
+    )
+    step.update_column(:good_job_id, good_job.id)
+
+    result = GoodPipeline::FailureMetadata.extract(step.reload)
+
+    assert_nil result.error_class
+    assert_nil result.error_message
+  end
+end

data/demo/test/good_pipeline/test_introspection.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestIntrospection < ActiveSupport::TestCase
+  def test_duration_returns_seconds_from_good_job
+    pipeline = create_pipeline
+    step = create_step(pipeline, key: "a")
+
+    performed_at = 10.seconds.ago
+    finished_at = Time.current
+    good_job = GoodJob::Job.create!(
+      id: SecureRandom.uuid,
+      active_job_id: SecureRandom.uuid,
+      job_class: "DownloadJob",
+      performed_at: performed_at,
+      finished_at: finished_at
+    )
+    step.update_column(:good_job_id, good_job.id)
+
+    assert_in_delta 10.0, step.duration, 0.5
+  end
+
+  def test_duration_returns_nil_when_no_good_job_id
+    pipeline = create_pipeline
+    step = create_step(pipeline, key: "a")
+
+    assert_nil step.duration
+  end
+
+  def test_duration_returns_nil_when_good_job_not_performed
+    pipeline = create_pipeline
+    step = create_step(pipeline, key: "a")
+
+    good_job = GoodJob::Job.create!(
+      id: SecureRandom.uuid,
+      active_job_id: SecureRandom.uuid,
+      job_class: "DownloadJob",
+      performed_at: nil,
+      finished_at: nil
+    )
+    step.update_column(:good_job_id, good_job.id)
+
+    assert_nil step.duration
+  end
+end

data/demo/test/good_pipeline/test_pipeline_callback_job.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestPipelineCallbackJob < ActiveSupport::TestCase
+  def setup
+    super
+    @callback_log = []
+  end
+
+  def build_pipeline_class(on_complete: nil, on_success: nil, on_failure: nil)
+    log = @callback_log
+    Class.new(GoodPipeline::Pipeline) do
+      self.on_complete(on_complete) if on_complete
+      self.on_success(on_success) if on_success
+      self.on_failure(on_failure) if on_failure
+
+      define_method(:notify_complete) { log << :on_complete }
+      define_method(:notify_success) { log << :on_success }
+      define_method(:notify_failure) { log << :on_failure }
+
+      def configure(**) = run(:a, Class.new)
+    end
+  end
+
+  def test_calls_on_complete_and_on_success_for_succeeded
+    klass = build_pipeline_class(on_complete: :notify_complete, on_success: :notify_success)
+    # We need a named class for constantize to work
+    self.class.const_set(:SucceededPipeline, klass) unless self.class.const_defined?(:SucceededPipeline)
+
+    pipeline = create_pipeline(type: self.class::SucceededPipeline.name)
+    job = GoodPipeline::PipelineCallbackJob.new
+    job.perform(pipeline.id, "succeeded")
+
+    assert_includes @callback_log, :on_complete
+    assert_includes @callback_log, :on_success
+    refute_includes @callback_log, :on_failure
+  end
+
+  def test_calls_on_complete_and_on_failure_for_failed
+    klass = build_pipeline_class(on_complete: :notify_complete, on_failure: :notify_failure)
+    self.class.const_set(:FailedPipeline, klass) unless self.class.const_defined?(:FailedPipeline)
+
+    pipeline = create_pipeline(type: self.class::FailedPipeline.name)
+    job = GoodPipeline::PipelineCallbackJob.new
+    job.perform(pipeline.id, "failed")
+
+    assert_includes @callback_log, :on_complete
+    assert_includes @callback_log, :on_failure
+    refute_includes @callback_log, :on_success
+  end
+
+  def test_calls_on_complete_and_on_failure_for_halted
+    klass = build_pipeline_class(on_complete: :notify_complete, on_failure: :notify_failure)
+    self.class.const_set(:HaltedPipeline, klass) unless self.class.const_defined?(:HaltedPipeline)
+
+    pipeline = create_pipeline(type: self.class::HaltedPipeline.name)
+    job = GoodPipeline::PipelineCallbackJob.new
+    job.perform(pipeline.id, "halted")
+
+    assert_includes @callback_log, :on_complete
+    assert_includes @callback_log, :on_failure
+  end
+
+  def test_handles_nil_callbacks_gracefully
+    klass = build_pipeline_class
+    self.class.const_set(:NilCallbackPipeline, klass) unless self.class.const_defined?(:NilCallbackPipeline)
+
+    pipeline = create_pipeline(type: self.class::NilCallbackPipeline.name)
+    job = GoodPipeline::PipelineCallbackJob.new
+    job.perform(pipeline.id, "succeeded")
+
+    assert_empty @callback_log
+  end
+
+  def test_rejects_invalid_terminal_status
+    klass = build_pipeline_class
+    self.class.const_set(:InvalidStatusPipeline, klass) unless self.class.const_defined?(:InvalidStatusPipeline)
+
+    pipeline = create_pipeline(type: self.class::InvalidStatusPipeline.name)
+    job = GoodPipeline::PipelineCallbackJob.new
+
+    assert_raises(ArgumentError) { job.perform(pipeline.id, "invalid") }
+    assert_raises(ArgumentError) { job.perform(pipeline.id, "pending") }
+  end
+
+  def test_error_in_callback_is_raised
+    log = @callback_log
+    klass = Class.new(GoodPipeline::Pipeline) do
+      on_complete(:exploding_callback)
+
+      define_method(:exploding_callback) do
+        log << :exploded
+        raise StandardError, "callback exploded"
+      end
+
+      def configure(**) = run(:a, Class.new)
+    end
+    self.class.const_set(:ExplodingPipeline, klass) unless self.class.const_defined?(:ExplodingPipeline)
+
+    pipeline = create_pipeline(type: self.class::ExplodingPipeline.name)
+    job = GoodPipeline::PipelineCallbackJob.new
+
+    error = assert_raises(StandardError) { job.perform(pipeline.id, "succeeded") }
+    assert_equal "callback exploded", error.message
+    assert_includes @callback_log, :exploded
+  end
+
+  def test_error_in_first_callback_still_runs_second
+    log = @callback_log
+    klass = Class.new(GoodPipeline::Pipeline) do
+      on_complete(:exploding_complete)
+      on_success(:record_success)
+
+      define_method(:exploding_complete) do
+        log << :complete_exploded
+        raise StandardError, "complete exploded"
+      end
+      define_method(:record_success) { log << :success_recorded }
+
+      def configure(**) = run(:a, Class.new)
+    end
+    self.class.const_set(:BothCallbacksPipeline, klass) unless self.class.const_defined?(:BothCallbacksPipeline)
+
+    pipeline = create_pipeline(type: self.class::BothCallbacksPipeline.name)
+    job = GoodPipeline::PipelineCallbackJob.new
+
+    assert_raises(StandardError) { job.perform(pipeline.id, "succeeded") }
+    assert_includes @callback_log, :complete_exploded
+    assert_includes @callback_log, :success_recorded
+  end
+end

data/demo/test/good_pipeline/test_pipeline_reconciliation_job.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestPipelineReconciliationJob < ActiveSupport::TestCase
+  def test_recomputes_pipeline_status_for_succeeded_pipeline
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    build_step(pipeline, key: "a").update_columns(coordination_status: "succeeded")
+
+    batch = GoodJob::Batch.new
+    batch.properties = { pipeline_id: pipeline.id }
+    batch.save
+
+    GoodPipeline::PipelineReconciliationJob.new.perform(batch, {})
+
+    assert_equal "succeeded", pipeline.reload.status
+  end
+
+  def test_does_not_transition_when_steps_still_pending
+    pipeline = create_pipeline(on_failure_strategy: "halt")
+    pipeline.update_columns(status: "running")
+    build_step(pipeline, key: "a")
+
+    batch = GoodJob::Batch.new
+    batch.properties = { pipeline_id: pipeline.id }
+    batch.save
+
+    GoodPipeline::PipelineReconciliationJob.new.perform(batch, {})
+
+    assert_equal "running", pipeline.reload.status
+  end
+end