procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_form_add_element.py

@@ -0,0 +1,256 @@
+"""Adding a control to a LIVE form (flowmodel-free: dto/form/addelement).
+
+Why this exists: `form-create` speaks an authoring config, `form-edit` rebuilds a form from one, and
+neither can add a control to a form that was hand-built in the designer — the two shapes are
+different languages (the create config has no element ids at all). Everything else in the toolkit is
+surgical (set one config, wire one event); adding a control was the missing verb, so a new admin
+button meant hand-writing a stored element DTO.
+
+The invariant that makes it safe: PROCESIO backs every control with a data-model sub-model whose id
+is the ELEMENT id and whose attribute ids are the ELEMENT'S OWN CONFIG IDS. So new controls can be
+SPLICED into the live `Data.dataModel` without touching what is already there — which matters,
+because a RUN_PROCESS map references a field by the path `root.fields.elementId.valueAttrId`, and
+regenerating those ids would break every existing mapping on the form.
+"""
+from __future__ import annotations
+
+import copy
+
+import pytest
+
+from tools.procesio.dto.form import addelement
+from tools.procesio.errors import UsageError
+
+
+ROOT = "65396456-36bf-4d9f-8d32-63a4a9e5c8c0"
+FIELDS_NS = "11223344-5566-7788-99aa-aabbccddeeff"
+EXISTING_EL = "aaaaaaaa-1111-1111-1111-111111111111"
+EXISTING_CFG = "bbbbbbbb-2222-2222-2222-222222222222"
+
+
+def _live_form() -> dict:
+    """A form as GET /api/FormTemplate/{id} returns it, with one existing control."""
+    return {
+        "id": "form-1", "name": "Admin", "isPrivate": True, "type": 1, "status": 1,
+        "state": True, "assignees": [], "customUrl": None,
+        "data": {
+            "elements": [
+                {"id": EXISTING_EL, "type": "input", "section": "body", "parentId": None,
+                 "category": "field",
+                 "configs": [{"id": EXISTING_CFG, "key": "value", "label": "Value", "value": ""},
+                             {"id": "cccccccc-3333-3333-3333-333333333333", "key": "name",
+                              "label": "Name", "value": "DefaultTimeZone"}]},
+            ],
+            "variables": [{"id": ROOT, "dataType": ROOT, "name": "form", "type": 20}],
+            "dataModel": {
+                "id": ROOT, "name": "form", "attributes": [
+                    {"id": FIELDS_NS, "dataTypeId": FIELDS_NS, "name": "fields",
+                     "parentDataTypeId": ROOT, "isDataModel": True, "attributes": [
+                         {"id": EXISTING_EL, "dataTypeId": EXISTING_EL, "name": "DefaultTimeZone",
+                          "parentDataTypeId": FIELDS_NS, "isDataModel": True, "attributes": [
+                              {"id": EXISTING_CFG, "name": "value", "parentDataTypeId": EXISTING_EL}]},
+                     ]},
+                ]},
+        },
+    }
+
+
+def _fields_attrs(data: dict) -> list:
+    fields = next(a for a in data["dataModel"]["attributes"] if a["id"] == FIELDS_NS)
+    return fields["attributes"]
+
+
+def _by_name(elements: list, name: str):
+    for el in elements:
+        for c in el.get("configs", []):
+            if c.get("key") == "name" and c.get("value") == name:
+                return el
+    return None
+
+
+# --------------------------------------------------------------------------- the happy path
+
+def test_a_new_control_is_appended_to_the_elements_list():
+    form = _live_form()
+    out = addelement.add_elements(form, [{"type": "input", "label": "Organiser Email",
+                                          "name": "OrganiserEmail"}])
+
+    assert len(out["elements"]) == 2
+    added = _by_name(out["elements"], "OrganiserEmail")
+    assert added is not None and added["type"] == "input"
+
+
+def test_the_existing_control_is_untouched_down_to_its_config_ids():
+    form = _live_form()
+    before = copy.deepcopy(form["data"]["elements"][0])
+
+    out = addelement.add_elements(form, [{"type": "input", "name": "OrganiserEmail"}])
+
+    assert out["elements"][0] == before
+
+
+def test_every_existing_data_model_id_survives():
+    """A RUN_PROCESS map references root.fields.elementId.valueAttrId — regenerating any of those
+    ids silently breaks every mapping already on the form."""
+    form = _live_form()
+    out = addelement.add_elements(form, [{"type": "input", "name": "OrganiserEmail"}])
+
+    existing = next(s for s in _fields_attrs(out) if s["id"] == EXISTING_EL)
+    assert existing["attributes"][0]["id"] == EXISTING_CFG
+    assert out["dataModel"]["id"] == ROOT
+
+
+def test_the_new_control_gets_a_sub_model_keyed_by_its_element_id():
+    form = _live_form()
+    out = addelement.add_elements(form, [{"type": "input", "name": "OrganiserEmail"}])
+
+    added = _by_name(out["elements"], "OrganiserEmail")
+    sub = next((s for s in _fields_attrs(out) if s["id"] == added["id"]), None)
+    assert sub is not None
+    assert sub["name"] == "OrganiserEmail"
+    assert sub["parentDataTypeId"] == FIELDS_NS
+
+
+def test_the_new_sub_model_attribute_ids_equal_the_new_element_config_ids():
+    form = _live_form()
+    out = addelement.add_elements(form, [{"type": "input", "name": "OrganiserEmail"}])
+
+    added = _by_name(out["elements"], "OrganiserEmail")
+    sub = next(s for s in _fields_attrs(out) if s["id"] == added["id"])
+    cfg_ids = {c["id"] for c in added["configs"]}
+    assert {a["id"] for a in sub["attributes"]} <= cfg_ids
+    assert any(a["name"] == "value" for a in sub["attributes"]), (
+        "the value attribute is what a process map binds to")
+
+
+# --------------------------------------------------------------------------- placement
+
+def test_a_control_can_be_parented_to_an_existing_container():
+    form = _live_form()
+    form["data"]["elements"].append(
+        {"id": "tab-1", "type": "tab", "section": "body", "parentId": None,
+         "configs": [{"id": "n1", "key": "name", "value": "Tab1"}]})
+
+    out = addelement.add_elements(form, [{"type": "button", "label": "Delete", "name": "delBtn"}],
+                                  parent="Tab1")
+
+    assert _by_name(out["elements"], "delBtn")["parentId"] == "tab-1"
+
+
+def test_an_unknown_parent_is_refused_and_names_what_exists():
+    form = _live_form()
+    with pytest.raises(UsageError) as e:
+        addelement.add_elements(form, [{"type": "button", "name": "b"}], parent="Nope")
+    assert "Nope" in str(e.value)
+
+
+def test_a_duplicate_control_name_is_refused():
+    """Two controls sharing a name make the field-path resolver ambiguous."""
+    form = _live_form()
+    with pytest.raises(UsageError) as e:
+        addelement.add_elements(form, [{"type": "input", "name": "DefaultTimeZone"}])
+    assert "DefaultTimeZone" in str(e.value)
+
+
+def test_several_controls_can_be_added_in_one_call_and_keep_their_order():
+    form = _live_form()
+    out = addelement.add_elements(form, [
+        {"type": "input", "name": "MinimumNoticeHours"},
+        {"type": "input", "name": "GoogleCalendarId"},
+        {"type": "input", "name": "OrganiserEmail"}])
+
+    names = [c["value"] for el in out["elements"] for c in el["configs"] if c["key"] == "name"]
+    assert names[-3:] == ["MinimumNoticeHours", "GoogleCalendarId", "OrganiserEmail"]
+
+
+def test_adding_nothing_is_refused_rather_than_writing_the_form_back_unchanged():
+    with pytest.raises(UsageError):
+        addelement.add_elements(_live_form(), [])
+
+
+def test_the_form_passed_in_is_not_mutated():
+    form = _live_form()
+    snapshot = copy.deepcopy(form)
+    addelement.add_elements(form, [{"type": "input", "name": "OrganiserEmail"}])
+    assert form == snapshot, "the caller decides when to write; the builder stays pure"
+
+
+# --------------------------------------------------------------------------- container registration
+
+def _form_with_tabs() -> dict:
+    """A tabs container that draws its children from its own `tabs` list, as the runtime does."""
+    form = _live_form()
+    form["data"]["elements"].append(
+        {"id": "tabs-1", "type": "tabs", "section": "body", "parentId": None,
+         "configs": [{"id": "tn", "key": "name", "value": "Tabs1"},
+                     {"id": "tl", "key": "tabs", "value": ["Tab1"]}]})
+    form["data"]["elements"].append(
+        {"id": "tab-1", "type": "tab", "section": "body", "parentId": "tabs-1",
+         "configs": [{"id": "t1n", "key": "name", "value": "Tab1"}]})
+    return form
+
+
+def test_a_new_tab_is_registered_in_its_container_list():
+    """Parenting alone is not enough: a tabs container renders the names in its `tabs` config, so a
+    spliced tab that is missing from it exists, saves, lints clean and never appears on screen."""
+    out = addelement.add_elements(_form_with_tabs(), [{"type": "tab", "name": "Tab2"}],
+                                  parent="Tabs1")
+    tabs = next(e for e in out["elements"] if e["id"] == "tabs-1")
+    listed = next(c["value"] for c in tabs["configs"] if c["key"] == "tabs")
+    assert listed == ["Tab1", "Tab2"]
+
+
+def test_a_table_row_is_registered_in_the_table_rows_list():
+    form = _live_form()
+    form["data"]["elements"].append(
+        {"id": "table-1", "type": "table", "section": "body", "parentId": None,
+         "configs": [{"id": "tbn", "key": "name", "value": "Table1"},
+                     {"id": "tbr", "key": "rows", "value": []}]})
+    out = addelement.add_elements(form, [{"type": "dynamic-table-row", "name": "Row1"}],
+                                  parent="Table1")
+    table = next(e for e in out["elements"] if e["id"] == "table-1")
+    assert next(c["value"] for c in table["configs"] if c["key"] == "rows") == ["Row1"]
+
+
+def test_a_container_with_no_list_config_is_untouched():
+    form = _live_form()
+    form["data"]["elements"].append(
+        {"id": "sec-1", "type": "section", "section": "body", "parentId": None,
+         "configs": [{"id": "sn", "key": "name", "value": "Section1"}]})
+    out = addelement.add_elements(form, [{"type": "input", "name": "Extra"}], parent="Section1")
+    sec = next(e for e in out["elements"] if e["id"] == "sec-1")
+    assert [c["key"] for c in sec["configs"]] == ["name"]
+
+
+def test_an_existing_entry_is_not_duplicated():
+    form = _form_with_tabs()
+    out = addelement.add_elements(form, [{"type": "tab", "name": "Tab2"}], parent="Tabs1")
+    form2 = {"id": "form-1", "data": out}
+    out2 = addelement.add_elements(form2, [{"type": "tab", "name": "Tab3"}], parent="Tabs1")
+    tabs = next(e for e in out2["elements"] if e["id"] == "tabs-1")
+    assert next(c["value"] for c in tabs["configs"] if c["key"] == "tabs") == ["Tab1", "Tab2", "Tab3"]
+
+
+def test_a_control_placed_inside_a_table_row_is_flagged_as_unreachable():
+    """A map cannot read a control that exists once per row, and nothing else reports that."""
+    elements = [
+        {"id": "tbl", "type": "table", "parentId": None,
+         "configs": [{"key": "name", "value": "Table1"}, {"key": "rows", "value": ["Row1"]}]},
+        {"id": "row", "type": "dynamic-table-row", "parentId": "tbl",
+         "configs": [{"key": "name", "value": "Row1"}]},
+        {"id": "panel", "type": "side-panel", "parentId": "row",
+         "configs": [{"key": "name", "value": "EditPanel"}]},
+    ]
+    warning = addelement.unreachable_in_row(elements, "panel")
+    assert warning is not None
+    assert "Row1" in warning
+    assert "$.item" in warning
+
+
+def test_a_control_outside_any_row_is_not_flagged():
+    elements = [
+        {"id": "tab", "type": "tab", "parentId": None,
+         "configs": [{"key": "name", "value": "Tab1"}]},
+    ]
+    assert addelement.unreachable_in_row(elements, "tab") is None
+    assert addelement.unreachable_in_row(elements, None) is None

procesio_cli/tools/procesio/tests/test_form_approval_gaps.py

@@ -0,0 +1,319 @@
+"""Three form gaps measured live on QA on 2026-09-25 while testing Approval Control events.
+
+1. form-create left the top-level `Assignees` empty on a form whose section had an assignee
+   and whose approval control had an approver. The designer's save
+   (user-playground Builder.component.vue::save + ui-builder utils/formBuilder/payload.ts)
+   builds one ASSIGNEE step (type 1) per element with assignee users and one APPROVER step
+   (type 2) per element with approver users: `{stepId: <element id>, orderId: n, users:
+   [{userId}]}`, orderId counting 1, 2, 3 within each list.
+2. form-create built a form data model with only `instance, fields` and no
+   `dataModelAttributeFormatVersion`. The designer writes `instance, flow, fields,
+   preventFormSubmit, browserTitle` and version "1" for a new form. Without the version the
+   designer treats the form as the legacy "0" format and LOWER-CASES every field attribute on
+   its next save (measured: `RequestText` became `requesttext`); without `preventFormSubmit`
+   a form script cannot block a submit.
+3. form-set-element-event refused to wire an approval trigger on an approval control saved
+   before its event slots existed (old forms). The runtime back-fills missing configs from
+   the element template on every load (ui-builder utils/formBuilder/elements.ts::
+   actualizeElements); the CLI now does the same for the one slot it needs, and says so.
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from tools.procesio import main
+from tools.procesio.client import ProcesioClient
+from tools.procesio.dto.form import builder
+from tools.procesio.errors import UsageError
+from tools.procesio.tests.conftest import FakeResp, FakeSession
+
+APIKEY = {"type": "apikey", "key": "N", "value": "V"}
+U1, U2, U3 = "u-1111", "u-2222", "u-3333"
+
+
+def _call(action, argv, session):
+    return main.dispatch(
+        action, argv,
+        client_builder=lambda prof: ProcesioClient(profile=APIKEY, name="t", session=session))
+
+
+def _ids():
+    n = iter(range(10_000))
+    return {"new_id": lambda: f"id-{next(n)}"}
+
+
+def _by_type(dto, kind):
+    return [e for e in dto["Data"]["elements"] if e["type"] == kind]
+
+
+# --------------------------------------------------------------------------- gap 1
+
+def _approval_form(**top):
+    return {
+        "name": "AUTO approval gaps",
+        **top,
+        "elements": [
+            {"type": "section", "label": "Request", "configs": {"assignee": U1},
+             "children": [{"type": "input", "label": "Text", "name": "RequestText"}]},
+            {"type": "approval", "label": "Approval step", "name": "Approval1",
+             "approver": U2, "configs": {"approverReplacement": [U3, "", U2]}},
+            {"type": "button", "label": "Submit", "submit": True},
+        ],
+    }
+
+
+def test_assignees_are_derived_from_assignee_and_approver_configs_like_the_designer():
+    dto = builder.build(_approval_form(isPrivate=True), _ids())
+    section, = _by_type(dto, "section")
+    approval, = _by_type(dto, "approval")
+    assert dto["Assignees"] == [
+        {"stepId": section["id"], "orderId": 1, "type": 1, "users": [{"userId": U1}]},
+        # approver first, then replacements; blanks dropped, duplicates collapsed
+        {"stepId": approval["id"], "orderId": 1, "type": 2,
+         "users": [{"userId": U2}, {"userId": U3}]},
+    ]
+
+
+def test_order_ids_count_within_each_list():
+    cfg = _approval_form()
+    cfg["elements"].insert(2, {"type": "approval", "label": "Second", "name": "Approval2",
+                               "approver": U3})
+    dto = builder.build(cfg, _ids())
+    approvers = [a for a in dto["Assignees"] if a["type"] == 2]
+    assert [a["orderId"] for a in approvers] == [1, 2]
+    assert [a["users"][0]["userId"] for a in approvers] == [U2, U3]
+
+
+def test_a_form_with_approvers_becomes_a_user_task_when_type_is_not_given():
+    assert builder.build(_approval_form(), _ids())["Type"] == 0
+
+
+def test_an_explicit_type_is_respected():
+    assert builder.build(_approval_form(type="general"), _ids())["Type"] == 1
+
+
+def test_explicit_assignees_in_the_config_still_win_verbatim():
+    mine = [{"stepId": "S", "orderId": 7, "type": 2, "users": [{"userId": "X"}]}]
+    assert builder.build(_approval_form(assignees=mine), _ids())["Assignees"] == mine
+
+
+def test_a_form_without_assignees_is_unchanged():
+    dto = builder.build({"name": "plain", "elements": [{"type": "input", "label": "A"}]}, _ids())
+    assert dto["Assignees"] == [] and dto["Type"] == 1
+
+
+# --------------------------------------------------------------------------- gap 2
+
+PREVENT = "d63722f4-0cd1-4bc2-8174-28276e7c7ab5"
+TITLE = "b8c1f2a3-4d5e-4a6b-8c7d-9e0f1a2b3c4d"
+FLOW = "c16e9d56-8484-444d-b1c5-36e48afb1d3d"
+INSTANCE = "8b49c48a-0834-40d0-920a-4c53566495a8"
+BOOL, STR = "0317bfee-b2f5-4bde-bfe8-121212121210", "0317bfee-b2f5-4bde-bfe8-121212121214"
+
+
+def test_data_model_matches_what_the_designer_saves_for_a_new_form():
+    dto = builder.build(_approval_form(), _ids())
+    data = dto["Data"]
+    assert data["dataModelAttributeFormatVersion"] == "1"
+    dm = data["dataModel"]
+    top = {a["name"]: a for a in dm["attributes"]}
+    assert [a["name"] for a in dm["attributes"]] == [
+        "instance", "flow", "fields", "preventFormSubmit", "browserTitle"]
+    root = data["variables"][0]["id"]
+    assert dm["id"] == root
+    assert all(a["parentDataTypeId"] == root for a in dm["attributes"])
+    assert (top["preventFormSubmit"]["id"], top["preventFormSubmit"]["dataTypeId"]) == (PREVENT, BOOL)
+    assert (top["browserTitle"]["id"], top["browserTitle"]["dataTypeId"]) == (TITLE, STR)
+    assert top["flow"]["id"] == FLOW and "statusEnum" in [a["name"] for a in top["flow"]["attributes"]]
+    assert top["instance"]["id"] == INSTANCE
+    assert [a["name"] for a in top["instance"]["attributes"]] == [
+        "id", "workspaceId", "submitter", "currentUser"]
+    # the fields container still carries one sub-model per element, named as-is (format "1")
+    assert "RequestText" in [a["name"] for a in top["fields"]["attributes"]]
+
+
+# --------------------------------------------------------------------------- gap 3
+
+def _old_form():
+    """An approval control as saved before its event slots existed (QA form 8d789e26…,
+    created 2025-06-03): 15 configs, no onBefore*/onAfter* keys."""
+    old_keys = ["label", "tooltip", "description", "info-text", "visible", "comment",
+                "responseDate", "responseUser", "response", "name", "id", "approver",
+                "approverReplacement", "additionalApprovers", "onInputEvents"]
+    configs = [{"id": f"c-{k}", "key": k, "value": None} for k in old_keys]
+    next(c for c in configs if c["key"] == "name")["value"] = "Approval1"
+    return {
+        "id": "F-OLD", "name": "Complex (Copy)", "isPrivate": True, "type": 0, "status": 1,
+        "state": True, "assignees": [], "customUrl": None,
+        "data": {"code": "", "dataModel": {"id": "dm"}, "elements": [
+            {"id": "A1", "type": "approval", "configs": configs},
+            {"id": "I1", "type": "input", "configs": [{"id": "c-n", "key": "name", "value": "Input1"}]},
+        ]},
+    }
+
+
+_JS = {"code": "console.log($event)"}
+
+
+def test_a_missing_approval_slot_is_backfilled_from_the_template_and_reported():
+    s = FakeSession(queue=[FakeResp(200, _old_form()), FakeResp(200, _old_form()), FakeResp(200, {})])
+    out = _call("form-set-element-event",
+                ["--id", "F-OLD", "--element", "Approval1", "--on", "beforeapprove",
+                 "--action", "RUN_JAVASCRIPT", "--config", json.dumps(_JS)], s)
+
+    assert out["updated"] is True
+    assert out["backfilled"] == ["onBeforeApproveEvents"]
+    put = s.calls[-1]
+    assert put["method"] == "PUT"
+    els = put["json"]["Data"]["elements"]
+    assert els[1] == _old_form()["data"]["elements"][1]            # sibling untouched
+    configs = els[0]["configs"]
+    slot = [c for c in configs if c["key"] == "onBeforeApproveEvents"]
+    assert len(slot) == 1
+    assert slot[0]["type"] == "field-events" and slot[0]["id"] not in {c.get("id") for c in _old_form()["data"]["elements"][0]["configs"]}
+    assert slot[0]["value"]["events"][0]["type"] == "BEFORE_APPROVE"
+    # every existing config survives, in its original order
+    assert [c for c in configs if c["key"] != "onBeforeApproveEvents"] == _old_form()["data"]["elements"][0]["configs"]
+
+
+def test_dry_run_reports_the_backfill_without_writing():
+    s = FakeSession(queue=[FakeResp(200, _old_form())])
+    out = _call("form-set-element-event",
+                ["--id", "F-OLD", "--element", "Approval1", "--on", "afterapprovalsubmit",
+                 "--action", "RUN_JAVASCRIPT", "--config", json.dumps(_JS), "--dry-run"], s)
+    assert out["dry_run"] is True and out["backfilled"] == ["onAfterApprovalSubmitEvents"]
+    assert all(c["method"] == "GET" for c in s.calls)
+
+
+def test_a_trigger_the_element_type_cannot_raise_is_still_refused():
+    s = FakeSession(queue=[FakeResp(200, _old_form())])
+    with pytest.raises(UsageError, match="cannot raise"):
+        _call("form-set-element-event",
+              ["--id", "F-OLD", "--element", "Input1", "--on", "beforeapprove",
+               "--action", "RUN_JAVASCRIPT", "--config", json.dumps(_JS)], s)
+    assert all(c["method"] == "GET" for c in s.calls)
+
+
+def test_an_existing_slot_is_used_as_is_and_nothing_is_reported_as_backfilled():
+    s = FakeSession(queue=[FakeResp(200, _old_form()), FakeResp(200, _old_form()), FakeResp(200, {})])
+    out = _call("form-set-element-event",
+                ["--id", "F-OLD", "--element", "Approval1", "--on", "input",
+                 "--action", "RUN_JAVASCRIPT", "--config", json.dumps(_JS)], s)
+    assert out["backfilled"] == []
+    configs = s.calls[-1]["json"]["Data"]["elements"][0]["configs"]
+    assert len(configs) == len(_old_form()["data"]["elements"][0]["configs"])
+
+
+# --------------------------------------------------------------- dynamic-row approval steps
+# Shape of a real designer-saved "Dynamic Table Approval" form (QA, ids replaced): approval
+# steps live in each dynamic row's `approvalSteps`, and each step is its own APPROVER step.
+
+def _cfg_el(eid, etype, parent=None, **configs):
+    return {"id": eid, "type": etype, "parentId": parent,
+            "configs": [{"key": k, "value": v} for k, v in configs.items()]}
+
+
+def _step(sid, approver, replacement=None, row_index="0"):
+    return {"id": sid, "rowIndex": row_index, "approver": approver,
+            "approverReplacement": replacement or []}
+
+
+def _table_form():
+    return [
+        _cfg_el("SEC", "section", assignee=U1),
+        _cfg_el("T", "table", assignee=U2),
+        _cfg_el("R1", "dynamic-table-row", "T", visible=True, approvalSteps=[
+            _step("S1", U1), _step("S2", U2, [U3, U2]),
+            _step("S-UNPLACED", U3, row_index=None)]),        # no rowIndex: not a step
+        _cfg_el("R2", "dynamic-table-row", "T", visible=False,  # hidden row: no steps
+                approvalSteps=[_step("S-HIDDEN", U1)]),
+        _cfg_el("R3", "dynamic-table-row", "SEC",               # not in a table: no steps
+                approvalSteps=[_step("S-ORPHAN", U1)]),
+        _cfg_el("A", "approval", approver=U3),
+    ]
+
+
+def test_dynamic_row_approval_steps_are_their_own_steps_like_the_designer():
+    rows = builder.derive_assignees(_table_form())
+    assert [(r["type"], r["stepId"], r["orderId"], [u["userId"] for u in r["users"]])
+            for r in rows] == [
+        (1, "SEC", 1, [U1]), (1, "T", 2, [U2]),
+        (2, "S1", 1, [U1]), (2, "S2", 2, [U2, U3]), (2, "A", 3, [U3]),
+    ]
+
+
+# --------------------------------------------------------------- surgical edits keep routing true
+
+def test_an_edit_that_does_not_change_routing_keeps_the_stored_list_byte_for_byte():
+    stale = [{"stepId": "whatever", "orderId": 9, "type": 2, "users": [{"userId": "x"}]}]
+    before = [_cfg_el("A", "approval", approver=U1, label="Old")]
+    after = [_cfg_el("A", "approval", approver=U1, label="New")]
+    assert builder.reconcile_assignees(stale, before, after) == (stale, None)
+
+
+def test_an_edit_that_changes_routing_rederives_the_whole_list():
+    before = [_cfg_el("A", "approval", approver=U1)]
+    after = [_cfg_el("A", "approval", approver=U2)]
+    saved, report = builder.reconcile_assignees([], before, after)
+    assert saved == [{"stepId": "A", "orderId": 1, "type": 2, "users": [{"userId": U2}]}]
+    assert report["rederived"] is True and report["after"] == [("A", 1, 2, (U2,))]
+
+
+def _live_approval_form(**top):
+    approver = {"id": "c-appr", "key": "approver", "value": U1}
+    return {
+        "id": "F-LIVE", "name": "Live", "isPrivate": True, "type": 0, "status": 1, "state": True,
+        "customUrl": None,
+        "assignees": [{"stepId": "A1", "orderId": 1, "type": 2,
+                       "users": [{"userId": U1, "firstName": "G", "lastName": "G"}]}],
+        "data": {
+            "code": "", "variables": [{"id": "root", "dataType": "root", "name": "form"}],
+            "dataModel": {"id": "root", "name": "form", "attributes": [
+                {"id": "11223344-5566-7788-99aa-aabbccddeeff", "name": "fields",
+                 "parentDataTypeId": "root", "attributes": []}]},
+            "elements": [
+                {"id": "A1", "type": "approval", "parentId": None, "section": "body",
+                 "configs": [{"id": "c-name", "key": "name", "value": "Approval1"},
+                             {"id": "c-label", "key": "label", "value": "Approve"}, approver]},
+            ]},
+        **top,
+    }
+
+
+def test_set_element_config_rederives_assignees_when_the_approver_changes():
+    s = FakeSession(queue=[FakeResp(200, _live_approval_form()), FakeResp(200, {})])
+    out = _call("form-set-element-config",
+                ["--id", "F-LIVE", "--element", "Approval1", "--set", f"approver={U2}"], s)
+    put = s.calls[-1]["json"]
+    assert put["Assignees"] == [{"stepId": "A1", "orderId": 1, "type": 2, "users": [{"userId": U2}]}]
+    assert out["assignees"]["rederived"] is True
+
+
+def test_set_element_config_leaves_assignees_alone_for_a_label_change():
+    s = FakeSession(queue=[FakeResp(200, _live_approval_form()), FakeResp(200, {})])
+    out = _call("form-set-element-config",
+                ["--id", "F-LIVE", "--element", "Approval1", "--set", "label=Check"], s)
+    assert s.calls[-1]["json"]["Assignees"] == _live_approval_form()["assignees"]   # echoed
+    assert "assignees" not in out
+
+
+def test_add_element_routes_a_new_approval_control():
+    s = FakeSession(queue=[FakeResp(200, _live_approval_form()), FakeResp(200, {})])
+    spec = {"type": "approval", "name": "Approval2", "approver": U3}
+    out = _call("form-add-element", ["--id", "F-LIVE", "--elements", json.dumps(spec)], s)
+    put = s.calls[-1]["json"]
+    new_id = out["added"][0]["id"]
+    assert put["Assignees"] == [
+        {"stepId": "A1", "orderId": 1, "type": 2, "users": [{"userId": U1}]},
+        {"stepId": new_id, "orderId": 2, "type": 2, "users": [{"userId": U3}]},
+    ]
+    assert out["assignees"]["rederived"] is True
+
+
+def test_delete_element_unroutes_a_removed_approval_control():
+    s = FakeSession(queue=[FakeResp(200, _live_approval_form()), FakeResp(200, {})])
+    out = _call("form-delete-element", ["--id", "F-LIVE", "--element", "Approval1"], s)
+    assert s.calls[-1]["json"]["Assignees"] == []
+    assert out["assignees"]["rederived"] is True

procesio_cli/tools/procesio/tests/test_form_auto_names.py

@@ -0,0 +1,60 @@
+"""Auto-generated field names are single lowercase words, stable across a designer save.
+
+When a form config gives no explicit `name`, the builder derives one from the label. It
+used to title-case it (`Company Name` -> `CompanyName`), which a designer save re-keys and
+`formlint.lint_field_names` then flags. The builder now makes a single lowercase word, so
+an auto-named field survives a designer save unchanged and does not trip the lint. The
+human-readable text stays in the label, not the name. `_slug` (flowgraph display, which
+keeps case) is a different function and is left alone.
+"""
+from __future__ import annotations
+
+import itertools
+
+from tools.procesio import formlint
+from tools.procesio.dto.form import builder as fb
+
+
+def _ctx():
+    cnt = itertools.count(1)
+    return {"new_id": lambda: f"00000000-0000-0000-0000-{next(cnt):012d}"}
+
+
+def test_field_slug_is_a_single_lowercase_word():
+    assert fb._field_slug("Company Name") == "companyname"
+    assert fb._field_slug("order_id") == "orderid"
+    assert fb._field_slug("Already lower") == "alreadylower"
+    assert fb._field_slug("") == "field"
+
+
+def test_unnamed_elements_get_lowercase_names_that_do_not_trip_the_lint():
+    dto = fb.build({"name": "F", "elements": [
+        {"type": "input", "label": "Company Name"},
+        {"type": "select", "label": "Order List", "options": ["a", "b"]},
+    ]}, _ctx())
+    data = dto["Data"]
+    names = [c["value"] for e in data["elements"] for c in e.get("configs", [])
+             if c.get("key") == "name"]
+    assert "companyname" in names and "orderlist" in names, names
+    assert all(fb._SINGLE_WORD.fullmatch(n) for n in names) if hasattr(fb, "_SINGLE_WORD") \
+        else all(n == n.lower() and n.isalnum() for n in names), names
+    assert formlint.lint_field_names(data) == []
+
+
+def test_an_explicit_mixed_case_name_is_left_as_written():
+    """Kept verbatim. Since 2026-10-05 the builder writes dataModelAttributeFormatVersion "1",
+    and a designer save keeps names at "1" (measured on QA: orderList, order_id and
+    Customer_First_Name survived a designer re-publish and form JS saw them as written), so a
+    builder-made form draws no warning. The same names on a form WITHOUT the version (legacy
+    "0", e.g. one built before that date) still warn."""
+    dto = fb.build({"name": "F", "elements": [
+        {"type": "input", "label": "x", "name": "OrderList"},
+    ]}, _ctx())
+    data = dto["Data"]
+    names = [c["value"] for e in data["elements"] for c in e.get("configs", [])
+             if c.get("key") == "name"]
+    assert "OrderList" in names, names
+    assert data["dataModelAttributeFormatVersion"] == "1"
+    assert formlint.lint_field_names(data) == []
+    legacy = {k: v for k, v in data.items() if k != "dataModelAttributeFormatVersion"}
+    assert formlint.lint_field_names(legacy), "a form without the version must still warn"