geneva_drive 0.6.0 → 0.7.0

data/test/dsl/signal_step_definition_test.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# wait: and wait_for: read alike and take disjoint types, so the step
+# definition enforces the disjointness in both directions at class load.
+class SignalStepDefinitionTest < ActiveSupport::TestCase
+  class NameSetMatcher
+    def initialize(*names)
+      @names = names.map(&:to_s)
+    end
+
+    def matches?(signal)
+      @names.include?(signal.name)
+    end
+  end
+
+  def build_step(**options)
+    GenevaDrive::StepDefinition.new(name: "capture", callable: proc {}, **options)
+  end
+
+  test "wait_for: with a symbol builds a name matcher" do
+    step_def = build_step(wait_for: :payment_confirmed)
+
+    assert step_def.waits_for_signal?
+    assert_equal "payment_confirmed", step_def.signal_matcher.name
+    assert_nil step_def.signal_matcher.condition
+  end
+
+  test "wait_for: with a string builds a name matcher" do
+    step_def = build_step(wait_for: "payment_confirmed")
+
+    assert step_def.waits_for_signal?
+    assert_equal "payment_confirmed", step_def.signal_matcher.name
+  end
+
+  test "wait_for: with a SignalMatcher keeps it as-is" do
+    matcher = GenevaDrive::SignalMatcher.new(:payment_confirmed) { |payload| payload[:order_id] == 1 }
+    step_def = build_step(wait_for: matcher)
+
+    assert_same matcher, step_def.signal_matcher
+    assert_equal "payment_confirmed", step_def.signal_matcher.name
+    assert step_def.signal_matcher.condition
+  end
+
+  test "a SignalMatcher needs a name" do
+    assert_raises(ArgumentError) { GenevaDrive::SignalMatcher.new(nil) }
+    assert_raises(ArgumentError) { GenevaDrive::SignalMatcher.new("") }
+  end
+
+  test "wait_for: with a custom matcher object delegates the whole predicate" do
+    matcher = NameSetMatcher.new(:a, :b)
+    step_def = build_step(wait_for: matcher)
+
+    assert step_def.waits_for_signal?
+    assert_same matcher, step_def.signal_matcher
+  end
+
+  test "steps without wait_for: do not wait for a signal" do
+    assert_not build_step.waits_for_signal?
+    assert_nil build_step.signal_matcher
+  end
+
+  test "wait_for: with a duration points at wait:" do
+    error = assert_raises(GenevaDrive::StepConfigurationError) { build_step(wait_for: 2.days) }
+
+    assert_match(/wait_for: 2 days/, error.message)
+    assert_match(/to delay the step, use wait:/, error.message)
+  end
+
+  test "wait_for: with a number points at wait:" do
+    error = assert_raises(GenevaDrive::StepConfigurationError) { build_step(wait_for: 30) }
+
+    assert_match(/to delay the step, use wait:/, error.message)
+  end
+
+  test "wait_for: with a time points at wait:" do
+    error = assert_raises(GenevaDrive::StepConfigurationError) { build_step(wait_for: Time.current) }
+
+    assert_match(/to delay the step, use wait:/, error.message)
+  end
+
+  test "wait: with a symbol points at wait_for:" do
+    error = assert_raises(GenevaDrive::StepConfigurationError) { build_step(wait: :payment_confirmed) }
+
+    assert_match(/wait: :payment_confirmed/, error.message)
+    assert_match(/to wait for a signal, use wait_for:/, error.message)
+  end
+
+  test "wait: with a string points at wait_for: instead of silently meaning zero seconds" do
+    error = assert_raises(GenevaDrive::StepConfigurationError) { build_step(wait: "payment_confirmed") }
+
+    assert_match(/to wait for a signal, use wait_for:/, error.message)
+  end
+
+  test "wait: with a duration-shaped string is rejected too" do
+    error = assert_raises(GenevaDrive::StepConfigurationError) { build_step(wait: "7200") }
+
+    assert_match(/to wait for a signal, use wait_for:/, error.message)
+  end
+
+  test "wait: with a matcher object points at wait_for:" do
+    error = assert_raises(GenevaDrive::StepConfigurationError) { build_step(wait: NameSetMatcher.new(:a)) }
+
+    assert_match(/to wait for a signal, use wait_for:/, error.message)
+  end
+
+  test "wait: still accepts durations and numbers" do
+    assert_equal 2.days, build_step(wait: 2.days).wait
+    assert_equal 30, build_step(wait: 30).wait
+  end
+
+  test "wait_for: with an unusable value is rejected" do
+    error = assert_raises(GenevaDrive::StepConfigurationError) { build_step(wait_for: Object.new) }
+
+    assert_match(/must be a Symbol, String, GenevaDrive::SignalMatcher, or an object responding to #matches\?/, error.message)
+  end
+
+  test "wait: and wait_for: compose" do
+    step_def = build_step(wait: 2.days, wait_for: :payment_confirmed)
+
+    assert_equal 2.days, step_def.wait
+    assert step_def.waits_for_signal?
+  end
+
+  test "resumable steps accept wait_for:" do
+    step_def = GenevaDrive::ResumableStepDefinition.new(name: "iterate", wait_for: :go) { |iter| }
+
+    assert step_def.resumable?
+    assert step_def.waits_for_signal?
+  end
+end

data/test/jobs/housekeeping_signals_test.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Signals are wiped with their workflows, and parked executions - which the
+# stuck sweeps deliberately ignore - are reported through gauges instead.
+class HousekeepingSignalsTest < ActiveSupport::TestCase
+  include GenevaDrive::TestHelpers
+
+  class GaugeRecorder
+    attr_reader :gauges
+
+    def initialize
+      @gauges = []
+    end
+
+    def set_gauge(name, value, tags = {})
+      @gauges << {name: name.to_s, value: value, tags: tags}
+    end
+
+    def instrument(*, &blk) = blk&.call
+
+    def add_distribution_value(*) = nil
+
+    def increment_counter(*) = nil
+  end
+
+  class WaitingWorkflow < GenevaDrive::Workflow
+    step :await_payment, wait_for: :payment_confirmed do
+    end
+  end
+
+  class OtherWaitingWorkflow < GenevaDrive::Workflow
+    step :await_approval, wait_for: :approved do
+    end
+  end
+
+  setup do
+    @user = create_user
+    @original_delete_after = GenevaDrive.delete_completed_workflows_after
+    @original_batch_size = GenevaDrive.housekeeping_batch_size
+    @original_waiting_threshold = GenevaDrive.waiting_visibility_threshold
+    @recorder = GaugeRecorder.new
+    Measurometer.drivers << @recorder
+  end
+
+  teardown do
+    GenevaDrive.delete_completed_workflows_after = @original_delete_after
+    GenevaDrive.housekeeping_batch_size = @original_batch_size
+    GenevaDrive.waiting_visibility_threshold = @original_waiting_threshold
+    Measurometer.drivers.delete(@recorder)
+  end
+
+  def gauge(name, workflow: nil)
+    found = @recorder.gauges.select { |g| g[:name] == name && g[:tags][:workflow] == workflow }
+    found.last&.fetch(:value)
+  end
+
+  def park_workflow(workflow_class, user)
+    workflow = workflow_class.create!(hero: user)
+    workflow.current_execution.execute!
+    workflow.reload
+  end
+
+  test "signals of old workflows are deleted before the workflows themselves" do
+    GenevaDrive.delete_completed_workflows_after = 30.days
+
+    workflow = WaitingWorkflow.create!(hero: @user)
+    workflow.signal!(:payment_confirmed)
+    workflow.signal!(:unrelated)
+    workflow.cancel!
+    workflow.update!(transitioned_at: 60.days.ago)
+
+    results = GenevaDrive::HousekeepingJob.perform_now
+
+    assert_equal 2, results[:signals_cleaned_up]
+    assert_equal 1, results[:workflows_cleaned_up]
+    assert_equal 0, GenevaDrive::Signal.where(workflow_id: workflow.id).count
+    assert_not GenevaDrive::Workflow.exists?(workflow.id)
+  end
+
+  test "signals of recent workflows are kept" do
+    GenevaDrive.delete_completed_workflows_after = 30.days
+
+    workflow = WaitingWorkflow.create!(hero: @user)
+    workflow.signal!(:payment_confirmed)
+    workflow.cancel!
+
+    results = GenevaDrive::HousekeepingJob.perform_now
+
+    assert_equal 0, results[:signals_cleaned_up]
+    assert_equal 1, GenevaDrive::Signal.where(workflow_id: workflow.id).count
+  end
+
+  test "signal deletion is batched" do
+    GenevaDrive.delete_completed_workflows_after = 30.days
+    GenevaDrive.housekeeping_batch_size = 2
+
+    workflow = WaitingWorkflow.create!(hero: @user)
+    4.times { |n| workflow.signal!(:noise, idempotency_key: "evt_#{n}") }
+    workflow.cancel!
+    workflow.update!(transitioned_at: 60.days.ago)
+
+    results = GenevaDrive::HousekeepingJob.perform_now
+
+    assert_equal 4, results[:signals_cleaned_up]
+    assert_equal 0, GenevaDrive::Signal.where(workflow_id: workflow.id).count
+  end
+
+  test "parked executions are counted per workflow class" do
+    park_workflow(WaitingWorkflow, @user)
+    park_workflow(OtherWaitingWorkflow, create_user(email: "two@example.com"))
+
+    GenevaDrive::HousekeepingJob.perform_now
+
+    assert_equal 1, gauge("geneva_drive.waiting_step_executions", workflow: WaitingWorkflow.name)
+    assert_equal 1, gauge("geneva_drive.waiting_step_executions", workflow: OtherWaitingWorkflow.name)
+    assert_equal 2, gauge("geneva_drive.waiting_step_executions")
+  end
+
+  test "parked executions past the visibility threshold are reported as overdue" do
+    GenevaDrive.waiting_visibility_threshold = 7.days
+
+    fresh = park_workflow(WaitingWorkflow, @user)
+    stale = park_workflow(OtherWaitingWorkflow, create_user(email: "two@example.com"))
+    stale.current_execution.update!(waiting_since: 30.days.ago)
+
+    GenevaDrive::HousekeepingJob.perform_now
+
+    assert_equal 1, gauge("geneva_drive.waiting_overdue")
+    assert_equal 1, gauge("geneva_drive.waiting_overdue", workflow: OtherWaitingWorkflow.name)
+    assert_nil gauge("geneva_drive.waiting_overdue", workflow: WaitingWorkflow.name)
+    assert_equal "waiting", fresh.current_execution.state
+  end
+
+  test "the overdue gauge can be disabled" do
+    GenevaDrive.waiting_visibility_threshold = nil
+    park_workflow(WaitingWorkflow, @user)
+
+    GenevaDrive::HousekeepingJob.perform_now
+
+    assert_nil gauge("geneva_drive.waiting_overdue")
+    assert_equal 1, gauge("geneva_drive.waiting_step_executions")
+  end
+
+  test "parked executions are never treated as stuck" do
+    GenevaDrive.delete_completed_workflows_after = nil
+    workflow = park_workflow(WaitingWorkflow, @user)
+    workflow.current_execution.update!(scheduled_for: 30.days.ago, waiting_since: 30.days.ago)
+
+    results = GenevaDrive::HousekeepingJob.perform_now
+
+    assert_equal 0, results[:stuck_scheduled_recovered]
+    assert_equal 0, results[:stuck_in_progress_recovered]
+    assert_equal "waiting", workflow.reload.current_execution.state
+  end
+
+  test "a worker crashing mid-step re-attaches to the same claimed signal" do
+    GenevaDrive.delete_completed_workflows_after = nil
+    workflow = park_workflow(WaitingWorkflow, @user)
+    signal = workflow.signal!(:payment_confirmed, payload: {amount_cents: 7})
+
+    # Pretend the worker died after the gate attached and the step started
+    crashed = workflow.reload.current_execution
+    crashed.update!(state: "in_progress", started_at: 30.days.ago)
+    workflow.update!(state: "performing", current_step_name: "await_payment")
+
+    results = GenevaDrive::HousekeepingJob.perform_now
+
+    assert_equal 1, results[:stuck_in_progress_recovered]
+    assert_equal "claimed", signal.reload.state
+
+    recovered = workflow.reload.current_execution
+    recovered.execute!
+
+    assert_equal signal.id, recovered.reload.signal_id
+    assert_equal "consumed", signal.reload.state
+  end
+
+  test "a dispatched execution whose job got lost is recovered as a stuck scheduled one" do
+    GenevaDrive.delete_completed_workflows_after = nil
+    workflow = park_workflow(WaitingWorkflow, @user)
+    signal = workflow.signal!(:payment_confirmed)
+
+    # Pretend the enqueue evaporated and the threshold has passed
+    workflow.current_execution.update!(scheduled_for: 30.days.ago)
+
+    results = GenevaDrive::HousekeepingJob.perform_now
+
+    assert_equal 1, results[:stuck_scheduled_recovered]
+
+    recovered = workflow.reload.current_execution
+    assert_equal "scheduled", recovered.state
+    # The fresh execution re-attaches to the still-claimed signal at its gate
+    recovered.execute!
+    assert_equal "consumed", signal.reload.state
+  end
+end

data/test/migration_helpers_test.rb

@@ -3,7 +3,7 @@
 require "test_helper"
 
 class MigrationHelpersTest < ActiveSupport::TestCase
-  FakeColumn = Struct.new(:name, :sql_type, :default_function, keyword_init: true)
+  FakeColumn = Struct.new(:name, :sql_type, :default_function)
 
   # Creates a fresh harness with the given fake columns as the app id columns.
   def build_migration(columns = [])

data/test/test_helper.rb

@@ -55,6 +55,8 @@ class ActiveSupport::TestCase
   setup do
     GenevaDrive::StepExecution.reset_metadata_column_cache!
     GenevaDrive::StepExecution.reset_resumable_columns_cache!
+    GenevaDrive::StepExecution.reset_signal_columns_cache!
+    GenevaDrive::Signal.reset_table_available_cache!
     GenevaDrive::Workflow.reset_metadata_column_cache!
   end