procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_transport.py

@@ -0,0 +1,147 @@
+"""PROCESIO polish: --workspace-id override, list-subworkspaces filter, export."""
+from __future__ import annotations
+
+import json
+
+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"}
+
+
+# -- --workspace-id override -------------------------------------------------
+
+def test_workspace_id_override_sets_header():
+    sess = FakeSession(queue=[FakeResp(200, [])])
+    main.dispatch("list-workspaces", ["--workspace-id", "WS-123"],
+                  client_builder=_builder(APIKEY, sess))
+    assert sess.calls[0]["headers"]["workspaceid"] == "WS-123"
+
+
+def test_workspace_id_overrides_profile_workspace():
+    sess = FakeSession(queue=[FakeResp(200, [])])
+    prof = {"type": "apikey", "key": "N", "value": "V", "workspace_id": "PROFILE-WS"}
+    main.dispatch("list-workspaces", ["--workspace-id", "CALL-WS"],
+                  client_builder=_builder(prof, sess))
+    assert sess.calls[0]["headers"]["workspaceid"] == "CALL-WS"   # call wins
+
+
+# -- list-subworkspaces active-only filter -----------------------------------
+
+_MIXED = {"pageItems": [
+    {"workspace": "Active A", "id": "a", "workspaceState": "active"},
+    {"workspace": "Removed B", "id": "b", "workspaceState": "removed"},
+    {"workspace": "Active C", "id": "c", "workspaceState": "active"},
+]}
+
+
+def test_list_subworkspaces_hides_removed_by_default():
+    sess = FakeSession(queue=[FakeResp(200, _MIXED)])
+    out = main.dispatch("list-subworkspaces", ["--parent-id", "RING"],
+                        client_builder=_builder(APIKEY, sess))
+    assert out["count"] == 2
+    assert {w["id"] for w in out["workspaces"]} == {"a", "c"}
+
+
+def test_list_subworkspaces_include_removed():
+    sess = FakeSession(queue=[FakeResp(200, _MIXED)])
+    out = main.dispatch("list-subworkspaces", ["--parent-id", "RING", "--include-removed"],
+                        client_builder=_builder(APIKEY, sess))
+    assert out["count"] == 3
+
+
+# -- export ------------------------------------------------------------------
+
+def _export_responder(export_bytes=None):
+    """Serves list endpoints for name resolution + the export POST."""
+    lists = {
+        "/api/DataTypes": [{"name": "lazarusDM", "id": "DM1"}],
+        "/api/Projects": [{"title": "Lazarus Data process", "id": "P1"},
+                          {"title": "Import excel products to pdf", "id": "P2"}],
+        "/api/DocumentTemplate": [{"name": "products from Excel", "id": "DOC1"}],
+        "/api/Webhooks": [], "/api/FormTemplate": [], "/api/Credentials": [],
+    }
+
+    def responder(method, url, kw):
+        if url.endswith("/api/Transport/export-entities"):
+            return FakeResp(200, content=export_bytes or b"{}")
+        for path, rows in lists.items():
+            if url.endswith(path):
+                return FakeResp(200, {"pageItems": rows})
+        return FakeResp(200, {"pageItems": []})
+    return responder
+
+
+def test_export_dry_run_resolves_names_excludes_credentials():
+    sess = FakeSession(responder=_export_responder())
+    out = main.dispatch(
+        "export",
+        ["--workspace-id", "WS", "--data-models", "lazarusDM",
+         "--processes", "Lazarus Data process,Import excel products to pdf",
+         "--documents", "all", "--dry-run"],
+        client_builder=_builder(APIKEY, sess),
+    )
+    assert out["dry_run"] is True
+    b = out["body"]
+    assert b["dataModelIds"] == ["DM1"]
+    assert b["flowIds"] == ["P1", "P2"]
+    assert b["documentIds"] == ["DOC1"]
+    assert b["credentialIds"] == []          # excluded by default
+    assert b["exportSensitiveData"] is False
+
+
+def test_export_requires_workspace_scope():
+    sess = FakeSession(responder=_export_responder())
+    with pytest.raises(errors.UsageError):
+        main.dispatch("export", ["--data-models", "lazarusDM"],
+                      client_builder=_builder(APIKEY, sess))
+
+
+def test_export_nothing_selected_errors():
+    sess = FakeSession(responder=_export_responder())
+    with pytest.raises(errors.UsageError):
+        main.dispatch("export", ["--workspace-id", "WS"],
+                      client_builder=_builder(APIKEY, sess))
+
+
+def test_export_unresolvable_name_errors():
+    sess = FakeSession(responder=_export_responder())
+    with pytest.raises(errors.UsageError):
+        main.dispatch("export", ["--workspace-id", "WS", "--processes", "Nope"],
+                      client_builder=_builder(APIKEY, sess))
+
+
+def test_export_saves_file(tmp_path):
+    bundle = json.dumps({"DataTypes": [{}], "Flows": [{}, {}], "DocumentTemplates": [{}],
+                         "Credentials": [], "Webhooks": [], "Forms": []}).encode()
+    sess = FakeSession(responder=_export_responder(export_bytes=bundle))
+    out_path = str(tmp_path / "exp.procesio")
+    out = main.dispatch(
+        "export",
+        ["--workspace-id", "WS", "--data-models", "lazarusDM",
+         "--processes", "Lazarus Data process", "--documents", "all", "--output", out_path],
+        client_builder=_builder(APIKEY, sess),
+    )
+    assert out["saved"] == out_path
+    assert out["bytes"] == len(bundle)
+    # DataStores joined the summary when data stores became selectable. It is
+    # counted even at zero: a caller cannot otherwise tell a pack that carries
+    # no store from one where the store was never requested, and reading the
+    # second as the first is exactly the mistake that made this change
+    # necessary.
+    assert out["sections"] == {"DataTypes": 1, "Flows": 2, "DocumentTemplates": 1,
+                               "Credentials": 0, "Webhooks": 0, "Forms": 0,
+                               "DataStores": 0}
+    with open(out_path, "rb") as f:
+        assert f.read() == bundle
+    # the export POST carried the built selection body
+    post = [c for c in sess.calls if c["url"].endswith("/Transport/export-entities")][0]
+    assert post["json"]["flowIds"] == ["P1"]

procesio_cli/tools/procesio/tests/test_transport_data_stores.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+"""Transport: data stores must be requestable on export, and import must send
+the part name and headers the endpoint actually requires.
+
+⚠ WHY THESE TESTS EXIST. `export` used to build its selection from a map that
+had no data-store entry, so the request never carried `dataStoreIds` and a pack
+silently arrived without the store. A referencing process travelled anyway,
+carrying a store id the receiving workspace does not have. The empty
+`DataStores` section was then read as evidence that the platform drops
+referenced stores - a conclusion about the server drawn from a request that
+could not name the thing.
+
+⚠ AND `import` posted its file part as `file` where the endpoint expects
+`importedData`, with none of the seven required boolean headers. That endpoint
+answers `403 Forbidden` with the body `MIGRATE` on ANY error, so a malformed
+request is indistinguishable from a permission failure - which is exactly how it
+was misread once.
+
+Each test asserts on the REQUEST that would be sent, because that is the thing
+that was wrong, and it is invisible in any response.
+"""
+from __future__ import annotations
+
+import argparse
+
+import pytest
+
+from tools.procesio.errors import UsageError
+from tools.procesio.handlers import resource_ops, transport
+
+
+class FakeClient:
+    """Captures what the handler would send."""
+
+    def __init__(self, listings=None):
+        self.workspace_id = "ws-1"
+        self.profile = {"workspace_id": "ws-1"}
+        self.listings = listings or {}
+        self.multipart = None
+        self.exported = None
+
+    def get(self, path, query=None):
+        return self.listings.get(path, [])
+
+    def request_bytes(self, method, path, body=None):
+        self.exported = {"method": method, "path": path, "body": body}
+        return 200, b'{"Flows":[1],"DataStores":[{"id":"ds-1"}]}', {}
+
+    def request_multipart(self, path, *, files, query=None, headers=None):
+        self.multipart = {"path": path, "files": files, "headers": headers}
+        return {"ok": True}
+
+
+def _export_args(**kw):
+    ns = argparse.Namespace(
+        data_models=None, processes=None, documents=None, webhooks=None,
+        forms=None, credentials=None, data_stores=None,
+        export_sensitive_data=False, output=None, dry_run=True)
+    for k, v in kw.items():
+        setattr(ns, k, v)
+    return ns
+
+
+def test_export_body_has_a_data_store_key():
+    """⚠ The body must carry `dataStoreIds` even when nothing selects one."""
+    c = FakeClient({"/api/Projects": [{"id": "f-1", "title": "p"}]})
+    out = transport.export(c, _export_args(processes="p"))
+    assert "dataStoreIds" in out["body"], (
+        "the export body must always carry a dataStoreIds key, so a store can "
+        "be requested at all")
+    assert out["body"]["dataStoreIds"] == []
+
+
+def test_export_resolves_a_data_store_by_name():
+    c = FakeClient({"/api/DataStore": [{"id": "ds-1", "name": "tokens"}]})
+    out = transport.export(c, _export_args(data_stores="tokens"))
+    assert out["body"]["dataStoreIds"] == ["ds-1"]
+    assert out["resolved"]["data_stores"]["ids"] == ["ds-1"]
+
+
+def test_a_data_store_alone_is_a_valid_selection():
+    """Selecting only a store must not trip the nothing-selected guard."""
+    c = FakeClient({"/api/DataStore": [{"id": "ds-1", "name": "tokens"}]})
+    out = transport.export(c, _export_args(data_stores="tokens"))
+    assert out["body"]["dataStoreIds"] == ["ds-1"]
+
+
+def test_export_still_refuses_an_empty_selection():
+    c = FakeClient()
+    with pytest.raises(UsageError):
+        transport.export(c, _export_args())
+
+
+def test_export_reports_the_DataStores_section(tmp_path):
+    # output= must be given: this is the one export test that actually writes, and with output=None
+    # the handler falls back to ./procesio-export.procesio, littering whatever directory pytest
+    # happens to run in (it left one in the repo root).
+    c = FakeClient({"/api/DataStore": [{"id": "ds-1", "name": "tokens"}]})
+    out = transport.export(c, _export_args(data_stores="tokens", dry_run=False,
+                                           output=str(tmp_path / "pack.procesio")))
+    assert "DataStores" in out["sections"], (
+        "a caller cannot tell whether the store travelled unless the summary "
+        "counts that section")
+    assert out["sections"]["DataStores"] == 1
+
+
+def _import_args(**kw):
+    ns = argparse.Namespace(file=None)
+    for dest in resource_ops._IMPORT_FLAGS:
+        setattr(ns, "no_" + dest, False)
+    for k, v in kw.items():
+        setattr(ns, k, v)
+    return ns
+
+
+def test_import_uses_the_documented_part_name(tmp_path):
+    """⚠ `importedData`, not `file`. A wrongly named part is not reported."""
+    f = tmp_path / "p.procesio"
+    f.write_bytes(b"{}")
+    c = FakeClient()
+    resource_ops.import_bundle(c, _import_args(file=str(f)))
+    assert list(c.multipart["files"]) == ["importedData"]
+
+
+def test_import_sends_all_seven_required_headers(tmp_path):
+    f = tmp_path / "p.procesio"
+    f.write_bytes(b"{}")
+    c = FakeClient()
+    out = resource_ops.import_bundle(c, _import_args(file=str(f)))
+    sent = c.multipart["headers"]
+    assert set(sent) == {"overrideData", "importDataTypes", "importFlows",
+                         "importCredentials", "importDocuments",
+                         "importForms", "importDataStores"}
+    assert all(v == "true" for v in sent.values()), (
+        "a pack is normally imported whole; a silently skipped category is "
+        "what this endpoint reports worst")
+    assert out["headers_sent"] == sent, (
+        "the result must echo the headers: a 403 from this endpoint cannot be "
+        "read without knowing what was asked")
+
+
+def test_import_flags_can_switch_a_category_off(tmp_path):
+    f = tmp_path / "p.procesio"
+    f.write_bytes(b"{}")
+    c = FakeClient()
+    resource_ops.import_bundle(c, _import_args(file=str(f),
+                                               no_credentials=True))
+    assert c.multipart["headers"]["importCredentials"] == "false"
+    assert c.multipart["headers"]["importDataStores"] == "true"
+
+
+# ⚠ PROVED ABLE TO FAIL. Each assertion above passes trivially if the handler
+# does the right thing; these two show the tests would have CAUGHT the original
+# defects rather than merely agreeing with the fix.
+
+def test_the_old_export_shape_would_fail_these_tests():
+    old_keys = {"dataModelIds", "flowIds", "documentIds", "webhookIds",
+                "formIds", "credentialIds"}
+    assert "dataStoreIds" not in old_keys
+    assert "dataStoreIds" in set(transport._BODY_KEYS), (
+        "the fix is precisely that dataStoreIds joined the body keys")
+
+
+def test_the_old_import_shape_would_fail_these_tests():
+    assert "file" != "importedData"
+    assert len(resource_ops._IMPORT_FLAGS) == 7, (
+        "seven headers are required; a handler sending none was accepted by "
+        "nothing and reported by nothing")

procesio_cli/tools/procesio/tests/test_transport_mapper_repair.py

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+"""Transport: a Data Store mapper must be repaired before a pack is shipped.
+
+WHY THIS EXISTS. The platform's EXPORT re-spells every Data Store mapper row
+from the shape the back end accepts into the Call SubProcess wire shape, and
+the import does not translate it back:
+
+    accepted   {"id": i, "source": {"value": "<%i%>",
+                                    "variable": [{"id": i, "variableId": g,
+                                                  "attribute": None}]},
+                "column": "<NAME>"}
+    in a pack  {"id": i, "process": "<flowId>.<variableId>",
+                "document": "<NAME>"}
+
+Nothing is lost - the column name and the variable GUID both survive under
+different keys - so every structural check passes on a process that cannot
+run. It fails only when executed, with "A Data Store Decisional column
+reference cannot be null or empty".
+
+These tests assert on the TRANSFORMED PACK, because that is the artefact
+shipped and the defect is invisible in any response.
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from tools.procesio.handlers import transport
+
+FLOW_ID = "8463a145-78a8-490b-a1da-a2e6615c231c"
+VAR_0 = "b3bf9af2-52ea-4192-94b0-b95afef7fa4a"
+VAR_1 = "b55f6ad7-3499-4820-b2f5-e9d62d9c773b"
+
+
+def _pack(rows):
+    return {"DataTypes": [], "Credentials": [], "Webhooks": [],
+            "DocumentTemplates": [], "Forms": [], "DataStores": [],
+            "TimeStamp": "2026-08-24T00:00:00Z",
+            "Flows": [{"Title": "w", "Id": FLOW_ID, "Variables": [],
+                       "Actions": [{"Parameters": [
+                           {"TabPropertyId": "x", "Value": rows,
+                            "Variable": []}]}]}]}
+
+
+def _exported_rows():
+    return [{"id": 0, "process": "%s.%s" % (FLOW_ID, VAR_0),
+             "document": "row_key"},
+            {"id": 1, "process": "%s.%s" % (FLOW_ID, VAR_1),
+             "document": "tenant_id"}]
+
+
+def _repair(pack):
+    return transport.repair_datastore_mapper_pack(pack)
+
+
+def test_exported_rows_are_rewritten_into_the_accepted_shape():
+    out, changed = _repair(_pack(_exported_rows()))
+    rows = out["Flows"][0]["Actions"][0]["Parameters"][0]["Value"]
+    assert changed == 2
+    assert sorted(rows[0]) == ["column", "id", "source"]
+    assert rows[0]["column"] == "row_key"
+    assert rows[0]["source"]["value"] == "<%0%>"
+    assert rows[0]["source"]["variable"] == [
+        {"id": 0, "variableId": VAR_0, "attribute": None}]
+
+
+def test_the_placeholder_index_tracks_the_row_id():
+    """The <%i%> placeholder must match the id INSIDE its own inline array."""
+    out, _ = _repair(_pack(_exported_rows()))
+    for row in out["Flows"][0]["Actions"][0]["Parameters"][0]["Value"]:
+        i = row["id"]
+        assert row["source"]["value"] == "<%%%d%%>" % i
+        assert row["source"]["variable"][0]["id"] == i
+
+
+def test_the_variable_guid_is_taken_from_the_composite_not_invented():
+    out, _ = _repair(_pack(_exported_rows()))
+    rows = out["Flows"][0]["Actions"][0]["Parameters"][0]["Value"]
+    assert [r["source"]["variable"][0]["variableId"] for r in rows] == \
+        [VAR_0, VAR_1]
+
+
+def test_no_document_or_process_key_survives():
+    out, _ = _repair(_pack(_exported_rows()))
+    blob = json.dumps(out)
+    assert '"document"' not in blob
+    assert '"process"' not in blob
+    assert blob.count('"column"') == 2
+    assert blob.count('"source"') == 2
+
+
+def test_it_is_IDEMPOTENT_so_a_fixed_export_is_never_corrupted():
+    """If PROCESIO fixes the export, this must become a no-op.
+
+    A repair that mangles an already-correct pack is worse than no repair,
+    because it would break the very case it is waiting for.
+    """
+    once, first = _repair(_pack(_exported_rows()))
+    twice, second = _repair(once)
+    assert second == 0, "a second pass must change nothing"
+    assert twice == once
+
+
+def test_an_already_accepted_row_is_passed_through_untouched():
+    good = [{"id": 0,
+             "source": {"value": "<%0%>",
+                        "variable": [{"id": 0, "variableId": VAR_0,
+                                      "attribute": None}]},
+             "column": "row_key"}]
+    out, changed = _repair(_pack(good))
+    assert changed == 0
+    assert out["Flows"][0]["Actions"][0]["Parameters"][0]["Value"] == good
+
+
+def test_the_parameter_variable_list_stays_empty():
+    """The variable array belongs INSIDE the source operand, not on the
+    parameter. Populating both is what fourteen earlier shapes got wrong."""
+    out, _ = _repair(_pack(_exported_rows()))
+    assert out["Flows"][0]["Actions"][0]["Parameters"][0]["Variable"] == []
+
+
+def test_a_pack_with_no_mapper_is_left_alone():
+    pack = _pack([{"id": 0, "somethingElse": 1}])
+    out, changed = _repair(pack)
+    assert changed == 0
+    assert out == pack
+
+
+def test_the_input_pack_is_not_mutated_in_place():
+    src = _pack(_exported_rows())
+    before = json.dumps(src)
+    _repair(src)
+    assert json.dumps(src) == before, "the caller's pack must be untouched"
+
+
+def test_the_action_is_registered_and_offline():
+    a = transport.ACTIONS["repair-datastore-mapper"]
+    assert a.needs_client is False, "this is an offline pack transform"
+    assert a.description
+
+
+@pytest.mark.parametrize("bad", [None, 12, "text", [], [1, 2]])
+def test_a_non_mapper_parameter_value_is_ignored(bad):
+    pack = _pack(_exported_rows())
+    pack["Flows"][0]["Actions"][0]["Parameters"].append(
+        {"TabPropertyId": "y", "Value": bad, "Variable": []})
+    out, changed = _repair(pack)
+    assert changed == 2
+    assert out["Flows"][0]["Actions"][0]["Parameters"][1]["Value"] == bad