Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
"""Contract tests for ``services.workflow_validator.validate_workflow``.
Locks the six issue codes the validator surfaces:
- ``DANGLING_EDGE`` — edge references a node id that isn't in the graph.
- ``UNKNOWN_NODE_TYPE`` — plugin not installed on this instance.
- ``INVALID_PARAM`` — Pydantic ``Params.model_validate`` raises.
- ``MISSING_CREDENTIAL`` — declared credential not stored.
- ``CYCLE`` — Kahn's algorithm leaves nodes unresolved.
- Empty report — valid workflow returns ``{errors: [], warnings: []}``.
Used to gate ``handle_execute_workflow`` (force=False), all
``handle_deploy_workflow`` calls, and ``example_loader.import_examples_for_user``.
"""
from __future__ import annotations
from unittest.mock import AsyncMock, MagicMock
import pytest
from pydantic import BaseModel, Field
pytestmark = pytest.mark.asyncio
# ---------------------------------------------------------------------------
# Fakes — a small in-memory plugin registry so tests are deterministic and
# don't depend on which plugins happen to be installed at run time.
# ---------------------------------------------------------------------------
class _FakeCredential:
id = "fake_provider"
auth = "api_key"
class _FakeParams(BaseModel):
text: str = Field(..., min_length=1)
class _FakeNodeClass:
type = "fakeNode"
Params = _FakeParams
credentials = (_FakeCredential,)
class _FakeNodelessClass:
"""Plugin with no credentials and a permissive Params (every workflow
invariant is honored)."""
type = "fakeNodeless"
class Params(BaseModel):
pass
credentials = ()
def _patch_registry(monkeypatch, mapping: dict[str, object]) -> None:
"""Patch ``get_node_class`` to return our fakes."""
monkeypatch.setattr(
"services.workflow_validator.get_node_class",
lambda node_type: mapping.get(node_type),
)
def _patch_auth(monkeypatch, has_valid_key_return: bool) -> None:
"""Patch the container so ``auth_service.has_valid_key`` returns a fixed bool."""
fake_auth = MagicMock()
fake_auth.has_valid_key = AsyncMock(return_value=has_valid_key_return)
fake_container = MagicMock()
fake_container.auth_service.return_value = fake_auth
monkeypatch.setattr("core.container.container", fake_container)
# ---------------------------------------------------------------------------
# Tests
# ---------------------------------------------------------------------------
async def test_dangling_edge_target_is_error(monkeypatch):
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {"fakeNodeless": _FakeNodelessClass})
_patch_auth(monkeypatch, True)
report = await validate_workflow(
nodes=[{"id": "n1", "type": "fakeNodeless", "data": {}}],
edges=[{"id": "e1", "source": "n1", "target": "ghost"}],
)
codes = [iss["code"] for iss in report["errors"]]
assert "DANGLING_EDGE" in codes
async def test_dangling_edge_source_is_error(monkeypatch):
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {"fakeNodeless": _FakeNodelessClass})
_patch_auth(monkeypatch, True)
report = await validate_workflow(
nodes=[{"id": "n1", "type": "fakeNodeless", "data": {}}],
edges=[{"id": "e1", "source": "ghost", "target": "n1"}],
)
codes = [iss["code"] for iss in report["errors"]]
assert "DANGLING_EDGE" in codes
async def test_unknown_node_type_is_error(monkeypatch):
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {})
_patch_auth(monkeypatch, True)
report = await validate_workflow(
nodes=[{"id": "n1", "type": "doesNotExist", "data": {}}],
edges=[],
)
codes = [iss["code"] for iss in report["errors"]]
assert "UNKNOWN_NODE_TYPE" in codes
issue = next(iss for iss in report["errors"] if iss["code"] == "UNKNOWN_NODE_TYPE")
assert issue["node_id"] == "n1"
assert issue["node_type"] == "doesNotExist"
async def test_invalid_param_is_warning(monkeypatch):
"""INVALID_PARAM is a WARNING — matches the runtime soft-fail at
``node_executor._prepare_parameters`` (logs WARN, continues)."""
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {"fakeNode": _FakeNodeClass})
_patch_auth(monkeypatch, True)
# text is required + min_length=1; empty triggers ValidationError.
report = await validate_workflow(
nodes=[{"id": "n1", "type": "fakeNode", "data": {"parameters": {"text": ""}}}],
edges=[],
)
codes = [iss["code"] for iss in report["warnings"]]
assert "INVALID_PARAM" in codes
assert all(
iss["code"] != "INVALID_PARAM" for iss in report["errors"]
), "INVALID_PARAM must not block execution; only deploy-time errors block."
async def test_missing_credential_is_warning(monkeypatch):
"""MISSING_CREDENTIAL is a WARNING so the workflow can be saved/imported
and credentials configured afterward. Runtime failure (different path,
different broadcast) is what surfaces to the user during execution."""
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {"fakeNode": _FakeNodeClass})
_patch_auth(monkeypatch, False) # credential NOT stored
report = await validate_workflow(
nodes=[{"id": "n1", "type": "fakeNode", "data": {"parameters": {"text": "ok"}}}],
edges=[],
)
codes = [iss["code"] for iss in report["warnings"]]
assert "MISSING_CREDENTIAL" in codes
issue = next(iss for iss in report["warnings"] if iss["code"] == "MISSING_CREDENTIAL")
assert issue["provider_id"] == "fake_provider"
assert issue["remediation"] == "add_key"
assert issue["node_id"] == "n1"
class _NamedRowsCredential:
"""A credential holding several named rows: it checks the one the node names."""
id = "fake_rows"
auth = "api_key"
@classmethod
async def is_configured(cls, auth_service, parameters):
return parameters.get("row") == "fake_rows:saved"
class _NamedRowsNodeClass:
type = "fakeRowsNode"
class Params(BaseModel):
row: str = ""
credentials = (_NamedRowsCredential,)
async def test_a_credential_can_check_the_row_the_node_names(monkeypatch):
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {"fakeRowsNode": _NamedRowsNodeClass})
_patch_auth(monkeypatch, False) # nothing stored under the bare id
report = await validate_workflow(
nodes=[
{"id": "saved", "type": "fakeRowsNode", "data": {"parameters": {"row": "fake_rows:saved"}}},
{"id": "gone", "type": "fakeRowsNode", "data": {"parameters": {"row": "fake_rows:gone"}}},
],
edges=[],
)
missing = [iss["node_id"] for iss in report["warnings"] if iss["code"] == "MISSING_CREDENTIAL"]
assert missing == ["gone"]
async def test_cycle_is_error(monkeypatch):
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {"fakeNodeless": _FakeNodelessClass})
_patch_auth(monkeypatch, True)
# Two-node cycle: n1 -> n2 -> n1
report = await validate_workflow(
nodes=[
{"id": "n1", "type": "fakeNodeless", "data": {}},
{"id": "n2", "type": "fakeNodeless", "data": {}},
],
edges=[
{"id": "e1", "source": "n1", "target": "n2"},
{"id": "e2", "source": "n2", "target": "n1"},
],
)
codes = [iss["code"] for iss in report["errors"]]
assert "CYCLE" in codes
cycle = next(iss for iss in report["errors"] if iss["code"] == "CYCLE")
assert set(cycle["nodes"]) == {"n1", "n2"}
async def test_valid_workflow_returns_empty_report(monkeypatch):
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {"fakeNodeless": _FakeNodelessClass})
_patch_auth(monkeypatch, True)
report = await validate_workflow(
nodes=[
{"id": "n1", "type": "fakeNodeless", "data": {}},
{"id": "n2", "type": "fakeNodeless", "data": {}},
],
edges=[{"id": "e1", "source": "n1", "target": "n2"}],
)
assert report == {"errors": [], "warnings": []}
@pytest.mark.parametrize("browsers", [[], ["browser"], ["browser", "browser-2"]])
async def test_a_browser_ai_agent_needs_exactly_one_browser_tool(browsers):
"""A plugin's own wiring rule (BaseNode.validate_graph) blocks Start and
import: a Browser AI Agent without exactly one Browser tool fails as soon
as it runs."""
import nodes # noqa: F401 -- populate plugin registry
from services.browser_agent_recipe import BROWSER_TOOL_REQUIRED
from services.workflow_validator import validate_workflow
report = await validate_workflow(
nodes=[{"id": "agent", "type": "browser_agent", "data": {}},
*({"id": browser, "type": "browser", "data": {}} for browser in browsers)],
edges=[{"id": f"e-{browser}", "source": browser, "target": "agent",
"sourceHandle": "output-tool", "targetHandle": "input-tools"} for browser in browsers],
auth_service=_fake_auth(),
)
issues = [issue for issue in report["errors"] if issue["code"] == "BROWSER_TOOL_REQUIRED"]
expected = [] if len(browsers) == 1 else [
{"code": "BROWSER_TOOL_REQUIRED", "node_id": "agent", "message": BROWSER_TOOL_REQUIRED}]
assert issues == expected
async def test_parameters_by_id_overrides_node_data(monkeypatch):
"""When parameters_by_id is supplied, it wins over node.data.parameters.
Used by the WS execute handler (hydrating from DB) and the
example_loader (which holds params in the JSON's nodeParameters block)."""
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {"fakeNode": _FakeNodeClass})
_patch_auth(monkeypatch, True)
# node.data has valid params, parameters_by_id has invalid → invalid wins.
report = await validate_workflow(
nodes=[{"id": "n1", "type": "fakeNode", "data": {"parameters": {"text": "good"}}}],
edges=[],
parameters_by_id={"n1": {"text": ""}},
)
codes = [iss["code"] for iss in report["warnings"]]
assert "INVALID_PARAM" in codes
async def test_report_shape_is_plain_dicts(monkeypatch):
"""Issues must be plain dicts (no dataclasses / enums) so the report
serializes directly to JSON without custom encoders."""
import json
from services.workflow_validator import validate_workflow
_patch_registry(monkeypatch, {})
_patch_auth(monkeypatch, True)
report = await validate_workflow(
nodes=[{"id": "n1", "type": "unknown", "data": {}}],
edges=[],
)
# Should round-trip through stdlib JSON without errors.
serialized = json.dumps(report)
assert "UNKNOWN_NODE_TYPE" in serialized
# ---------------------------------------------------------------------------
# WS-handler gating invariants
# ---------------------------------------------------------------------------
class TestExecuteAndDeployHandlersGate:
"""Static-source contract: ``handle_execute_workflow`` and
``handle_deploy_workflow`` MUST call ``validate_workflow`` before
handing the graph off to ``WorkflowService``. Anchor on the function
name string so a rename forces a deliberate test update.
"""
@staticmethod
def _handler_source(handler) -> str:
import inspect
fn = handler
while hasattr(fn, "__wrapped__"):
fn = fn.__wrapped__
return inspect.getsource(fn)
def test_execute_workflow_calls_validator(self):
from routers import websocket as ws_module
src = self._handler_source(ws_module.handle_execute_workflow)
assert "validate_workflow" in src, (
"handle_execute_workflow must call validate_workflow so " "broken workflows are blocked at the gate (force=true overrides)."
)
assert "force" in src, (
"handle_execute_workflow must support the force=true override " "so 'Run anyway' can bypass warnings (Windmill pattern)."
)
def test_deploy_workflow_calls_validator_unconditionally(self):
# Wave 13.2: handle_deploy_workflow moved out of routers.websocket
# into services/deployment/handlers.py.
from services.deployment.handlers import handle_deploy_workflow
src = self._handler_source(handle_deploy_workflow)
assert "validate_workflow" in src, (
"handle_deploy_workflow must call validate_workflow — a broken "
"workflow deployed on a schedule is much worse than a failed "
"manual run, so deploy never honors a force-override."
)
def test_validate_workflow_handler_registered(self):
from routers import websocket as ws_module
assert "validate_workflow" in ws_module.MESSAGE_HANDLERS, (
"validate_workflow message type must be in MESSAGE_HANDLERS " "so the frontend live-lint and import dry-run paths can reach it."
)
def test_example_loader_calls_validator(self):
"""First-launch example import must run validator to skip
malformed examples (errors) and log credential gaps (warnings)."""
import inspect
from services import example_loader
src = inspect.getsource(example_loader.import_examples_for_user)
assert "validate_workflow" in src, (
"import_examples_for_user must run validate_workflow before " "save_workflow — broken examples shipped on disk are bugs."
)
def test_example_loader_remaps_node_ids(self):
"""Example loader MUST rewrite node ids before save. Without this,
two example workflows that share a node id (today: AI Assistant +
Claude Assistant share 6 trigger/console/memory nodes) collide in
the node_parameters table (keyed unique on node_id), and the
second example silently overwrites the first's parameters."""
import inspect
from services import example_loader
src = inspect.getsource(example_loader.import_examples_for_user)
assert "remap_node_ids" in src, (
"import_examples_for_user must call workflow_import.remap_node_ids " "before save_workflow / save_node_parameters."
)
class TestRemapNodeIds:
"""Regression contract for ``services.workflow_import.remap_node_ids``.
Two example workflows in ``workflows/`` share 6 node ids — this helper
is what prevents parameter overwrites at import time."""
def test_remap_eliminates_duplicate_ids(self):
"""Two graphs with identical input ids must emit disjoint output
id sets after independent remap calls."""
from services.workflow_import import remap_node_ids
nodes_a = [{"id": "shared-1", "type": "telegramSend", "data": {}}]
nodes_b = [{"id": "shared-1", "type": "telegramSend", "data": {}}]
a_nodes, _, _ = remap_node_ids(nodes_a, [], {"shared-1": {"x": 1}})
b_nodes, _, _ = remap_node_ids(nodes_b, [], {"shared-1": {"x": 2}})
a_ids = {n["id"] for n in a_nodes}
b_ids = {n["id"] for n in b_nodes}
assert a_ids.isdisjoint(b_ids), f"Remap must produce disjoint id sets, got overlap: {a_ids & b_ids}"
def test_remap_rewrites_edge_refs(self):
"""Edges must point at the new node ids; no dangling references."""
from services.workflow_import import remap_node_ids
nodes = [
{"id": "n1", "type": "start", "data": {}},
{"id": "n2", "type": "httpRequest", "data": {}},
]
edges = [{"id": "e1", "source": "n1", "target": "n2"}]
new_nodes, new_edges, _ = remap_node_ids(nodes, edges, {})
node_id_set = {n["id"] for n in new_nodes}
assert len(new_edges) == 1
assert new_edges[0]["source"] in node_id_set
assert new_edges[0]["target"] in node_id_set
def test_remap_rekeys_parameters(self):
"""nodeParameters keys must be remapped to match the new node ids."""
from services.workflow_import import remap_node_ids
nodes = [{"id": "orig-1", "type": "telegramSend", "data": {}}]
new_nodes, _, new_params = remap_node_ids(nodes, [], {"orig-1": {"text": "hello"}})
assert "orig-1" not in new_params
assert new_nodes[0]["id"] in new_params
assert new_params[new_nodes[0]["id"]] == {"text": "hello"}
def test_remap_drops_orphan_parameters(self):
"""A parameter entry whose node isn't in the graph is dead data
(rare, only happens when an export was hand-edited). Dropped."""
from services.workflow_import import remap_node_ids
_, _, new_params = remap_node_ids(
[{"id": "n1", "type": "start", "data": {}}],
[],
{"n1": {"x": 1}, "ghost": {"y": 2}},
)
assert len(new_params) == 1, "orphan parameter entry should be dropped"
def test_remap_real_examples_no_collisions(self):
"""Spot check against the actual example workflow files shipped in
``workflows/``: today AI Assistant + Claude Assistant share 6
node ids; after remap, the union must be collision-free."""
import collections
import glob
import json
from core.paths import example_workflows_dir
from services.workflow_import import remap_node_ids
examples_dir = example_workflows_dir()
all_ids = collections.defaultdict(list)
for path in sorted(glob.glob(str(examples_dir / "*.json"))):
with open(path, encoding="utf-8") as fh:
wf = json.load(fh)
nodes, _, _ = remap_node_ids(
wf.get("nodes", []),
wf.get("edges", []),
wf.get("nodeParameters", {}),
)
for node in nodes:
all_ids[node["id"]].append(path)
collisions = {k: v for k, v in all_ids.items() if len(v) > 1}
assert not collisions, f"Remap should produce disjoint ids across all example " f"workflows; found collisions: {collisions}"
# ---------------------------------------------------------------------------
# workflow_import orchestrator tests
# ---------------------------------------------------------------------------
class _FakeWorkflow:
"""Mimics the SQLModel.Workflow rows returned by get_all_workflows."""
def __init__(self, name: str):
self.name = name
def _fake_database(existing_names: list[str] | None = None):
"""In-memory database double for the orchestrator tests."""
saved_workflows: list[dict] = []
saved_params: dict[str, dict] = {}
db = MagicMock()
next_workflow_id = 1
async def allocate_workflow_id():
nonlocal next_workflow_id
workflow_id = str(next_workflow_id)
next_workflow_id += 1
return workflow_id
db.allocate_workflow_id = AsyncMock(side_effect=allocate_workflow_id)
db.get_all_workflows = AsyncMock(return_value=[_FakeWorkflow(n) for n in (existing_names or [])])
# Wave 14: workflow_import.import_workflow allocates a slug via
# ``next_available_slug`` before save, which scans existing slugs.
db.list_workflow_slugs = AsyncMock(return_value=[])
async def save_workflow(**kwargs):
saved_workflows.append(kwargs)
return True
async def save_node_parameters(node_id, params):
saved_params[node_id] = params
return True
async def delete_node_parameters(node_id):
saved_params.pop(node_id, None)
return True
db.save_workflow = AsyncMock(side_effect=save_workflow)
db.save_node_parameters = AsyncMock(side_effect=save_node_parameters)
# Canonicalization rekeys parameter rows, so the double must expose the
# real Database's async delete. A bare MagicMock returns a non-awaitable.
db.delete_node_parameters = AsyncMock(side_effect=delete_node_parameters)
db._saved_workflows = saved_workflows # test-readable
db._saved_params = saved_params
return db
def _fake_auth(has_valid_key_return: bool = True):
auth = MagicMock()
auth.has_valid_key = AsyncMock(return_value=has_valid_key_return)
return auth
class TestImportWorkflowOrchestrator:
"""Contract for ``services.workflow_import.import_workflow``. Locks the
two-step UX: first call returns preview when confirmations are needed
(name conflict / missing creds), second call with confirmations saves."""
async def test_save_path_with_no_conflicts_no_missing_creds(self, monkeypatch):
"""Happy path: valid workflow, no name conflict, no missing creds
→ preview is False, workflow saved, workflow_id returned."""
from services.workflow_import import import_workflow
# Patch the registry so the synthetic node type validates.
_patch_registry_in_validator(monkeypatch)
db = _fake_database(existing_names=[])
auth = _fake_auth(has_valid_key_return=True)
result = await import_workflow(
{
"name": "My Workflow",
"nodes": [{"id": "n1", "type": "fakeNodeless", "data": {}}],
"edges": [],
},
auth_service=auth,
database=db,
)
assert result["success"] is True
assert result["preview"] is False
assert result["workflow_id"] == "1"
assert result["name"] == "My Workflow"
assert len(db._saved_workflows) == 1
async def test_preview_when_name_conflicts(self, monkeypatch):
"""Name conflict → preview=True with suggested_name; no save yet."""
from services.workflow_import import import_workflow
_patch_registry_in_validator(monkeypatch)
db = _fake_database(existing_names=["My Workflow"])
auth = _fake_auth(has_valid_key_return=True)
result = await import_workflow(
{
"name": "My Workflow",
"nodes": [{"id": "n1", "type": "fakeNodeless", "data": {}}],
"edges": [],
},
auth_service=auth,
database=db,
)
assert result["success"] is True
assert result["preview"] is True
assert result["name_conflict"] is True
assert result["suggested_name"] == "My Workflow (imported)"
assert len(db._saved_workflows) == 0 # NOT saved yet
async def test_preview_when_credentials_missing(self, monkeypatch):
"""Missing credentials (without force flag) → preview=True with
missing_credentials list; no save yet."""
from services.workflow_import import import_workflow
_patch_registry_in_validator(monkeypatch)
# Patch CREDENTIAL_REGISTRY so cross-check can pull display info.
monkeypatch.setattr(
"services.plugin.credential.CREDENTIAL_REGISTRY",
{"fake_provider": _FakeCredential},
)
db = _fake_database(existing_names=[])
auth = _fake_auth(has_valid_key_return=False) # no creds stored
result = await import_workflow(
{
"name": "Need Creds",
"nodes": [{"id": "n1", "type": "fakeNode", "data": {"parameters": {"text": "ok"}}}],
"edges": [],
},
auth_service=auth,
database=db,
)
assert result["preview"] is True
assert len(result["missing_credentials"]) == 1
assert result["missing_credentials"][0]["provider_id"] == "fake_provider"
assert len(db._saved_workflows) == 0
async def test_force_credentials_skips_preview(self, monkeypatch):
"""force_credentials=True bypasses the missing-credential preview."""
from services.workflow_import import import_workflow
_patch_registry_in_validator(monkeypatch)
monkeypatch.setattr(
"services.plugin.credential.CREDENTIAL_REGISTRY",
{"fake_provider": _FakeCredential},
)
# Mock the broadcaster — save path emits workflow.imported.
_patch_broadcaster(monkeypatch)
db = _fake_database(existing_names=[])
auth = _fake_auth(has_valid_key_return=False)
result = await import_workflow(
{
"name": "Force",
"nodes": [{"id": "n1", "type": "fakeNode", "data": {"parameters": {"text": "ok"}}}],
"edges": [],
},
force_credentials=True,
auth_service=auth,
database=db,
)
assert result["success"] is True
assert result["preview"] is False
assert len(db._saved_workflows) == 1
async def test_validation_errors_block_import(self, monkeypatch):
"""Validation errors (e.g. unknown node type, cycle) short-circuit
with success=False — no preview, no save."""
from services.workflow_import import import_workflow
_patch_registry_in_validator(monkeypatch)
db = _fake_database()
auth = _fake_auth()
result = await import_workflow(
{
"name": "Bad",
"nodes": [{"id": "n1", "type": "doesNotExist", "data": {}}],
"edges": [],
},
auth_service=auth,
database=db,
)
assert result["success"] is False
assert result["error"] == "validation_failed"
assert any(i["code"] == "UNKNOWN_NODE_TYPE" for i in result["report"]["errors"])
assert len(db._saved_workflows) == 0
async def test_save_path_remaps_node_ids(self, monkeypatch):
"""Save path applies remap_node_ids so the saved workflow has
fresh ids regardless of the input. Two saves of the same JSON
produce disjoint id sets."""
from services.workflow_import import import_workflow
_patch_registry_in_validator(monkeypatch)
_patch_broadcaster(monkeypatch)
db = _fake_database(existing_names=[])
auth = _fake_auth(has_valid_key_return=True)
payload = {
"name": "Remap A",
"nodes": [{"id": "orig-1", "type": "fakeNodeless", "data": {}}],
"edges": [],
"nodeParameters": {"orig-1": {"x": 1}},
}
r1 = await import_workflow(payload, auth_service=auth, database=db)
r2 = await import_workflow({**payload, "name": "Remap B"}, auth_service=auth, database=db)
# Saved node ids must differ across the two imports.
saved_a_nodes = db._saved_workflows[0]["data"]["nodes"]
saved_b_nodes = db._saved_workflows[1]["data"]["nodes"]
a_ids = {n["id"] for n in saved_a_nodes}
b_ids = {n["id"] for n in saved_b_nodes}
assert a_ids.isdisjoint(b_ids), f"Two imports of the same JSON must produce disjoint node ids; " f"overlap: {a_ids & b_ids}"
# Parameters saved under the NEW ids, not the original.
assert "orig-1" not in db._saved_params
assert len(db._saved_params) >= 2 # both r1 and r2 saved their params
# Sanity: r1 and r2 both succeeded.
assert r1["success"] and r2["success"]
async def test_save_path_broadcasts_workflow_imported(self, monkeypatch):
"""Save path must emit a CloudEvents-typed workflow.imported event
via broadcast_workflow_lifecycle. Other connected clients listen
for this and invalidate the workflows query."""
from services.workflow_import import import_workflow
_patch_registry_in_validator(monkeypatch)
broadcaster, calls = _patch_broadcaster(monkeypatch)
db = _fake_database()
auth = _fake_auth()
await import_workflow(
{
"name": "Broadcast Test",
"nodes": [{"id": "n1", "type": "fakeNodeless", "data": {}}],
"edges": [],
},
auth_service=auth,
database=db,
)
assert len(calls) == 1, "import_workflow save path must call broadcast_workflow_lifecycle " "exactly once on success."
stage, kwargs = calls[0]
assert stage == "imported"
assert kwargs["workflow_id"] == "1"
assert kwargs["name"] == "Broadcast Test"
def _patch_registry_in_validator(monkeypatch):
"""Patch ``services.workflow_validator.get_node_class`` (the lookup
used by the validator)."""
registry = {"fakeNodeless": _FakeNodelessClass, "fakeNode": _FakeNodeClass}
monkeypatch.setattr(
"services.workflow_validator.get_node_class",
lambda t: registry.get(t),
)
# workflow_import.extract_requirements imports get_node_class too.
monkeypatch.setattr(
"services.workflow_import.get_node_class",
lambda t: registry.get(t),
)
def _patch_broadcaster(monkeypatch):
"""Replace get_status_broadcaster with a stub that records lifecycle
calls so tests can assert on them without touching real WebSockets."""
calls: list[tuple[str, dict]] = []
class _StubBroadcaster:
async def broadcast_workflow_lifecycle(self, stage: str, **kwargs):
calls.append((stage, kwargs))
stub = _StubBroadcaster()
monkeypatch.setattr(
"services.status_broadcaster.get_status_broadcaster",
lambda: stub,
)
return stub, calls
# ---------------------------------------------------------------------------
# extract_requirements + cross_check_credentials + check_name_conflict
# ---------------------------------------------------------------------------
class TestExtractRequirements:
def test_pulls_credential_ids_and_node_versions(self, monkeypatch):
from services.workflow_import import extract_requirements
monkeypatch.setattr(
"services.workflow_import.get_node_class",
lambda t: {
"fakeNode": _FakeNodeClass,
"fakeNodeless": _FakeNodelessClass,
}.get(t),
)
reqs = extract_requirements(
[
{"id": "n1", "type": "fakeNode"},
{"id": "n2", "type": "fakeNodeless"},
]
)
cred_ids = [c["provider_id"] for c in reqs["credentials"]]
types = [n["type"] for n in reqs["nodes"]]
assert "fake_provider" in cred_ids
assert "fakeNode" in types
assert "fakeNodeless" in types
def test_ignores_unknown_types(self, monkeypatch):
from services.workflow_import import extract_requirements
monkeypatch.setattr(
"services.workflow_import.get_node_class",
lambda t: None,
)
reqs = extract_requirements([{"id": "n1", "type": "unknown"}])
assert reqs == {"credentials": [], "nodes": []}
class TestCrossCheckCredentials:
async def test_reports_missing_with_display_info(self, monkeypatch):
from services.workflow_import import cross_check_credentials
monkeypatch.setattr(
"services.plugin.credential.CREDENTIAL_REGISTRY",
{"fake_provider": _FakeCredential},
)
auth = _fake_auth(has_valid_key_return=False)
missing = await cross_check_credentials({"credentials": [{"provider_id": "fake_provider"}]}, auth)
assert len(missing) == 1
assert missing[0]["provider_id"] == "fake_provider"
assert "display_name" in missing[0]
assert missing[0]["kind"] == "api_key"
async def test_empty_when_all_stored(self, monkeypatch):
from services.workflow_import import cross_check_credentials
auth = _fake_auth(has_valid_key_return=True)
missing = await cross_check_credentials({"credentials": [{"provider_id": "x"}]}, auth)
assert missing == []
class TestCheckNameConflict:
async def test_detects_conflict_and_suggests_name(self):
from services.workflow_import import check_name_conflict
db = _fake_database(existing_names=["My Flow", "Other"])
result = await check_name_conflict("My Flow", db)
assert result["has_conflict"] is True
assert result["suggested_name"] == "My Flow (imported)"
async def test_increments_suffix_when_suggestion_also_conflicts(self):
from services.workflow_import import check_name_conflict
db = _fake_database(existing_names=["A", "A (imported)"])
result = await check_name_conflict("A", db)
assert result["suggested_name"] == "A (imported) 2"
async def test_no_conflict_returns_none(self):
from services.workflow_import import check_name_conflict
db = _fake_database(existing_names=["Other"])
result = await check_name_conflict("Unique", db)
assert result["has_conflict"] is False
assert result["suggested_name"] is None
class TestCloudEventsBroadcastShape:
"""The save path emits a real WorkflowEvent envelope. Static-source
check that the broadcaster method uses the typed factory."""
def test_broadcaster_uses_workflow_lifecycle_factory(self):
import inspect
from services import status_broadcaster
src = inspect.getsource(status_broadcaster.StatusBroadcaster.broadcast_workflow_lifecycle)
assert "WorkflowEvent.workflow_lifecycle" in src, (
"broadcast_workflow_lifecycle must build the envelope via the "
"typed factory so the dataschema URI + reverse-DNS type prefix "
"are consistent with the rest of the CloudEvents surface."
)
assert '"workflow_lifecycle"' in src, (
"wire-format key must be 'workflow_lifecycle' so the frontend " "WebSocketContext.tsx case statement routes correctly."
)
def test_import_workflow_emits_imported_lifecycle(self):
import inspect
from services import workflow_import
from services.workflow_storage import persist
# The import saves through the shared helper, which broadcasts the
# stage its caller names (test_save_path_broadcasts_workflow_imported
# checks the stage arrives).
import_src = inspect.getsource(workflow_import.import_workflow)
assert "persist_new_workflow(" in import_src, (
"import_workflow must save through persist_new_workflow, which broadcasts "
"workflow_lifecycle so connected clients refresh."
)
assert 'lifecycle_stage="imported"' in import_src, (
"import_workflow must use the 'imported' lifecycle stage (matches WorkflowEvent.workflow_lifecycle Literal)."
)
persist_src = inspect.getsource(persist.persist_new_workflow)
assert "broadcast_workflow_lifecycle(" in persist_src, (
"persist_new_workflow must broadcast via broadcast_workflow_lifecycle so connected clients refresh."
)