129 lines
4.7 KiB
Python
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()
|