procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_form_code_style.py

@@ -0,0 +1,178 @@
+"""Form-level CSS/JS (encrypted Data.code) + per-component styling.
+
+Scheme verified live against real exports (2026-06-25): Data.code is JSON {JAVASCRIPT,CSS}
+encrypted CryptoJS-style (AES-256-CBC, EVP_BytesToKey/MD5, Salted__). Tests use an injected
+key (ctx['form_code_key']) so they need no Credential Manager access.
+"""
+import uuid
+
+import pytest
+
+from tools.procesio.dto.form import builder, code_cipher
+from tools.procesio.errors import UsageError
+
+KEY = "TESTKEY123456789"
+
+
+def _ctx():
+    return {"new_id": lambda: str(uuid.uuid4()), "form_code_key": KEY}
+
+
+# ---- cipher ---------------------------------------------------------------
+def test_code_cipher_roundtrip():
+    blob = code_cipher.encrypt_code("console.log(1)", "body{color:red}", KEY)
+    assert blob.startswith("U2FsdGVkX1")  # base64("Salted__")
+    out = code_cipher.decrypt_code(blob, KEY)
+    assert out == {"JAVASCRIPT": "console.log(1)", "CSS": "body{color:red}"}
+
+
+def test_code_cipher_wrong_key_fails():
+    blob = code_cipher.encrypt_code("x", "y", KEY)
+    with pytest.raises(Exception):
+        code_cipher.decrypt_code(blob, "WRONGKEY12345678")
+
+
+# ---- builder: form-level code --------------------------------------------
+def test_build_sets_encrypted_code():
+    dto = builder.build(
+        {"name": "F", "css": "a{}", "javascript": "b()",
+         "elements": [{"type": "input", "label": "X"}]}, _ctx())
+    blob = dto["Data"]["code"]
+    assert code_cipher.decrypt_code(blob, KEY) == {"JAVASCRIPT": "b()", "CSS": "a{}"}
+
+
+def test_build_code_object_form():
+    dto = builder.build(
+        {"name": "F", "code": {"css": "c{}", "javascript": "d()"},
+         "elements": [{"type": "input", "label": "X"}]}, _ctx())
+    assert code_cipher.decrypt_code(dto["Data"]["code"], KEY)["CSS"] == "c{}"
+
+
+def test_build_no_code_is_empty_string():
+    dto = builder.build({"name": "F", "elements": [{"type": "input", "label": "X"}]}, _ctx())
+    assert dto["Data"]["code"] == ""
+
+
+# ---- builder: per-component style -----------------------------------------
+def test_element_style_sets_enabled_cssproperties():
+    dto = builder.build(
+        {"name": "F", "elements": [
+            {"type": "input", "label": "X", "style": {"--h-input": "50px"}}]}, _ctx())
+    el = next(e for e in dto["Data"]["elements"] if e["type"] == "input")
+    style = next(c for c in el["configs"] if c["key"] == "style")["value"]
+    assert style == [{"label": "Height", "value": "50px",
+                      "cssVariable": "--h-input", "type": None, "enabled": True}]
+
+
+def test_element_style_unknown_var_fails_loud():
+    with pytest.raises(UsageError):
+        builder.build({"name": "F", "elements": [
+            {"type": "input", "label": "X", "style": {"--bogus": "1"}}]}, _ctx())
+
+
+def test_element_style_on_unstylable_type_fails():
+    with pytest.raises(UsageError):
+        builder.build({"name": "F", "elements": [
+            {"type": "heading", "label": "H", "style": {"--x": "y"}}]}, _ctx())
+
+
+# ---- dynamic vs static tables ---------------------------------------------
+def _table(dynamic):
+    spec = {"type": "table", "name": "items", "columns": [
+        {"key": "p", "label": "P", "cell": {"type": "input"}}]}
+    if dynamic:
+        spec["dynamic"] = True
+    dto = builder.build({"name": "T", "elements": [spec]}, _ctx())
+    return dto["Data"]["elements"]
+
+
+def test_dynamic_table_uses_dynamic_row_with_add_remove():
+    els = _table(dynamic=True)
+    rows = [e for e in els if e["type"] == "dynamic-table-row"]
+    assert rows, "dynamic table must emit a dynamic-table-row"
+    cfg = {c["key"]: c.get("value") for c in rows[0]["configs"]}
+    assert cfg.get("canAdd") is True and cfg.get("canRemove") is True
+
+
+def test_static_table_uses_static_row():
+    els = _table(dynamic=False)
+    assert any(e["type"] == "static-table-row" for e in els)
+    assert not any(e["type"] == "dynamic-table-row" for e in els)
+
+
+# ---- element alignment properties -----------------------------------------
+
+def _style_of(dto, idx=0):
+    el = dto["Data"]["elements"][idx]
+    return {p["cssVariable"]: p["value"]
+            for p in next(c for c in el["configs"] if c["key"] == "style")["value"]}
+
+
+def test_section_accepts_alignment_vars():
+    dto = builder.build(
+        {"name": "F", "elements": [
+            {"type": "section", "label": "S",
+             "style": {"--fd-section": "row", "--jc-section": "center",
+                       "--ai-section": "stretch"}}]}, _ctx())
+    s = _style_of(dto)
+    assert s["--fd-section"] == "row" and s["--jc-section"] == "center"
+    assert s["--ai-section"] == "stretch"
+
+
+def test_columns_alignment_suffix():
+    dto = builder.build(
+        {"name": "F", "elements": [
+            {"type": "columns", "label": "C",
+             "style": {"--jc-column": "space-between"}}]}, _ctx())
+    assert _style_of(dto)["--jc-column"] == "space-between"
+
+
+def test_alignment_var_wrong_suffix_still_fails_loud():
+    # --jc-section is invalid on a columns element (its suffix is 'column').
+    with pytest.raises(UsageError):
+        builder.build({"name": "F", "elements": [
+            {"type": "columns", "label": "C", "style": {"--jc-section": "center"}}]}, _ctx())
+
+
+# ---- dark theme (ModeProperties on the Colors group) ----------------------
+
+def _colors_group(dto):
+    for g in dto["Data"]["theme"]:
+        if str(g.get("label", "")).strip().lower() == "colors":
+            return g
+    return None
+
+
+def _mode_var(dto, mode, cssvar):
+    for p in _colors_group(dto)["properties"][mode]:
+        if p.get("cssVariable") == cssvar:
+            return p["value"]
+    return None
+
+
+def test_dark_mode_puts_modeproperties_on_colors_group():
+    dto = builder.build(
+        {"name": "F", "dark": True,
+         "elements": [{"type": "input", "label": "X"}]}, _ctx())
+    colors = _colors_group(dto)
+    # Colors group's properties becomes {light, dark}; other groups stay flat lists
+    assert isinstance(colors["properties"], dict)
+    assert set(colors["properties"]) == {"light", "dark"}
+    assert _mode_var(dto, "dark", "--c-primary") == "#4663f5"        # DARK_PALETTE default
+    others = [g for g in dto["Data"]["theme"] if str(g.get("label")).lower() != "colors"]
+    assert all(isinstance(g["properties"], list) for g in others)
+
+
+def test_dark_override_wins():
+    dto = builder.build(
+        {"name": "F", "dark": True, "themeDark": {"--c-primary": "#000000"},
+         "elements": [{"type": "input", "label": "X"}]}, _ctx())
+    assert _mode_var(dto, "dark", "--c-primary") == "#000000"
+    # light side keeps the light default
+    assert _mode_var(dto, "light", "--c-primary") != "#000000"
+
+
+def test_no_dark_by_default():
+    dto = builder.build({"name": "F", "elements": [{"type": "input", "label": "X"}]}, _ctx())
+    assert isinstance(_colors_group(dto)["properties"], list)        # flat, no {light,dark}
+    assert "themeMode" not in dto["Data"] and "themeDark" not in dto["Data"]

procesio_cli/tools/procesio/tests/test_form_delete_element.py

@@ -0,0 +1,99 @@
+"""Removing a control is the mirror of splicing one in, and is guarded the same way.
+
+The property that makes `form-add-element` safe is that it touches nothing that already exists.
+Delete has to hold the same line: every surviving element keeps its id and its field path, and a
+control something still points at is refused rather than quietly turned into a dangling path -
+which the platform saves without any error, leaving the referring control launching nothing.
+"""
+import pytest
+
+from tools.procesio.dto.form import addelement
+from tools.procesio.errors import UsageError
+
+FORM_ID = "ffffffff-ffff-ffff-ffff-ffffffffffff"
+ROOT = "11111111-1111-1111-1111-111111111111"
+
+
+def _el(eid, name, parent=None, etype="input", configs=None):
+    return {"id": eid, "type": etype, "parentId": parent, "section": "body",
+            "configs": (configs or []) + [{"key": "name", "value": name}]}
+
+
+def _form(elements, attrs=None, events=None):
+    return {"id": FORM_ID,
+            "data": {"elements": elements,
+                     "variables": [{"id": ROOT}],
+                     "events": events or [],
+                     "dataModel": {"id": ROOT, "name": "form", "attributes": [
+                         {"id": "fields-ns", "name": "fields",
+                          "attributes": attrs or []}]}}}
+
+
+def test_the_control_and_its_model_entry_both_go():
+    form = _form([_el("a", "Keep"), _el("b", "Drop")],
+                 attrs=[{"id": "a", "name": "Keep"}, {"id": "b", "name": "Drop"}])
+    data, report = addelement.delete_element(form, "Drop")
+    assert [e["id"] for e in data["elements"]] == ["a"]
+    assert report["model_attributes_removed"] == 1
+    assert [r["name"] for r in report["removed"]] == ["Drop"]
+
+
+def test_it_can_be_addressed_by_id_as_well_as_by_name():
+    form = _form([_el("a", "Keep"), _el("b", "Drop")])
+    data, _ = addelement.delete_element(form, "b")
+    assert [e["id"] for e in data["elements"]] == ["a"]
+
+
+def test_a_surviving_control_is_untouched():
+    keep = _el("a", "Keep")
+    form = _form([keep, _el("b", "Drop")])
+    data, _ = addelement.delete_element(form, "Drop")
+    assert data["elements"][0] == keep
+
+
+def test_a_referenced_control_is_refused():
+    referring = _el("a", "Keep", configs=[{"key": "onClickEvents",
+                                           "value": {"events": [{"config": {"inputMap": [
+                                               {"right": {"value": f"{FORM_ID}.fields.b"}}]}}]}}])
+    form = _form([referring, _el("b", "Drop")])
+    with pytest.raises(UsageError) as e:
+        addelement.delete_element(form, "Drop")
+    assert "still referenced" in str(e.value)
+
+
+def test_force_deletes_a_referenced_control_and_reports_the_breakage():
+    referring = _el("a", "Keep", configs=[{"key": "onClickEvents",
+                                           "value": {"events": [{"config": {"inputMap": [
+                                               {"right": {"value": f"{FORM_ID}.fields.b"}}]}}]}}])
+    form = _form([referring, _el("b", "Drop")])
+    data, report = addelement.delete_element(form, "Drop", force=True)
+    assert [e["id"] for e in data["elements"]] == ["a"]
+    assert report["broken_references"] == ["b"]
+
+
+def test_a_container_with_children_is_refused_then_removed_whole_with_force():
+    form = _form([_el("box", "Box", etype="tabs"),
+                  _el("c1", "Child1", parent="box"),
+                  _el("c2", "Child2", parent="box")])
+    with pytest.raises(UsageError) as e:
+        addelement.delete_element(form, "Box")
+    assert "contains 2 control" in str(e.value)
+
+    data, report = addelement.delete_element(form, "Box", force=True)
+    assert data["elements"] == []
+    assert report["descendants"] == 2
+
+
+def test_the_container_list_stops_naming_a_removed_child():
+    box = _el("box", "Box", etype="tabs", configs=[{"key": "tabs", "value": ["Child1", "Child2"]}])
+    form = _form([box, _el("c1", "Child1", parent="box"), _el("c2", "Child2", parent="box")])
+    data, _ = addelement.delete_element(form, "Child1")
+    listed = next(c["value"] for c in data["elements"][0]["configs"] if c["key"] == "tabs")
+    assert listed == ["Child2"]
+
+
+def test_an_unknown_element_is_refused_with_the_known_names():
+    form = _form([_el("a", "Keep")])
+    with pytest.raises(UsageError) as e:
+        addelement.delete_element(form, "Nope")
+    assert "Keep" in str(e.value)

procesio_cli/tools/procesio/tests/test_form_element_config.py

@@ -0,0 +1,141 @@
+"""form-get-element / form-set-element-config: surgical rewrite of one element's configs.
+
+The invariants worth guarding are the ones whose breach is SILENT on the platform:
+a rewritten config that gets a fresh id breaks every value path pointing at it, and
+a config invented on an element has no data-model attribute behind it, so the
+designer renders raw guids and values never flow. Both must fail loudly here rather
+than produce a form that looks saved and does not work.
+"""
+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.tests.conftest import FakeResp, FakeSession
+
+APIKEY = {"type": "apikey", "key": "N", "value": "V"}
+
+
+def _call(action, argv, session):
+    return main.dispatch(
+        action, argv,
+        client_builder=lambda prof: ProcesioClient(profile=APIKEY, name="t", session=session))
+
+
+def _form() -> dict:
+    return {
+        "id": "F1", "name": "Some form", "isPrivate": False, "type": 1, "status": 1,
+        "state": True, "assignees": [], "customUrl": None,
+        "data": {
+            "code": "",
+            "elements": [
+                {"id": "e1", "type": "paragraph", "parentId": "s1", "section": "body",
+                 "configs": [
+                     {"id": "c-label", "key": "label", "value": "<p>old</p>"},
+                     {"id": "c-name", "key": "name", "value": "intro1"},
+                     {"id": "c-visible", "key": "visible", "value": True},
+                 ]},
+                {"id": "e2", "type": "input", "parentId": "s1", "section": "body",
+                 "configs": [
+                     {"id": "c2-name", "key": "name", "value": "cnp"},
+                     {"id": "c2-req", "key": "required", "value": False},
+                     {"id": "c2-regex", "key": "regex", "value": ""},
+                     {"id": "c2-input", "key": "onInputEvents", "value": None},
+                 ]},
+            ],
+            "theme": [{"label": "Colors"}],
+            "dataModel": {"id": "dm"},
+        },
+    }
+
+
+def test_get_element_by_name_returns_its_configs():
+    s = FakeSession(queue=[FakeResp(200, _form())])
+    out = _call("form-get-element", ["--id", "F1", "--element", "intro1"], s)
+    assert out["element_id"] == "e1" and out["type"] == "paragraph"
+    assert out["configs"]["label"] == "<p>old</p>"
+
+
+def test_get_element_can_be_narrowed_to_one_key():
+    s = FakeSession(queue=[FakeResp(200, _form())])
+    out = _call("form-get-element",
+                ["--id", "F1", "--element", "cnp", "--key", "regex"], s)
+    assert out["configs"] == {"regex": ""}
+    assert "required" in out["config_keys"]        # the full key list is still reported
+
+
+def test_set_preserves_the_config_id_and_leaves_every_sibling_untouched():
+    """The data model addresses each attribute by the element's OWN config id, so a
+    fresh id on a rewritten config silently breaks every value path pointing at it."""
+    s = FakeSession(queue=[FakeResp(200, _form()), FakeResp(200, {})])
+    out = _call("form-set-element-config",
+                ["--id", "F1", "--element", "intro1", "--set", "label=<p>new</p>"], s)
+    assert out["updated"] is True
+    assert out["previous"] == {"label": "<p>old</p>"}
+
+    put = s.calls[-1]
+    elements = put["json"]["Data"]["elements"]
+    label = next(c for c in elements[0]["configs"] if c["key"] == "label")
+    assert label["id"] == "c-label" and label["value"] == "<p>new</p>"
+    # every sibling element and config byte-identical
+    assert elements[1] == _form()["data"]["elements"][1]
+    assert put["json"]["Data"]["theme"] == [{"label": "Colors"}]
+    assert put["json"]["Data"]["dataModel"] == {"id": "dm"}
+
+
+def test_scalars_are_parsed_as_json_so_required_stores_a_boolean():
+    s = FakeSession(queue=[FakeResp(200, _form()), FakeResp(200, {})])
+    _call("form-set-element-config",
+          ["--id", "F1", "--element", "cnp",
+           "--set", "required=true", "--set", "regex=^[0-9]{13}$"], s)
+    configs = {c["key"]: c["value"] for c in s.calls[-1]["json"]["Data"]["elements"][1]["configs"]}
+    assert configs["required"] is True                  # boolean, not the string "true"
+    assert configs["regex"] == "^[0-9]{13}$"            # not valid JSON -> kept as a string
+
+
+def test_set_file_carries_a_long_html_label(tmp_path):
+    body = tmp_path / "label.html"
+    body.write_text("<div>lung</div>", encoding="utf-8")
+    s = FakeSession(queue=[FakeResp(200, _form()), FakeResp(200, {})])
+    _call("form-set-element-config",
+          ["--id", "F1", "--element", "intro1", "--set-file", f"label={body}"], s)
+    label = next(c for c in s.calls[-1]["json"]["Data"]["elements"][0]["configs"]
+                 if c["key"] == "label")
+    assert label["value"] == "<div>lung</div>"
+
+
+def test_an_unknown_config_is_refused_before_anything_is_written():
+    """Inventing a config would need a matching data-model attribute with the same id;
+    without one the designer shows raw guids. Refusing is the honest failure."""
+    s = FakeSession(queue=[FakeResp(200, _form())])
+    with pytest.raises(UsageError) as e:
+        _call("form-set-element-config",
+              ["--id", "F1", "--element", "intro1", "--set", "placeholder=x"], s)
+    assert "no config placeholder" in str(e.value)
+    assert not any(c["method"] == "PUT" for c in s.calls)
+
+
+def test_event_configs_are_routed_to_the_event_action():
+    s = FakeSession(queue=[FakeResp(200, _form())])
+    with pytest.raises(UsageError) as e:
+        _call("form-set-element-config",
+              ["--id", "F1", "--element", "cnp", "--set", 'onInputEvents={"events":[]}'], s)
+    assert "form-set-element-event" in str(e.value)
+
+
+def test_dry_run_reports_the_change_without_writing():
+    s = FakeSession(queue=[FakeResp(200, _form())])
+    out = _call("form-set-element-config",
+                ["--id", "F1", "--element", "intro1",
+                 "--set", "visible=false", "--dry-run"], s)
+    assert out["dry_run"] is True and out["set"] == {"visible": False}
+    assert out["elements"] == 2          # the count to watch on every write
+    assert not any(c["method"] == "PUT" for c in s.calls)
+
+
+def test_nothing_to_set_is_a_usage_error():
+    s = FakeSession(queue=[])
+    with pytest.raises(UsageError):
+        _call("form-set-element-config", ["--id", "F1", "--element", "intro1"], s)

procesio_cli/tools/procesio/tests/test_form_event_maps.py

@@ -0,0 +1,135 @@
+"""RUN_PROCESS input/output map resolution on a form element event (handlers/form_events).
+
+The bug this guards: `isList` was hardcoded false on both sides of every map row, and a caller's
+own value was discarded. A list-valued process variable then bound into a scalar slot, so the form
+received nothing from a process that had run perfectly — and there is no error anywhere to read,
+because both the API and the designer accept the row. Every result-set mapping was silently wrong.
+"""
+from __future__ import annotations
+
+import pytest
+
+from tools.procesio.errors import UsageError
+from tools.procesio.handlers import form_events as fe
+
+
+PID = "process-1"
+
+
+class _Client:
+    """Serves one process's variable DTOs, the way GET /api/Projects/{id} does."""
+
+    def __init__(self, variables):
+        self.variables = variables
+
+    def get(self, path, query=None):
+        assert path == f"/api/Projects/{PID}"
+        assert query == {"variablesOnly": "true"}    # only the variables are read
+        return {"flow": {"variables": self.variables}}
+
+
+def _client() -> _Client:
+    return _Client([
+        {"id": "var-rows", "name": "bookingResultRaw", "isList": True},
+        {"id": "var-name", "name": "clientName", "isList": False},
+    ])
+
+
+def _row(config, side="outputMap", index=0):
+    return config[side][index]
+
+
+def test_a_list_process_variable_maps_as_a_list_on_both_sides():
+    config = {"processId": PID,
+              "outputMap": [{"id": 0, "left": {"value": "bookingResultRaw"},
+                             "right": {"value": "form-var"}}]}
+
+    out = fe._resolve_maps(config, _client())
+
+    row = _row(out)
+    assert row["left"]["isList"] is True
+    assert row["right"]["isList"] is True, "the form side holds what the process side produced"
+
+
+def test_a_scalar_process_variable_still_maps_as_a_scalar():
+    config = {"processId": PID,
+              "inputMap": [{"id": 0, "left": {"value": "clientName"},
+                            "right": {"value": "form-var"}}]}
+
+    out = fe._resolve_maps(config, _client())
+
+    row = _row(out, "inputMap")
+    assert row["left"]["isList"] is False
+    assert row["right"]["isList"] is False
+
+
+def test_a_variable_named_by_guid_resolves_its_list_ness_too():
+    config = {"processId": PID,
+              "outputMap": [{"id": 0, "left": {"value": "var-rows"},
+                             "right": {"value": "form-var"}}]}
+
+    out = fe._resolve_maps(config, _client())
+
+    assert _row(out)["left"]["value"] == "var-rows"
+    assert _row(out)["left"]["isList"] is True
+
+
+def test_an_explicit_is_list_from_the_caller_wins_over_the_variable():
+    """Mapping ONE attribute out of a list is a scalar row against a list variable."""
+    config = {"processId": PID,
+              "outputMap": [{"id": 0,
+                             "left": {"value": "bookingResultRaw", "isList": False},
+                             "right": {"value": "form-var", "isList": False}}]}
+
+    out = fe._resolve_maps(config, _client())
+
+    assert _row(out)["left"]["isList"] is False
+    assert _row(out)["right"]["isList"] is False
+
+
+def test_a_variable_name_is_resolved_to_its_guid():
+    config = {"processId": PID,
+              "inputMap": [{"id": 0, "left": {"value": "clientName"},
+                            "right": {"value": "form-var"}}]}
+
+    out = fe._resolve_maps(config, _client())
+
+    assert _row(out, "inputMap")["left"]["value"] == "var-name"
+
+
+def test_the_two_sides_keep_the_path_shapes_the_designer_expects():
+    config = {"processId": PID,
+              "outputMap": [{"id": 0, "left": {"value": "bookingResultRaw"},
+                             "right": {"value": "form-var"}}]}
+
+    out = fe._resolve_maps(config, _client())
+
+    assert _row(out)["left"]["path"] == {}
+    assert _row(out)["right"]["path"] is None
+
+
+def test_an_attribute_path_supplied_by_the_caller_survives():
+    config = {"processId": PID,
+              "outputMap": [{"id": 0,
+                             "left": {"value": "bookingResultRaw", "path": {"attributeId": "a1"}},
+                             "right": {"value": "form-var"}}]}
+
+    out = fe._resolve_maps(config, _client())
+
+    assert _row(out)["left"]["path"] == {"attributeId": "a1"}
+
+
+def test_an_unknown_variable_fails_loudly_before_anything_is_written():
+    config = {"processId": PID,
+              "inputMap": [{"id": 0, "left": {"value": "nope"}, "right": {"value": "f"}}]}
+
+    with pytest.raises(UsageError) as e:
+        fe._resolve_maps(config, _client())
+
+    assert "nope" in str(e.value)
+    assert "clientName" in str(e.value), "the error must name what IS available"
+
+
+def test_a_config_without_a_process_id_is_refused():
+    with pytest.raises(UsageError):
+        fe._resolve_maps({"outputMap": []}, _client())