good_pipeline 0.1.0 → 0.2.1

data/app/views/layouts/good_pipeline/application.html.erb

@@ -36,5 +36,120 @@
       });
     });
   </script>
+  <script>
+    (function() {
+      var MIN_SCALE = 0.5, MAX_SCALE = 4, ZOOM_STEP = 0.25;
+      var states = new WeakMap();
+
+      function getState(container) {
+        if (!states.has(container)) states.set(container, { scale: 1, panX: 0, panY: 0 });
+        return states.get(container);
+      }
+
+      function applyTransform(container) {
+        var s = getState(container);
+        var canvas = container.querySelector('.diagram-canvas');
+        if (canvas) canvas.style.transform = 'translate(' + s.panX + 'px, ' + s.panY + 'px) scale(' + s.scale + ')';
+      }
+
+      function clampScale(val) {
+        return Math.min(MAX_SCALE, Math.max(MIN_SCALE, val));
+      }
+
+      function zoomAroundPoint(s, centerX, centerY, newScale) {
+        var oldScale = s.scale;
+        newScale = clampScale(newScale);
+        if (newScale === oldScale) return;
+        var ratio = newScale / oldScale;
+        s.panX = centerX - (centerX - s.panX) * ratio;
+        s.panY = centerY - (centerY - s.panY) * ratio;
+        s.scale = newScale;
+      }
+
+      // Button actions via event delegation
+      document.addEventListener('click', function(e) {
+        var btn = e.target.closest('[data-action]');
+        if (!btn) return;
+        var container = btn.closest('.diagram-container');
+        if (!container) return;
+        var s = getState(container);
+        var action = btn.dataset.action;
+
+        if (action === 'zoom-in' || action === 'zoom-out') {
+          var viewport = container.querySelector('.diagram-viewport');
+          var rect = viewport.getBoundingClientRect();
+          var centerX = rect.width / 2;
+          var centerY = rect.height / 2;
+          var delta = action === 'zoom-in' ? ZOOM_STEP : -ZOOM_STEP;
+          zoomAroundPoint(s, centerX, centerY, s.scale + delta);
+        } else if (action === 'zoom-reset') {
+          s.scale = 1; s.panX = 0; s.panY = 0;
+        } else if (action === 'fullscreen') {
+          if (document.fullscreenElement === container) {
+            document.exitFullscreen();
+          } else {
+            container.requestFullscreen();
+          }
+          return;
+        }
+        applyTransform(container);
+      });
+
+      // Mouse wheel zoom toward cursor
+      document.querySelectorAll('.diagram-viewport').forEach(function(viewport) {
+        viewport.addEventListener('wheel', function(e) {
+          e.preventDefault();
+          var container = viewport.closest('.diagram-container');
+          var s = getState(container);
+          var rect = viewport.getBoundingClientRect();
+          var cursorX = e.clientX - rect.left;
+          var cursorY = e.clientY - rect.top;
+          var delta = e.deltaY < 0 ? ZOOM_STEP : -ZOOM_STEP;
+          zoomAroundPoint(s, cursorX, cursorY, s.scale + delta);
+          applyTransform(container);
+        }, { passive: false });
+      });
+
+      // Click-drag pan
+      document.querySelectorAll('.diagram-viewport').forEach(function(viewport) {
+        viewport.addEventListener('mousedown', function(e) {
+          if (e.button !== 0) return;
+          var container = viewport.closest('.diagram-container');
+          var canvas = container.querySelector('.diagram-canvas');
+          var s = getState(container);
+          var startX = e.clientX - s.panX;
+          var startY = e.clientY - s.panY;
+          canvas.classList.add('dragging');
+
+          function onMove(ev) {
+            s.panX = ev.clientX - startX;
+            s.panY = ev.clientY - startY;
+            applyTransform(container);
+          }
+          function onUp() {
+            canvas.classList.remove('dragging');
+            document.removeEventListener('mousemove', onMove);
+            document.removeEventListener('mouseup', onUp);
+          }
+          document.addEventListener('mousemove', onMove);
+          document.addEventListener('mouseup', onUp);
+        });
+      });
+
+      // Reset zoom when switching definitions
+      document.querySelectorAll('.definition-item').forEach(function(btn) {
+        btn.addEventListener('click', function() {
+          var type = btn.dataset.pipeline;
+          var panel = document.querySelector('.definition-panel[data-pipeline="' + type + '"]');
+          if (!panel) return;
+          var container = panel.querySelector('.diagram-container');
+          if (!container) return;
+          var s = getState(container);
+          s.scale = 1; s.panX = 0; s.panY = 0;
+          applyTransform(container);
+        });
+      });
+    })();
+  </script>
 </body>
 </html>

data/demo/app/pipelines/branch_test_pipeline.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class BranchTestPipeline < GoodPipeline::Pipeline
+  description "Pipeline with branching for integration tests"
+
+  def configure(choice:, **)
+    run :analyze, DownloadJob, with: { choice: choice }
+
+    branch :format_check, after: :analyze, by: :pick_format do
+      on :hd do
+        run :transcode_hd, TranscodeJob, with: { choice: choice }
+        run :upscale, ThumbnailJob, with: { choice: choice }, after: :transcode_hd
+      end
+
+      on :sd do
+        run :transcode_sd, PublishJob, with: { choice: choice }
+      end
+    end
+
+    run :finish, CleanupJob, with: { choice: choice }, after: :format_check
+  end
+
+  private
+
+  def pick_format
+    params[:choice].to_sym
+  end
+end

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

@@ -26,8 +26,8 @@ class CreateGoodPipelineTables < ActiveRecord::Migration[8.1]
       t.jsonb :params, null: false, default: {}
       t.string :coordination_status, null: false, default: "pending"
       t.string :on_failure_strategy
-      t.string :queue
-      t.integer :priority
+      t.jsonb :enqueue_options, null: false, default: {}
+      t.jsonb :branch, null: false, default: {}
       t.uuid :good_job_batch_id
       t.uuid :good_job_id
       t.integer :attempts
@@ -38,6 +38,7 @@ class CreateGoodPipelineTables < ActiveRecord::Migration[8.1]
     end
 
     add_index :good_pipeline_steps, %i[pipeline_id key], unique: true
+    add_index :good_pipeline_steps, :coordination_status
 
     create_table :good_pipeline_dependencies do |t|
       t.references :pipeline, null: false, foreign_key: { to_table: :good_pipeline_pipelines }, type: :uuid
@@ -49,5 +50,8 @@ class CreateGoodPipelineTables < ActiveRecord::Migration[8.1]
       t.references :upstream_pipeline, null: false, foreign_key: { to_table: :good_pipeline_pipelines }, type: :uuid
       t.references :downstream_pipeline, null: false, foreign_key: { to_table: :good_pipeline_pipelines }, type: :uuid
     end
+
+    add_index :good_pipeline_chains, %i[upstream_pipeline_id downstream_pipeline_id], unique: true,
+                                                                                      name: :index_good_pipeline_chains_uniqueness
   end
 end

data/demo/db/seeds.rb

@@ -24,10 +24,13 @@ end
 def add_steps(pipeline, *step_defs)
   records = {}
   step_defs.each do |definition|
+    branch_hash = definition.slice(:decides, :branch_result, :empty_arms, :branch_key, :branch_arm).transform_keys(&:to_s)
+
     records[definition[:key]] = GoodPipeline::StepRecord.create!(
       pipeline: pipeline, key: definition[:key], job_class: definition[:job],
       coordination_status: definition.fetch(:status, "succeeded"),
-      error_class: definition[:error_class], error_message: definition[:error_message]
+      error_class: definition[:error_class], error_message: definition[:error_message],
+      branch: branch_hash
     )
   end
   records
@@ -150,4 +153,225 @@ ingest2_steps = add_steps(ingest2,
                           { key: "load", job: "LoadJob", status: "pending" })
 add_edges(ingest2, ingest2_steps, %w[extract validate], %w[validate transform], %w[transform load])
 
+# 11. MediaProcessingPipeline (succeeded, HD path taken) — single branch
+branch_job = GoodPipeline::BRANCH_JOB_CLASS
+media = create_pipeline(type: "MediaProcessingPipeline", status: "succeeded",
+                         params: { media_id: 4421, source: "upload" }, age: 1.hour, duration: 20.minutes)
+media_steps = add_steps(media,
+                        { key: "analyze", job: "AnalyzeJob" },
+                        { key: "format_check", job: branch_job, decides: "detect_format", branch_result: "hd" },
+                        { key: "transcode_hd", job: "TranscodeHDJob", branch_key: "format_check", branch_arm: "hd" },
+                        { key: "upscale", job: "UpscaleJob", branch_key: "format_check", branch_arm: "hd" },
+                        { key: "transcode_sd", job: "TranscodeSDJob", branch_key: "format_check", branch_arm: "sd",
+                          status: "skipped_by_branch" },
+                        { key: "publish", job: "PublishJob" })
+add_edges(media, media_steps,
+          %w[analyze format_check],
+          %w[format_check transcode_hd], %w[format_check transcode_sd],
+          %w[transcode_hd upscale],
+          %w[upscale publish], %w[transcode_sd publish])
+
+# 12. DeploymentPipeline (succeeded, canary path) — branch with multi-step arms
+deploy = create_pipeline(type: "DeploymentPipeline", status: "succeeded",
+                          params: { service: "api-gateway", version: "2.4.1", env: "production" },
+                          age: 4.hours, duration: 45.minutes)
+deploy_steps = add_steps(deploy,
+                         { key: "build", job: "BuildJob" },
+                         { key: "run_tests", job: "RunTestsJob" },
+                         { key: "deploy_strategy", job: branch_job, decides: "pick_strategy", branch_result: "canary" },
+                         { key: "canary_deploy", job: "CanaryDeployJob", branch_key: "deploy_strategy", branch_arm: "canary" },
+                         { key: "canary_monitor", job: "CanaryMonitorJob", branch_key: "deploy_strategy", branch_arm: "canary" },
+                         { key: "canary_promote", job: "CanaryPromoteJob", branch_key: "deploy_strategy", branch_arm: "canary" },
+                         { key: "blue_green_swap", job: "BlueGreenSwapJob", branch_key: "deploy_strategy", branch_arm: "blue_green",
+                           status: "skipped_by_branch" },
+                         { key: "blue_green_verify", job: "BlueGreenVerifyJob", branch_key: "deploy_strategy", branch_arm: "blue_green",
+                           status: "skipped_by_branch" },
+                         { key: "notify_team", job: "NotifyTeamJob" })
+add_edges(deploy, deploy_steps,
+          %w[build run_tests], %w[run_tests deploy_strategy],
+          %w[deploy_strategy canary_deploy], %w[deploy_strategy blue_green_swap],
+          %w[canary_deploy canary_monitor], %w[canary_monitor canary_promote],
+          %w[blue_green_swap blue_green_verify],
+          %w[canary_promote notify_team], %w[blue_green_verify notify_team])
+
+# 13. MediaProcessingPipeline (succeeded, SD path) — same pipeline type, different branch result
+media2 = create_pipeline(type: "MediaProcessingPipeline", status: "succeeded",
+                          params: { media_id: 4422, source: "api" }, age: 30.minutes, duration: 10.minutes)
+media2_steps = add_steps(media2,
+                         { key: "analyze", job: "AnalyzeJob" },
+                         { key: "format_check", job: branch_job, decides: "detect_format", branch_result: "sd" },
+                         { key: "transcode_hd", job: "TranscodeHDJob", branch_key: "format_check", branch_arm: "hd",
+                           status: "skipped_by_branch" },
+                         { key: "upscale", job: "UpscaleJob", branch_key: "format_check", branch_arm: "hd",
+                           status: "skipped_by_branch" },
+                         { key: "transcode_sd", job: "TranscodeSDJob", branch_key: "format_check", branch_arm: "sd" },
+                         { key: "publish", job: "PublishJob" })
+add_edges(media2, media2_steps,
+          %w[analyze format_check],
+          %w[format_check transcode_hd], %w[format_check transcode_sd],
+          %w[transcode_hd upscale],
+          %w[upscale publish], %w[transcode_sd publish])
+
+# 14. ContentModerationPipeline (succeeded) — two sequential branches
+#   ingest → classify_content(branch: text/image) → [text arm / image arm] →
+#   review_priority(branch: high/low) → [fast review / standard review] → publish
+moderation = create_pipeline(type: "ContentModerationPipeline", status: "succeeded",
+                              params: { content_id: 99_201, source: "user_upload" },
+                              age: 2.hours, duration: 35.minutes)
+moderation_steps = add_steps(moderation,
+                             { key: "ingest", job: "IngestContentJob" },
+                             # First branch: content type
+                             { key: "classify_content", job: branch_job, decides: "detect_content_type",
+                               branch_result: "image" },
+                             { key: "extract_text", job: "ExtractTextJob",
+                               branch_key: "classify_content", branch_arm: "text", status: "skipped_by_branch" },
+                             { key: "run_nlp", job: "RunNlpJob",
+                               branch_key: "classify_content", branch_arm: "text", status: "skipped_by_branch" },
+                             { key: "detect_objects", job: "DetectObjectsJob",
+                               branch_key: "classify_content", branch_arm: "image" },
+                             { key: "check_nsfw", job: "CheckNsfwJob",
+                               branch_key: "classify_content", branch_arm: "image" },
+                             # Second branch: review priority
+                             { key: "review_priority", job: branch_job, decides: "determine_priority",
+                               branch_result: "low" },
+                             { key: "fast_review", job: "FastReviewJob",
+                               branch_key: "review_priority", branch_arm: "high", status: "skipped_by_branch" },
+                             { key: "standard_review", job: "StandardReviewJob",
+                               branch_key: "review_priority", branch_arm: "low" },
+                             { key: "publish_content", job: "PublishContentJob" })
+add_edges(moderation, moderation_steps,
+          %w[ingest classify_content],
+          %w[classify_content extract_text], %w[classify_content detect_objects],
+          %w[extract_text run_nlp],
+          %w[detect_objects check_nsfw],
+          # Both arms feed into second branch
+          %w[run_nlp review_priority], %w[check_nsfw review_priority],
+          %w[review_priority fast_review], %w[review_priority standard_review],
+          %w[fast_review publish_content], %w[standard_review publish_content])
+
+# 15. DataEnrichmentPipeline (succeeded, skip arm taken) — branch with empty arm
+enrichment = create_pipeline(type: "DataEnrichmentPipeline", status: "succeeded",
+                              params: { record_id: 33_100, source: "api" },
+                              age: 20.minutes, duration: 8.minutes)
+enrichment_steps = add_steps(enrichment,
+                             { key: "fetch_record", job: "FetchRecordJob" },
+                             { key: "quality_check", job: branch_job, decides: "needs_enrichment",
+                               branch_result: "skip", empty_arms: %w[skip] },
+                             { key: "geocode", job: "GeocodeJob",
+                               branch_key: "quality_check", branch_arm: "enrich", status: "skipped_by_branch" },
+                             { key: "normalize", job: "NormalizeJob",
+                               branch_key: "quality_check", branch_arm: "enrich", status: "skipped_by_branch" },
+                             { key: "save_record", job: "SaveRecordJob" })
+add_edges(enrichment, enrichment_steps,
+          %w[fetch_record quality_check],
+          %w[quality_check geocode],
+          %w[geocode normalize],
+          %w[normalize save_record])
+
+# 16. DataEnrichmentPipeline (succeeded, enrich arm taken) — same type, different path
+enrichment2 = create_pipeline(type: "DataEnrichmentPipeline", status: "succeeded",
+                               params: { record_id: 33_101, source: "upload" },
+                               age: 10.minutes, duration: 15.minutes)
+enrichment2_steps = add_steps(enrichment2,
+                              { key: "fetch_record", job: "FetchRecordJob" },
+                              { key: "quality_check", job: branch_job, decides: "needs_enrichment",
+                                branch_result: "enrich", empty_arms: %w[skip] },
+                              { key: "geocode", job: "GeocodeJob",
+                                branch_key: "quality_check", branch_arm: "enrich" },
+                              { key: "normalize", job: "NormalizeJob",
+                                branch_key: "quality_check", branch_arm: "enrich" },
+                              { key: "save_record", job: "SaveRecordJob" })
+add_edges(enrichment2, enrichment2_steps,
+          %w[fetch_record quality_check],
+          %w[quality_check geocode],
+          %w[geocode normalize],
+          %w[normalize save_record])
+
+# 17. OrderRoutingPipeline (succeeded, skip on first branch, process on second) — 2 sequential branches with empty arms
+routing = create_pipeline(type: "OrderRoutingPipeline", status: "succeeded",
+                           params: { order_id: 50_100, region: "eu" },
+                           age: 40.minutes, duration: 12.minutes)
+routing_steps = add_steps(routing,
+                          { key: "receive_order", job: "ReceiveOrderJob" },
+                          # First branch: fraud check — skip (no fraud)
+                          { key: "fraud_check", job: branch_job, decides: "check_fraud",
+                            branch_result: "safe", empty_arms: %w[safe] },
+                          { key: "manual_review", job: "ManualReviewJob",
+                            branch_key: "fraud_check", branch_arm: "suspicious",
+                            status: "skipped_by_branch" },
+                          { key: "flag_account", job: "FlagAccountJob",
+                            branch_key: "fraud_check", branch_arm: "suspicious",
+                            status: "skipped_by_branch" },
+                          # Second branch: shipping method
+                          { key: "shipping_method", job: branch_job, decides: "pick_shipping",
+                            branch_result: "express", empty_arms: %w[pickup] },
+                          { key: "schedule_courier", job: "ScheduleCourierJob",
+                            branch_key: "shipping_method", branch_arm: "express" },
+                          { key: "generate_label", job: "GenerateLabelJob",
+                            branch_key: "shipping_method", branch_arm: "express" },
+                          { key: "notify_warehouse", job: "NotifyWarehouseJob",
+                            branch_key: "shipping_method", branch_arm: "standard",
+                            status: "skipped_by_branch" },
+                          { key: "send_confirmation", job: "SendConfirmationJob" })
+add_edges(routing, routing_steps,
+          %w[receive_order fraud_check],
+          %w[fraud_check manual_review], %w[manual_review flag_account],
+          # First branch exit → second branch
+          %w[flag_account shipping_method],
+          %w[shipping_method schedule_courier], %w[shipping_method notify_warehouse],
+          %w[schedule_courier generate_label],
+          %w[generate_label send_confirmation], %w[notify_warehouse send_confirmation])
+
+# 18. OrderRoutingPipeline (succeeded, suspicious + pickup) — both empty arms skipped through
+routing2 = create_pipeline(type: "OrderRoutingPipeline", status: "succeeded",
+                            params: { order_id: 50_101, region: "us" },
+                            age: 25.minutes, duration: 18.minutes)
+routing2_steps = add_steps(routing2,
+                           { key: "receive_order", job: "ReceiveOrderJob" },
+                           # First branch: fraud — suspicious path taken
+                           { key: "fraud_check", job: branch_job, decides: "check_fraud",
+                             branch_result: "suspicious", empty_arms: %w[safe] },
+                           { key: "manual_review", job: "ManualReviewJob",
+                             branch_key: "fraud_check", branch_arm: "suspicious" },
+                           { key: "flag_account", job: "FlagAccountJob",
+                             branch_key: "fraud_check", branch_arm: "suspicious" },
+                           # Second branch: shipping — pickup (empty arm)
+                           { key: "shipping_method", job: branch_job, decides: "pick_shipping",
+                             branch_result: "pickup", empty_arms: %w[pickup] },
+                           { key: "schedule_courier", job: "ScheduleCourierJob",
+                             branch_key: "shipping_method", branch_arm: "express",
+                             status: "skipped_by_branch" },
+                           { key: "generate_label", job: "GenerateLabelJob",
+                             branch_key: "shipping_method", branch_arm: "express",
+                             status: "skipped_by_branch" },
+                           { key: "notify_warehouse", job: "NotifyWarehouseJob",
+                             branch_key: "shipping_method", branch_arm: "standard",
+                             status: "skipped_by_branch" },
+                           { key: "send_confirmation", job: "SendConfirmationJob" })
+add_edges(routing2, routing2_steps,
+          %w[receive_order fraud_check],
+          %w[fraud_check manual_review], %w[manual_review flag_account],
+          %w[flag_account shipping_method],
+          %w[shipping_method schedule_courier], %w[shipping_method notify_warehouse],
+          %w[schedule_courier generate_label],
+          %w[generate_label send_confirmation], %w[notify_warehouse send_confirmation])
+
+# 19. NotificationRoutingPipeline (succeeded, skip arm to End) — branch at the end with empty arm
+notif_routing = create_pipeline(type: "NotificationRoutingPipeline", status: "succeeded",
+                                 params: { user_id: 77_200, event: "purchase" },
+                                 age: 5.minutes, duration: 3.minutes)
+notif_routing_steps = add_steps(notif_routing,
+                                { key: "load_preferences", job: "LoadPreferencesJob" },
+                                { key: "notification_channel", job: branch_job, decides: "preferred_channel",
+                                  branch_result: "none", empty_arms: %w[none] },
+                                { key: "send_email", job: "SendEmailJob",
+                                  branch_key: "notification_channel", branch_arm: "email",
+                                  status: "skipped_by_branch" },
+                                { key: "send_push", job: "SendPushJob",
+                                  branch_key: "notification_channel", branch_arm: "push",
+                                  status: "skipped_by_branch" })
+add_edges(notif_routing, notif_routing_steps,
+          %w[load_preferences notification_channel],
+          %w[notification_channel send_email], %w[notification_channel send_push])
+
 puts "Done! #{GoodPipeline::PipelineRecord.count} pipelines seeded."

data/demo/test/good_pipeline/test_coordinator.rb

@@ -193,6 +193,24 @@ class TestCoordinator < ActiveSupport::TestCase
     assert_predicate pipeline.reload, :halt_triggered?
   end
 
+  def test_halt_with_step_ignore_exempts_transitive_descendants
+    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", dependencies: [step_b])
+    step_d = build_step(pipeline, key: "d")
+    step_a.update_columns(coordination_status: "enqueued")
+
+    GoodPipeline::Coordinator.complete_step(step_a.reload, succeeded: false)
+
+    refute_equal "skipped", step_b.reload.coordination_status
+    refute_equal "skipped", step_c.reload.coordination_status,
+                 "Transitive descendant of :ignore step should NOT be skipped by halt"
+    assert_equal "skipped", step_d.reload.coordination_status,
+                 "Unrelated step should still be skipped under :halt"
+  end
+
   # --- Continue strategy ---
 
   def test_continue_skips_only_unsatisfied_descendants

data/demo/test/good_pipeline/test_step_record.rb

@@ -100,20 +100,20 @@ class TestStepRecord < ActiveSupport::TestCase
 
   # --- transition_coordination_status_to! invalid transitions ---
 
-  def test_transition_pending_to_succeeded_raises
+  def test_transition_pending_to_succeeded_allowed_for_branch_steps
     pipeline = create_pipeline
     step = create_step(pipeline)
-    assert_raises(GoodPipeline::InvalidTransition) do
-      step.transition_coordination_status_to!(:succeeded)
-    end
+    step.transition_coordination_status_to!(:succeeded)
+
+    assert_equal "succeeded", step.coordination_status
   end
 
-  def test_transition_pending_to_failed_raises
+  def test_transition_pending_to_failed_allowed_for_branch_resolution_failures
     pipeline = create_pipeline
     step = create_step(pipeline)
-    assert_raises(GoodPipeline::InvalidTransition) do
-      step.transition_coordination_status_to!(:failed)
-    end
+    step.transition_coordination_status_to!(:failed)
+
+    assert_equal "failed", step.coordination_status
   end
 
   def test_transition_enqueued_to_pending_raises
@@ -169,11 +169,13 @@ class TestStepRecord < ActiveSupport::TestCase
   def test_error_message_includes_step_key
     pipeline = create_pipeline
     step = create_step(pipeline, key: "transcode")
+    step.transition_coordination_status_to!(:enqueued)
     error = assert_raises(GoodPipeline::InvalidTransition) do
-      step.transition_coordination_status_to!(:succeeded)
+      step.transition_coordination_status_to!(:pending)
     end
+
     assert_includes error.message, "transcode"
-    assert_includes error.message, "from 'pending' to 'succeeded'"
+    assert_includes error.message, "from 'enqueued' to 'pending'"
   end
 
   # --- Accepts symbols ---

data/demo/test/integration/test_branch_execution.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestBranchExecution < ActiveSupport::TestCase
+  def test_full_branch_pipeline_hd_path
+    chain = BranchTestPipeline.run(choice: "hd")
+    perform_enqueued_jobs_inline
+
+    pipeline = chain.reload
+    assert_equal "succeeded", pipeline.status
+
+    steps = pipeline.steps.index_by(&:key)
+    assert_equal "succeeded", steps["analyze"].coordination_status
+    assert_equal "succeeded", steps["format_check"].coordination_status
+    assert_equal "succeeded", steps["transcode_hd"].coordination_status
+    assert_equal "succeeded", steps["upscale"].coordination_status
+    assert_equal "skipped_by_branch", steps["transcode_sd"].coordination_status
+    assert_equal "succeeded", steps["finish"].coordination_status
+
+    branch_step = steps["format_check"]
+    assert_equal "hd", branch_step.branch_result
+  end
+
+  def test_full_branch_pipeline_sd_path
+    chain = BranchTestPipeline.run(choice: "sd")
+    perform_enqueued_jobs_inline
+
+    pipeline = chain.reload
+    steps = pipeline.steps.index_by(&:key)
+
+    assert_equal "succeeded", pipeline.status
+    assert_equal "succeeded", steps["analyze"].coordination_status
+    assert_equal "succeeded", steps["format_check"].coordination_status
+    assert_equal "skipped_by_branch", steps["transcode_hd"].coordination_status
+    assert_equal "skipped_by_branch", steps["upscale"].coordination_status
+    assert_equal "succeeded", steps["transcode_sd"].coordination_status
+    assert_equal "succeeded", steps["finish"].coordination_status
+  end
+
+  def test_branch_skipped_arm_satisfies_downstream
+    chain = BranchTestPipeline.run(choice: "hd")
+    perform_enqueued_jobs_inline
+
+    pipeline = chain.reload
+    finish_step = pipeline.steps.find_by(key: "finish")
+
+    assert_equal "succeeded", finish_step.coordination_status
+  end
+
+  def test_branch_with_multiple_steps_per_arm
+    chain = BranchTestPipeline.run(choice: "hd")
+    perform_enqueued_jobs_inline
+
+    pipeline = chain.reload
+    steps = pipeline.steps.index_by(&:key)
+
+    assert_equal "succeeded", steps["transcode_hd"].coordination_status
+    assert_equal "succeeded", steps["upscale"].coordination_status
+  end
+
+  def test_branch_decision_result_cached_on_step
+    chain = BranchTestPipeline.run(choice: "sd")
+    perform_enqueued_jobs_inline
+
+    pipeline = chain.reload
+    branch_step = pipeline.steps.find_by(key: "format_check")
+
+    assert_equal "sd", branch_step.branch_result
+  end
+
+  def test_branch_step_is_real_step_with_sentinel_job_class
+    chain = BranchTestPipeline.run(choice: "hd")
+
+    pipeline = chain.reload
+    branch_step = pipeline.steps.find_by(key: "format_check")
+
+    assert_predicate branch_step, :branch_step?
+    assert_equal GoodPipeline::BRANCH_JOB_CLASS, branch_step.job_class
+    assert_equal "pick_format", branch_step.decides
+  end
+
+  def test_arm_steps_have_branch_metadata
+    chain = BranchTestPipeline.run(choice: "hd")
+
+    pipeline = chain.reload
+    arm_steps = pipeline.steps.select(&:branch_arm_step?)
+
+    assert_equal 3, arm_steps.size
+    arm_steps.each { |step| assert_equal "format_check", step.branch_key }
+
+    hd_steps = arm_steps.select { |step| step.branch_arm == "hd" }
+    sd_steps = arm_steps.select { |step| step.branch_arm == "sd" }
+
+    assert_equal 2, hd_steps.size
+    assert_equal 1, sd_steps.size
+  end
+end