test: preserve caller lifecycle guarantees

Author: cardmagic

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## Unreleased
+
+- Preserve caller lifecycle guarantees with regression tests for concurrent
+  synchronous calls retaining their staged effects and for caller process
+  re-registration after stale-process cleanup and retention. Both cases
+  already work in Ruby; no runtime behavior or configuration changes.
+
 ## 0.17.4 - 2026-10-12
 
 - Renew activations between turns in a drain pass when renewal is due,

test/integration/caller_lifecycle_test.rb

@@ -0,0 +1,92 @@
+# rbs_inline: enabled
+
+require "database_test_helper"
+require "timeout"
+
+class CallerLifecycleTest < ActiveSupport::TestCase
+  class Counter < SolidObjects::Actor
+    actor_type "caller-lifecycle-counter"
+    attribute :count, default: 0
+
+    class << self
+      attr_accessor :started, :release
+    end
+
+    # @rbs (label: String) -> Integer
+    def increment(label:)
+      self.count += 1
+      emit(:caller_effect, label:)
+      if self.class.started
+        self.class.started << label
+        self.class.release.pop
+      end
+      count
+    end
+  end
+
+  setup do
+    SolidObjects.configuration.max_attempts = 1
+  end
+
+  teardown do
+    Counter.started = nil
+    Counter.release = nil
+  end
+
+  test "concurrent callers preserve staged effects and ordered state" do
+    Counter.started = Queue.new
+    Counter.release = Queue.new
+    enqueued = Queue.new
+    subscription = ActiveSupport::Notifications.subscribe("solid_objects.message.enqueued") { enqueued << true }
+    reference = Counter.ref("concurrent")
+
+    first = Thread.new { reference.increment(label: "first") }
+    assert_equal "first", Timeout.timeout(10) { Counter.started.pop }
+    second = Thread.new { reference.increment(label: "second") }
+    2.times { Timeout.timeout(10) { enqueued.pop } }
+    Counter.release << true
+    assert_equal 1, Timeout.timeout(10) { first.value }
+    assert_equal "second", Timeout.timeout(10) { Counter.started.pop }
+    Counter.release << true
+    assert_equal 2, Timeout.timeout(10) { second.value }
+
+    instance = SolidObjects::Instance.find_by!(actor_type: Counter.actor_type, actor_id: "concurrent")
+    assert_equal({ "count" => 2 }, instance.state)
+    assert_equal [ "first", "second" ], SolidObjects::Effect.all.map { |effect| effect.arguments.fetch("label") }.sort
+    assert_equal [ 1, 1 ], SolidObjects::Message.order(:sequence).pluck(:attempt_count)
+    assert_empty SolidObjects::ClaimedMessage.all
+    assert_empty SolidObjects::DeadLetter.all
+  ensure
+    Counter.release << true if first&.alive?
+    Counter.release << true if second&.alive?
+    first&.join(10)
+    second&.join(10)
+    ActiveSupport::Notifications.unsubscribe(subscription) if subscription
+  end
+
+  test "caller re-registers after stale cleanup and process retention" do
+    reference = Counter.ref("retained-process")
+    assert_equal 1, reference.increment(label: "before")
+    original_process = SolidObjects.caller_process.process_registry.process_record
+    original_process.update!(last_heartbeat_at: 2.minutes.ago)
+    assert_equal 1, SolidObjects::ProcessRegistry.cleanup_dead
+    assert_equal "stopped", original_process.reload.shutdown_state
+
+    assert_equal 2, reference.increment(label: "after-cleanup")
+    stopped_process = SolidObjects.caller_process.process_registry.process_record
+    refute_equal original_process.id, stopped_process.id
+    assert_equal "running", stopped_process.shutdown_state
+    stopped_process.update!(last_heartbeat_at: 2.minutes.ago)
+    assert_equal 1, SolidObjects::ProcessRegistry.cleanup_dead
+    SolidObjects::Process.where(id: [ original_process.id, stopped_process.id ]).update_all(stopped_at: 8.days.ago)
+    assert_equal 2, SolidObjects::ProcessPruner.new.prune
+    refute SolidObjects::Process.exists?(stopped_process.id)
+
+    assert_equal 3, reference.increment(label: "after-retention")
+    replacement = SolidObjects.caller_process.process_registry.process_record
+    refute_equal stopped_process.id, replacement.id
+    assert_equal "running", replacement.shutdown_state
+    assert_equal [ 1, 1, 1 ], SolidObjects::Message.order(:sequence).pluck(:attempt_count)
+    assert_empty SolidObjects::DeadLetter.all
+  end
+end