import unittest from typing import Any from plba.workflow import ( StepResult, WorkflowContext, WorkflowDefinition, WorkflowEngine, WorkflowNode, WorkflowTransitionError, ) class MemoryPersistence: def __init__(self) -> None: self.events: list[tuple[str, str, dict[str, Any]]] = [] async def record_run_started(self, run_id: str, workflow_name: str, context: WorkflowContext) -> None: self.events.append(("run_started", workflow_name, dict(context.state))) async def record_step_started(self, run_id: str, step_name: str, context: WorkflowContext) -> None: self.events.append(("step_started", step_name, dict(context.state))) async def record_step_completed( self, run_id: str, step_name: str, context: WorkflowContext, result: StepResult ) -> None: self.events.append(("step_completed", step_name, dict(context.state))) async def record_step_failed( self, run_id: str, step_name: str, context: WorkflowContext, error: BaseException ) -> None: self.events.append(("step_failed", step_name, dict(context.state))) async def record_run_completed( self, run_id: str, workflow_name: str, context: WorkflowContext, status: str ) -> None: self.events.append(("run_completed", workflow_name, dict(context.state))) async def record_run_failed( self, run_id: str, workflow_name: str, context: WorkflowContext, error: BaseException ) -> None: self.events.append(("run_failed", workflow_name, dict(context.state))) class WorkflowEngineTests(unittest.IsolatedAsyncioTestCase): async def test_named_steps_follow_only_declared_transitions(self) -> None: persistence = MemoryPersistence() async def first(context: WorkflowContext) -> StepResult: self.assertEqual(dict(context.state), {}) return StepResult(transition="continue", updates={"count": 1}) async def second(context: WorkflowContext) -> StepResult: self.assertEqual(context.state["count"], 1) return StepResult(updates={"done": True}) definition = WorkflowDefinition( name="inventory_sync", initial_step="load", nodes={ "load": WorkflowNode(first, {"continue": "save"}), "save": WorkflowNode(second), }, ) result = await WorkflowEngine(persistence).run(definition, WorkflowContext()) self.assertEqual(result.status, "completed") self.assertEqual(dict(result.context.state), {"count": 1, "done": True}) self.assertEqual( [event[0] for event in persistence.events], [ "run_started", "step_started", "step_completed", "step_started", "step_completed", "run_completed", ], ) self.assertEqual(persistence.events[0][2], {}) self.assertEqual(persistence.events[-1][2], {"count": 1, "done": True}) async def test_step_error_is_persisted_and_original_exception_propagates(self) -> None: persistence = MemoryPersistence() error = RuntimeError("step failed") later_called = False async def fail(_: WorkflowContext) -> StepResult: raise error async def later(_: WorkflowContext) -> StepResult: nonlocal later_called later_called = True return StepResult() definition = WorkflowDefinition( "failure_case", "first", {"first": WorkflowNode(fail, {"next": "later"}), "later": WorkflowNode(later)}, ) with self.assertRaises(RuntimeError) as raised: await WorkflowEngine(persistence).run(definition, WorkflowContext()) self.assertIs(raised.exception, error) self.assertFalse(later_called) self.assertEqual([event[0] for event in persistence.events][-2:], ["step_failed", "run_failed"]) async def test_undeclared_transition_fails_without_running_target(self) -> None: persistence = MemoryPersistence() async def choose_unknown(_: WorkflowContext) -> StepResult: return StepResult(transition="unknown") definition = WorkflowDefinition( "invalid_transition", "first", {"first": WorkflowNode(choose_unknown), "later": WorkflowNode(choose_unknown)}, ) with self.assertRaises(WorkflowTransitionError): await WorkflowEngine(persistence).run(definition, WorkflowContext()) self.assertEqual([event[0] for event in persistence.events][-2:], ["step_failed", "run_failed"]) if __name__ == "__main__": unittest.main()