procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_form_parity.py

@@ -0,0 +1,171 @@
+"""PARITY TESTS — the builder's output must match the STRUCTURE of real PROCESIO exports.
+
+Why this file exists: every form bug we've hit (enum values, event types, RUN_PROCESS map
+orientation) shared one shape — the builder produced a DTO that PASSED schema/dry-run
+validation but did NOT match what the real platform produces, so it only failed when a human
+opened the form in the designer / ran it. The real `.procesio` exports under
+docs_info/Exports are the platform's own ground truth: the exact shape a *working* form has.
+
+Each invariant below is checked TWICE:
+  (a) it actually holds across the real exports  -> proves the invariant is real, and
+  (b) the builder's output satisfies the same invariant -> catches divergence pre-ship.
+
+DISCIPLINE: whenever the builder learns to emit a new construct (a new event kind, a new
+container wiring, a new mapping...), add a reality-derived invariant here. That is the
+mechanism that removes the need for manual UI testing of structural correctness.
+"""
+import glob
+import json
+import os
+import re
+import uuid
+from pathlib import Path
+
+import pytest
+
+from tools.procesio.dto.form import builder
+
+EXPORTS = Path(__file__).resolve().parents[1] / "docs_info" / "Exports"
+
+# The reality-side invariants are calibrated against the platform's own exports.
+# That corpus is not carried into every distribution of this tool (a .procesio
+# export names real processes and serializes credentials inline), so those tests
+# SKIP where it is absent rather than failing, while the builder-side invariants
+# run everywhere. Skipping is the honest outcome: without ground truth there is
+# nothing to calibrate against, and a vacuous pass would be worse than no test.
+requires_corpus = pytest.mark.skipif(
+    not sorted(EXPORTS.glob("*.procesio")),
+    reason="no .procesio export corpus in this checkout")
+_GUID = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.I)
+
+
+def _is_guid(v):
+    return isinstance(v, str) and bool(_GUID.match(v))
+
+
+def _form_datas():
+    for p in glob.glob(str(EXPORTS / "*.procesio")):
+        dd = json.loads(Path(p).read_text(encoding="utf-8"))
+        for fm in dd.get("Forms") or []:
+            v = fm.get("Data")
+            v = json.loads(v) if isinstance(v, str) else v
+            if isinstance(v, dict):
+                yield os.path.basename(p), v
+
+
+def _iter_events(data):
+    for el in data.get("elements") or []:
+        for c in el.get("configs") or []:
+            v = c.get("value")
+            if isinstance(v, dict) and isinstance(v.get("events"), list):
+                for ev in v["events"]:
+                    yield el, c.get("key"), v, ev
+
+
+def _build_run_process_form():
+    """Build a form whose button runs a process with one input + one output map, with the
+    process variables 'resolved' (as prepare_ctx would do live)."""
+    pid = str(uuid.uuid4())
+    in_var, out_var = str(uuid.uuid4()), str(uuid.uuid4())
+    ctx = {"new_id": lambda: str(uuid.uuid4()),
+           "process_vars": {pid: {"inText": in_var, "outText": out_var}}}
+    cfg = {"name": "P", "elements": [
+        {"type": "input", "label": "A", "name": "fieldA"},
+        {"type": "input", "label": "B", "name": "fieldB"},
+        {"type": "button", "label": "Run", "name": "runBtn", "events": [
+            {"on": "click", "do": "process", "processId": pid, "syncRun": True,
+             "inputs": [{"to": "inText", "from": "fieldA"}],
+             "outputs": [{"to": "fieldB", "from": "outText"}]}]}]}
+    dto = builder.build(cfg, ctx)
+    btn = next(e for e in dto["Data"]["elements"]
+               if any(c.get("value") == "runBtn" for c in e["configs"]))
+    cfg_ev = next(c["value"] for c in btn["configs"] if c["key"] == "onClickEvents")
+    return cfg_ev["events"][0]["config"], in_var, out_var
+
+
+# ---------- invariant 1: RUN_PROCESS map orientation (the bug we just fixed) ----------
+def _seg_count(v):
+    return v.count(".") + 1 if isinstance(v, str) else 0
+
+
+def _is_proc_ref(v):
+    # a process-variable reference: a bare GUID, or {value: <guid|"">, ...}
+    if _is_guid(v):
+        return True
+    if isinstance(v, dict) and "value" in v:
+        return _is_guid(v["value"]) or v["value"] == ""
+    return False
+
+
+@requires_corpus
+def test_reality_run_process_left_is_never_a_form_path():
+    """Calibrated to reality: across all real exports, a RUN_PROCESS map's `left` is the
+    PROCESS-variable side (a GUID, sometimes wrapped as {value}) and is NEVER a form field
+    value-path (4 dotted GUIDs). That is exactly the orientation our output-map bug broke."""
+    proc_ref_lefts = 0
+    for fn, data in _form_datas():
+        for _el, _k, _grp, ev in _iter_events(data):
+            if ev.get("action") != "RUN_PROCESS":
+                continue
+            cfg = ev.get("config") or {}
+            for m in (cfg.get("inputMap") or []) + (cfg.get("outputMap") or []):
+                left = m.get("left")
+                assert _seg_count(left) < 3, (
+                    f"{fn}: RUN_PROCESS map 'left' is a form path (should be a process var): {left!r}")
+                if _is_proc_ref(left):
+                    proc_ref_lefts += 1
+    assert proc_ref_lefts > 0, "no real RUN_PROCESS process-var lefts found to validate against"
+
+
+def test_builder_run_process_map_matches_reality():
+    cfg, in_var, out_var = _build_run_process_form()
+    for m in cfg["inputMap"] + cfg["outputMap"]:
+        assert _is_guid(m["left"]), f"builder RUN_PROCESS map 'left' not a GUID: {m['left']!r}"
+    # process variable on the LEFT (resolved to its id); form field path on the RIGHT
+    assert cfg["inputMap"][0]["left"] == in_var
+    assert cfg["outputMap"][0]["left"] == out_var          # <-- would fail with the old swap
+    assert cfg["inputMap"][0]["right"].count(".") == 3     # form value-path = 4 segments
+    assert cfg["outputMap"][0]["right"].count(".") == 3
+
+
+# ---------- invariant 2: stored event object shape ----------
+@requires_corpus
+def test_reality_event_shape():
+    n = 0
+    for _fn, data in _form_datas():
+        for _el, _k, grp, ev in _iter_events(data):
+            assert {"id", "type", "action"} <= set(ev)
+            assert "events" in grp and "debounce" in grp
+            n += 1
+    assert n > 0
+
+
+def test_builder_event_shape():
+    """Split out of the reality test: the builder half needs no corpus, and pairing
+    them meant losing builder coverage wherever the corpus is absent."""
+    cfg, _i, _o = _build_run_process_form()
+    assert {"processId", "inputMap", "outputMap"} <= set(cfg)
+
+
+# ---------- invariant 3: a DATA-FIELD's `value` config is canonical (exposed + EMIT_INPUT) ----------
+# Scoped to user-data input controls (the ones whose `value` the platform's on-save compiler
+# turns into the field value attribute). Non-field controls (assignee, table rows, approval,
+# containers) legitimately have a different/absent value config, so they are excluded.
+# NOTE: dropdown is an action MENU (items), not a value field -> excluded.
+_DATA_FIELDS = {"input", "number-input", "datetime-input", "textarea", "select",
+                "radiobox", "checkbox", "file-upload"}
+
+
+def test_data_field_value_config_canonical_in_goldens():
+    elems = Path(builder.__file__).resolve().parent / "elements"
+    checked = 0
+    for p in elems.glob("*.json"):
+        if p.stem not in _DATA_FIELDS:
+            continue
+        cfgs = json.loads(p.read_text(encoding="utf-8")).get("configs", [])
+        vc = next((c for c in cfgs if c.get("key") == "value"), None)
+        assert vc is not None, f"{p.name}: data field must have a value config"
+        assert vc.get("exposed") is True, f"{p.name}: value config must be exposed"
+        assert vc.get("events") == ["EMIT_INPUT"], f"{p.name}: value events must be [EMIT_INPUT]"
+        checked += 1
+    assert checked >= len(_DATA_FIELDS) - 1

procesio_cli/tools/procesio/tests/test_form_select_source.py

@@ -0,0 +1,74 @@
+"""A select's option source reaches the form's data model, in the designer's shape.
+
+Only data-model attributes reach `ProcesioForm` in form JS. The builder used to keep
+`sourceType` / `sourceValue` out of the data model, so a script on an API-built form
+could never read a select's options, while a save in the designer added them. These pin
+the shape a designer save writes, captured on 2026-10-01 from a form built here and then
+saved and published in the designer: attribute ids equal the config ids, `sourceType` is
+a plain string, and a static `sourceValue` is a list of Objects.
+"""
+from __future__ import annotations
+
+import itertools
+
+from tools.procesio.dto.form import addelement
+from tools.procesio.dto.form import builder as fb
+
+STR = "0317bfee-b2f5-4bde-bfe8-121212121214"
+OBJECT = "0317bfee-b2f5-4bde-bfe8-121212121221"
+
+# The designer's attribute shape, as captured. Ids differ per form; the rest is fixed.
+DESIGNER = {
+    "sourceType": {"dataTypeId": STR, "isList": False, "isDataModel": False,
+                   "isPublic": False, "isProcesio": False, "jsonProperty": None,
+                   "attributes": [], "hidden": False},
+    "sourceValue": {"dataTypeId": OBJECT, "isList": True, "isDataModel": False,
+                    "isPublic": False, "isProcesio": False, "jsonProperty": None,
+                    "attributes": [], "hidden": False},
+}
+
+
+def _ctx():
+    cnt = itertools.count(1)
+    return {"new_id": lambda: f"00000000-0000-0000-0000-{next(cnt):012d}"}
+
+
+def _built(spec):
+    dto = fb.build({"name": "F", "elements": [spec]}, _ctx())
+    data = dto["Data"]
+    el = next(e for e in data["elements"] if e.get("type") == "select")
+    fields = next(a for a in data["dataModel"]["attributes"] if a["id"] == fb._FIELDS_NS)
+    sub = next(s for s in fields["attributes"] if s["id"] == el["id"])
+    return el, {a["name"]: a for a in sub["attributes"]}
+
+
+def _cfg(el, key):
+    return next(c for c in el["configs"] if c["key"] == key)
+
+
+def test_a_static_select_carries_its_option_source_in_the_designer_shape():
+    el, attrs = _built({"type": "select", "label": "Pick", "name": "pick",
+                        "options": ["alpha", "beta"]})
+    for key, shape in DESIGNER.items():
+        assert key in attrs, f"{key} is missing from the data model"
+        attr = attrs[key]
+        assert attr["id"] == _cfg(el, key)["id"], f"{key}: attribute id must equal the config id"
+        assert attr["parentDataTypeId"] == el["id"]
+        assert {k: attr[k] for k in shape} == shape, key
+    assert _cfg(el, "sourceValue")["value"] == [{"name": "alpha", "value": "alpha"},
+                                                 {"name": "beta", "value": "beta"}]
+
+
+def test_a_json_sourced_select_gets_no_guessed_source_value_attribute():
+    """Only the static-list shape was captured from the designer."""
+    _el, attrs = _built({"type": "select", "label": "Pick", "name": "pick",
+                         "optionsSource": {"type": "json", "value": "[]"}})
+    assert "sourceType" in attrs
+    assert "sourceValue" not in attrs
+
+
+def test_form_add_element_writes_the_same_attributes_as_form_create():
+    """The two used to carry separate copies of this rule; now they share one."""
+    el, attrs = _built({"type": "select", "label": "Pick", "name": "pick", "options": ["a"]})
+    spliced = addelement._sub_model(el, fb._FIELDS_NS, {})
+    assert {a["name"]: a for a in spliced["attributes"]} == attrs

procesio_cli/tools/procesio/tests/test_form_sync.py

@@ -0,0 +1,35 @@
+"""Guard: the form-control goldens must stay in sync with FormBuilder mock.ts.
+
+Mirrors test_manifest_sync.py's intent for the form layer. If this fails, either a
+golden was hand-edited or the mock changed without regenerating — run
+`python tools/procesio/dto/form/sync_from_mock.py --write`.
+"""
+from tools.procesio.dto.form import sync_from_mock as s
+
+
+def test_all_goldens_match_mock():
+    goldens, _stats, _res = s.build_goldens()
+    drift = []
+    for t, g in goldens.items():
+        path = s.ELEMENTS / f"{t}.json"
+        if not path.exists():
+            drift.append(f"{t} (missing on disk)")
+        elif path.read_text(encoding="utf-8").strip() != s._dump(g).strip():
+            drift.append(t)
+    assert not drift, (
+        "form goldens out of sync with FormBuilder mock.ts: "
+        f"{drift} — run sync_from_mock.py --write")
+
+
+def test_every_mock_control_has_a_golden():
+    goldens, _stats, _res = s.build_goldens()
+    on_disk = {p.stem for p in s.ELEMENTS.glob("*.json")}
+    assert set(goldens) <= on_disk, f"mock controls with no golden: {set(goldens) - on_disk}"
+
+
+def test_soundness_no_enum_contradictions():
+    # build_goldens resolves every enum; a wrong mapping would change a value that an
+    # existing golden already had. The --check path asserts this; here we just confirm
+    # the generator runs and produces the full set.
+    goldens, _stats, _res = s.build_goldens()
+    assert len(goldens) >= 33

procesio_cli/tools/procesio/tests/test_form_update.py

@@ -0,0 +1,133 @@
+"""form-update: safe GET->deep-merge->PUT of a live form.
+
+Verifies the accepted PascalCase envelope, deep-merge semantics (nested merge,
+array/scalar replace), top-level overrides (rename/publish), dry-run, and usage
+errors. CustomUrl is ECHOED from the GET (main's behaviour; the PUT ignores it
+either way — verified live). HTTP via FakeSession (no live API)."""
+from __future__ import annotations
+
+import pytest
+
+from tools.procesio import errors, main
+from tools.procesio.client import ProcesioClient
+from tools.procesio.handlers.form_code import build_put_body
+from tools.procesio.tests.conftest import FakeResp, FakeSession
+
+APIKEY = {"type": "apikey", "key": "N", "value": "V"}
+ENVELOPE = {"Id", "Name", "IsPrivate", "Type", "Status", "State", "Assignees", "Data", "CustomUrl"}
+
+
+def _call(action, argv, session):
+    builder = lambda prof: ProcesioClient(profile=APIKEY, name="t", session=session)
+    return main.dispatch(action, argv, client_builder=builder)
+
+
+def _form(*, status=1, state=True, data=None):
+    """A GET echo (camelCase) with server metadata that must be dropped from the PUT.
+    No updatedOn/version field, so the concurrency guard is inert (GET + PUT only)."""
+    d = data or {
+        "code": "ENC", "elements": [{"id": "el1"}], "theme": [], "hideBranding": False,
+        "images": {"logo": None, "header": "H"},
+    }
+    return {
+        "id": "F1", "name": "Overview", "isPrivate": False, "type": 1,
+        "status": status, "state": state, "assignees": [],
+        "customUrl": {"tinyUrl": "t"},                 # separate entity — echoed, PUT ignores it
+        "createdBy": "server-meta", "workspaceName": "server-meta",  # server metadata, dropped
+        "data": d,
+    }
+
+
+def test_scalar_patch_builds_accepted_envelope_and_preserves_data():
+    s = FakeSession(queue=[FakeResp(200, _form()), FakeResp(200, {})])
+    out = _call("form-update", ["--id", "F1", "--data", '{"hideBranding": true}'], s)
+
+    assert out["applied"] is True and out["patched_keys"] == ["hideBranding"]
+    get, put = s.calls
+    assert get["method"] == "GET" and get["url"].endswith("/api/FormTemplate/F1")
+    assert put["method"] == "PUT" and put["url"].endswith("/api/FormTemplate")
+    body = put["json"]
+    # PascalCase top level only, no server metadata, CustomUrl echoed
+    assert set(body) == ENVELOPE
+    assert body["Id"] == "F1" and body["Name"] == "Overview"
+    assert body["CustomUrl"] == {"tinyUrl": "t"}
+    # patched key applied; everything else in Data round-trips untouched
+    assert body["Data"]["hideBranding"] is True
+    assert body["Data"]["elements"] == [{"id": "el1"}]
+    assert body["Data"]["code"] == "ENC"
+    assert body["Data"]["images"] == {"logo": None, "header": "H"}
+
+
+def test_nested_merge_and_array_replace():
+    s = FakeSession(queue=[FakeResp(200, _form()), FakeResp(200, {})])
+    _call("form-update",
+          ["--id", "F1", "--data", '{"images": {"logo": "X"}, "elements": [{"id": "new"}]}'], s)
+    data = s.calls[1]["json"]["Data"]
+    assert data["images"] == {"logo": "X", "header": "H"}   # nested dict merges (header kept)
+    assert data["elements"] == [{"id": "new"}]              # array replaces wholesale
+
+
+def test_top_level_overrides_publish_a_draft():
+    s = FakeSession(queue=[FakeResp(200, _form(status=0, state=False)), FakeResp(200, {})])
+    out = _call("form-update",
+                ["--id", "F1", "--name", "ENG/ Overview", "--status", "1", "--state", "true"], s)
+    body = s.calls[1]["json"]
+    assert body["Name"] == "ENG/ Overview" and body["Status"] == 1 and body["State"] is True
+    assert out["name"] == "ENG/ Overview" and out["status"] == 1 and out["state"] is True
+    assert out["patched_keys"] == []                        # no Data patch given
+
+
+def test_dry_run_gets_only_and_returns_dto():
+    s = FakeSession(queue=[FakeResp(200, _form())])
+    out = _call("form-update", ["--id", "F1", "--data", '{"hideBranding": true}', "--dry-run"], s)
+    assert out["applied"] is False and out["dry_run"] is True
+    assert out["dto"]["Data"]["hideBranding"] is True
+    assert len(s.calls) == 1 and s.calls[0]["method"] == "GET"
+
+
+def test_usage_errors():
+    with pytest.raises(errors.UsageError):   # nothing to update (no patch, no override) -> no GET
+        _call("form-update", ["--id", "F1"], FakeSession(queue=[]))
+    with pytest.raises(errors.UsageError):   # invalid JSON, rejected before any HTTP call
+        _call("form-update", ["--id", "F1", "--data", "{bad"], FakeSession(queue=[]))
+    with pytest.raises(errors.UsageError):   # patch must be an object, not an array
+        _call("form-update", ["--id", "F1", "--data", "[1, 2]"], FakeSession(queue=[]))
+
+
+def test_build_put_body_transform_contract():
+    """The single canonical transform: camelCase echo -> PascalCase envelope, CustomUrl echoed."""
+    echo = _form(status=0, state=False)
+    body = build_put_body(echo, data={"k": 1}, name="R", status=1, state=True)
+    assert set(body) == ENVELOPE
+    assert body["Name"] == "R" and body["Status"] == 1 and body["State"] is True
+    assert body["Data"] == {"k": 1} and body["CustomUrl"] == {"tinyUrl": "t"}
+    # omitted overrides fall back to the echo's values
+    keep = build_put_body(echo)
+    assert keep["Name"] == "Overview" and keep["Status"] == 0 and keep["State"] is False
+    # missing required echo key is refused
+    with pytest.raises(errors.UsageError):
+        build_put_body({"id": "X", "name": "Y"})   # no 'data'
+
+
+# --------------------------------------------------------------- IsPrivate (publishing switch)
+
+def test_is_private_is_echoed_untouched_when_not_asked_for():
+    """Reachability is a publishing decision: an unrelated save must never flip it."""
+    form = {"id": "f1", "name": "F", "data": {"elements": []}, "isPrivate": True,
+            "type": 1, "status": 1, "state": True, "assignees": [], "customUrl": None}
+    body = build_put_body(form, name="Renamed")
+    assert body["IsPrivate"] is True
+
+
+def test_is_private_false_is_what_opens_a_form_to_an_anonymous_visitor():
+    form = {"id": "f1", "name": "F", "data": {"elements": []}, "isPrivate": True,
+            "type": 1, "status": 1, "state": True, "assignees": [], "customUrl": None}
+    body = build_put_body(form, is_private=False)
+    assert body["IsPrivate"] is False
+    assert body["Status"] == 1, "publishing also needs Status 1, which must survive untouched"
+
+
+def test_is_private_can_be_put_back():
+    form = {"id": "f1", "name": "F", "data": {"elements": []}, "isPrivate": False,
+            "type": 1, "status": 1, "state": True, "assignees": [], "customUrl": None}
+    assert build_put_body(form, is_private=True)["IsPrivate"] is True

procesio_cli/tools/procesio/tests/test_formlint.py

@@ -0,0 +1,155 @@
+"""DTO safety lints (warnings, never blockers) — red/green for each check."""
+from __future__ import annotations
+
+import pytest
+
+from tools.procesio import formlint
+
+
+def _el(el_id, parent=None, configs=None):
+    return {"id": el_id, "parentId": parent, "configs": configs or []}
+
+
+def _cfg(key, value):
+    return {"key": key, "value": value}
+
+
+# -- (a) phantom parentId ---------------------------------------------------
+
+def test_phantom_parent_flagged():
+    data = {"elements": [
+        _el("tab1"),
+        _el("child", parent="GHOST"),          # references no element
+    ]}
+    warns = formlint.lint_phantom_parent(data)
+    assert len(warns) == 1
+    assert "GHOST" in warns[0] and "NO pane" in warns[0]
+
+
+def test_valid_parent_not_flagged():
+    data = {"elements": [_el("tab1"), _el("child", parent="tab1")]}
+    assert formlint.lint_phantom_parent(data) == []
+
+
+def test_null_parent_not_flagged():
+    data = {"elements": [_el("top", parent=None)]}
+    assert formlint.lint_phantom_parent(data) == []
+
+
+# -- (b) duplicate id/name configs ------------------------------------------
+
+def test_duplicate_name_config_flagged():
+    data = {"elements": [
+        _el("a", configs=[_cfg("name", "email")]),
+        _el("b", configs=[_cfg("name", "email")]),
+    ]}
+    warns = formlint.lint_duplicate_configs(data)
+    assert any("name" in w and "email" in w for w in warns)
+
+
+def test_unique_configs_not_flagged():
+    data = {"elements": [
+        _el("a", configs=[_cfg("name", "email"), _cfg("id", "e1")]),
+        _el("b", configs=[_cfg("name", "phone"), _cfg("id", "e2")]),
+    ]}
+    assert formlint.lint_duplicate_configs(data) == []
+
+
+# -- (c) patch-key wrapping mistake -----------------------------------------
+
+def test_patch_data_wrapping_mistake_flagged():
+    existing = {"hideBranding": False, "elements": []}
+    warns = formlint.lint_patch_keys(existing, {"Data": {"hideBranding": True}})
+    assert len(warns) == 1 and "wrapping mistake" in warns[0]
+
+
+def test_patch_unknown_key_flagged_as_addition():
+    existing = {"hideBranding": False}
+    warns = formlint.lint_patch_keys(existing, {"hideBrandng": True})   # typo
+    assert len(warns) == 1 and "not an existing Data field" in warns[0]
+
+
+def test_patch_known_key_not_flagged():
+    existing = {"hideBranding": False}
+    assert formlint.lint_patch_keys(existing, {"hideBranding": True}) == []
+
+
+# -- (d) multiple-select without isList -------------------------------------
+
+def test_multiple_select_missing_islist_flagged():
+    data = {"elements": [_el("s1", configs=[
+        _cfg("multiple", True),
+        {"key": "value", "isList": False},
+    ])]}
+    warns = formlint.lint_multiple_select_islist(data)
+    assert len(warns) == 1 and "isList" in warns[0]
+
+
+def test_multiple_select_with_islist_ok():
+    data = {"elements": [_el("s1", configs=[
+        _cfg("multiple", True),
+        {"key": "value", "isList": True},
+    ])]}
+    assert formlint.lint_multiple_select_islist(data) == []
+
+
+def test_single_select_not_flagged():
+    data = {"elements": [_el("s1", configs=[
+        _cfg("multiple", False),
+        {"key": "value", "isList": False},
+    ])]}
+    assert formlint.lint_multiple_select_islist(data) == []
+
+
+# -- IS_TRUE / IS_FALSE on a Boolean variable whose default is a STRING ------
+
+def _cond(left, op, right=""):
+    return {"operator": op, "leftOperator": {"value": left}, "rightOperator": {"value": right}}
+
+
+def _form_with_condition(default, op="IS_TRUE", left="var-pj"):
+    return {
+        "variables": [{"id": "var-pj", "name": "isPJ", "defaultValue": default}],
+        "elements": [_el("btn", configs=[
+            _cfg("name", "confirm"),
+            _cfg("onClickEvents", {"events": [{"action": "MAP_FORM_DATA", "config": {
+                "mapping": [], "conditions": [_cond(left, op)]}}]}),
+        ])],
+    }
+
+
+@pytest.mark.parametrize("default", ["False", "false"])
+def test_is_true_on_text_false_default_flagged(default):
+    # measured live: IS_TRUE passes on both spellings, because any non-empty text is true
+    warns = formlint.lint_string_boolean_conditions(_form_with_condition(default))
+    assert len(warns) == 1
+    assert "isPJ IS_TRUE" in warns[0] and repr(default) in warns[0] and "'confirm'" in warns[0]
+    assert "PASSES" in warns[0]
+    assert warns[0] in formlint.lint_form_data(_form_with_condition(default))
+
+
+def test_is_false_on_text_false_default_flagged_as_never_passing():
+    warns = formlint.lint_string_boolean_conditions(_form_with_condition("False", op="IS_FALSE"))
+    assert len(warns) == 1 and "never passes" in warns[0]
+
+
+def test_text_true_default_is_not_flagged():
+    # "True" evaluates the way it reads, in both directions
+    assert formlint.lint_string_boolean_conditions(_form_with_condition("True")) == []
+    assert formlint.lint_string_boolean_conditions(_form_with_condition("True", op="IS_FALSE")) == []
+
+
+def test_null_default_equals_operator_and_field_operand_not_flagged():
+    assert formlint.lint_string_boolean_conditions(_form_with_condition(None)) == []
+    assert formlint.lint_string_boolean_conditions(_form_with_condition("False", op="EQUALS")) == []
+    field = "root.11223344-5566-7788-99aa-aabbccddeeff.el.cfg"
+    assert formlint.lint_string_boolean_conditions(_form_with_condition("False", left=field)) == []
+
+
+def test_form_level_events_are_checked_too():
+    data = {"variables": [{"id": "v", "name": "flag", "defaultValue": "False"}],
+            "events": [{"action": "MAP_FORM_DATA",
+                        "config": {"mapping": [], "conditions": [_cond("v", "IS_TRUE")]}}],
+            "elements": []}
+    warns = formlint.lint_string_boolean_conditions(data)
+    assert len(warns) == 1 and warns[0].startswith("form-level event")

procesio_cli/tools/procesio/tests/test_formlint_css_scope.py

@@ -0,0 +1,38 @@
+"""Form custom CSS is scoped to the form container, so code that styles or mounts UI outside it
+needs the scope attribute copied onto <html>; the lint says so, and stays quiet otherwise."""
+from __future__ import annotations
+
+from tools.procesio import formlint
+
+FIX = ("var host = document.querySelector('[data-form-css-scope]');"
+       "document.documentElement.setAttribute('data-form-css-scope',"
+       " host.getAttribute('data-form-css-scope'));")
+
+
+def test_ui_mounted_on_body_without_the_attribute_is_warned():
+    w = formlint.lint_form_code_scope(".card{color:red}", "document.body.appendChild(el);")
+    assert len(w) == 1 and "document.body" in w[0] and "<html>" in w[0]
+
+
+def test_page_level_css_without_the_attribute_is_warned():
+    w = formlint.lint_form_code_scope(":root{--brand:#123} html, body{margin:0} .x{}", "")
+    assert len(w) == 1 and ":root / body / html" in w[0]
+
+
+def test_a_framework_mounted_on_body_is_warned():
+    assert formlint.lint_form_code_scope("", "createApp(App).mount(document.body)")
+    assert formlint.lint_form_code_scope("", "app.mount('body')")
+
+
+def test_code_that_propagates_the_attribute_is_not_warned():
+    assert formlint.lint_form_code_scope(":root{--a:1}", FIX + "document.body.appendChild(el);") == []
+
+
+def test_ui_that_stays_inside_the_form_is_not_warned():
+    css = ".card{color:red} @media (max-width:600px){.card{color:blue}} /* body{} */"
+    assert formlint.lint_form_code_scope(css, "document.querySelector('.card').append(x);") == []
+
+
+def test_body_inside_another_selector_is_not_a_page_rule():
+    # `.tbody` / `.html-preview` are classes, not the html/body elements.
+    assert formlint.lint_form_code_scope(".tbody td{} .html-preview{}", "") == []