geneva_drive 0.3.0 → 0.4.0

data/test/workflow/executor_test.rb

@@ -537,4 +537,97 @@ class ExecutorTest < ActiveSupport::TestCase
     assert_equal [:around_before, :step_body, :around_after], events
     assert_equal step_execution.id, AroundHookTrackingWorkflow.step_execution_id
   end
+
+  test "marks step as failed and pauses workflow when hero class does not exist" do
+    # Create a workflow with a hero_type that references a non-existent class
+    workflow = BasicWorkflow.create!(hero: @user)
+    step_execution = workflow.step_executions.first
+
+    # Manually set hero_type to a non-existent class
+    workflow.update_column(:hero_type, "NonExistentClass")
+
+    # Execute the job - should raise but also record the failure
+    error = assert_raises(NameError) do
+      GenevaDrive::Executor.execute!(step_execution)
+    end
+
+    assert_match(/NonExistentClass/, error.message)
+
+    step_execution.reload
+    workflow.reload
+
+    assert_equal "failed", step_execution.state
+    assert_equal "paused", workflow.state
+    assert_match(/uninitialized constant/, step_execution.error_message)
+    assert_equal "NameError", step_execution.error_class_name
+    assert_not_nil step_execution.error_backtrace
+  end
+
+  # Workflow that raises during prepare_execution but has on_exception: :skip!
+  class PrepareExceptionSkipWorkflow < GenevaDrive::Workflow
+    step :first_step, on_exception: :skip! do
+      # This won't run - exception happens during prepare
+    end
+
+    step :second_step do
+      Thread.current[:prepare_exception_skip_ran] = true
+    end
+
+    def self.second_ran?
+      Thread.current[:prepare_exception_skip_ran]
+    end
+
+    def self.reset_tracking!
+      Thread.current[:prepare_exception_skip_ran] = nil
+    end
+  end
+
+  test "respects on_exception: :skip! policy for prepare_execution exceptions" do
+    PrepareExceptionSkipWorkflow.reset_tracking!
+    workflow = PrepareExceptionSkipWorkflow.create!(hero: @user)
+    step_execution = workflow.step_executions.first
+
+    # Manually set hero_type to a non-existent class
+    workflow.update_column(:hero_type, "NonExistentClass")
+
+    error = assert_raises(NameError) do
+      GenevaDrive::Executor.execute!(step_execution)
+    end
+
+    assert_match(/NonExistentClass/, error.message)
+
+    step_execution.reload
+    workflow.reload
+
+    assert_equal "failed", step_execution.state
+    assert_equal "ready", workflow.state
+    # Should have scheduled the next step
+    assert_equal 2, workflow.step_executions.count
+    assert_equal "second_step", workflow.step_executions.order(:id).last.step_name
+  end
+
+  # Workflow that raises during prepare_execution but has on_exception: :cancel!
+  class PrepareExceptionCancelWorkflow < GenevaDrive::Workflow
+    step :first_step, on_exception: :cancel! do
+      # This won't run - exception happens during prepare
+    end
+  end
+
+  test "respects on_exception: :cancel! policy for prepare_execution exceptions" do
+    workflow = PrepareExceptionCancelWorkflow.create!(hero: @user)
+    step_execution = workflow.step_executions.first
+
+    # Manually set hero_type to a non-existent class
+    workflow.update_column(:hero_type, "NonExistentClass")
+
+    assert_raises(NameError) do
+      GenevaDrive::Executor.execute!(step_execution)
+    end
+
+    step_execution.reload
+    workflow.reload
+
+    assert_equal "failed", step_execution.state
+    assert_equal "canceled", workflow.state
+  end
 end

data/test/workflow/max_reattempts_test.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class MaxReattemptsTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+
+  # Disable transactional tests to test proper locking flows
+  self.use_transactional_tests = false
+
+  class TransientError < StandardError; end
+
+  # Workflow that always fails with reattempt limit
+  class LimitedReattemptWorkflow < GenevaDrive::Workflow
+    step :failing_step, on_exception: :reattempt!, max_reattempts: 3 do
+      raise TransientError, "Always failing"
+    end
+  end
+
+  # Workflow with unlimited reattempts (nil)
+  class UnlimitedReattemptWorkflow < GenevaDrive::Workflow
+    step :failing_step, on_exception: :reattempt!, max_reattempts: nil do
+      self.class.increment_execution_count!
+      raise TransientError, "Always failing"
+    end
+
+    class << self
+      def execution_count
+        @execution_count ||= 0
+      end
+
+      def increment_execution_count!
+        @execution_count ||= 0
+        @execution_count += 1
+      end
+
+      def reset_tracking!
+        @execution_count = 0
+      end
+    end
+  end
+
+  # Workflow that fails a few times then succeeds
+  class EventuallySucceedsWorkflow < GenevaDrive::Workflow
+    step :flaky_step, on_exception: :reattempt!, max_reattempts: 10 do
+      self.class.increment_execution_count!
+
+      # Fail first 5 times, succeed on 6th
+      if self.class.execution_count <= 5
+        raise TransientError, "Transient failure #{self.class.execution_count}"
+      end
+    end
+
+    class << self
+      def execution_count
+        @execution_count ||= 0
+      end
+
+      def increment_execution_count!
+        @execution_count ||= 0
+        @execution_count += 1
+      end
+
+      def reset_tracking!
+        @execution_count = 0
+      end
+    end
+  end
+
+  # Workflow that uses manual reattempt! calls
+  class ManualReattemptWorkflow < GenevaDrive::Workflow
+    class << self
+      def execution_count
+        @execution_count ||= 0
+      end
+
+      def increment_execution_count!
+        @execution_count ||= 0
+        @execution_count += 1
+      end
+
+      def reset_tracking!
+        @execution_count = 0
+      end
+    end
+
+    # max_reattempts: 2 for automatic exception handling
+    step :manual_reattempt_step, on_exception: :reattempt!, max_reattempts: 2 do
+      self.class.increment_execution_count!
+
+      # Use manual reattempt! for first 5 attempts, then succeed
+      if self.class.execution_count <= 5
+        reattempt!
+      end
+    end
+  end
+
+  # Workflow with precondition that fails
+  class PreconditionReattemptWorkflow < GenevaDrive::Workflow
+    step :step_with_flaky_precondition, on_exception: :reattempt!, max_reattempts: 2, skip_if: :flaky_check do
+      # Step body - never reached
+    end
+
+    class << self
+      def execution_count
+        @execution_count ||= 0
+      end
+
+      def increment_execution_count!
+        @execution_count ||= 0
+        @execution_count += 1
+      end
+
+      def reset_tracking!
+        @execution_count = 0
+      end
+    end
+
+    def flaky_check
+      self.class.increment_execution_count!
+      raise TransientError, "Precondition failure"
+    end
+  end
+
+  setup do
+    clean_database!
+    @user = User.create!(email: "test@example.com", name: "Test User")
+    UnlimitedReattemptWorkflow.reset_tracking!
+    EventuallySucceedsWorkflow.reset_tracking!
+    PreconditionReattemptWorkflow.reset_tracking!
+    ManualReattemptWorkflow.reset_tracking!
+  end
+
+  teardown do
+    clean_database!
+    UnlimitedReattemptWorkflow.reset_tracking!
+    EventuallySucceedsWorkflow.reset_tracking!
+    PreconditionReattemptWorkflow.reset_tracking!
+    ManualReattemptWorkflow.reset_tracking!
+  end
+
+  test "pauses workflow when max_reattempts is exceeded" do
+    workflow = LimitedReattemptWorkflow.create!(hero: @user)
+
+    # Execute 3 attempts (max_reattempts: 3)
+    3.times do |i|
+      step_execution = workflow.step_executions.order(:created_at).last
+      assert_raises(TransientError) do
+        GenevaDrive::PerformStepJob.perform_now(step_execution.id)
+      end
+      workflow.reload
+    end
+
+    # After 3 reattempts, workflow should still be ready with 4 step executions
+    assert_equal "ready", workflow.state
+    assert_equal 4, workflow.step_executions.count
+
+    # 4th attempt should trigger the limit and pause
+    fourth_step_execution = workflow.step_executions.order(:created_at).last
+    assert_raises(TransientError) do
+      GenevaDrive::PerformStepJob.perform_now(fourth_step_execution.id)
+    end
+
+    workflow.reload
+    fourth_step_execution.reload
+
+    # Workflow should now be paused
+    assert_equal "paused", workflow.state
+
+    # Step execution should be failed with error stored
+    assert_equal "failed", fourth_step_execution.state
+    assert_equal "failed", fourth_step_execution.outcome
+    assert_equal "Always failing", fourth_step_execution.error_message
+
+    # No new step execution should be created
+    assert_equal 4, workflow.step_executions.count
+  end
+
+  test "allows unlimited reattempts when max_reattempts is nil" do
+    workflow = UnlimitedReattemptWorkflow.create!(hero: @user)
+
+    # Execute many attempts - should never pause due to limit
+    10.times do
+      step_execution = workflow.step_executions.order(:created_at).last
+      assert_raises(TransientError) do
+        GenevaDrive::PerformStepJob.perform_now(step_execution.id)
+      end
+      workflow.reload
+    end
+
+    # After 10 reattempts, workflow should still be ready
+    assert_equal "ready", workflow.state
+    assert_equal 11, workflow.step_executions.count
+
+    # All completed step executions should have "reattempted" outcome
+    completed_executions = workflow.step_executions.where(state: "completed")
+    assert_equal 10, completed_executions.count
+    assert completed_executions.all? { |se| se.outcome == "reattempted" }
+  end
+
+  test "resets reattempt count after successful execution" do
+    workflow = EventuallySucceedsWorkflow.create!(hero: @user)
+
+    # Execute 5 failing attempts
+    5.times do
+      step_execution = workflow.step_executions.order(:created_at).last
+      assert_raises(TransientError) do
+        GenevaDrive::PerformStepJob.perform_now(step_execution.id)
+      end
+      workflow.reload
+    end
+
+    # 6th attempt should succeed
+    sixth_step_execution = workflow.step_executions.order(:created_at).last
+    GenevaDrive::PerformStepJob.perform_now(sixth_step_execution.id)
+
+    workflow.reload
+    sixth_step_execution.reload
+
+    # Workflow should be finished (only one step)
+    assert_equal "finished", workflow.state
+
+    # Step execution should be completed with success
+    assert_equal "completed", sixth_step_execution.state
+    assert_equal "success", sixth_step_execution.outcome
+
+    # Should have 6 step executions total
+    assert_equal 6, workflow.step_executions.count
+  end
+
+  test "counts only consecutive reattempts since last success" do
+    # First, create a workflow that will eventually succeed
+    workflow = EventuallySucceedsWorkflow.create!(hero: @user)
+
+    # Execute 5 failing attempts + 1 success
+    5.times do
+      step_execution = workflow.step_executions.order(:created_at).last
+      assert_raises(TransientError) do
+        GenevaDrive::PerformStepJob.perform_now(step_execution.id)
+      end
+      workflow.reload
+    end
+
+    # 6th attempt succeeds
+    sixth_execution = workflow.step_executions.order(:created_at).last
+    GenevaDrive::PerformStepJob.perform_now(sixth_execution.id)
+    workflow.reload
+
+    # At this point we have 5 reattempts + 1 success
+    assert_equal "finished", workflow.state
+
+    # Verify the counts
+    reattempted_count = workflow.step_executions.where(outcome: "reattempted").count
+    success_count = workflow.step_executions.where(outcome: "success").count
+
+    assert_equal 5, reattempted_count
+    assert_equal 1, success_count
+  end
+
+  test "enforces limit on precondition exceptions" do
+    workflow = PreconditionReattemptWorkflow.create!(hero: @user)
+
+    # First 2 attempts should reattempt
+    2.times do
+      step_execution = workflow.step_executions.order(:created_at).last
+      assert_raises(TransientError) do
+        GenevaDrive::PerformStepJob.perform_now(step_execution.id)
+      end
+      workflow.reload
+    end
+
+    assert_equal "ready", workflow.state
+    assert_equal 3, workflow.step_executions.count
+
+    # 3rd attempt should trigger limit and pause
+    third_step_execution = workflow.step_executions.order(:created_at).last
+    assert_raises(TransientError) do
+      GenevaDrive::PerformStepJob.perform_now(third_step_execution.id)
+    end
+
+    workflow.reload
+    third_step_execution.reload
+
+    # Workflow should be paused
+    assert_equal "paused", workflow.state
+    assert_equal "failed", third_step_execution.state
+    assert_equal "failed", third_step_execution.outcome
+    assert_match(/Precondition failure/, third_step_execution.error_message)
+  end
+
+  test "manual reattempt! flow control is not limited" do
+    ManualReattemptWorkflow.reset_tracking!
+
+    workflow = ManualReattemptWorkflow.create!(hero: @user)
+
+    # Execute 5 manual reattempts - should not be limited
+    5.times do
+      step_execution = workflow.step_executions.order(:created_at).last
+      GenevaDrive::PerformStepJob.perform_now(step_execution.id)
+      workflow.reload
+    end
+
+    # After 5 manual reattempts, workflow should still be ready
+    assert_equal "ready", workflow.state
+    assert_equal 6, workflow.step_executions.count
+
+    # 6th attempt should succeed
+    sixth_execution = workflow.step_executions.order(:created_at).last
+    GenevaDrive::PerformStepJob.perform_now(sixth_execution.id)
+
+    workflow.reload
+
+    assert_equal "finished", workflow.state
+
+    ManualReattemptWorkflow.reset_tracking!
+  end
+
+  private
+
+  def clean_database!
+    GenevaDrive::StepExecution.delete_all
+    GenevaDrive::Workflow.delete_all
+    User.delete_all
+  end
+end

data/test/workflow/resume_and_skip_test.rb

@@ -224,6 +224,118 @@ class ResumeAndSkipTest < ActiveSupport::TestCase
     assert step_two_executions.exists?(state: "scheduled")
   end
 
+  test "resume! preserves remaining wait time when original scheduled time is still in the future" do
+    # This test verifies Option B behavior for pause/resume:
+    # When a workflow is paused and then resumed BEFORE the original scheduled time,
+    # the step should be rescheduled for the REMAINING time, not run immediately.
+    #
+    # Timeline:
+    # - T+0: step_one completes, step_two scheduled for T+2days
+    # - T+1day: workflow paused (1 day remaining until step_two)
+    # - T+1day: workflow resumed -> step_two should be scheduled for T+2days (original time)
+
+    start_time = Time.current
+    workflow = nil
+
+    travel_to(start_time) do
+      workflow = WaitingWorkflow.create!(hero: @user)
+
+      # Execute step_one - this schedules step_two for 2 days from now
+      perform_next_step(workflow)
+      assert_equal "step_two", workflow.next_step_name
+
+      original_execution = workflow.step_executions.where(step_name: "step_two", state: "scheduled").first
+      assert original_execution, "Should have a scheduled step_two execution"
+
+      # step_two should be scheduled for 2 days from start_time
+      expected_original_time = start_time + 2.days
+      assert_in_delta expected_original_time.to_f, original_execution.scheduled_for.to_f, 1.0,
+        "step_two should be scheduled for 2 days from now"
+    end
+
+    # Fast forward 1 day (halfway through the wait) and pause
+    travel_to(start_time + 1.day) do
+      workflow.pause!
+
+      assert_equal "paused", workflow.state
+
+      # The original execution should be canceled
+      canceled_execution = workflow.step_executions.where(step_name: "step_two", outcome: "workflow_paused").first
+      assert canceled_execution, "Should have a canceled step_two execution with outcome 'workflow_paused'"
+
+      # Now resume - step_two should be scheduled for the REMAINING time (1 day from now),
+      # which means at the ORIGINAL absolute time (start_time + 2.days)
+      workflow.resume!
+
+      assert_equal "ready", workflow.state
+
+      new_execution = workflow.step_executions.where(step_name: "step_two", state: "scheduled").first
+      assert new_execution, "Should have a new scheduled step_two execution"
+      assert_not_equal canceled_execution.id, new_execution.id, "Should be a different execution record"
+
+      # The new execution should be scheduled for the original time (start_time + 2.days),
+      # NOT for "now" (start_time + 1.day) and NOT for "now + 2.days" (start_time + 3.days)
+      expected_new_time = start_time + 2.days
+      assert_in_delta expected_new_time.to_f, new_execution.scheduled_for.to_f, 1.0,
+        "Resumed step_two should be scheduled for the original time (remaining wait preserved), not immediately"
+    end
+  end
+
+  test "resume! runs step immediately when paused before scheduled time but resumed after" do
+    # This test verifies the scenario where:
+    # - A step is scheduled for a future time
+    # - Workflow is paused BEFORE that time arrives
+    # - Workflow is resumed AFTER that time has passed
+    # - The step should run immediately (not wait for a negative duration)
+    #
+    # Timeline:
+    # - T+0: step_one completes, step_two scheduled for T+2days
+    # - T+1day: workflow paused (step_two was supposed to run in 1 more day)
+    # - T+3days: workflow resumed (original T+2days has passed)
+    # - Result: step_two runs immediately
+
+    start_time = Time.current
+    workflow = nil
+
+    travel_to(start_time) do
+      workflow = WaitingWorkflow.create!(hero: @user)
+
+      # Execute step_one - this schedules step_two for 2 days from now
+      perform_next_step(workflow)
+      assert_equal "step_two", workflow.next_step_name
+
+      original_execution = workflow.step_executions.where(step_name: "step_two", state: "scheduled").first
+      assert_in_delta (start_time + 2.days).to_f, original_execution.scheduled_for.to_f, 1.0,
+        "step_two should be scheduled for T+2days"
+    end
+
+    # T+1day: Pause BEFORE the scheduled time (1 day remaining)
+    travel_to(start_time + 1.day) do
+      workflow.pause!
+      assert_equal "paused", workflow.state
+
+      # The canceled execution should have the original scheduled_for time
+      canceled_execution = workflow.step_executions.where(step_name: "step_two", outcome: "workflow_paused").first
+      assert canceled_execution, "Should have a canceled execution"
+      assert_in_delta (start_time + 2.days).to_f, canceled_execution.scheduled_for.to_f, 1.0,
+        "Canceled execution should preserve original scheduled_for time"
+    end
+
+    # T+3days: Resume AFTER the original scheduled time has passed
+    travel_to(start_time + 3.days) do
+      workflow.resume!
+      assert_equal "ready", workflow.state
+
+      new_execution = workflow.step_executions.where(step_name: "step_two", state: "scheduled").first
+      assert new_execution, "Should have a new scheduled step_two execution"
+
+      # The step should run immediately since the original time (T+2days) has passed
+      # It should NOT be scheduled for T+5days (now + 2.days) or any other future time
+      assert_in_delta Time.current.to_f, new_execution.scheduled_for.to_f, 1.0,
+        "Resumed step_two should run immediately when original scheduled time has passed"
+    end
+  end
+
   test "skip! on externally paused workflow advances to next step" do
     workflow = WaitingWorkflow.create!(hero: @user)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geneva_drive
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -189,10 +189,11 @@ files:
 - test/dummy_install/config/puma.rb
 - test/dummy_install/config/routes.rb
 - test/dummy_install/db/migrate/20241217000000_create_users.rb
-- test/dummy_install/db/migrate/20260126164025_create_geneva_drive_workflows.rb
-- test/dummy_install/db/migrate/20260126164026_create_geneva_drive_step_executions.rb
-- test/dummy_install/db/migrate/20260126164027_add_finished_at_to_geneva_drive_step_executions.rb
-- test/dummy_install/db/migrate/20260126164028_add_error_class_name_to_geneva_drive_step_executions.rb
+- test/dummy_install/db/migrate/20260128104738_create_geneva_drive_workflows.rb
+- test/dummy_install/db/migrate/20260128104739_create_geneva_drive_step_executions.rb
+- test/dummy_install/db/migrate/20260128104740_add_finished_at_to_geneva_drive_step_executions.rb
+- test/dummy_install/db/migrate/20260128104741_add_error_class_name_to_geneva_drive_step_executions.rb
+- test/dummy_install/db/migrate/20260128104742_add_resumable_step_support_to_geneva_drive_step_executions.rb
 - test/dummy_install/db/schema.rb
 - test/dummy_install/log/test.log
 - test/dummy_install/public/400.html
@@ -213,6 +214,7 @@ files:
 - test/workflow/executor_test.rb
 - test/workflow/flow_control_test.rb
 - test/workflow/instrumentation_test.rb
+- test/workflow/max_reattempts_test.rb
 - test/workflow/missing_sti_class_resolution_test.rb
 - test/workflow/precondition_exception_test.rb
 - test/workflow/reattempt_on_exception_integration_test.rb