procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_client_reliability.py

@@ -0,0 +1,139 @@
+"""Client-level reliability: total deadline, GET-only retry, run-process exemption.
+
+Exercises the guardrails end-to-end through ProcesioClient with a fake session,
+including the conflict-register assertions C1 (deadline vs long runs) and C4
+(retry vs side effects)."""
+from __future__ import annotations
+
+import time
+
+import pytest
+import requests
+
+from tools.procesio import errors, main
+from tools.procesio.client import ProcesioClient
+from tools.procesio.errors import DeadlineExceeded, ProcesioAPIError
+from tools.procesio.tests.conftest import FakeResp, FakeSession
+
+
+def _client(session, profile=None):
+    return ProcesioClient(
+        profile=profile or {"type": "apikey", "key": "N", "value": "V"},
+        name="t", session=session)
+
+
+def _builder(profile, session):
+    return lambda prof: ProcesioClient(profile=profile, name="t", session=session)
+
+
+@pytest.fixture(autouse=True)
+def _no_backoff_sleep(monkeypatch):
+    """Make retry backoff instant so tests don't actually sleep."""
+    monkeypatch.setattr("tools.procesio.reliability.full_jitter", lambda *a, **k: 0.0)
+
+
+# -- C1: total deadline vs long runs ----------------------------------------
+
+def test_get_trips_total_deadline_on_slow_response():
+    def responder(method, url, kwargs):
+        time.sleep(1.0)                 # server accepts then stalls
+        return FakeResp(200, {"never": "seen"})
+    c = _client(FakeSession(responder=responder))
+    with pytest.raises(DeadlineExceeded) as ei:
+        c.get("/api/FormTemplate/F1", deadline=0.15)
+    assert ei.value.endpoint_class == "read"
+
+
+def test_deadline_error_classifies_to_structured_envelope():
+    err = DeadlineExceeded("/api/Projects/X", "read", 90.0, 91.2)
+    code, msg, details, exit_code = errors.classify(err)
+    assert code == "deadline_exceeded"
+    assert exit_code == 1
+    assert details["kind"] == "deadline"
+    assert details["endpoint"] == "/api/Projects/X"
+    assert details["outcome"] == "unknown"     # a write may or may not have landed
+
+
+def test_run_process_is_exempt_from_the_deadline():
+    # A synchronous run legitimately takes a long time; run-process passes
+    # deadline=None so a slow response does NOT raise DeadlineExceeded.
+    def responder(method, url, kwargs):
+        time.sleep(0.3)
+        return FakeResp(200, {"instanceId": "i1", "status": 50})
+    out = main.dispatch(
+        "run-process", ["--id", "PID", "--payload", "{}"],
+        client_builder=_builder({"type": "apikey", "key": "N", "value": "V"},
+                                FakeSession(responder=responder)))
+    assert out["result"]["status"] == 50
+
+
+# -- C4: retry vs side effects ----------------------------------------------
+
+def test_get_retries_transient_then_succeeds():
+    sess = FakeSession(queue=[FakeResp(503, {"message": "busy"}),
+                              FakeResp(200, {"ok": 1})])
+    c = _client(sess)
+    assert c.get("/api/Projects", deadline=5) == {"ok": 1}
+    assert len(sess.calls) == 2                 # retried exactly once
+
+
+def test_get_gives_up_after_max_retries():
+    sess = FakeSession(queue=[FakeResp(503, {}) for _ in range(5)])
+    c = _client(sess)
+    with pytest.raises(ProcesioAPIError) as ei:
+        c.get("/api/Projects", deadline=5)
+    assert ei.value.status == 503
+    assert len(sess.calls) == 1 + 2             # first attempt + MAX_RETRIES
+
+
+def test_get_500_is_not_retried():
+    sess = FakeSession(queue=[FakeResp(500, {"message": "boom"})])
+    c = _client(sess)
+    with pytest.raises(ProcesioAPIError):
+        c.get("/api/Projects", deadline=5)
+    assert len(sess.calls) == 1                 # 500 excluded from retry
+
+
+def test_post_is_never_retried_even_on_503():
+    sess = FakeSession(queue=[FakeResp(503, {}) for _ in range(5)])
+    c = _client(sess)
+    with pytest.raises(ProcesioAPIError):
+        c.post("/api/Projects/PID/run", {"payload": {}})
+    assert len(sess.calls) == 1                 # re-POSTing would double-execute
+
+
+def test_run_process_post_makes_exactly_one_attempt():
+    # The C4 guarantee end-to-end: an execution is structurally un-retryable.
+    def responder(method, url, kwargs):
+        return FakeResp(503, {"message": "queue full"})
+    sess = FakeSession(responder=responder)
+    with pytest.raises(ProcesioAPIError):
+        main.dispatch("run-process", ["--id", "PID", "--payload", "{}"],
+                      client_builder=_builder(
+                          {"type": "apikey", "key": "N", "value": "V"}, sess))
+    assert len(sess.calls) == 1
+
+
+def test_get_retries_on_network_error():
+    calls = {"n": 0}
+
+    def responder(method, url, kwargs):
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise requests.exceptions.ConnectionError("reset")
+        return FakeResp(200, {"ok": 1})
+    c = _client(FakeSession(responder=responder))
+    assert c.get("/api/Projects", deadline=5) == {"ok": 1}
+    assert calls["n"] == 2
+
+
+def test_post_network_error_propagates_without_retry():
+    calls = {"n": 0}
+
+    def responder(method, url, kwargs):
+        calls["n"] += 1
+        raise requests.exceptions.ConnectionError("reset")
+    c = _client(FakeSession(responder=responder))
+    with pytest.raises(requests.exceptions.ConnectionError):
+        c.post("/api/Projects/PID/run", {"payload": {}})
+    assert calls["n"] == 1                      # cannot know if the POST landed

procesio_cli/tools/procesio/tests/test_customaction.py

@@ -0,0 +1,103 @@
+"""customaction sub-tool: upload (.nupkg multipart), delete, list."""
+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
+
+APIKEY = {"type": "apikey", "key": "N", "value": "V"}
+NUPKG = b"PK\x03\x04 fake nupkg bytes"
+
+
+def _builder(session):
+    return lambda prof: ProcesioClient(profile=APIKEY, name="t", session=session)
+
+
+def test_upload_posts_nupkg_as_multipart_package(tmp_path):
+    pkg = tmp_path / "MyConnector.1.0.0.nupkg"
+    pkg.write_bytes(NUPKG)
+    sess = FakeSession(queue=[FakeResp(200, {"id": "NEWID"})])
+    out = main.dispatch("customaction-upload", ["--workspace-id", "WS1", "--file", str(pkg)],
+                        client_builder=_builder(sess))
+    call = sess.calls[0]
+    assert call["method"] == "POST" and call["url"].endswith("/api/actions")
+    assert call["headers"]["workspaceid"] == "WS1"
+    assert "Content-Type" not in call["headers"]          # requests writes the multipart boundary
+    field = call["files"]["package"]
+    assert field == ("MyConnector.1.0.0.nupkg", NUPKG, "application/x-compressed")
+    # The backend takes the designer display name off the `name` header, so an
+    # upload with no --action-name still has to carry one (the package stem).
+    assert call["headers"]["name"] == "MyConnector.1.0.0"
+    # No --icon-path: a generic icon is defaulted (never iconless) and a warning returned.
+    assert call["headers"]["path"] == "icon-custom-action"
+    assert out["uploaded"] is True and out["id"] == "NEWID"
+    assert out["name"] == "MyConnector.1.0.0.nupkg"
+    assert out["actionName"] == "MyConnector.1.0.0"
+    assert out["iconPath"] == "icon-custom-action"
+    assert out["bytes"] == len(NUPKG)
+    assert out["warnings"] and "icon" in out["warnings"][0].lower()
+
+
+def test_upload_action_name_sets_display_name_header(tmp_path):
+    pkg = tmp_path / "MyConnector.1.0.0.nupkg"
+    pkg.write_bytes(NUPKG)
+    sess = FakeSession(queue=[FakeResp(200, {"id": "X"})])
+    out = main.dispatch("customaction-upload",
+                        ["--workspace-id", "WS1", "--file", str(pkg),
+                         "--action-name", "Prelude", "--icon-path", "icons/prelude.svg"],
+                        client_builder=_builder(sess))
+    assert sess.calls[0]["headers"]["name"] == "Prelude"
+    assert sess.calls[0]["headers"]["path"] == "icons/prelude.svg"
+    # an explicit icon is used verbatim and raises no warning
+    assert out["iconPath"] == "icons/prelude.svg" and "warnings" not in out
+
+
+def test_upload_name_override(tmp_path):
+    pkg = tmp_path / "raw.nupkg"
+    pkg.write_bytes(NUPKG)
+    sess = FakeSession(queue=[FakeResp(200, {"id": "X"})])
+    main.dispatch("customaction-upload",
+                  ["--workspace-id", "WS1", "--file", str(pkg), "--name", "Pretty.1.0.0.nupkg"],
+                  client_builder=_builder(sess))
+    assert sess.calls[0]["files"]["package"][0] == "Pretty.1.0.0.nupkg"
+
+
+def test_upload_missing_file_is_usage_error():
+    sess = FakeSession()
+    with pytest.raises(errors.UsageError):
+        main.dispatch("customaction-upload", ["--workspace-id", "WS1", "--file", "/no/such.nupkg"],
+                      client_builder=_builder(sess))
+
+
+def test_delete_calls_delete_endpoint():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    out = main.dispatch("customaction-delete", ["--workspace-id", "WS1", "--id", "AID"],
+                        client_builder=_builder(sess))
+    assert sess.calls[0]["method"] == "DELETE"
+    assert sess.calls[0]["url"].endswith("/api/actions/AID")
+    assert out == {"deleted": True, "id": "AID"}
+
+
+def test_list_custom_only_uses_iscustom_filter():
+    sess = FakeSession(queue=[FakeResp(200, {"actions": [
+        {"actionId": "A1", "name": "My CA", "description": "d",
+         "inputPorts": 1, "outputPorts": 1, "isProcesioAction": False}]})])
+    out = main.dispatch("customaction-list", ["--workspace-id", "WS1"],
+                        client_builder=_builder(sess))
+    call = sess.calls[0]
+    assert call["url"].endswith("/api/Actions/node")
+    assert call["params"] == {"getFullAction": "true", "isCustom": "true"}
+    assert out["count"] == 1
+    assert out["actions"][0] == {"actionId": "A1", "name": "My CA", "description": "d",
+                                 "inputPorts": 1, "outputPorts": 1, "isCustom": True}
+
+
+def test_list_all_uses_full_catalog():
+    sess = FakeSession(queue=[FakeResp(200, {"actions": [
+        {"actionId": "X", "name": "builtin", "isProcesioAction": True}]})])
+    out = main.dispatch("customaction-list", ["--workspace-id", "WS1", "--all"],
+                        client_builder=_builder(sess))
+    assert sess.calls[0]["url"].endswith("/api/Actions")
+    assert out["count"] == 1 and out["actions"][0]["isCustom"] is False

procesio_cli/tools/procesio/tests/test_customaction_test.py

@@ -0,0 +1,80 @@
+"""customaction-test runs an action in test mode and polls for the resolved result.
+
+POST /api/Actions/test only STARTS the test and returns a server-assigned gid; the
+result is produced asynchronously, so the handler polls GET /api/Actions/test/{gid}
+until a terminal status and returns {status, errorMessage, testResult, variables}.
+The friendly path builds the request from the live catalog (built-in OR a workspace
+custom action), binding each supplied input and every output to a test variable.
+"""
+import time
+
+import tools.procesio.handlers.resource_ops as ro
+
+FAKE_ACTION = {
+    "actionId": "11111111-1111-1111-1111-111111111111",
+    "name": "Demo Action",
+    "isProcesioAction": False,
+    "configuration": [
+        {"label": "Config", "settings": [
+            {"id": "a1a1a1a1-0000-0000-0000-000000000001", "label": "Input One",
+             "direction": 1, "dataTypeId": "dt-string"},
+            {"id": "b2b2b2b2-0000-0000-0000-000000000002", "label": "Result",
+             "direction": 3, "dataTypeId": "dt-string"},
+        ]},
+    ],
+}
+
+
+class _FakeClient:
+    def __init__(self, polls=None):
+        self.posted = None
+        self._polls = list(polls or [])
+
+    def get(self, path, query=None, **kw):
+        if path == "/api/Actions/node":          # the scoped custom-action fetch
+            return {"actions": [FAKE_ACTION]}
+        return self._polls.pop(0)                 # a test-result poll
+
+    def post(self, path, body=None, query=None, **kw):
+        self.posted = (path, body)
+        return {"testActionInstance": {"gid": "ta-123"}}
+
+
+def test_build_request_binds_supplied_inputs_and_every_output():
+    body = ro._build_test_request(_FakeClient(), "Demo Action", {"Input One": "hello"})
+    assert body["Action"]["gtid"] == "11111111-1111-1111-1111-111111111111"
+    bound = {p["TabPropertyId"] for p in body["Action"]["parameters"]}
+    assert bound == {"a1a1a1a1-0000-0000-0000-000000000001",   # input bound
+                     "b2b2b2b2-0000-0000-0000-000000000002"}    # output captured
+    assert [v["Type"] for v in body["variables"]] == [10, 30]   # INPUT / OUTPUT
+    assert body["TestValues"] == [
+        {"VariableId": body["variables"][0]["Id"], "Value": "hello", "Attribute": None}]
+
+
+def test_unknown_value_label_is_rejected():
+    import pytest
+    with pytest.raises(ro.UsageError):
+        ro._build_test_request(_FakeClient(), "Demo Action", {"Nope": 1})
+
+
+def test_run_test_action_polls_until_terminal_and_parses_result(monkeypatch):
+    monkeypatch.setattr(time, "sleep", lambda s: None)
+    c = _FakeClient(polls=[
+        {"status": 30},                                           # still running
+        {"status": 40, "errorMessage": None,                     # terminal (success)
+         "testResult": '{"b2b2b2b2-0000-0000-0000-000000000002": {"ok": 1}}',
+         "variables": []},
+    ])
+    out = ro._run_test_action(c, {"Gid": "x"}, timeout=30)
+    assert out["tested"] is True and out["gid"] == "ta-123"
+    assert out["status"] == 40 and out["errorMessage"] is None
+    assert out["testResult"] == {"b2b2b2b2-0000-0000-0000-000000000002": {"ok": 1}}
+
+
+def test_run_test_action_stops_on_failure_status_90(monkeypatch):
+    monkeypatch.setattr(time, "sleep", lambda s: None)
+    c = _FakeClient(polls=[
+        {"status": 90, "errorMessage": "boom", "errorCode": 400, "testResult": "{}"},
+    ])
+    out = ro._run_test_action(c, {"Gid": "x"}, timeout=30)
+    assert out["status"] == 90 and out["errorMessage"] == "boom"

procesio_cli/tools/procesio/tests/test_cycles.py

@@ -0,0 +1,69 @@
+"""Cycle-aware layout: a large embedded cycle is collapsed to a compact band; a small one is
+left to the engine's loop-curl."""
+from tools.procesio.layout import cycles, engine
+
+
+def _maxedge(P, edges):
+    return max((abs(P[e["source"]]["x"] - P[e["dest"]]["x"])
+                + abs(P[e["source"]]["y"] - P[e["dest"]]["y"])) for e in edges)
+
+
+def _chain_with_cycle(n):
+    """a -> b -> c -> [k0..k{n-1} cycle] -> out."""
+    nodes = [{"id": x} for x in ("a", "b", "c", "out")] + [{"id": f"k{i}"} for i in range(n)]
+    edges = [{"source": "a", "dest": "b"}, {"source": "b", "dest": "c"},
+             {"source": "c", "dest": "k0"}, {"source": "k2", "dest": "out"}]
+    for i in range(n):
+        edges.append({"source": f"k{i}", "dest": f"k{(i + 1) % n}"})   # k(n-1) -> k0 closes it
+    return nodes, edges
+
+
+def test_sccs_finds_the_cycle():
+    nodes, edges = _chain_with_cycle(8)
+    comps = cycles._sccs([n["id"] for n in nodes],
+                         [(e["source"], e["dest"]) for e in edges])
+    big = [c for c in comps if len(c) > 1]
+    assert len(big) == 1 and set(big[0]) == {f"k{i}" for i in range(8)}
+
+
+def test_large_cycle_collapsed_and_expanded():
+    """An 8-node cycle (>= MIN_CYCLE) is collapsed to a meta-node and expanded back: every real
+    node is placed, the meta-node never leaks into the output, and it's deterministic. (The
+    canvas-spanning-edge win is topology-dependent — proven live on Get-info-SalesOMMO where the
+    main flow interleaves the cycle: max edge 2538 -> 1280px — not on a standalone ring.)"""
+    nodes, edges = _chain_with_cycle(8)
+    a1 = cycles.layout(nodes, edges, opts=None, subset=None, dispatch_layout=engine.layout)
+    a2 = cycles.layout(nodes, edges, opts=None, subset=None, dispatch_layout=engine.layout)
+    assert set(a1["positions"]) == {n["id"] for n in nodes}   # all real nodes placed
+    assert cycles._META not in a1["positions"]                # meta-node removed on expand
+    assert a1["positions"] == a2["positions"]                 # deterministic
+
+
+def test_small_cycle_left_untouched():
+    """A 4-node cycle is below MIN_CYCLE (8) — cycle-aware must be a pure pass-through so the
+    engine's loop-curl still owns it."""
+    nodes, edges = _chain_with_cycle(4)
+    plain = engine.layout(nodes, edges)
+    aware = cycles.layout(nodes, edges, opts=None, subset=None, dispatch_layout=engine.layout)
+    assert aware["positions"] == plain["positions"]
+
+
+def test_subset_mode_passes_through():
+    nodes, edges = _chain_with_cycle(8)
+    aware = cycles.layout(nodes, edges, opts=None, subset=["b"], dispatch_layout=engine.layout)
+    plain = engine.layout(nodes, edges, subset=["b"])
+    assert aware["positions"] == plain["positions"]
+
+
+def test_large_cycle_prefers_ring_two_rows():
+    """The reference ring pattern: a large collapsible cycle expands as a compact TWO-ROW ring
+    (forward row + return row), not a wide one-row band, when that costs no crossings.
+    (A mid-ring exit can make the band win -- that is the score guard's call.)"""
+    nodes = [{"id": x} for x in ("a", "b")] + [{"id": f"k{i}"} for i in range(8)]
+    edges = ([{"source": "a", "dest": "b"}, {"source": "b", "dest": "k0"}]
+             + [{"source": f"k{i}", "dest": f"k{(i + 1) % 8}"} for i in range(8)])
+    res = cycles.layout(nodes, edges, opts=None, subset=None, dispatch_layout=engine.layout)
+    ys = sorted({round(res["positions"][f"k{i}"]["y"]) for i in range(8)})
+    assert len(ys) == 2                                   # two rows...
+    xs = {round(res["positions"][f"k{i}"]["x"]) for i in range(8)}
+    assert len(xs) <= 4                                   # ...folded to half the width