Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
"""Release command identities and worker/replayer registration cannot drift."""
from __future__ import annotations
import json
import textwrap
from pathlib import Path
from tests.temporal.workflow_identities import digest, handler_snapshot, identity_snapshot
GOLDEN = Path(__file__).with_name("fixtures") / "workflow_identities.json"
def _markers(snapshot: dict, command: str) -> set[str]:
return {item["type"].strip("'\"") for module in snapshot.values() for item in module["commands"] if item["command"] == command}
def _vanished_markers(release: dict, current: dict) -> set[str]:
return _markers(release, "patched") - _markers(current, "patched") - _markers(current, "deprecate_patch")
def _missing_handlers(release: dict, current: dict) -> dict[str, list[str]]:
missing = {name: sorted(set(handlers) - set(current.get(name, []))) for name, handlers in release.items()}
return {name: handlers for name, handlers in missing.items() if handlers}
def _registered_types() -> list[str]:
from services.temporal.workflow_registry import replay_workflows
return [item.__temporal_workflow_definition.name for item in replay_workflows()]
def _new_types(golden: dict) -> set[str]:
"""Workflow types added since the release, named in reviewed entries:
no recorded history runs them, so they need no patch marker."""
return {name for entry in golden.get("patch_entries", []) for name in entry.get("new_types", [])}
def test_workflow_command_identities_match_release_or_explicit_patch_entry():
golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
current = identity_snapshot()
if current == golden["identities"]:
return
before, after = digest(golden["identities"]), digest(current)
entries = [entry for entry in golden.get("patch_entries", []) if entry["before"] == before and entry["after"] == after]
assert entries, "Temporal activity names/child IDs/markers changed: add a reviewed versioning patch entry and replay N-1 histories"
from services.temporal.workflow import GENERATION_FLAGS
markers = _markers(current, "patched") | _markers(current, "deprecate_patch")
registered = set(_registered_types())
for entry in entries:
assert entry.get("reason"), entry
added = set(entry.get("new_types", []))
# A new type must be registered and absent from the release.
assert added <= registered and not added & set(golden["workflow_types"]), entry
# A flag frozen per generation gates the change for new generations
# only (RFC-0005 §24.1 rule 2).
flags = set(entry.get("flags", []))
assert flags <= set(GENERATION_FLAGS), entry
assert entry.get("patch") in markers or ((added or flags) and "patch" not in entry), entry
def test_patch_markers_move_to_deprecated_before_they_vanish():
"""RFC-0005 §24.3: a marker the release patches stays in the code, as
``workflow.patched`` or ``workflow.deprecate_patch``; only one the release
already deprecated may be removed, a release later."""
golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
vanished = _vanished_markers(golden["identities"], identity_snapshot())
assert not vanished, f"Patch markers removed without a release of deprecate_patch: {sorted(vanished)}"
def test_the_marker_rule_allows_deprecation_and_catches_removal():
def snapshot(*commands):
return {"m.py": {"commands": [{"command": command, "type": f'"{marker}"'} for command, marker in commands]}}
release = snapshot(("patched", "x-v1"), ("deprecate_patch", "y-v1"))
assert not _vanished_markers(release, snapshot(("patched", "x-v1")))
assert not _vanished_markers(release, snapshot(("deprecate_patch", "x-v1")))
assert _vanished_markers(release, snapshot(("deprecate_patch", "y-v1"))) == {"x-v1"}
def test_message_handlers_are_never_renamed_or_removed():
"""A recorded Signal or Update names its handler, so open runs of the
release would lose one that is renamed or removed. New handlers are fine."""
golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
missing = _missing_handlers(golden["handlers"], handler_snapshot())
assert not missing, f"Message handlers renamed or removed: {missing}"
def test_the_handler_rule_allows_additions_and_catches_renames():
release = {"W": ["signal:pause", "update:set_control_state"]}
assert not _missing_handlers(release, {"W": ["signal:pause", "signal:wake", "update:set_control_state"]})
assert _missing_handlers(release, {"W": ["signal:pause", "update:set_state"]}) == {"W": ["update:set_control_state"]}
assert _missing_handlers(release, {}) == {"W": ["signal:pause", "update:set_control_state"]}
def test_the_handler_inventory_reads_names_from_the_decorators(tmp_path):
temporal = tmp_path / "services" / "temporal"
temporal.mkdir(parents=True)
cron = tmp_path / "nodes" / "scheduler" / "cron_scheduler"
cron.mkdir(parents=True)
(cron / "_workflow.py").write_text("", encoding="utf-8")
(temporal / "probe.py").write_text(textwrap.dedent('''\
from temporalio import workflow
NAME = "ProbeWorkflow"
@workflow.defn(name=NAME, sandboxed=False)
class Probe:
@workflow.signal
def pause(self): ...
@workflow.update(name="apply")
async def apply_change(self): ...
@workflow.query
def status(self): ...
@workflow.signal(dynamic=True)
def other(self, name, args): ...
'''), encoding="utf-8")
assert handler_snapshot(tmp_path) == {"ProbeWorkflow": ["query:status", "signal:<dynamic>", "signal:pause", "update:apply"]}
def test_worker_and_replayer_use_the_shared_production_registry():
from services.temporal.worker import _framework_workflows
from services.temporal.workflow_registry import framework_workflows
assert _framework_workflows is framework_workflows
names = _registered_types()
golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
assert sorted(names) == sorted([*golden["workflow_types"], *_new_types(golden)])
assert len(names) == len(set(names)), "Duplicate workflow registrations"
def test_plugin_activity_type_versions_retain_the_release_names():
import nodes # noqa: F401 -- discover the production node classes
from services.node_registry import registered_node_classes
golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
current = {name: f"node.{cls.type}.v{cls.version}" for name, cls in registered_node_classes().items()}
# New node types are additive; old names must remain registerable until
# their N-1 workflows have drained or a reviewed migration is supplied.
changed = {name: expected for name, expected in golden["plugin_activity_types"].items() if current.get(name) != expected}
assert not changed, f"Historical plugin activity names changed without compatibility registration: {changed}"
def test_plugin_task_queues_retain_the_release_queues():
"""An open agent run's frozen tool policy names each tool's queue, so a
released plugin that moves queue strands those runs. New plugins are
additive."""
import nodes # noqa: F401 -- discover the production node classes
from services.node_registry import registered_node_classes
golden = json.loads(GOLDEN.read_text(encoding="utf-8"))
current = {name: cls.task_queue for name, cls in registered_node_classes().items()}
changed = {name: expected for name, expected in golden["plugin_task_queues"].items() if current.get(name) != expected}
assert not changed, f"Released plugins changed task queue; open runs would wait on the old one: {changed}"