325 lines
10 KiB
Python
325 lines
10 KiB
Python
from __future__ import annotations
|
|
|
|
import inspect
|
|
from typing import Any, cast
|
|
|
|
import pytest
|
|
|
|
from wf_client import App, Run
|
|
from wf_client.errors import DeploymentNotRunnable, InvalidResponse
|
|
from wf_client.protocols import WorkflowClientPort
|
|
|
|
|
|
def _payload(
|
|
*, run_id: str | None = "run-1", status: str = "interrupted"
|
|
) -> dict[str, Any]:
|
|
return {
|
|
"artifact_id": "report",
|
|
"artifact_version": 1,
|
|
"deployment_id": "report.production",
|
|
"status": status,
|
|
"run_id": run_id,
|
|
"resume_readiness": "ready" if status == "interrupted" else "not_applicable",
|
|
"interrupt": {
|
|
"id": "interrupt-1",
|
|
"frame_id": "root",
|
|
"node_id": "approve",
|
|
"kind": "approval",
|
|
"payload": {"question": "approve?"},
|
|
"resumable": True,
|
|
"route": None,
|
|
"outcomes": ["submitted"],
|
|
"request_schema": {"type": "object"},
|
|
"resume_schema": {"type": "object"},
|
|
"typed": False,
|
|
}
|
|
if status == "interrupted"
|
|
else None,
|
|
"outcome": None if status == "interrupted" else "ok",
|
|
"error": None,
|
|
"output": None if status == "interrupted" else {"result": "done"},
|
|
"trace_count": 1,
|
|
"max_steps": 10_000,
|
|
"steps_executed": 1,
|
|
"steps_remaining": 9_999,
|
|
"diagnostics": [],
|
|
"next_actions": {
|
|
"can_continue": status == "interrupted",
|
|
"can_save_now": None,
|
|
"recommended_next_tool": None,
|
|
"reason": "ready",
|
|
"patch_examples": [],
|
|
"warnings": [],
|
|
},
|
|
}
|
|
|
|
|
|
class _Port:
|
|
def __init__(self) -> None:
|
|
self.calls: list[tuple[str, dict[str, Any]]] = []
|
|
self.resume_payload = _payload(status="completed")
|
|
self.trace_payload = {
|
|
**_payload(status="completed"),
|
|
"trace": [
|
|
{
|
|
"frame_id": "root",
|
|
"node_id": "approve",
|
|
"step_type": "node",
|
|
"step_number": 1,
|
|
"resolved_input": {},
|
|
"outcome": "ok",
|
|
"next_node_id": "__end__",
|
|
"output": {},
|
|
"state_changes": {},
|
|
}
|
|
],
|
|
"trace_start": 0,
|
|
"trace_limit": 25,
|
|
"trace_truncated": False,
|
|
}
|
|
|
|
async def resume_run(self, **params: Any) -> object:
|
|
self.calls.append(("resume_run", params))
|
|
return self.resume_payload
|
|
|
|
async def inspect_run(self, **params: Any) -> object:
|
|
self.calls.append(("inspect_run", params))
|
|
return self.resume_payload
|
|
|
|
async def read_run_trace(self, **params: Any) -> object:
|
|
self.calls.append(("read_run_trace", params))
|
|
return self.trace_payload
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_interrupted_run_resumes_and_reads_bounded_trace() -> None:
|
|
port = _Port()
|
|
run = Run.from_payload(cast(WorkflowClientPort, port), _payload())
|
|
completed = await run.resume({"approved": True})
|
|
trace = await completed.trace(limit=25)
|
|
assert completed.status == "completed"
|
|
assert completed.output == {"result": "done"}
|
|
assert trace.start == 0
|
|
assert trace.limit == 25
|
|
assert len(trace.frames) == 1
|
|
assert trace.frames[0].step_number == 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_refresh_returns_a_new_snapshot() -> None:
|
|
port = _Port()
|
|
original = Run.from_payload(cast(WorkflowClientPort, port), _payload())
|
|
refreshed = await original.refresh()
|
|
assert refreshed is not original
|
|
assert refreshed.status == "completed"
|
|
assert original.status == "interrupted"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_app_run_rejects_mismatched_inspection_id() -> None:
|
|
port = _Port()
|
|
port.resume_payload["run_id"] = "different-run"
|
|
app = App._from_port(cast(WorkflowClientPort, port))
|
|
with pytest.raises(InvalidResponse, match="workflow.runs.inspect"):
|
|
await app.run("run-1")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_refresh_rejects_mismatched_inspection_id() -> None:
|
|
port = _Port()
|
|
port.resume_payload["run_id"] = "different-run"
|
|
run = Run.from_payload(cast(WorkflowClientPort, port), _payload())
|
|
with pytest.raises(InvalidResponse, match="workflow.runs.inspect"):
|
|
await run.refresh()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_resume_rejects_mismatched_result_id() -> None:
|
|
port = _Port()
|
|
port.resume_payload["run_id"] = "different-run"
|
|
run = Run.from_payload(cast(WorkflowClientPort, port), _payload())
|
|
with pytest.raises(InvalidResponse, match="workflow.runs.resume"):
|
|
await run.resume({"approved": True})
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize("operation", ["refresh", "resume"])
|
|
async def test_run_lifecycle_rejects_mismatched_deployment_identity(
|
|
operation: str,
|
|
) -> None:
|
|
port = _Port()
|
|
port.resume_payload["deployment_id"] = "other.deployment"
|
|
run = Run.from_payload(cast(WorkflowClientPort, port), _payload())
|
|
|
|
with pytest.raises(InvalidResponse, match="workflow.runs"):
|
|
if operation == "refresh":
|
|
await run.refresh()
|
|
else:
|
|
await run.resume({"approved": True})
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_malformed_interrupt_route_is_invalid_response() -> None:
|
|
payload = _payload()
|
|
payload["interrupt"]["route"] = {
|
|
"frame_id": "child",
|
|
"node_id": "approve",
|
|
"scope_id": "scope",
|
|
"lineage_id": "lineage",
|
|
"parent_frame_id": "root",
|
|
"workflow_ref": {"name": "local", "artifact_id": "also-invalid", "version": 1},
|
|
}
|
|
with pytest.raises(InvalidResponse, match="workflow.runs.inspect"):
|
|
Run.from_payload(cast(WorkflowClientPort, _Port()), payload)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_missing_run_id_preserves_server_error() -> None:
|
|
payload = _payload(run_id=None, status="failed")
|
|
payload["error"] = "server refused to start"
|
|
with pytest.raises(DeploymentNotRunnable) as captured:
|
|
Run.from_payload(cast(WorkflowClientPort, _Port()), payload)
|
|
assert captured.value.error == "server refused to start"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_non_resumable_run_is_rejected_before_io() -> None:
|
|
port = _Port()
|
|
payload = _payload()
|
|
assert payload["interrupt"] is not None
|
|
payload["interrupt"]["resumable"] = False
|
|
run = Run.from_payload(cast(WorkflowClientPort, port), payload)
|
|
with pytest.raises(ValueError, match="not resumable"):
|
|
await run.resume({"approved": True})
|
|
assert port.calls == []
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_trace_rejects_invalid_bounds_before_io() -> None:
|
|
port = _Port()
|
|
run = Run.from_payload(cast(WorkflowClientPort, port), _payload())
|
|
with pytest.raises(ValueError):
|
|
await run.trace(start=-1)
|
|
with pytest.raises(ValueError):
|
|
await run.trace(limit=101)
|
|
assert port.calls == []
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
("field", "value"),
|
|
[
|
|
("run_id", "other-run"),
|
|
("deployment_id", "other.deployment"),
|
|
("trace_start", 1),
|
|
("trace_limit", 26),
|
|
],
|
|
)
|
|
async def test_trace_rejects_mismatched_identity_or_page(
|
|
field: str,
|
|
value: object,
|
|
) -> None:
|
|
port = _Port()
|
|
port.trace_payload[field] = value
|
|
run = Run.from_payload(cast(WorkflowClientPort, port), _payload())
|
|
|
|
with pytest.raises(InvalidResponse, match="workflow.runs.trace"):
|
|
await run.trace(start=0, limit=25)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_snapshot_defensively_copies_nested_public_values() -> None:
|
|
port = _Port()
|
|
payload = _payload()
|
|
payload["output"] = {"nested": {"value": "original"}}
|
|
payload["diagnostics"] = [
|
|
{
|
|
"severity": "warning",
|
|
"code": "drift",
|
|
"logical_ref": "app.default",
|
|
"bound_source": "company.production",
|
|
"message": "original",
|
|
"repair_hint": None,
|
|
}
|
|
]
|
|
run = Run.from_payload(cast(WorkflowClientPort, port), payload)
|
|
|
|
exposed_output = run.output
|
|
exposed_interrupt = run.interrupt
|
|
exposed_diagnostics = run.diagnostics
|
|
assert exposed_output is not None
|
|
assert exposed_interrupt is not None
|
|
exposed_output["nested"]["value"] = "mutated"
|
|
exposed_interrupt.payload["question"] = "mutated"
|
|
exposed_diagnostics[0].message = "mutated"
|
|
|
|
assert run.output == {"nested": {"value": "original"}}
|
|
assert run.interrupt is not None
|
|
assert run.interrupt.payload == {"question": "approve?"}
|
|
assert run.diagnostics[0].message == "original"
|
|
await run.resume({"approved": True})
|
|
assert port.calls[-1][1]["run_id"] == "run-1"
|
|
|
|
|
|
def _budgeted_payload(
|
|
*, status: str = "interrupted", max_steps: int = 7
|
|
) -> dict[str, Any]:
|
|
payload = _payload(status=status)
|
|
payload.update(
|
|
{
|
|
"max_steps": max_steps,
|
|
"steps_executed": 2,
|
|
"steps_remaining": max_steps - 2,
|
|
}
|
|
)
|
|
return payload
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_decoder_requires_budget_fields() -> None:
|
|
for field in ("max_steps", "steps_executed", "steps_remaining"):
|
|
payload = _budgeted_payload()
|
|
del payload[field]
|
|
with pytest.raises(InvalidResponse, match="workflow.runs.inspect"):
|
|
Run.from_payload(cast(WorkflowClientPort, _Port()), payload)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_run_exposes_step_budget() -> None:
|
|
run = Run.from_payload(
|
|
cast(WorkflowClientPort, _Port()), _budgeted_payload(max_steps=7)
|
|
)
|
|
assert run.max_steps == 7
|
|
assert run.steps_executed == 2
|
|
assert run.steps_remaining == 5
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_refresh_preserves_step_budget() -> None:
|
|
port = _Port()
|
|
port.resume_payload = _budgeted_payload(status="completed", max_steps=9)
|
|
run = Run.from_payload(
|
|
cast(WorkflowClientPort, port), _budgeted_payload(max_steps=7)
|
|
)
|
|
refreshed = await run.refresh()
|
|
assert refreshed.max_steps == 9
|
|
assert refreshed.steps_executed == 2
|
|
assert refreshed.steps_remaining == 7
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_resume_preserves_step_budget() -> None:
|
|
port = _Port()
|
|
port.resume_payload = _budgeted_payload(status="completed", max_steps=9)
|
|
run = Run.from_payload(
|
|
cast(WorkflowClientPort, port), _budgeted_payload(max_steps=7)
|
|
)
|
|
resumed = await run.resume({"approved": True})
|
|
assert resumed.max_steps == 9
|
|
assert resumed.steps_executed == 2
|
|
assert resumed.steps_remaining == 7
|
|
|
|
|
|
def test_resume_signature_excludes_max_steps() -> None:
|
|
assert "max_steps" not in inspect.signature(Run.resume).parameters
|