Files
plba_v2/tests/test_workflow.py
2026-10-10 19:36:32 +03:00

129 lines
4.7 KiB
Python

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()