procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_layout_report.py

@@ -0,0 +1,88 @@
+"""Tests for the engine-agnostic layout verification (report.build_report / layout-report)."""
+from __future__ import annotations
+
+from tools.procesio.layout import adapter, report
+
+
+def _linear_flow():
+    return {"Id": "f", "Actions": [
+        {"Id": "start", "ActionTemplateName": "Start",
+         "CustomData": {"type": "circle", "position": {"x": 0, "y": 0}},
+         "Ports": [{"SourceId": "start", "DestinationId": "a", "Type": 0}]},
+        {"Id": "a", "ActionTemplateName": "Map Data",
+         "CustomData": {"type": "square", "position": {"x": 0, "y": 0}},
+         "Ports": [{"SourceId": "a", "DestinationId": "stop", "Type": 0}]},
+        {"Id": "stop", "ActionTemplateName": "Stop",
+         "CustomData": {"type": "circle", "position": {"x": 0, "y": 0}}, "Ports": []},
+    ]}
+
+
+def _foreach_flow():
+    return {"Id": "f", "Actions": [
+        {"Id": "start", "ActionTemplateName": "Start",
+         "CustomData": {"type": "circle", "position": {"x": 0, "y": 0}},
+         "Ports": [{"SourceId": "start", "DestinationId": "loop", "Type": 0}]},
+        {"Id": "loop", "ActionTemplateName": "For Each",
+         "CustomData": {"type": "area", "name": "For Each", "position": {"x": 0, "y": 0},
+                        "areaSize": {"width": 0, "height": 0, "x": 0, "y": 0}},
+         "Ports": [{"SourceId": "loop", "DestinationId": "k1", "Type": 0},
+                   {"SourceId": "loop", "DestinationId": "stop", "Type": 0}]},
+        {"Id": "k1", "ActionTemplateName": "Map Data", "ParentId": "loop",
+         "CustomData": {"type": "square", "position": {"x": 0, "y": 0}},
+         "Ports": [{"SourceId": "k1", "DestinationId": "k2", "Type": 0}]},
+        {"Id": "k2", "ActionTemplateName": "Add", "ParentId": "loop",
+         "CustomData": {"type": "square", "position": {"x": 0, "y": 0}}, "Ports": []},
+        {"Id": "stop", "ActionTemplateName": "Stop",
+         "CustomData": {"type": "circle", "position": {"x": 0, "y": 0}}, "Ports": []},
+    ]}
+
+
+def test_report_on_clean_layout():
+    b = adapter.layout_flow(_linear_flow())["bundle"]
+    r = report.build_report(b)
+    assert r["ok"] is True and r["hard_issue_count"] == 0
+    m = r["metrics"]
+    assert m["nodes"] == 3 and m["edges"] == 2
+    for k in ("crossings", "max_edge_px", "vertical_rows", "aspect_w_to_h", "back_edges"):
+        assert k in m
+
+
+def test_report_detects_overlap():
+    # two leaf nodes stacked on the same point → overlap hard-issue
+    flow = {"Id": "f", "Actions": [
+        {"Id": "a", "CustomData": {"type": "square", "position": {"x": 100, "y": 100}}, "Ports": []},
+        {"Id": "b", "CustomData": {"type": "square", "position": {"x": 110, "y": 100}}, "Ports": []},
+    ]}
+    r = report.build_report(flow)
+    assert r["ok"] is False
+    assert any(i["type"] == "overlap" for i in r["hard_issues"])
+
+
+def test_report_detects_child_outside_frame_and_small_container():
+    # a For-Each whose frame is tiny (0x0) with a child at (200,200) → outside + size warnings
+    flow = {"Id": "f", "Actions": [
+        {"Id": "loop", "CustomData": {"type": "area", "name": "For Each",
+         "position": {"x": 0, "y": 0}, "areaSize": {"width": 0, "height": 0}}, "Ports": []},
+        {"Id": "k1", "ParentId": "loop",
+         "CustomData": {"type": "square", "position": {"x": 200, "y": 200}}, "Ports": []},
+    ]}
+    r = report.build_report(flow)
+    assert r["ok"] is False
+    assert any(i["type"] == "child_outside_frame" for i in r["hard_issues"])
+    c = r["containers"][0]
+    assert c["warnings"]                                  # width/height < min flagged
+
+
+def test_report_engine_agnostic():
+    # the SAME verification runs on either engine's output and yields the same structure
+    import os
+    legacy = report.build_report(adapter.layout_flow(_foreach_flow())["bundle"])
+    os.environ["LAYOUT_ENGINE"] = "elk"
+    try:
+        elk = report.build_report(adapter.layout_flow(_foreach_flow())["bundle"])
+    finally:
+        os.environ.pop("LAYOUT_ENGINE", None)
+    for rep_ in (legacy, elk):
+        assert set(rep_) >= {"ok", "metrics", "containers", "hard_issues"}
+        assert rep_["metrics"]["nodes"] == 5
+        assert rep_["containers"] and rep_["containers"][0]["name"] == "For Each"

procesio_cli/tools/procesio/tests/test_manifest_sync.py

@@ -0,0 +1,68 @@
+"""Guard: tool.yaml must declare exactly the actions the dispatcher registers,
+and every declared arg must match the action's argparse (both directions),
+with required argparse flags marked required in the manifest."""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from tools._lib.manifest import load_tool
+from tools.procesio import main
+
+
+def _manifest():
+    tool_root = Path(main.__file__).resolve().parent
+    return load_tool(tool_root / "tool.yaml")
+
+
+def test_manifest_actions_match_dispatch():
+    m = _manifest()
+    manifest_actions = set(m.action_names())
+    dispatch_actions = set(main.ACTIONS)
+    assert manifest_actions == dispatch_actions, (
+        f"only in manifest: {manifest_actions - dispatch_actions}; "
+        f"only in code: {dispatch_actions - manifest_actions}"
+    )
+
+
+def test_manifest_args_match_argparse():
+    m = _manifest()
+    for name, defn in main.ACTIONS.items():
+        parser = argparse.ArgumentParser()
+        defn.add_args(parser)
+        argparse_names = set()
+        for action in parser._actions:
+            for opt in action.option_strings:
+                if opt.startswith("--") and opt != "--help":
+                    argparse_names.add(opt[2:])
+        spec = m.get_action(name)
+        manifest_names = {a.name for a in spec.args}
+        assert manifest_names == argparse_names, (
+            f"action {name}: only in manifest {manifest_names - argparse_names}; "
+            f"only in argparse {argparse_names - manifest_names}"
+        )
+
+
+def test_required_args_marked_required_in_manifest():
+    m = _manifest()
+    for name, defn in main.ACTIONS.items():
+        parser = argparse.ArgumentParser()
+        defn.add_args(parser)
+        argparse_names = set()
+        required_argparse = set()
+        for action in parser._actions:
+            for opt in action.option_strings:
+                if opt.startswith("--") and opt != "--help":
+                    argparse_names.add(opt[2:])
+                    if getattr(action, "required", False):
+                        required_argparse.add(opt[2:])
+        spec = m.get_action(name)
+        required_manifest = {a.name for a in spec.args if a.required}
+        assert required_argparse <= required_manifest, (
+            f"action {name}: argparse-required but not manifest-required: "
+            f"{required_argparse - required_manifest}"
+        )
+        assert required_manifest <= argparse_names, (
+            f"action {name}: manifest-required but not an argparse flag: "
+            f"{required_manifest - argparse_names}"
+        )

procesio_cli/tools/procesio/tests/test_nodedelete.py

@@ -0,0 +1,151 @@
+"""Deleting one node from a live flow and healing the graph behind it (flowmodel/nodeparam).
+
+A dead node is not free: it still runs, still consumes an execution, and still fails into whatever
+error variable it was given, so a flow whose SQL contract moved on quietly throws on every run. The
+designer removes such a node and reconnects its neighbours in one gesture; over the API the edge
+healing has to be done explicitly, and getting it wrong strands the tail of the flow.
+"""
+from __future__ import annotations
+
+import copy
+
+import pytest
+
+from tools.procesio.flowmodel import nodeparam as np
+
+
+FLOW_ID = "flow-1"
+
+
+def _port(source: str, dest: str) -> dict:
+    return {"id": f"port-{source}-{dest}", "flowId": FLOW_ID, "sourceId": source,
+            "destinationId": dest, "type": 0, "state": 1, "data": {}, "errors": {}, "config": {}}
+
+
+def _linear_flow() -> dict:
+    """Start -> Query -> Node -> Stop, plus the all-zeros entry edge the designer writes."""
+    return {
+        "id": FLOW_ID,
+        "actions": [
+            {"id": "start", "actionName": "Start", "actionTemplateName": "Start",
+             "ports": [_port("start", "query"),
+                       _port("00000000-0000-0000-0000-000000000000", "start")]},
+            {"id": "query", "actionName": "sp_GetAvailableSlots", "actionTemplateName": "Execute Query",
+             "ports": [_port("query", "node")]},
+            {"id": "node", "actionName": "Node", "actionTemplateName": "Node",
+             "ports": [_port("node", "stop")]},
+            {"id": "stop", "actionName": "Stop", "actionTemplateName": "Stop", "ports": []},
+        ],
+        "variables": [],
+    }
+
+
+def _ids(flow: dict) -> list[str]:
+    return [a["id"] for a in flow["actions"]]
+
+
+def _edges(flow: dict) -> set[tuple[str, str]]:
+    return {(p["sourceId"], p["destinationId"]) for a in flow["actions"] for p in a.get("ports") or []}
+
+
+def test_deleting_a_middle_node_reconnects_its_predecessor_to_its_successor():
+    flow = _linear_flow()
+
+    changed, msg = np.delete_node(flow, np.find_node(flow, "Node"))
+
+    assert changed is True
+    assert "Node" in msg
+    assert _ids(flow) == ["start", "query", "stop"]
+    assert ("query", "stop") in _edges(flow), "the tail of the flow must stay reachable"
+    assert not any(dest == "node" for _, dest in _edges(flow))
+
+
+def test_the_healed_edge_keeps_the_flow_id_so_the_designer_can_render_it():
+    flow = _linear_flow()
+    np.delete_node(flow, np.find_node(flow, "Node"))
+
+    healed = next(p for a in flow["actions"] for p in a.get("ports") or []
+                  if (p["sourceId"], p["destinationId"]) == ("query", "stop"))
+    assert healed["flowId"] == FLOW_ID
+    assert healed["type"] == 0
+
+
+def test_deleting_a_tail_node_just_drops_the_edge_into_it():
+    flow = _linear_flow()
+    # make Node the last action: Start -> Query -> Node
+    node = np.find_node(flow, "Node")
+    node["ports"] = []
+
+    changed, _ = np.delete_node(flow, node)
+
+    assert changed is True
+    assert _ids(flow) == ["start", "query", "stop"]
+    assert not any(dest == "node" for _, dest in _edges(flow))
+    assert ("query", "stop") not in _edges(flow), "a tail node has no successor to reconnect to"
+
+
+def test_a_predecessor_that_already_reaches_the_successor_does_not_get_a_duplicate_edge():
+    flow = _linear_flow()
+    query = np.find_node(flow, "sp_GetAvailableSlots")
+    query["ports"].append(_port("query", "stop"))
+
+    np.delete_node(flow, np.find_node(flow, "Node"))
+
+    edges = [(p["sourceId"], p["destinationId"]) for a in flow["actions"] for p in a.get("ports") or []]
+    assert edges.count(("query", "stop")) == 1
+
+
+def test_healing_never_creates_a_self_loop():
+    flow = _linear_flow()
+    node = np.find_node(flow, "Node")
+    node["ports"] = [_port("node", "query")]      # Node loops back to its own predecessor
+
+    np.delete_node(flow, node)
+
+    assert not any(src == dest for src, dest in _edges(flow))
+
+
+def test_start_and_stop_are_refused():
+    for key in ("Start", "Stop"):
+        flow = _linear_flow()
+        before = copy.deepcopy(flow)
+        changed, msg = np.delete_node(flow, np.find_node(flow, key))
+        assert changed is False
+        assert "Start" in msg or "Stop" in msg
+        assert flow == before
+
+
+def test_a_branching_node_is_refused_rather_than_guessed():
+    flow = _linear_flow()
+    node = np.find_node(flow, "Node")
+    node["ports"] = [_port("node", "stop"), _port("node", "query")]
+    before = copy.deepcopy(flow)
+
+    changed, msg = np.delete_node(flow, node)
+
+    assert changed is False
+    assert "more than one" in msg
+    assert flow == before, "a refused delete must not half-rewire the graph"
+
+
+def test_deleting_a_node_that_is_not_in_the_flow_is_refused():
+    flow = _linear_flow()
+    stranger = {"id": "ghost", "actionName": "Ghost", "actionTemplateName": "Node", "ports": []}
+    changed, msg = np.delete_node(flow, stranger)
+    assert changed is False
+    assert "not in" in msg
+
+
+def test_variables_are_left_alone_because_another_node_may_still_read_them():
+    flow = _linear_flow()
+    flow["variables"] = [{"id": "v1", "name": "availableSlots"}]
+
+    np.delete_node(flow, np.find_node(flow, "Node"))
+
+    assert flow["variables"] == [{"id": "v1", "name": "availableSlots"}]
+
+
+@pytest.mark.parametrize("key", ["node", "Node"])
+def test_find_node_accepts_either_the_id_or_the_action_name(key):
+    flow = _linear_flow()
+    assert np.find_node(flow, key)["id"] == "node"