Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
import importlib.util
import sys
import uuid
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock
import pytest
from sqlalchemy.exc import IntegrityError
from services.deployment.control import WorkflowControlService, serialize_control
from services.deployment.runtime_state import archive_and_reset_node_state
@pytest.fixture
async def control_database():
module_name = "tests._real_workflow_control_database"
spec = importlib.util.spec_from_file_location(
module_name, Path(__file__).resolve().parents[2] / "core" / "database.py"
)
assert spec and spec.loader
module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
spec.loader.exec_module(module)
db_path = Path.cwd() / f".workflow-control-{uuid.uuid4().hex}.db"
database = module.Database(SimpleNamespace(
database_url=f"sqlite+aiosqlite:///{db_path.as_posix()}",
database_echo=False, database_pool_size=5, database_max_overflow=5,
))
await database.startup()
try:
yield database
finally:
await database.shutdown()
sys.modules.pop(module_name, None)
for candidate in (db_path, Path(f"{db_path}-wal"), Path(f"{db_path}-shm")):
candidate.unlink(missing_ok=True)
@pytest.mark.asyncio
async def test_begin_generation_is_idempotent():
db = AsyncMock()
db.get_workflow_control_by_idempotency_key.side_effect = [None, None]
db.get_latest_workflow_control.return_value = None
db.create_workflow_control.side_effect = lambda control: control
service = WorkflowControlService(db)
control, created = await service.begin_generation(
workflow_id="wf", nodes=[], edges=[], session_id="s", idempotency_key="request-1"
)
assert created is True
assert control.generation == 1
assert control.revision == 0
assert control.status == "starting"
assert control.data_scope_id == control.execution_id
assert serialize_control(control)["data_scope_id"] == control.execution_id
assert serialize_control(control)["can_pause"] is False
@pytest.mark.asyncio
async def test_generation_records_the_slug_its_temporal_ids_are_named_by():
db = AsyncMock()
db.get_workflow_control_by_idempotency_key.return_value = None
db.get_latest_workflow_control.return_value = None
db.get_workflow.return_value = SimpleNamespace(slug="Ana_1")
db.create_workflow_control.side_effect = lambda control: control
service = WorkflowControlService(db)
control, _ = await service.begin_generation(
workflow_id="wf", nodes=[], edges=[], session_id="s", idempotency_key="start-1"
)
assert control.graph_snapshot["workflow_slug"] == "Ana_1"
# A workflow that was never saved names its ids by its id instead.
db.get_workflow.return_value = None
control, _ = await service.begin_generation(
workflow_id="wf", nodes=[], edges=[], session_id="s", idempotency_key="start-2"
)
assert control.graph_snapshot["workflow_slug"] is None
@pytest.mark.asyncio
async def test_a_live_generations_slug_is_not_handed_out_again(control_database):
"""Renamed while it runs, a workflow keeps the slug its Start recorded:
another workflow given that slug would collide with its cron Schedule."""
from services.workflow_naming import next_available_slug
await control_database.save_workflow("wf-a", "Maya", "Maya_1", {"nodes": [], "edges": []})
await WorkflowControlService(control_database).begin_generation(
workflow_id="wf-a", nodes=[], edges=[], session_id="s", idempotency_key="start-a"
)
assert await control_database.rename_workflow("wf-a", "Maya Ortiz", "Maya_Ortiz_1")
assert await next_available_slug("Maya", control_database) == "Maya_2"
# The workflow itself may take its own slug back.
assert await next_available_slug("Maya", control_database, exclude_id="wf-a") == "Maya_1"
@pytest.mark.asyncio
async def test_generation_atomically_creates_and_archives_isolated_data_scope(control_database):
service = WorkflowControlService(control_database)
control, created = await service.begin_generation(
workflow_id="wf-scope",
nodes=[{"id": "agent-1", "type": "aiAgent", "data": {"label": "Researcher"}}],
edges=[], session_id="browser-session", idempotency_key="scope-1",
)
assert created is True
scope = await control_database.get_workflow_run_data_scope(control.data_scope_id)
assert scope.execution_id == control.execution_id
assert scope.source_session_id == "browser-session"
assert scope.node_data["agent-1"]["data"]["label"] == "Researcher"
assert scope.runtime_data["nodes"]["agent-1"] == {
"type": "aiAgent",
"canvas_data": {"label": "Researcher"},
"parameters": {},
}
assert scope.status == "active"
await control_database.update_workflow_run_data_scope(
scope.id, temporal_run_id="temporal-run-1", status="archived",
)
archived = await control_database.get_workflow_run_data_scope(scope.id)
assert archived.temporal_workflow_id == control.controller_workflow_id
assert archived.temporal_run_id == "temporal-run-1"
assert archived.status == "archived"
await control_database.add_chat_message("wf-scope", "user", "archived", execution_id=scope.id)
await control_database.add_chat_message("wf-scope", "user", "new", execution_id="new-scope")
current_chat = await control_database.read_chat_messages(
"wf-scope", execution_id="new-scope",
)
assert [item["message"] for item in current_chat] == ["new"]
await control_database.add_console_log({
"node_id": "console-1", "label": "Console", "workflow_id": "wf-scope",
"execution_id": scope.id, "data": {"value": "archived"}, "formatted": "archived",
})
await control_database.add_console_log({
"node_id": "console-1", "label": "Console", "workflow_id": "wf-scope",
"execution_id": "new-scope", "data": {"value": "new"}, "formatted": "new",
})
current_logs = await control_database.get_console_logs(
workflow_id="wf-scope", execution_id="new-scope",
)
assert [item["formatted"] for item in current_logs] == ["new"]
@pytest.mark.asyncio
async def test_active_generation_scope_redacts_context_runtime_payloads(
control_database,
):
await control_database.save_node_parameters(
"memory-1",
{
"reset_policy": "preserve",
"memory_content": "private legacy transcript",
"provider_bindings": {"session_uuid": "private-binding"},
"thought_signature": "private-signature",
},
)
service = WorkflowControlService(control_database)
control, _ = await service.begin_generation(
workflow_id="wf-safe-scope",
nodes=[
{
"id": "memory-1",
"type": "simpleMemory",
"data": {
"label": "Memory",
"contextJournal": [{"content": "private journal"}],
"providerState": {"opaque": "private-state"},
},
}
],
edges=[],
session_id="browser-session",
idempotency_key="safe-scope-1",
graph_version=2,
)
scope = await control_database.get_workflow_run_data_scope(
control.data_scope_id
)
serialized = str(scope.node_data) + str(scope.runtime_data)
assert "private legacy transcript" not in serialized
assert "private-binding" not in serialized
assert "private-signature" not in serialized
assert "private journal" not in serialized
assert "private-state" not in serialized
assert scope.runtime_data["nodes"]["memory-1"]["parameters"] == {
"reset_policy": "preserve"
}
@pytest.mark.asyncio
async def test_reset_archives_every_node_then_calls_plugin_lifecycle(monkeypatch):
database = AsyncMock()
database.get_node_parameters.side_effect = [
{"configured": True},
]
database.get_workflow_run_data_scope.return_value = SimpleNamespace(
runtime_data={"existing": True},
)
broadcaster = SimpleNamespace(
broadcast_node_parameters_updated=AsyncMock(),
)
lifecycle = AsyncMock(return_value={
"reset": True, "parameters": {"configured": True, "runtime": "empty"},
})
node_class = SimpleNamespace(reset_execution_state=lifecycle)
monkeypatch.setattr("services.node_registry.get_node_class", lambda _node_type: node_class)
control = SimpleNamespace(
workflow_id="wf",
execution_id="execution-1",
data_scope_id="scope-1",
graph_snapshot={
"nodes": [
{"id": "stateful-1", "type": "statefulPlugin", "data": {"label": "Node"}},
],
"edges": [],
},
)
result = await archive_and_reset_node_state(control, database, broadcaster)
assert result == {"archived_nodes": 1, "reset_nodes": ["stateful-1"]}
archived = database.update_workflow_run_data_scope.await_args.kwargs["runtime_data"]
assert archived["nodes"]["stateful-1"]["parameters"] == {"configured": True}
lifecycle.assert_awaited_once()
broadcaster.broadcast_node_parameters_updated.assert_awaited_once()
@pytest.mark.asyncio
async def test_concurrent_insert_rereads_idempotent_winner():
db = AsyncMock()
winner = AsyncMock()
winner.generation = 1
db.get_workflow_control_by_idempotency_key.side_effect = [None, winner]
db.get_latest_workflow_control.return_value = None
db.create_workflow_control.side_effect = IntegrityError("insert", {}, Exception("unique"))
service = WorkflowControlService(db)
control, created = await service.begin_generation(
workflow_id="wf", nodes=[], edges=[], session_id="s", idempotency_key="same-key"
)
assert control is winner
assert created is False
@pytest.mark.asyncio
async def test_transition_rejects_stale_revision():
db = AsyncMock()
db.transition_workflow_control.return_value = None
service = WorkflowControlService(db)
control = AsyncMock(id="control", revision=2)
with pytest.raises(ValueError, match="control_revision_conflict"):
await service.transition(
control, expected_revision=1, from_statuses={"running"}, status="pausing"
)
@pytest.mark.asyncio
async def test_reset_generation_is_ready_for_explicit_start():
reset_control = AsyncMock(status="reset", generation=3)
reset_control.workflow_id = "wf"
reset_control.revision = 9
reset_control.execution_id = "old-execution"
reset_control.root_execution_id = "old-execution"
reset_control.data_scope_id = "old-execution"
reset_control.controller_workflow_id = "old-controller"
reset_control.controller_run_id = "old-run"
reset_control.created_at = None
reset_control.updated_at = None
reset_control.terminal_reason = "workflow_reset"
status = serialize_control(reset_control)
assert status["state"] == "ready"
assert status["can_start"] is True
assert status["can_reset"] is False
db = AsyncMock()
db.get_workflow_control_by_idempotency_key.return_value = None
db.get_latest_workflow_control.return_value = reset_control
db.create_workflow_control.side_effect = lambda control: control
control, created = await WorkflowControlService(db).begin_generation(
workflow_id="wf", nodes=[], edges=[], session_id="s", idempotency_key="start-after-reset"
)
assert created is True
assert control.generation == 4
assert control.revision == 10
async def test_generation_captures_parameters_before_the_owner_changes_saved_scopes():
db = AsyncMock()
db.get_workflow_control_by_idempotency_key.return_value = None
db.get_latest_workflow_control.return_value = None
db.get_workflow.return_value = SimpleNamespace(slug="Team")
db.create_workflow_control.side_effect = lambda control: control
parameters = {"send": {"recipient": "original", "operation": "send"}}
control, _ = await WorkflowControlService(db).begin_generation(workflow_id="wf", nodes=[{"id": "send", "type": "telegramSend"}], edges=[], session_id="s", idempotency_key="snapshot", parameters=parameters)
parameters["send"]["recipient"] = "changed"
assert control.graph_snapshot["parameters"]["send"]["recipient"] == "original"