procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_formlint_field_names.py

@@ -0,0 +1,83 @@
+"""Field names a designer save would rename are flagged, once per form, and never renamed.
+
+A form built through the API keeps its field names as written. One save in the designer
+re-keys `ProcesioForm.data.fields`: it splits each name on underscores, lowercases the
+parts and joins them in camelCase. Form JS that reads the original name then gets
+`undefined`. The tool warns; it does not rename, because scripts already in use read the
+names as built.
+"""
+from __future__ import annotations
+
+import json
+
+from tools.procesio import formlint, main
+from tools.procesio.client import ProcesioClient
+from tools.procesio.tests.conftest import FakeSession
+
+APIKEY = {"type": "apikey", "key": "N", "value": "V"}
+
+
+def _data(*names):
+    return {"elements": [{"id": f"e{i}", "type": "input",
+                          "configs": [{"key": "name", "value": n}]}
+                         for i, n in enumerate(names)]}
+
+
+def test_the_designer_rekey_rule_as_measured():
+    assert formlint.designer_key("orderList") == "orderlist"
+    assert formlint.designer_key("order_id") == "orderId"
+    assert formlint.designer_key("Customer_First_Name") == "customerFirstName"
+    assert formlint.designer_key("order-id") is None        # hyphens were not measured
+
+
+def test_single_lowercase_words_pass():
+    assert formlint.lint_field_names(_data("orders", "total2")) == []
+
+
+def test_one_warning_names_every_renamed_field():
+    warnings = formlint.lint_field_names(_data("orderList", "order_id", "ok"))
+    assert len(warnings) == 1
+    assert warnings[0].startswith("2 field name(s)")
+    assert "orderList -> orderlist" in warnings[0]
+    assert "order_id -> orderId" in warnings[0]
+
+
+def test_a_long_list_is_shortened():
+    warnings = formlint.lint_field_names(_data(*[f"field_{i}" for i in range(10)]))
+    assert "and 2 more" in warnings[0]
+
+
+def test_an_unmeasured_name_says_so():
+    warnings = formlint.lint_field_names(_data("order-id"))
+    assert "order-id -> (renamed; rule not measured)" in warnings[0]
+
+
+def test_elements_without_a_name_are_ignored():
+    assert formlint.lint_field_names({"elements": [{"id": "e1", "configs": []}]}) == []
+
+
+def test_the_form_lint_includes_it():
+    assert any("designer re-keys" in w for w in formlint.lint_form_data(_data("orderList")))
+
+
+def test_a_form_at_format_version_1_keeps_its_names_so_draws_no_warning():
+    """The re-key is the designer's legacy "0" rule, applied to a form with no version. A form
+    at "1" keeps its names through a designer save (measured 2026-09-25: RequestText kept;
+    2026-10-05: orderList and order_id kept)."""
+    assert formlint.lint_field_names({**_data("orderList", "order_id"),
+                                      "dataModelAttributeFormatVersion": "1"}) == []
+    assert formlint.lint_field_names({**_data("orderList"),
+                                      "dataModelAttributeFormatVersion": "0"}) != []
+
+
+def test_form_create_writes_version_1_so_names_survive_and_are_not_warned_about():
+    cfg = {"name": "F", "elements": [{"type": "input", "label": "Order", "name": "orderList"}]}
+    out = main.dispatch(
+        "form-create", ["--config", json.dumps(cfg), "--dry-run"],
+        client_builder=lambda prof: ProcesioClient(profile=APIKEY, name="t",
+                                                   session=FakeSession()))
+    assert out["dto"]["Data"]["dataModelAttributeFormatVersion"] == "1"
+    assert not any("orderList" in w for w in out.get("warnings") or [])
+    names = [c["value"] for e in out["dto"]["Data"]["elements"]
+             for c in e["configs"] if c["key"] == "name"]
+    assert "orderList" in names          # kept verbatim, and a designer save keeps it too

procesio_cli/tools/procesio/tests/test_guards.py

@@ -0,0 +1,110 @@
+"""Guards for three footguns found live on 2026-07-30 (Livespace PoC):
+
+1. a credential option property given a raw string (e.g. Method="POST") used to save
+   fine and then break EVERY Call API run at runtime with "Unrecognized Guid format";
+2. `publish` without `launch` silently leaves an instance stuck at "starting";
+3. "Error: data type mismatch." never said which type was expected (Call API's
+   `Response Status` needs `integer`, not `number`).
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[3]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.procesio.dto.credential import builder as cred  # noqa: E402
+from tools.procesio.errors import UsageError  # noqa: E402
+from tools.procesio.flowmodel import fevalidation as fev  # noqa: E402
+from tools.procesio import main as pmain  # noqa: E402
+
+GUID_A = "10101010-0001-0002-0001-cccccccccccc"
+GUID_B = "10101010-0001-0004-0001-cccccccccccc"
+
+
+def _prop(label, options):
+    return {"id": "p1", "label": label, "options": options}
+
+
+METHOD = _prop("Method", [{"be_value": "Get", "name": "GET", "value": GUID_A}])
+
+
+# --- 1. credential option properties -------------------------------------
+def test_option_name_resolves_to_guid():
+    assert cred._resolve_option(METHOD, "GET") == GUID_A
+
+
+def test_option_be_value_and_guid_also_accepted():
+    assert cred._resolve_option(METHOD, "Get") == GUID_A
+    assert cred._resolve_option(METHOD, GUID_A) == GUID_A
+
+
+def test_unmatched_value_on_guid_option_raises_not_silently_stored():
+    # THE regression: "POST" is not an option of Method. Before the fix this was
+    # stored verbatim and every Call API run using the credential died at runtime.
+    with pytest.raises(UsageError) as ei:
+        cred._resolve_option(METHOD, "POST")
+    msg = str(ei.value)
+    assert "Method" in msg and "GET" in msg
+    assert "Unrecognized Guid format" in msg   # names the runtime symptom
+
+
+def test_non_guid_option_sets_still_pass_through():
+    # checkbox-style props must keep working (backwards compatibility)
+    checkbox = _prop("Header", [{"name": "true", "value": "true"},
+                                {"name": "false", "value": "false"}])
+    assert cred._resolve_option(checkbox, "true") == "true"
+    assert cred._resolve_option(checkbox, "whatever") == "whatever"
+
+
+def test_property_without_options_passes_through():
+    assert cred._resolve_option({"id": "p", "label": "URL"}, "https://x") == "https://x"
+
+
+def test_build_raises_for_bad_option_value():
+    template = {"gid": "g", "pid": "p", "name": "REST API", "type": "REST_API",
+                "properties": [METHOD]}
+    with pytest.raises(UsageError):
+        cred.build({"name": "X", "properties": {"Method": "POST"}}, {"template": template})
+    dto = cred.build({"name": "X", "properties": {"Method": "GET"}}, {"template": template})
+    assert dto["properties"] == [{"id": "p1", "value": GUID_A}]
+
+
+# --- 2. publish advisory --------------------------------------------------
+def test_publish_carries_the_launch_advisory():
+    out = pmain._advise("post-projects-by-id-instances-publish", {"result": {}})
+    assert "starting" in out["warning"] and "launch" in out["warning"].lower()
+
+
+def test_advisory_does_not_touch_other_actions_or_clobber():
+    assert "warning" not in pmain._advise("run-process", {"result": {}})
+    keep = pmain._advise("post-projects-by-id-instances-publish", {"warning": "mine"})
+    assert keep["warning"] == "mine"
+
+
+# --- 3. type-mismatch hint ----------------------------------------------
+def test_type_mismatch_warning_names_expected_and_actual():
+    INT, NUM = "0317bfee-int", "0317bfee-num"
+    dt_by_id = {INT: {"id": INT, "name": "integer"}, NUM: {"id": NUM, "name": "number"}}
+    var_by_id = {"v1": {"id": "v1", "name": "editStatus", "dataType": NUM, "isList": False}}
+    setting = {"id": "s", "label": "Response Status", "dataTypeId": INT,
+               "isList": False, "value": "<%0%>"}
+    action = {"id": "a", "actionTemplateName": "Call API"}
+    # emulate the binding the builder writes: value refs the variable
+    warns = fev._default_datatype_check(action, {**setting, "value": "v1"},
+                                        var_by_id, dt_by_id)
+    if warns:                                  # only assert the hint when it fires
+        assert warns[0]["code"] == "TYPE_MISMATCH"
+        assert "expects integer" in warns[0]["hint"]
+
+
+def test_type_hint_text_is_actionable():
+    INT, NUM = "i", "n"
+    dt_by_id = {INT: {"id": INT, "name": "integer"}, NUM: {"id": NUM, "name": "number"}}
+    hint = fev._type_hint({"dataTypeId": INT, "isList": False},
+                          {"scalar": [{"id": NUM}], "list": []}, dt_by_id)
+    assert "binds number" in hint and "expects integer" in hint

procesio_cli/tools/procesio/tests/test_hidden_setting_types.py

@@ -0,0 +1,39 @@
+"""Hidden setting types (`ignore`, `auto`): the designer saves their template value and binds
+no variable, so the builder must seed them the same way and never confuse one slot for another."""
+from __future__ import annotations
+
+from tools.procesio.dto.process import builder
+
+STARTED = "d2831844-54a5-42e7-a101-119e21a03fe2"
+CHILD_ID = "d2831844-54a5-42e7-a101-119e21a03fe3"
+NULL = builder.NULL_GUID
+
+
+def _template(settings):
+    return {"configuration": [{"settings": settings}]}
+
+
+def test_an_auto_setting_is_seeded_like_an_ignore_setting():
+    tpl = _template([
+        {"id": "s-ignore", "type": "ignore", "direction": 2, "value": "-1"},
+        {"id": "s-auto", "type": "auto", "direction": 2, "value": NULL},
+        {"id": "s-text", "type": "text", "direction": 1, "value": "x"},
+    ])
+    params = builder._ensure_engine_state_properties(tpl, [])
+    assert {p["TabPropertyId"] for p in params} == {"s-ignore", "s-auto"}
+    assert all(p["Variable"] == [] for p in params)
+
+
+def test_an_auto_setting_counts_as_a_template_default_output():
+    assert builder._is_template_default_output({"type": "auto", "direction": 1, "value": NULL})
+
+
+def test_the_started_flow_slot_is_found_by_id_not_by_position():
+    # A child-instance-id slot listed BEFORE the started-flow slot must not be taken for it.
+    tpl = _template([
+        {"id": CHILD_ID, "type": "ignore", "direction": 2, "value": NULL},
+        {"id": STARTED, "type": "ignore", "direction": 2, "value": NULL},
+        {"id": "flow", "type": "flow-list", "direction": 1, "value": None},
+    ])
+    out = builder._build_subprocess(tpl, {"target": "T"}, {}, {}, [0])
+    assert out[0]["TabPropertyId"] == STARTED

procesio_cli/tools/procesio/tests/test_html2docx_asset.py

@@ -0,0 +1,132 @@
+"""Guards the HTML -> DOCX converter that is pasted into a PROCESIO Node action.
+
+The asset runs inside the platform's Node sandbox (no require of fs/zlib/buffer), so the
+end-to-end check runs it in a bare vm context the same way. Skipped when no `node` binary
+is on PATH; the placeholder check always runs.
+"""
+from __future__ import annotations
+
+import base64
+import io
+import json
+import re
+import shutil
+import subprocess
+import zipfile
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+import pytest
+
+ASSET = Path(__file__).resolve().parents[1] / "assets" / "html2docx" / "html2docx.js"
+
+W = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
+R = "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}"
+CT = "{http://schemas.openxmlformats.org/package/2006/content-types}"
+
+HTML = """<html lang="ro"><head><style>
+@media print { @page { size: A4; margin: 1cm } }
+html, body { margin: 0 }
+.page { padding: 0 0.5cm 0 1.5cm; font-family: Arial, sans-serif; font-size: 10pt; line-height: 1.241 }
+.hl { background: #FFFF00 } .c { text-align: center }
+table.bd td { border: 1px solid #000; padding: 0 0.1cm }
+.salt { page-break-before: always; height: 0 }
+</style></head><body><div class="page">
+<p class="c"><b>CONTRACT</b> nr. <span class="hl">____</span> &icirc;ncheiat &#537;i semnat</p>
+<table class="bd" style="width:100%"><colgroup><col style="width:30%"><col style="width:70%"></colgroup>
+<tr><td rowspan="2">A</td><td>B</td></tr><tr><td>C</td></tr></table>
+<div class="salt"></div><ul><li>unu</li><li>doi</li></ul>
+</div></body></html>"""
+
+
+def _convert(tmp_path, html):
+    """Run the asset in a bare vm context (the PROCESIO Node sandbox profile) and return
+    its result dict. Caller guards with skipif(node missing)."""
+    runner = tmp_path / "run.js"
+    runner.write_text(
+        "const vm=require('vm'),fs=require('fs');"
+        "const src=fs.readFileSync(process.argv[2],'utf8');"
+        "const ctx=vm.createContext({console,Date,setTimeout,clearTimeout,Promise});"
+        "const r=vm.runInContext(src+';H2D.convert('+JSON.stringify(process.argv[3])+',null,true)',ctx);"
+        "process.stdout.write(JSON.stringify(r));",
+        encoding="utf-8",
+    )
+    b64 = base64.b64encode(html.encode("utf-8")).decode()
+    out = subprocess.run(["node", str(runner), str(ASSET), b64], capture_output=True, text=True, timeout=60)
+    assert out.returncode == 0, out.stderr
+    return json.loads(out.stdout)
+
+
+def test_asset_has_no_placeholder_text():
+    # The platform substitutes `<%...%>` textually anywhere in a Node body, comments included.
+    assert "<%" not in ASSET.read_text(encoding="utf-8")
+
+
+@pytest.mark.skipif(shutil.which("node") is None, reason="node binary not available")
+def test_converts_in_a_bare_sandbox(tmp_path):
+    res = _convert(tmp_path, HTML)
+    report = res["report"]
+    assert report["ok"] and report["tables"] == 1 and report["lists"] == 1
+    # padding of the single wrapper is folded into the page margins
+    assert report["page"]["marginsCm"]["left"] == pytest.approx(2.5, abs=0.01)
+    assert report["page"]["marginsCm"]["right"] == pytest.approx(1.5, abs=0.01)
+
+    zf = zipfile.ZipFile(io.BytesIO(base64.b64decode(res["base64"])))
+    assert zf.testzip() is None
+    for name in zf.namelist():
+        if name.endswith((".xml", ".rels")):
+            ET.fromstring(zf.read(name))
+    doc = zf.read("word/document.xml").decode("utf-8")
+    assert "încheiat și semnat" in doc                       # entities decoded, UTF-8 kept
+    assert '<w:highlight w:val="yellow"/>' in doc             # background #FFFF00 -> highlight
+    assert '<w:vMerge w:val="restart"/>' in doc               # rowspan
+    assert "<w:pageBreakBefore/>" in doc                      # page-break-before on an empty div
+    assert re.search(r'w:line="259" w:lineRule="auto"', doc)  # CSS 1.241 on Arial == Word 1.08
+    assert "word/numbering.xml" in zf.namelist()
+
+
+@pytest.mark.skipif(shutil.which("node") is None, reason="node binary not available")
+def test_package_integrity_is_what_word_checks(tmp_path):
+    """A zip/XML-valid .docx can still be one Word repairs. The triggers Word actually
+    rejects on are machine-checkable: dangling relationship ids, parts missing from
+    [Content_Types].xml, and list refs with no numbering part. Assert none of them."""
+    res = _convert(tmp_path, HTML)
+    zf = zipfile.ZipFile(io.BytesIO(base64.b64decode(res["base64"])))
+    doc = ET.fromstring(zf.read("word/document.xml"))
+
+    # 1. every r:id / r:embed in document.xml resolves to a declared relationship
+    refs = set()
+    for el in doc.iter():
+        for attr, val in el.attrib.items():
+            if attr in (R + "id", R + "embed"):
+                refs.add(val)
+    rels = {r.get("Id") for r in ET.fromstring(zf.read("word/_rels/document.xml.rels"))}
+    assert refs <= rels, f"dangling relationship ids (Word would repair): {refs - rels}"
+
+    # 2. every part is covered by [Content_Types].xml (default extension or explicit override)
+    ct = ET.fromstring(zf.read("[Content_Types].xml"))
+    defaults = {d.get("Extension", "").lower() for d in ct.findall(CT + "Default")}
+    overrides = {o.get("PartName") for o in ct.findall(CT + "Override")}
+    for name in zf.namelist():
+        if name.endswith("/") or name == "[Content_Types].xml":
+            continue
+        ext = name.rsplit(".", 1)[-1].lower() if "." in name else ""
+        assert ext in defaults or ("/" + name) in overrides, f"part not in [Content_Types].xml: {name}"
+
+    # 3. a list reference implies the numbering part exists
+    if any(True for _ in doc.iter(W + "numPr")):
+        assert "word/numbering.xml" in zf.namelist()
+
+
+@pytest.mark.skipif(shutil.which("node") is None, reason="node binary not available")
+def test_unsupported_css_is_reported_not_silent(tmp_path):
+    """Layout the converter cannot do (flex/grid/float) must surface as a warning in the
+    report, so an author learns why side-by-side boxes stacked instead of guessing."""
+    html = ('<html><body>'
+            '<div style="display:flex"><div>a</div><div>b</div></div>'
+            '<div style="display:grid"><div>c</div></div>'
+            '<div style="float:left">d</div>'
+            '</body></html>')
+    res = _convert(tmp_path, html)
+    warns = " ".join(res["report"]["warnings"]).lower()
+    assert "flex" in warns and "grid" in warns and "float" in warns, res["report"]["warnings"]

procesio_cli/tools/procesio/tests/test_key_handle_terminology.py

@@ -0,0 +1,45 @@
+"""Regression coverage for PROCESIO's API-key field terminology."""
+from __future__ import annotations
+
+from tools.procesio import main, profiles
+from tools.procesio.handlers import profile_admin
+
+
+class _TTY:
+    @staticmethod
+    def isatty() -> bool:
+        return True
+
+
+def test_add_credential_prompts_for_key_handle_then_value(store, monkeypatch):
+    prompts: list[str] = []
+    answers = iter(("alpha-entry", "omega-entry"))
+
+    monkeypatch.setattr(profile_admin.sys, "stdin", _TTY())
+
+    def fake_getpass(prompt: str) -> str:
+        prompts.append(prompt)
+        return next(answers)
+
+    monkeypatch.setattr(profile_admin.getpass, "getpass", fake_getpass)
+
+    out = main.dispatch(
+        "add-credential",
+        [
+            "--name", "workspace-key",
+            "--type", "apikey",
+            "--workspace-id", "workspace-id",
+        ],
+    )
+
+    assert prompts == [
+        "PROCESIO API key name: ",
+        "PROCESIO API key value (shown once): ",
+    ]
+    stored = profiles.get_profile("workspace-key")
+    assert stored["key"] == "alpha-entry"
+    assert stored["value"] == "omega-entry"
+    assert out["profile"]["has_key"] is True
+    assert out["profile"]["has_value"] is True
+    assert "alpha-entry" not in str(out)
+    assert "omega-entry" not in str(out)