procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_sqlformat.py

@@ -0,0 +1,83 @@
+"""The SQL formatter may move whitespace and nothing else.
+
+The formatter exists so a Query Store node is readable in the designer, and a Query Store node
+IS its statement - so a formatter that could alter one would be trading correctness for looks.
+These tests pin the guarantee rather than the cosmetics: same tokens, same order, idempotent,
+and hands the input back whenever it cannot prove that.
+"""
+from tools.procesio.sqlformat import SINGLE_LINE_LIMIT, format_sql, is_unreadable, _tokens
+
+
+def test_one_line_statement_is_laid_out():
+    out = format_sql("SELECT a, b FROM t WHERE x = 1 AND y = 2")
+    assert out.splitlines() == ["SELECT a, b", "FROM t", "WHERE x = 1", "AND y = 2"]
+
+
+def test_only_whitespace_changes():
+    sql = ("WITH c AS (SELECT MAX(n) AS n FROM t WHERE k = 'a') "
+           "SELECT p.id, q.v FROM p JOIN q ON q.id = p.id WHERE p.n > 0 ORDER BY p.id")
+    assert _tokens(format_sql(sql)) == _tokens(sql)
+
+
+def test_formatting_is_idempotent():
+    sql = "SELECT a FROM t WHERE b = 1 AND c = 2 ORDER BY a"
+    once = format_sql(sql)
+    assert format_sql(once) == once
+
+
+def test_a_keyword_inside_a_string_literal_is_left_alone():
+    sql = "UPDATE t SET msg = 'select from where and or' WHERE id = 1"
+    out = format_sql(sql)
+    assert "'select from where and or'" in out
+    assert _tokens(out) == _tokens(sql)
+
+
+def test_a_doubled_quote_inside_a_literal_survives():
+    sql = "SELECT 'it''s fine, and from where' AS s FROM t WHERE a = 1"
+    out = format_sql(sql)
+    assert "'it''s fine, and from where'" in out
+    assert _tokens(out) == _tokens(sql)
+
+
+def test_placeholders_and_chips_are_opaque():
+    sql = "SELECT <%0%> FROM {{ds:Settings}} WHERE {{col:Settings.Key}} = @k AND <%1%> IS NULL"
+    out = format_sql(sql)
+    for token in ("<%0%>", "{{ds:Settings}}", "{{col:Settings.Key}}", "<%1%>", "@k"):
+        assert token in out
+
+
+def test_already_multiline_sql_is_left_exactly_as_the_author_wrote_it():
+    sql = "SELECT a\n  FROM t\n WHERE b = 1"
+    assert format_sql(sql) == sql
+
+
+def test_blank_and_non_string_inputs_pass_through():
+    assert format_sql("") == ""
+    assert format_sql(None) is None
+
+
+def test_nested_parentheses_indent():
+    out = format_sql("SELECT (SELECT x FROM u WHERE u.id = t.id) AS v FROM t")
+    assert any(line.startswith("  ") for line in out.splitlines())
+
+
+def test_is_unreadable_only_fires_on_a_long_single_line():
+    assert is_unreadable("SELECT " + "a" * SINGLE_LINE_LIMIT)
+    assert not is_unreadable("SELECT a FROM t")
+    assert not is_unreadable("SELECT " + "a" * SINGLE_LINE_LIMIT + "\nFROM t")
+
+
+def test_the_builder_refuses_a_long_one_line_script():
+    """SQL gets laid out; a script gets refused, because rewriting code could change it."""
+    import pytest
+
+    import tools.procesio.dto.process.builder as pb
+
+    long_line = "var x = 1; " * 40                       # ~440 characters, one line
+    cfg = {"title": "t",
+           "variables": [{"name": "out", "type": "string", "direction": "output"}],
+           "actions": [{"id": "n", "action": "Node",
+                        "params": {"Code": long_line, "Single Result": {"var": "out"}}}]}
+    with pytest.raises(Exception) as e:
+        pb.build(cfg, {"var_ids": {"out": "22222222-2222-2222-2222-222222222222"}})
+    assert "ONE line" in str(e.value)

procesio_cli/tools/procesio/tests/test_sqlparam.py

@@ -0,0 +1,187 @@
+"""SQL-action parameterization (tools.procesio.flowmodel.sqlparam) — pure-logic unit tests."""
+from __future__ import annotations
+
+from tools.procesio.flowmodel import sqlparam
+
+CRED = "45a1dd18-9d06-47cf-8a7b-7732447264af"
+SQL = "EXEC dbo.sp_Foo\n    @A = N'<%0%>',\n    @B = N'<%1%>',\n    @TopN = 5"
+
+
+def _inline_eq_node():
+    """An 'Execute Query' node that inlines two values as N'<%0%>' / N'<%1%>' (the anti-pattern)."""
+    return {
+        "id": "n1", "actionName": "Get X", "actionTemplateName": "Execute Query",
+        "templateId": sqlparam.EQ_TEMPLATE_ID,
+        "customData": {"configuration": [{"settings": [
+            {"id": sqlparam.PID_CRED, "type": "credentials", "value": CRED},
+            {"id": sqlparam.PID_SIDEPANEL, "type": "side-pannel", "value": [
+                {"id": sqlparam.PID_QUERY, "label": "Query", "type": "code-editor",
+                 "language": "sql", "value": SQL},
+            ]},
+        ]}]},
+        "parameters": [
+            {"tabPropertyId": sqlparam.PID_CRED, "value": CRED},
+            {"tabPropertyId": sqlparam.PID_QUERY, "value": SQL,
+             "variable": [{"id": 0, "variableId": "aaaaaaaa-0000-0000-0000-000000000000", "attribute": None},
+                          {"id": 1, "variableId": "bbbbbbbb-0000-0000-0000-000000000000", "attribute": None}]},
+        ],
+    }
+
+
+def test_scan_flags_inline():
+    rows = sqlparam.scan({"actions": [_inline_eq_node()]})
+    assert rows == [{"actionName": "Get X", "id": "n1", "template": "Execute Query", "inline": True}]
+
+
+def test_parameterize_rewrites_sql_and_builds_binding():
+    node = _inline_eq_node()
+    ok, msg = sqlparam.parameterize_node(node)
+    assert ok and "@p0" in msg and "@p1" in msg
+
+    qp = next(p for p in node["parameters"] if isinstance(p["value"], str) and "EXEC" in p["value"])
+    assert "<%" not in qp["value"]                       # no inline placeholders left
+    assert "@p0" in qp["value"] and "@p1" in qp["value"]  # named params
+    assert "@TopN = 5" in qp["value"]                    # literal stays inline
+    assert "variable" not in qp                          # inline var-map removed
+
+    bp = next(p for p in node["parameters"] if p["tabPropertyId"] == sqlparam.PID_BIND)
+    assert [e["destination"]["value"] for e in bp["value"]] == ["p0", "p1"]
+    assert bp["value"][0]["source"]["variable"][0]["variableId"] == "aaaaaaaa-0000-0000-0000-000000000000"
+
+    sub = node["customData"]["configuration"][0]["settings"][1]["value"]
+    assert any(s.get("id") == sqlparam.PID_BIND and s.get("type") == "map-parameters" for s in sub)
+
+
+def test_parameterize_is_idempotent():
+    node = _inline_eq_node()
+    assert sqlparam.parameterize_node(node)[0] is True
+    assert sqlparam.parameterize_node(node)[0] is False   # already parameterized
+    assert sqlparam.scan({"actions": [node]})[0]["inline"] is False
+
+
+def test_attribute_path_source():
+    node = _inline_eq_node()
+    node["parameters"][1]["variable"][0]["attribute"] = {"attributeId": "cccccccc-0000-0000-0000-000000000000",
+                                                         "nextAttribute": None}
+    sqlparam.parameterize_node(node)
+    bp = next(p for p in node["parameters"] if p["tabPropertyId"] == sqlparam.PID_BIND)
+    sub = node["customData"]["configuration"][0]["settings"][1]["value"]
+    designer = next(s for s in sub if s.get("id") == sqlparam.PID_BIND)
+    assert designer["value"][0]["source"] == "aaaaaaaa-0000-0000-0000-000000000000.cccccccc-0000-0000-0000-000000000000"
+
+
+def test_v2_template_migrates_to_execute_query():
+    # The real bug: a node LABELLED "Execute Query" but on the deprecated V2 template (a9f851c2). Must be
+    # keyed on templateId, not the label — else it keeps V2 (no binding property) -> unbound @params.
+    node = _inline_eq_node()
+    node["actionTemplateName"] = "Execute Query"                       # mislabelled
+    node["templateId"] = "a9f851c2-e0ba-4fee-9a06-5445ba000001"        # ...but really on V2
+    node["parameters"][0]["tabPropertyId"] = "a9f851c2-e0ba-4fee-9a06-5445bc000011"  # cred (GUID value)
+    node["parameters"][1]["tabPropertyId"] = "a9f851c2-e0ba-4fee-9a06-5445bc000014"  # query
+    ok, _ = sqlparam.parameterize_node(node)
+    assert ok
+    assert node["templateId"] == sqlparam.EQ_TEMPLATE_ID              # migrated to the latest template
+    qp = next(p for p in node["parameters"] if isinstance(p["value"], str) and "EXEC" in p["value"])
+    assert qp["tabPropertyId"] == sqlparam.PID_QUERY
+    cred = next(p for p in node["parameters"] if p["value"] == CRED)
+    assert cred["tabPropertyId"] == sqlparam.PID_CRED
+
+
+CMD_SQL = "EXEC xch.Save @Body = N'<%0%>'"
+EC_V1 = "c2760ff2-cd9e-49b4-b751-c05c88e06dac"
+EC_V1_CRED = "6701cb8b-3bde-4c7e-a45d-c37eaeff5e3d"
+EC_V1_SIDE = "fea72099-4718-473d-a091-7749aa38305b"
+EC_V1_CMD = "53896b0d-73a6-412f-9e67-224ca1daae7c"
+EC_V1_OUT = "f3452b3a-2c10-40df-9d34-2d2779dc6ed7"
+
+
+def _inline_command_v1_node(label="Execute Command"):
+    """An inline-SQL node on the DEPRECATED 'Execute Command V1' template. Note the label says
+    'Execute Command' while templateId is V1 - the real-world shape, and why the family is keyed on
+    templateId. V1 has no Parameters config tab and no Time Out."""
+    return {
+        "id": "n2", "actionName": "save rates to DB", "actionTemplateName": label,
+        "templateId": EC_V1,
+        "customData": {"configuration": [{"settings": [
+            {"id": EC_V1_CRED, "type": "credentials", "value": CRED},
+            {"id": EC_V1_SIDE, "type": "side-pannel", "value": [
+                {"id": EC_V1_CMD, "label": "Command", "type": "code-editor",
+                 "language": "sql", "value": CMD_SQL},
+                {"id": EC_V1_OUT, "label": "Output", "type": "number", "value": None},
+            ]},
+        ]}]},
+        "parameters": [
+            {"tabPropertyId": EC_V1_CRED, "value": CRED},
+            {"tabPropertyId": EC_V1_CMD, "value": CMD_SQL,
+             "variable": [{"id": 0, "variableId": "dddddddd-0000-0000-0000-000000000000", "attribute": None}]},
+            {"tabPropertyId": EC_V1_OUT, "value": "<%1%>",
+             "variable": [{"id": 1, "variableId": "eeeeeeee-0000-0000-0000-000000000000", "attribute": None}]},
+        ],
+    }
+
+
+def test_family_is_keyed_on_templateid_not_the_label():
+    assert sqlparam.family_of(_inline_command_v1_node())[0] == sqlparam.EC_TEMPLATE
+    assert sqlparam.family_of(_inline_eq_node())[0] == sqlparam.EQ_TEMPLATE
+
+
+def test_command_binds_its_own_parameters_tab_not_the_query_one():
+    """The bug this guards: writing the Execute QUERY bind id onto a Command node leaves every
+    @param unbound at runtime, silently."""
+    node = _inline_command_v1_node()
+    assert sqlparam.bind_pid(node) == sqlparam.EC_PID_BIND
+    assert sqlparam.EC_PID_BIND != sqlparam.PID_BIND
+    ok, _ = sqlparam.parameterize_node(node)
+    assert ok
+    assert any(p["tabPropertyId"] == sqlparam.EC_PID_BIND for p in node["parameters"])
+    assert not any(p["tabPropertyId"] == sqlparam.PID_BIND for p in node["parameters"])
+
+
+def test_command_v1_migrates_to_current_command_template():
+    node = _inline_command_v1_node()
+    sqlparam.parameterize_node(node)
+    assert node["templateId"] == sqlparam.EC_TEMPLATE_ID
+    assert node["actionTemplateName"] == sqlparam.EC_TEMPLATE
+    ids = {p["tabPropertyId"] for p in node["parameters"]}
+    assert sqlparam.EC_PID_CRED in ids and sqlparam.EC_PID_COMMAND in ids and sqlparam.EC_PID_OUTPUT in ids
+    assert not (ids & {EC_V1_CRED, EC_V1_CMD, EC_V1_OUT})     # no legacy id left behind
+    side = node["customData"]["configuration"][0]["settings"][1]
+    assert side["id"] == sqlparam.EC_PID_SIDEPANEL
+    assert {s["id"] for s in side["value"]} >= {sqlparam.EC_PID_COMMAND, sqlparam.EC_PID_OUTPUT}
+
+
+def test_migration_seeds_the_required_timeout_the_legacy_template_lacked():
+    node = _inline_command_v1_node()
+    sqlparam.parameterize_node(node)
+    tp = next(p for p in node["parameters"] if p["tabPropertyId"] == sqlparam.EC_PID_TIMEOUT)
+    assert 60 <= int(tp["value"]) <= 1800
+    side = node["customData"]["configuration"][0]["settings"][1]["value"]
+    assert any(s["id"] == sqlparam.EC_PID_TIMEOUT for s in side)
+
+
+def test_command_sql_is_rewritten_and_the_variable_moves_to_the_binding():
+    node = _inline_command_v1_node()
+    sqlparam.parameterize_node(node)
+    qp = next(p for p in node["parameters"] if p["tabPropertyId"] == sqlparam.EC_PID_COMMAND)
+    assert qp["value"] == "EXEC xch.Save @Body = @p0"
+    assert "variable" not in qp
+    bp = next(p for p in node["parameters"] if p["tabPropertyId"] == sqlparam.EC_PID_BIND)
+    assert bp["value"][0]["destination"]["value"] == "p0"
+    assert bp["value"][0]["source"]["variable"][0]["variableId"] == "dddddddd-0000-0000-0000-000000000000"
+
+
+def test_command_parameterize_is_idempotent():
+    node = _inline_command_v1_node()
+    assert sqlparam.parameterize_node(node)[0] is True
+    assert sqlparam.parameterize_node(node)[0] is False
+
+
+def test_migration_refreshes_labels_to_the_current_template_wording():
+    node = _inline_command_v1_node()
+    sqlparam.parameterize_node(node)
+    settings = node["customData"]["configuration"][0]["settings"]
+    cred = next(s for s in settings if s["id"] == sqlparam.EC_PID_CRED)
+    assert cred["label"] == "Select Database Server"      # was the V1 'Select SQL credentials'
+    side = next(s for s in settings if s["id"] == sqlparam.EC_PID_SIDEPANEL)
+    assert side["label"] == "Execute Command"
+    assert {s["label"] for s in side["value"] if s["id"] == sqlparam.EC_PID_COMMAND} == {"Command"}

procesio_cli/tools/procesio/tests/test_superseded_actions.py

@@ -0,0 +1,54 @@
+"""The process builder must BLOCK frozen/superseded action version pins (e.g.
+"Call API v3") and point at the live/latest action, unless --force pins one
+intentionally. Guards against silently building on an old action generation.
+"""
+from __future__ import annotations
+
+import itertools
+
+import pytest
+
+from tools.procesio.dto.process import builder as pb
+from tools.procesio.errors import UsageError
+
+
+def _ctx(force: bool = False):
+    counter = itertools.count(1)
+    ctx = {"new_id": lambda: f"00000000-0000-0000-0000-{next(counter):012d}"}
+    if force:
+        ctx["_force"] = True
+    return ctx
+
+
+def _cfg(action: str):
+    return {"title": "t", "variables": [{"name": "q", "type": "string"}],
+            "actions": [{"id": "c", "action": action,
+                         "params": {"Verb": "3ab385bd-f8ae-b641-9176-e7db886aec01"}}]}
+
+
+@pytest.mark.parametrize("action", ["Call API v1", "Call API v2", "Call API v3"])
+def test_superseded_call_api_is_blocked(action):
+    with pytest.raises(UsageError, match="superseded"):
+        pb.build(_cfg(action), _ctx())
+
+
+def test_block_message_names_the_latest_action():
+    with pytest.raises(UsageError, match=r"Call API"):
+        pb.build(_cfg("Call API v3"), _ctx())
+
+
+def test_force_allows_pinning_the_old_version():
+    # --force (ctx["_force"]) is the escape hatch for an intentional pin.
+    dto = pb.build(_cfg("Call API v3"), _ctx(force=True))
+    assert dto["Actions"], "forced build should proceed past the superseded guard"
+
+
+def test_latest_call_api_builds_cleanly():
+    dto = pb.build(_cfg("Call API"), _ctx())
+    assert any((a.get("ActionTemplateName") or "").strip() == "Call API" for a in dto["Actions"])
+
+
+def test_execute_query_v2_is_blocked():
+    # Guard fires before catalog resolution, so it applies even to versioned SQL pins.
+    with pytest.raises(UsageError, match="Execute Query"):
+        pb.build({"title": "t", "actions": [{"id": "e", "action": "Execute Query V2"}]}, _ctx())

procesio_cli/tools/procesio/tests/test_surgical_concurrency.py

@@ -0,0 +1,156 @@
+"""Optimistic-concurrency guard shared by the surgical write actions.
+
+A surgical action reads the live DTO, changes one field, and PUTs the whole thing
+back — last-write-wins. The guard re-reads right before the PUT and refuses to
+overwrite if the resource's update-token moved since it was read. It is INERT when
+the resource exposes no update-timestamp/version field (a safe no-op, never a false
+conflict), which is why the token-less fakes in the other suites are unaffected.
+"""
+from __future__ import annotations
+
+import pytest
+
+from tools.procesio import main
+from tools.procesio.client import ProcesioClient
+from tools.procesio.errors import UsageError
+from tools.procesio.handlers import common
+from tools.procesio.tests.conftest import FakeResp, FakeSession
+
+APIKEY = {"type": "apikey", "key": "N", "value": "V"}
+KEY = "test-passphrase"
+
+
+# -- guard unit ---------------------------------------------------------------
+
+def test_concurrency_token_matches_common_fields_case_insensitively():
+    assert common.concurrency_token({"updatedOn": "2026-08-07T10:00:00Z"})[1] == "2026-08-07T10:00:00Z"
+    assert common.concurrency_token({"Version": 7})[1] == 7
+    assert common.concurrency_token({"name": "x", "data": {}}) is None   # no token field
+    assert common.concurrency_token("not a dict") is None
+
+
+def test_guard_is_inert_without_a_token_and_never_refetches():
+    calls = []
+    def refetch():
+        calls.append(1); return {}
+    out = common.guard_unchanged(refetch, {"name": "no token here"}, force=False)
+    assert out["checked"] is False and "inactive" in out["note"]
+    assert calls == []                                    # no extra GET when inert
+
+
+def test_guard_passes_when_the_token_is_unchanged():
+    base = {"updatedOn": "T1"}
+    out = common.guard_unchanged(lambda: {"updatedOn": "T1"}, base, force=False)
+    assert out == {"checked": True, "token": "T1"}
+
+
+def test_guard_aborts_when_the_token_moved():
+    base = {"updatedOn": "T1"}
+    with pytest.raises(UsageError, match="changed since it was read"):
+        common.guard_unchanged(lambda: {"updatedOn": "T2"}, base, force=False)
+
+
+def test_force_skips_the_check_and_does_not_refetch():
+    calls = []
+    def refetch():
+        calls.append(1); return {"updatedOn": "T2"}
+    out = common.guard_unchanged(refetch, {"updatedOn": "T1"}, force=True)
+    assert out["forced"] is True and out["checked"] is False
+    assert calls == []                                    # forced -> no refetch
+
+
+# -- integration through form-set-code ---------------------------------------
+
+@pytest.fixture(autouse=True)
+def _stub_key(monkeypatch):
+    monkeypatch.setattr("tools.procesio.handlers.form_code._code_key", lambda *_a, **_k: KEY)
+
+
+def _call(action, argv, session):
+    return main.dispatch(
+        action, argv,
+        client_builder=lambda prof: ProcesioClient(profile=APIKEY, name="t", session=session))
+
+
+def _form(updated_on):
+    """A form DTO that carries an update token, so the guard is ACTIVE on it."""
+    return {"id": "F1", "name": "F", "isPrivate": False, "type": 1, "status": 1,
+            "state": True, "assignees": [], "customUrl": None, "updatedOn": updated_on,
+            "data": {"code": "", "elements": []}}
+
+
+def test_set_code_proceeds_when_the_form_is_unchanged():
+    # GET (read) -> GET (guard re-read, same token) -> PUT -> GET (read-back)
+    s = FakeSession(queue=[FakeResp(200, _form("T1")), FakeResp(200, _form("T1")),
+                           FakeResp(200, {})])
+    out = _call("form-set-code", ["--id", "F1", "--css", ".x{}"], s)
+    assert out["updated"] is True and out["concurrency"] == {"checked": True, "token": "T1"}
+    assert [c["method"] for c in s.calls] == ["GET", "GET", "PUT", "GET"]
+
+
+def test_set_code_aborts_when_the_form_changed_since_read():
+    # GET (read, T1) -> GET (guard re-read, T2) -> abort BEFORE any PUT
+    s = FakeSession(queue=[FakeResp(200, _form("T1")), FakeResp(200, _form("T2"))])
+    with pytest.raises(UsageError, match="changed since it was read"):
+        _call("form-set-code", ["--id", "F1", "--css", ".x{}"], s)
+    assert all(c["method"] == "GET" for c in s.calls)     # never wrote
+
+
+def test_set_code_force_overwrites_without_re_reading():
+    # force -> no guard GET: GET (read) -> PUT -> GET (read-back of what was stored)
+    s = FakeSession(queue=[FakeResp(200, _form("T1")), FakeResp(200, {})])
+    out = _call("form-set-code", ["--id", "F1", "--css", ".x{}", "--force"], s)
+    assert out["updated"] is True and out["concurrency"]["forced"] is True
+    assert [c["method"] for c in s.calls] == ["GET", "PUT", "GET"]   # single read before the PUT, no guard GET
+
+
+# -- integration through rename-actions (the other guarded writer) ------------
+
+class _FlowClient:
+    """A process client whose flow token can move between the baseline read and the
+    guard's re-read, to exercise rename-actions' concurrency guard."""
+    def __init__(self, tokens):
+        self.workspace_id = "ws"
+        self.profile = {}                             # unbound -> production designer host
+        self._tokens = list(tokens)
+        self.i = 0
+        self.puts = []
+
+    def _flow(self):
+        tok = self._tokens[min(self.i, len(self._tokens) - 1)]
+        self.i += 1
+        return {"id": "P", "updatedOn": tok,
+                "actions": [{"id": "a1", "actionName": "Node",
+                             "customData": {"name": "Node"}}]}
+
+    def get(self, path, query=None):
+        return {"flow": self._flow()}
+
+    def post(self, path, body=None, query=None):
+        return {"raw_text": ""}
+
+    def put(self, path, body=None, query=None):
+        self.puts.append(body)
+        return {}
+
+
+def _rename_args(force=False):
+    from argparse import Namespace
+    return Namespace(id="P", workspace_id="ws", profile=None, map='{"a1": "Renamed"}',
+                     map_file=None, no_validate=True, dry_run=False, force=force)
+
+
+def test_rename_actions_proceeds_when_the_flow_is_unchanged():
+    from tools.procesio.handlers import process_naming as pn
+    c = _FlowClient(["T1", "T1"])                      # baseline read + guard re-read: same
+    out = pn.rename_actions(c, _rename_args())["result"]
+    assert out["saved"] is True and out["concurrency"] == {"checked": True, "token": "T1"}
+    assert len(c.puts) == 1
+
+
+def test_rename_actions_aborts_when_the_flow_moved():
+    from tools.procesio.handlers import process_naming as pn
+    c = _FlowClient(["T1", "T2"])                      # token moved between read and re-read
+    with pytest.raises(UsageError, match="changed since it was read"):
+        pn.rename_actions(c, _rename_args())
+    assert c.puts == []                                # never saved

procesio_cli/tools/procesio/tests/test_tier4.py

@@ -0,0 +1,123 @@
+"""Tier-4 ergonomics: inspect-flow, action families, form optionsSource + chainConfig."""
+from __future__ import annotations
+
+import itertools
+
+from tools.procesio.flowmodel import families
+from tools.procesio.flowmodel.inspect import inspect
+
+
+def _flow():
+    return {
+        "Id": "f1", "Title": "Sample",
+        "Variables": [{"Id": "v1", "Name": "items", "Type": 10, "IsRequired": True}],
+        "Actions": [
+            {"Id": "start", "ActionTemplateName": "Start",
+             "CustomData": {"type": "circle"},
+             "Ports": [{"SourceId": "start", "DestinationId": "fe", "Type": 0}]},
+            {"Id": "fe", "ActionTemplateName": "For Each",
+             "CustomData": {"type": "area", "name": "For Each"},
+             "Ports": [{"SourceId": "fe", "DestinationId": "api", "Type": 0}]},
+            {"Id": "api", "ActionTemplateName": "Call API", "ParentId": "fe",
+             "CustomData": {"type": "square"},
+             "Ports": [{"SourceId": "api", "DestinationId": "d", "Type": 0}]},
+            {"Id": "d", "ActionTemplateName": "Decisional",
+             "CustomData": {"type": "diamond"},
+             "Ports": [{"SourceId": "d", "DestinationId": "stop", "Type": 0},
+                       {"SourceId": "d", "DestinationId": "stop2", "Type": 0}]},
+            {"Id": "stop", "ActionTemplateName": "Stop", "CustomData": {"type": "circle"}, "Ports": []},
+            {"Id": "stop2", "ActionTemplateName": "Stop", "CustomData": {"type": "circle"}, "Ports": []},
+        ],
+    }
+
+
+def test_families_classify():
+    assert families.classify("Call API") == "integration"
+    assert families.classify("Node") == "scripting"
+    assert families.classify("For Each") == "control"
+    assert families.classify("Totally Unknown Action") == "other"
+    assert families.describe("Call API")
+
+
+def test_inspect_counts_and_families():
+    r = inspect(_flow())
+    assert r["counts"]["actions"] == 6
+    assert r["counts"]["decisionals"] == 1
+    assert r["counts"]["stops"] == 2
+    assert r["counts"]["foreach"] == 1
+    assert r["action_families"].get("integration") == 1
+    assert r["action_families"].get("control")  # start/stop/foreach/decisional
+
+
+def test_inspect_branches():
+    r = inspect(_flow())
+    assert len(r["branches"]) == 1
+    assert r["branches"][0]["cases"] == 2
+
+
+def test_inspect_smells():
+    codes = {s["code"] for s in inspect(_flow())["smells"]}
+    # Call API inside a For Each, with no error port -> two smells fire
+    assert "no_error_port" in codes
+    assert "slow_in_loop" in codes
+    assert "required_inputs" in codes
+
+
+def test_inspect_variables_contract():
+    r = inspect(_flow())
+    assert r["variables"]["inputs"] == ["items"]
+    assert r["variables"]["required"] == ["items"]
+
+
+# -- form builder optionsSource + chainConfig --------------------------------
+
+def _form_ctx():
+    cnt = itertools.count(1)
+    return {"new_id": lambda: f"00000000-0000-0000-0000-{next(cnt):012d}"}
+
+
+def _configs(el):
+    return {c.get("key"): c.get("value") for c in el.get("configs", [])}
+
+
+def _select(elements, name=None):
+    return next(e for e in elements if e.get("type") == "select")
+
+
+def test_form_options_source_json():
+    from tools.procesio.dto.form import builder as fb
+    cfg = {"name": "F", "elements": [
+        {"type": "select", "label": "Pick",
+         "optionsSource": {"type": "json", "value": [{"label": "A", "value": "a"}]}}]}
+    els = fb.build(cfg, _form_ctx())["Data"]["elements"]
+    c = _configs(_select(els))
+    assert c["sourceType"] == "JSON"
+    assert c["sourceValue"] == [{"label": "A", "value": "a"}]
+
+
+def test_form_options_source_url():
+    from tools.procesio.dto.form import builder as fb
+    cfg = {"name": "F", "elements": [
+        {"type": "select", "label": "Pick",
+         "optionsSource": {"type": "url", "value": "https://x/opts"}}]}
+    els = fb.build(cfg, _form_ctx())["Data"]["elements"]
+    c = _configs(_select(els))
+    assert c["sourceType"] == "URL"
+    assert c["sourceValue"] == "https://x/opts"
+
+
+def test_form_static_options_unchanged():
+    from tools.procesio.dto.form import builder as fb
+    cfg = {"name": "F", "elements": [
+        {"type": "select", "label": "Pick", "options": ["A", "B"]}]}
+    els = fb.build(cfg, _form_ctx())["Data"]["elements"]
+    assert _configs(_select(els))["sourceType"] == "static-list"
+
+
+def test_form_chainconfig_emitted_only_when_present():
+    from tools.procesio.dto.form import builder as fb
+    base = {"name": "F", "elements": [{"type": "paragraph", "label": "hi"}]}
+    assert "chainConfig" not in fb.build(base, _form_ctx())["Data"]
+    chained = {**base, "chainConfig": {"columns": [{"forms": ["a"]}]}}
+    data = fb.build(chained, _form_ctx())["Data"]
+    assert data["chainConfig"] == {"columns": [{"forms": ["a"]}]}