procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_datastore.py

@@ -0,0 +1,378 @@
+"""Data Store curated actions — faked client boundary (zero live HTTP).
+
+Mirrors tests/test_schedules.py: a FakeSession records every HTTP call and serves
+canned responses, so we assert the method, URL, query, and body each Data Store
+action emits — including the recursive filter-tree the read/update/delete paths build
+and the raw escape hatches. Contract verified against PROCESIO/Web-Api main (2026-08).
+"""
+from __future__ import annotations
+
+import pytest
+
+from tools.procesio import errors, main
+from tools.procesio.client import ProcesioClient
+from tools.procesio.tests.conftest import FakeResp, FakeSession
+
+
+def _builder(profile, session):
+    return lambda prof: ProcesioClient(profile=profile, name="t", session=session)
+
+
+APIKEY = {"type": "apikey", "key": "N", "value": "V"}
+DS = "11111111-1111-1111-1111-111111111111"
+
+
+def _last(sess):
+    return sess.calls[-1]
+
+
+# -- metadata / schema ------------------------------------------------------
+
+def test_create_posts_payload():
+    sess = FakeSession(queue=[FakeResp(200, {"id": "NEW"})])
+    out = main.dispatch("datastore-create",
+                        ["--payload", '{"name":"Clients","columns":[]}'],
+                        client_builder=_builder(APIKEY, sess))
+    assert out["result"] == {"id": "NEW"}
+    c = _last(sess)
+    assert c["method"] == "POST" and c["url"].endswith("/api/DataStore")
+    assert c["json"] == {"name": "Clients", "columns": []}
+
+
+def test_update_puts_payload():
+    sess = FakeSession(queue=[FakeResp(200, {"ok": True})])
+    main.dispatch("datastore-update", ["--payload", '{"id":"D1","name":"C2"}'],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "PUT" and c["url"].endswith("/api/DataStore")
+    assert c["json"] == {"id": "D1", "name": "C2"}
+
+
+def test_modify_column_patches_path():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-modify-column",
+                  ["--id", DS, "--payload",
+                   '{"originalColumn":{"name":"A"},"updatedColumn":{"name":"B"}}'],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "PATCH"
+    assert c["url"].endswith(f"/api/DataStore/{DS}/column")
+    assert c["json"]["updatedColumn"] == {"name": "B"}
+
+
+def test_delete_uses_id_in_path():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-delete", ["--id", DS],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "DELETE" and c["url"].endswith(f"/api/DataStore/{DS}")
+
+
+def test_get_uses_id_in_path():
+    sess = FakeSession(queue=[FakeResp(200, {"id": DS})])
+    main.dispatch("datastore-get", ["--id", DS],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["url"].endswith(f"/api/DataStore/{DS}")
+
+
+def test_list_maps_paging():
+    sess = FakeSession(queue=[FakeResp(200, {"pageItems": []})])
+    main.dispatch("datastore-list", ["--page", "2", "--page-size", "10", "--search", "x"],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "GET" and c["url"].endswith("/api/DataStore")
+    assert c["params"] == {"pageNumber": 2, "pageItemCount": 10, "searchName": "x"}
+
+
+def test_list_restricted_endpoint():
+    sess = FakeSession(queue=[FakeResp(200, [])])
+    main.dispatch("datastore-list-restricted", [],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["url"].endswith("/api/DataStore/restricted")
+
+
+def test_from_data_model_posts():
+    sess = FakeSession(queue=[FakeResp(200, {"id": "NEW"})])
+    main.dispatch("datastore-from-data-model",
+                  ["--payload", '{"dataModelId":"M1","name":"C"}'],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["url"].endswith("/api/DataStore/from-data-model")
+    assert c["json"] == {"dataModelId": "M1", "name": "C"}
+
+
+def test_from_json_posts():
+    sess = FakeSession(queue=[FakeResp(200, {"id": "NEW"})])
+    main.dispatch("datastore-from-json",
+                  ["--payload", '{"name":"C","content":"[]"}'],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["url"].endswith("/api/DataStore/from-json")
+
+
+def test_get_data_model_path():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-get-data-model", ["--id", DS],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["url"].endswith(f"/api/DataStore/{DS}/data-model")
+
+
+# -- rows: read (filter tree) -----------------------------------------------
+
+def test_get_rows_builds_filter_tree_and_query_paging():
+    sess = FakeSession(queue=[FakeResp(200, {"rows": {"pageItems": []}})])
+    main.dispatch("datastore-get-rows",
+                  ["--id", DS, "--page", "1", "--page-size", "50",
+                   "--filters", '[{"column":"Status","operator":"Contains","value":"A"}]',
+                   "--sort", '{"column":"CreatedOn","direction":"desc"}'],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "POST"
+    assert c["url"].endswith(f"/api/DataStore/{DS}/rows/filter")
+    # pagination is on the query string, NOT the body
+    assert c["params"] == {"pageNumber": 1, "pageItemCount": 50}
+    assert c["json"]["filter"] == {
+        "id": 0, "logic": 1, "items": [
+            {"id": 0, "type": 1, "logic": 1,
+             "condition": {"id": 0, "column": "Status", "operator": 17, "value": "A"}}]}
+    assert c["json"]["sort"] == [{"column": "CreatedOn", "direction": 2}]  # desc=2
+    assert "pageNumber" not in c["json"]                                    # not in body
+
+
+def test_get_rows_between_uses_auxvalue():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-get-rows",
+                  ["--id", DS,
+                   "--filters", '[{"column":"Age","operator":"between","value":18,"auxValue":65}]'],
+                  client_builder=_builder(APIKEY, sess))
+    cond = _last(sess)["json"]["filter"]["items"][0]["condition"]
+    assert cond["operator"] == 7 and cond["value"] == 18 and cond["auxValue"] == 65
+
+
+def test_get_rows_logic_or():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-get-rows",
+                  ["--id", DS, "--logic", "or",
+                   "--filters", '[{"column":"A","operator":"equals","value":1},'
+                                '{"column":"B","operator":"equals","value":2}]'],
+                  client_builder=_builder(APIKEY, sess))
+    grp = _last(sess)["json"]["filter"]
+    assert grp["logic"] == 2 and len(grp["items"]) == 2 and grp["items"][1]["logic"] == 2
+
+
+def test_get_rows_accepts_numeric_operator():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-get-rows",
+                  ["--id", DS, "--filters", '[{"column":"N","operator":1,"value":"x"}]'],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["json"]["filter"]["items"][0]["condition"]["operator"] == 1
+
+
+def test_get_rows_rejects_unknown_operator():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("datastore-get-rows",
+                      ["--id", DS, "--filters", '[{"column":"N","operator":"wat"}]'],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+def test_get_rows_condition_requires_column():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("datastore-get-rows",
+                      ["--id", DS, "--filters", '[{"operator":"equals","value":1}]'],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+def test_get_rows_raw_filter_group_overrides():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    grp = '{"id":0,"logic":2,"items":[{"id":0,"type":2,"logic":1,"group":{"id":1,"logic":1,"items":[]}}]}'
+    main.dispatch("datastore-get-rows", ["--id", DS, "--filter", grp],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["json"]["filter"]["items"][0]["type"] == 2   # nested group, verbatim
+
+
+def test_get_rows_raw_body_overrides():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-get-rows",
+                  ["--id", DS, "--body", '{"custom":true}'],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["json"] == {"custom": True}
+
+
+def test_get_rows_no_filter_reads_all():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-get-rows", ["--id", DS],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["json"] is None                                  # empty body = read all
+    assert c["params"] == {"pageNumber": 1, "pageItemCount": 50}
+
+
+# -- rows: add / update / delete --------------------------------------------
+
+def test_add_rows_wraps_rows_key():
+    sess = FakeSession(queue=[FakeResp(200, {"affectedRows": 2})])
+    main.dispatch("datastore-add-rows",
+                  ["--id", DS, "--rows", '[{"Name":"a"},{"Name":"b"}]'],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "POST" and c["url"].endswith(f"/api/DataStore/{DS}/rows")
+    assert c["json"] == {"rows": [{"Name": "a"}, {"Name": "b"}]}
+
+
+def test_add_rows_rejects_non_array():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("datastore-add-rows", ["--id", DS, "--rows", '{"Name":"a"}'],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+def test_update_row_values_and_filter():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-update-row",
+                  ["--id", DS, "--values", '{"Status":"Done"}',
+                   "--filters", '[{"column":"Id","operator":"equals","value":"1"}]'],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "PUT" and c["url"].endswith(f"/api/DataStore/{DS}/rows")
+    assert c["json"]["values"] == {"Status": "Done"}
+    assert c["json"]["filter"]["items"][0]["condition"] == {
+        "id": 0, "column": "Id", "operator": 1, "value": "1"}
+
+
+def test_update_row_requires_values():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("datastore-update-row",
+                      ["--id", DS, "--filters", '[{"column":"Id","operator":"equals","value":"1"}]'],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+def test_update_row_requires_filter():
+    with pytest.raises(errors.UsageError, match="filter"):
+        main.dispatch("datastore-update-row", ["--id", DS, "--values", '{"Status":"Done"}'],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+def test_update_row_raw_body_overrides():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-update-row", ["--id", DS, "--body", '{"raw":1}'],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["json"] == {"raw": 1}
+
+
+def test_delete_rows_wraps_filter():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-delete-rows",
+                  ["--id", DS, "--filters", '[{"column":"Id","operator":"equals","value":"1"}]'],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "DELETE" and c["url"].endswith(f"/api/DataStore/{DS}/rows")
+    assert c["json"]["filter"]["items"][0]["condition"]["column"] == "Id"
+
+
+def test_delete_rows_requires_filter():
+    with pytest.raises(errors.UsageError, match="filter"):
+        main.dispatch("datastore-delete-rows", ["--id", DS],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+# -- CSV --------------------------------------------------------------------
+
+def test_export_start_posts_no_body():
+    sess = FakeSession(queue=[FakeResp(200, {"jobId": "J1"})])
+    main.dispatch("datastore-export-start", ["--id", DS],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "POST"
+    assert c["url"].endswith(f"/api/DataStore/{DS}/export-start")
+    assert c["json"] is None
+
+
+def test_export_download_writes_bytes(tmp_path):
+    out = tmp_path / "rows.csv"
+    sess = FakeSession(queue=[FakeResp(200, content=b"a,b\n1,2\n")])
+    res = main.dispatch("datastore-export-download",
+                        ["--id", DS, "--job-id", "J1", "--out", str(out)],
+                        client_builder=_builder(APIKEY, sess))
+    assert out.read_bytes() == b"a,b\n1,2\n"
+    assert res["result"]["bytes"] == 8
+    assert _last(sess)["url"].endswith(f"/api/DataStore/{DS}/export-download/J1")
+
+
+def test_import_start_sends_multipart(tmp_path):
+    csv = tmp_path / "in.csv"
+    csv.write_bytes(b"Name\nx\n")
+    sess = FakeSession(queue=[FakeResp(200, {"jobId": "J2"})])
+    main.dispatch("datastore-import-start", ["--id", DS, "--file", str(csv)],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "POST"
+    assert c["url"].endswith(f"/api/DataStore/{DS}/import-start")
+    assert c["files"]["file"][0] == "in.csv"
+
+
+def test_import_failures_get_path():
+    sess = FakeSession(queue=[FakeResp(200, {"failures": []})])
+    main.dispatch("datastore-import-failures", ["--id", DS, "--job-id", "J2"],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["url"].endswith(f"/api/DataStore/{DS}/import-failures/J2")
+
+
+# -- provisioning timeout ----------------------------------------------------
+
+def test_provisioning_ops_use_longer_timeout():
+    sess = FakeSession(queue=[FakeResp(200, {"id": "NEW"})])
+    main.dispatch("datastore-create", ["--payload", '{"name":"C","columns":[]}'],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["timeout"] == 300          # table provisioning gets a longer budget
+
+
+def test_row_reads_use_default_timeout():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("datastore-get-rows", ["--id", DS],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["timeout"] == 60           # row reads are fast: default read timeout
+
+
+# -- B-048 cluster 4a: add-attribute must not silently destroy a store -------
+
+_MODEL = "22222222-2222-2222-2222-222222222222"
+
+
+def _add_attr(session, extra=None):
+    argv = ["--id", _MODEL, "--name", "x", "--data-type", "string"] + (extra or [])
+    return main.dispatch("datatype-add-attribute", argv,
+                         client_builder=_builder(APIKEY, session))
+
+
+def test_add_attribute_warns_when_model_backs_a_store():
+    # GET /api/DataStore -> one store whose data-model IS the target model: the add still
+    # PROCEEDS (4a did not reproduce live) but carries a caution to verify the store after.
+    s = FakeSession(queue=[
+        FakeResp(200, {"data": [{"id": DS}]}),   # store list
+        FakeResp(200, {"id": _MODEL}),           # its data-model == target
+        FakeResp(200, {}),                       # POST attribute
+        FakeResp(200, {"attributes": []}),       # re-GET model
+    ])
+    out = _add_attr(s)
+    assert out["added"] is True and "warning" in out and DS in out["warning"]
+
+
+def test_add_attribute_proceeds_clean_when_no_store_backs_the_model():
+    # GET /api/DataStore -> empty -> no caution -> POST + re-GET the model.
+    s = FakeSession(queue=[
+        FakeResp(200, {"data": []}),
+        FakeResp(200, {}),                       # POST attribute
+        FakeResp(200, {"attributes": []}),       # re-GET model
+    ])
+    out = _add_attr(s)
+    assert out["added"] is True and "warning" not in out
+    assert any(c["url"].endswith("/api/DataStore") for c in s.calls)
+
+
+def test_add_attribute_force_skips_the_store_check_entirely():
+    # --force -> no /api/DataStore read at all, straight to POST + re-GET.
+    s = FakeSession(queue=[
+        FakeResp(200, {}),                       # POST attribute
+        FakeResp(200, {"attributes": []}),       # re-GET model
+    ])
+    out = _add_attr(s, ["--force"])
+    assert out["added"] is True and "warning" not in out
+    assert not any("/api/DataStore" in c["url"] for c in s.calls)

procesio_cli/tools/procesio/tests/test_datastore_node.py

@@ -0,0 +1,94 @@
+"""Locks the Data Store NODE authoring shapes (dsMap / dsWhere) the builder emits.
+
+These runtime shapes were reverse-engineered from a live PROCESIO export and verified
+end-to-end (SELECT+Where filters, INSERT+Set Values writes) against a real Data Store.
+The three shape facts below are what make the node RUN rather than just validate:
+  - Set Values  (a103) row = {id, column:<name>, source:{value,variable}}         (column by NAME)
+  - Where       (a106) value = [{id:<GUID>, condition:[{...operator/left/right...}]}]  (element id is a GUID,
+                param-level Variable is EMPTY, operator is a decisional token like EQUALS)
+A regression on any of these reproduces a silent runtime failure (e.g. an int element id ->
+.NET 'Nullable object must have a value.'), so they are pinned here.
+"""
+from __future__ import annotations
+
+import itertools
+import re
+
+from tools.procesio.dto.process import builder as pb
+
+_GUID = re.compile(r"^[0-9a-fA-F-]{36}$")
+_DS = "667379d7-f146-4a04-9b9f-66682858e162"
+
+
+def _ctx():
+    counter = itertools.count(1)
+    return {"new_id": lambda: f"00000000-0000-0000-0000-{next(counter):012d}"}
+
+
+def _ds_node(dto):
+    return [a for a in dto["Actions"] if a.get("ActionTemplateName") == "Data Store"]
+
+
+def _param(node, tail):
+    return next(p for p in node["Parameters"] if p["TabPropertyId"].endswith(tail))
+
+
+def _cd_setting(node, stype):
+    def walk(settings):
+        for s in settings or []:
+            if s.get("type") == stype:
+                return s
+            if isinstance(s.get("value"), list):
+                r = walk(s["value"])
+                if r:
+                    return r
+    for tab in node["CustomData"]["configuration"]:
+        r = walk(tab.get("settings", []))
+        if r:
+            return r
+
+
+def test_ds_where_runtime_shape():
+    cfg = {"title": "t",
+           "variables": [{"name": "keyIn", "type": "string", "direction": "input"},
+                         {"name": "rows", "type": "json", "direction": "output"}],
+           "actions": [{"id": "sel", "action": "Data Store",
+                        "params": {"Select Data Store": _DS, "Operation": "SelectRows",
+                                   "Result Rows": {"var": "rows"}},
+                        "dsWhere": [{"column": "rowKey", "op": "equals", "value": {"var": "keyIn"}}]}]}
+    node = _ds_node(pb.build(cfg, _ctx()))[0]
+    p = _param(node, "a106")
+    assert p["Variable"] == []                          # variables live INLINE, not at param level
+    val = p["Value"]
+    assert isinstance(val, list) and len(val) == 1      # IList<InputDataStoreDecisional>
+    el = val[0]
+    assert _GUID.match(str(el["id"]))                   # element id is a GUID (int -> Nullable error)
+    c = el["condition"][0]
+    assert c["operator"] == "EQUALS"                    # decisional token, not a QueryOperators int
+    assert c["leftOperator"] == {"value": "rowKey", "variable": []}   # column on the left, by name
+    rop = c["rightOperator"]
+    assert re.match(r"^<%\d+%>$", rop["value"])                      # placeholder value
+    assert rop["variable"][0]["variableId"]                          # bound var inline on the right
+    assert rop["value"] == f"<%{rop['variable'][0]['id']}%>"         # placeholder index matches inline id
+    assert c["auxOperator"] is None
+    # designer card mirrors it and satisfies the FE Where validator
+    cd = _cd_setting(node, "data-store-decisional")["value"]
+    assert cd[0]["name"] == "Where" and cd[0]["condition"][0]["leftOperator"]["value"] == "rowKey"
+
+
+def test_ds_setvalues_runtime_shape():
+    cfg = {"title": "t",
+           "variables": [{"name": "k", "type": "string", "direction": "input"},
+                         {"name": "rate", "type": "double", "direction": "input"}],
+           "actions": [{"id": "ins", "action": "Data Store",
+                        "params": {"Select Data Store": _DS, "Operation": "InsertRows"},
+                        "dsMap": {"rowKey": {"var": "k"}, "rateRON": {"var": "rate"},
+                                  "sourceUrl": "https://curs.bnr.ro"}}]}
+    node = _ds_node(pb.build(cfg, _ctx()))[0]
+    rows = _param(node, "a103")["Value"]
+    assert [r["column"] for r in rows] == ["rowKey", "rateRON", "sourceUrl"]   # target by NAME
+    assert rows[0]["source"]["variable"][0]["variableId"]                      # var binding inline
+    assert rows[2]["source"] == {"value": "https://curs.bnr.ro", "variable": []}  # bare = literal
+    # designer rows are {id, left, right} (NOT the document-mapper {process, document})
+    cd = _cd_setting(node, "data-store-mapper")["value"]
+    assert cd[0]["left"] == "rowKey" and "document" not in cd[0]

procesio_cli/tools/procesio/tests/test_dispatch.py

@@ -0,0 +1,170 @@
+"""End-to-end dispatch: action routing, generic request, curated actions,
+list-endpoints (bundled data), profile admin, error classification."""
+from __future__ import annotations
+
+import pytest
+
+from tools.procesio import errors, main, profiles, swagger
+from tools.procesio.client import ProcesioClient
+from tools.procesio.tests.conftest import FakeResp, FakeSession
+
+
+def _builder(profile, session):
+    return lambda prof: ProcesioClient(profile=profile, name="t", session=session)
+
+
+# -- routing ----------------------------------------------------------------
+
+def test_unknown_action_raises_usage():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("nope", [])
+
+
+def test_all_actions_have_manifest_descriptions():
+    assert len(main.ACTIONS) >= 20
+    assert all(d.description for d in main.ACTIONS.values())
+
+
+# -- generic request --------------------------------------------------------
+
+def test_request_action_passthrough():
+    sess = FakeSession(queue=[FakeResp(200, {"hello": "world"})])
+    out = main.dispatch(
+        "request",
+        ["--method", "GET", "--path", "/api/Workspaces"],
+        client_builder=_builder({"type": "apikey", "key": "N", "value": "V"}, sess),
+    )
+    assert out["result"] == {"hello": "world"}
+    assert sess.calls[0]["url"].endswith("/api/Workspaces")
+
+
+def test_request_unmangles_shell_mangled_path(capsys):
+    # Git Bash rewrites '/api/FormTemplate/F1' into a Windows filesystem path;
+    # the request action must recover the intended '/api/...' tail and warn.
+    sess = FakeSession(queue=[FakeResp(200, {"ok": True})])
+    mangled = "/C:/Program Files/Git/api/FormTemplate/F1"
+    out = main.dispatch(
+        "request", ["--method", "GET", "--path", mangled],
+        client_builder=_builder({"type": "apikey", "key": "N", "value": "V"}, sess),
+    )
+    assert out["result"] == {"ok": True}
+    assert out["path"] == "/api/FormTemplate/F1"
+    assert sess.calls[0]["url"].endswith("/api/FormTemplate/F1")
+    assert "C:" not in sess.calls[0]["url"]
+    assert "shell-mangled" in capsys.readouterr().err     # warning went to stderr
+
+
+def test_request_collapses_double_slash_workaround():
+    sess = FakeSession(queue=[FakeResp(200, {"ok": True})])
+    out = main.dispatch(
+        "request", ["--method", "GET", "--path", "//api/Workspaces"],
+        client_builder=_builder({"type": "apikey", "key": "N", "value": "V"}, sess),
+    )
+    assert out["path"] == "/api/Workspaces"
+    assert sess.calls[0]["url"].endswith("/api/Workspaces")
+
+
+def test_request_leaves_clean_path_untouched(capsys):
+    sess = FakeSession(queue=[FakeResp(200, {"ok": True})])
+    main.dispatch(
+        "request", ["--method", "GET", "--path", "/api/Workspaces"],
+        client_builder=_builder({"type": "apikey", "key": "N", "value": "V"}, sess),
+    )
+    assert sess.calls[0]["url"].endswith("/api/Workspaces")
+    assert capsys.readouterr().err == ""                  # no false-positive warning
+
+
+def test_request_rejects_bad_method():
+    with pytest.raises(errors.UsageError):
+        main.dispatch(
+            "request", ["--path", "/api/X", "--method", "FETCH"],
+            client_builder=_builder({"type": "apikey", "key": "N", "value": "V"},
+                                    FakeSession()),
+        )
+
+
+def test_request_rejects_bad_json_body():
+    with pytest.raises(errors.UsageError):
+        main.dispatch(
+            "request", ["--path", "/api/X", "--method", "POST", "--body", "{bad"],
+            client_builder=_builder({"type": "apikey", "key": "N", "value": "V"},
+                                    FakeSession()),
+        )
+
+
+# -- list-endpoints (bundled, no client) ------------------------------------
+
+def test_list_endpoints_tags_only():
+    out = main.dispatch("list-endpoints", ["--tags-only"])
+    tags = {t["tag"] for t in out["tags"]}
+    assert "ProcessTemplate" in tags and "Workspace" in tags
+    assert out["meta"]["count"] == len(swagger.all_endpoints())
+
+
+def test_list_endpoints_filter():
+    out = main.dispatch("list-endpoints", ["--tag", "ProcessInstance", "--filter", "run"])
+    assert any(e["path"] == "/api/Projects/{id}/run" for e in out["endpoints"])
+
+
+# -- curated: run-process dry-run -------------------------------------------
+
+def test_run_process_dry_run_builds_body():
+    out = main.dispatch(
+        "run-process",
+        ["--id", "PID", "--payload", '{"a":1}', "--synchronous", "--dry-run"],
+        client_builder=_builder({"type": "apikey", "key": "N", "value": "V"},
+                                FakeSession()),
+    )
+    assert out["dry_run"] is True
+    assert out["path"] == "/api/Projects/PID/run"
+    assert out["body"] == {"payload": {"a": 1}, "connectionid": None}
+    assert out["query"]["runSynchronous"] == "true"
+
+
+def test_list_processes_maps_paging():
+    sess = FakeSession(queue=[FakeResp(200, [])])
+    main.dispatch(
+        "list-processes", ["--page", "2", "--page-size", "50", "--search", "inv"],
+        client_builder=_builder({"type": "apikey", "key": "N", "value": "V"}, sess),
+    )
+    assert sess.calls[0]["params"] == {"pageNumber": 2, "pageItemCount": 50,
+                                       "searchName": "inv"}
+
+
+# -- profile admin (no client) ----------------------------------------------
+
+def test_add_and_list_credentials(store):
+    main.dispatch("add-credential",
+                  ["--name", "wsA", "--type", "apikey", "--key", "K", "--value", "S",
+                   "--workspace-id", "G", "--workspace", "A"])
+    out = main.dispatch("list-credentials", [])
+    assert out["count"] == 1
+    prof = out["profiles"][0]
+    assert prof["name"] == "wsA" and prof["type"] == "apikey"
+    assert "value" not in prof and prof["has_value"] is True
+    assert prof["is_default"] is True
+
+
+def test_add_userpass_requires_fields(store):
+    with pytest.raises(errors.UsageError):
+        main.dispatch("add-credential", ["--name", "x", "--type", "userpass"])
+
+
+def test_set_default_and_remove(store):
+    main.dispatch("add-credential",
+                  ["--name", "a", "--type", "apikey", "--key", "K", "--value", "S"])
+    main.dispatch("add-credential",
+                  ["--name", "b", "--type", "apikey", "--key", "K", "--value", "S"])
+    main.dispatch("set-default", ["--name", "b"])
+    assert profiles.get_default() == "b"
+    out = main.dispatch("remove-credential", ["--name", "b"])
+    assert out["default"] == "a"
+
+
+# -- error classification ---------------------------------------------------
+
+def test_classify_api_error_maps_407():
+    err = errors.ProcesioAPIError(407, "HTTP 407", {"message": "proxy"})
+    code, msg, details, exit_code = errors.classify(err)
+    assert code == "proxy_auth_failed"
+    assert details["status"] == 407

procesio_cli/tools/procesio/tests/test_document_page_size.py

@@ -0,0 +1,19 @@
+"""documentPageSize must be one the document designer knows, spelled its way: any other value is
+silently reset to Default the next time the document is re-saved in the UI."""
+from __future__ import annotations
+
+import pytest
+
+from tools.procesio.dto.document import builder
+from tools.procesio.errors import UsageError
+
+
+@pytest.mark.parametrize("given,saved", [("A4", "A4"), ("a4", "A4"), (" letter ", "Letter"),
+                                         ("comm10e", "Comm10E"), ("", ""), (None, "")])
+def test_a_known_page_size_is_saved_in_the_designers_spelling(given, saved):
+    assert builder._page_size(given) == saved
+
+
+def test_an_unknown_page_size_is_refused_rather_than_silently_reset():
+    with pytest.raises(UsageError, match="resets it to Default"):
+        builder._page_size("A10")