procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_fevalidation.py

@@ -0,0 +1,317 @@
+"""Front-end (designer-layer) process-validation pure-logic tests.
+
+Every case maps to a rule in docs_info/process-validation-reference-1.md.
+"""
+from tools.procesio.flowmodel import fevalidation as fv
+from tools.procesio.flowmodel.fevalidation import validate_flow, split_severity
+
+
+# -- tiny DTO builders (camelCase, like the live Web-API) ----------------------
+
+def _act(aid, name, tmpl="Concatenate", settings=None, ports=None, shape="square",
+         parent=None):
+    a = {"id": aid, "actionName": name, "actionTemplateName": tmpl,
+         "customData": {"type": shape,
+                        "configuration": [{"settings": settings or []}]},
+         "ports": ports or []}
+    if parent:
+        a["parentId"] = parent
+    return a
+
+
+def _start(ports=None):
+    return _act("start", "Start", "Start", ports=ports or [])
+
+
+def _stop():
+    return _act("stop", "Stop", "Stop", ports=[])
+
+
+def _flow(actions, variables=None):
+    return {"actions": actions, "variables": variables or []}
+
+
+def _line(src, dst, **d):
+    return {"sourceId": src, "destinationId": dst, "type": d.get("type", 0),
+            "data": d.get("data", {})}
+
+
+def _errs(flow, **kw):
+    e, _ = split_severity(validate_flow(flow, **kw))
+    return e
+
+
+def _codes(flow, **kw):
+    return {w["code"] for w in validate_flow(flow, **kw)}
+
+
+# -- valid baseline ------------------------------------------------------------
+
+def _valid_flow():
+    return _flow([
+        _start(ports=[_line("start", "mid")]),
+        _act("mid", "Mid", settings=[], ports=[_line("mid", "stop")]),
+        _stop(),
+    ])
+
+
+def test_valid_flow_clean():
+    assert _errs(_valid_flow(), target_vars_of=lambda f: {}) == []
+
+
+# -- points (ref checkPointsValidation) ---------------------------------------
+
+def test_missing_start():
+    flow = _flow([_act("mid", "Mid", ports=[_line("mid", "stop")]), _stop()])
+    assert "START_COUNT" in _codes(flow)
+
+
+def test_two_starts():
+    flow = _flow([_start(ports=[_line("start", "stop")]),
+                  _act("s2", "Start2", "Start", ports=[_line("s2", "stop")]), _stop()])
+    assert "START_COUNT" in _codes(flow)
+
+
+def test_missing_stop():
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", ports=[])])
+    assert "STOP_COUNT" in _codes(flow)
+
+
+# -- node names (ref checkNodeNameValidation) ---------------------------------
+
+def test_empty_node_name():
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "", ports=[_line("mid", "stop")]), _stop()])
+    assert "NODE_NAME" in _codes(flow)
+
+
+# -- connectivity (ref noUnconnectedNodes) ------------------------------------
+
+def test_unconnected_start():
+    flow = _flow([_start(ports=[]), _stop()])
+    codes = _codes(flow)
+    assert "UNCONNECTED" in codes
+
+
+def test_node_only_connected_to_stop_flagged():
+    # mid's single line goes to Stop -> UNCONNECTED (ref: len==1 && endpoint is Stop)
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", ports=[_line("mid", "stop")]),
+                  _act("orphan", "Orphan", ports=[_line("orphan", "stop")]), _stop()])
+    # orphan: lines = [orphan->stop] only, len 1, endpoint stop -> UNCONNECTED
+    assert "UNCONNECTED" in _codes(flow)
+
+
+def test_error_path_only_missing_stop():
+    # a node whose only NON-error line is incoming -> MISSING_STOP variant
+    flow = _flow([
+        _start(ports=[_line("start", "mid")]),
+        _act("mid", "Mid", ports=[_line("mid", "err", type=1, data={"isDefault": "error"})]),
+        _act("err", "ErrHandler", ports=[_line("err", "stop")]),
+        _stop(),
+    ])
+    codes = _codes(flow)
+    assert "MISSING_STOP" in codes
+
+
+# -- required fields (ref DefaultControlValidator.doRequiredCheck) -------------
+
+def test_required_empty_default():
+    s = {"id": "s1", "type": "text", "label": "URL", "isRequired": True,
+         "dataTypeId": fv.STRING, "isList": False, "value": ""}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    assert "REQUIRED" in _codes(flow)
+
+
+def test_required_filled_ok():
+    s = {"id": "s1", "type": "text", "label": "URL", "isRequired": True,
+         "dataTypeId": fv.STRING, "isList": False, "value": "https://x"}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    assert "REQUIRED" not in _codes(flow)
+
+
+# -- placeholders (ref doPlaceholdersCheck) -----------------------------------
+
+def test_leftover_placeholder():
+    s = {"id": "s1", "type": "text", "label": "Body", "isRequired": False,
+         "dataTypeId": fv.STRING, "value": "xxxxxxxx-xxxx-xxxx-xxxx-abcdefghijk"}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    assert "PLACEHOLDER" in _codes(flow)
+
+
+def test_empty_template_marker_placeholder():
+    s = {"id": "s1", "type": "text", "label": "Body", "value": "a <%%> b"}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    assert "PLACEHOLDER" in _codes(flow)
+
+
+# -- value format (ref doValueCheck) ------------------------------------------
+
+def test_empty_optional_numeric_not_flagged():
+    # an optional number field left blank (e.g. a Delay's unused "Runtime Amount") is a
+    # valid FORMAT — emptiness is the required check's job, not the value check's.
+    s = {"id": "s1", "type": "number", "label": "Runtime Amount", "isRequired": False,
+         "dataTypeId": fv.INTEGER, "isList": False, "value": ""}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    codes = _codes(flow)
+    assert "VALUE_INTEGER" not in codes and "VALUE_NUMBER" not in codes
+
+
+def test_value_not_a_number():
+    s = {"id": "s1", "type": "text", "label": "Count", "dataTypeId": fv.NUMBER,
+         "isList": False, "value": "abc"}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    assert "VALUE_NUMBER" in _codes(flow)
+
+
+def test_value_integer_bad():
+    s = {"id": "s1", "type": "text", "label": "N", "dataTypeId": fv.INTEGER,
+         "isList": False, "value": "3.5"}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    assert "VALUE_INTEGER" in _codes(flow)
+
+
+def test_value_number_with_variable_skipped():
+    # a variable reference -> value check is skipped (concrete value unknown at design time)
+    s = {"id": "s1", "type": "text", "label": "N", "dataTypeId": fv.NUMBER,
+         "value": "11111111-2222-4333-8444-555555555555"}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    assert "VALUE_NUMBER" not in _codes(flow)
+
+
+# -- limits (ref checkLimits) --------------------------------------------------
+
+def test_limits_out_of_range():
+    s = {"id": "s1", "type": "number", "label": "Retries", "dataTypeId": fv.INTEGER,
+         "value": 99, "limits": {"min": 0, "max": 10}}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    assert "LIMIT_RANGE" in _codes(flow)
+
+
+def test_limits_within_range_ok():
+    s = {"id": "s1", "type": "number", "label": "Retries", "dataTypeId": fv.INTEGER,
+         "value": 5, "limits": {"min": 0, "max": 10}}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()])
+    assert "LIMIT_RANGE" not in _codes(flow)
+
+
+# -- variables (ref checkVariables) -------------------------------------------
+
+def test_duplicate_variable_names():
+    flow = _valid_flow()
+    flow["variables"] = [{"id": "v1", "name": "x", "dataType": fv.STRING},
+                         {"id": "v2", "name": "x", "dataType": fv.STRING}]
+    assert "VAR_UNIQUE" in _codes(flow, target_vars_of=lambda f: {})
+
+
+def test_primitive_name_collision():
+    flow = _valid_flow()
+    # named "string" but typed integer -> collision
+    flow["variables"] = [{"id": "v1", "name": "string", "dataType": fv.INTEGER}]
+    assert "VAR_PRIMITIVE_NAME" in _codes(flow, target_vars_of=lambda f: {})
+
+
+def test_primitive_name_matching_type_ok():
+    flow = _valid_flow()
+    flow["variables"] = [{"id": "v1", "name": "string", "dataType": fv.STRING}]
+    assert "VAR_PRIMITIVE_NAME" not in _codes(flow, target_vars_of=lambda f: {})
+
+
+# -- subprocess mapping (ref checkSubprocess) ---------------------------------
+
+def _subcall(target, inputs=None, outputs=None):
+    subsecs = [{"type": "process-inputs", "value": inputs or []},
+               {"type": "process-outputs", "value": outputs or []}]
+    return {"id": "call", "actionName": "Call X", "actionTemplateName": "Call Subprocess",
+            "customData": {"type": "square", "configuration": [{"settings": [
+                {"type": "side-pannel", "id": "5456caf0", "value": subsecs},
+                {"type": "flow-list", "value": target}]}]},
+            "ports": [_line("call", "stop")], "parameters": []}
+
+
+def test_subprocess_required_input_unmapped():
+    tgt = "11111111-2222-4333-8444-555555555555"
+    call = _subcall(tgt, inputs=[])
+    flow = _flow([_start(ports=[_line("start", "call")]), call, _stop()])
+    tv = {"B": {"name": "SessionId", "type": 10, "isRequired": True}}
+    assert "SUB_REQ_UNMAPPED" in _codes(flow, target_vars_of=lambda f: tv if f == tgt else {})
+
+
+def test_subprocess_mapped_ok():
+    tgt = "11111111-2222-4333-8444-555555555555"
+    call = _subcall(tgt, inputs=[{"subprocess": "B", "process": "v1"}])
+    flow = _flow([_start(ports=[_line("start", "call")]), call, _stop()],
+                 variables=[{"id": "v1", "name": "sess", "type": 20}])
+    tv = {"B": {"name": "SessionId", "type": 10, "isRequired": True}}
+    codes = _codes(flow, target_vars_of=lambda f: tv if f == tgt else {})
+    assert "SUB_REQ_UNMAPPED" not in codes
+
+
+# -- decisional cases (ref ConditionalValidator + DecisionalCardValidation) ----
+
+def test_decisional_case_incomplete():
+    s = {"id": "11d4044a-8586-47f6-b3ce-1cae5da40f30", "type": "decisional-case",
+         "label": "Cases", "value": [{"name": "", "target": "t", "condition": []}]}
+    node = _act("dec", "Decision", "Decisional", settings=[s],
+                ports=[_line("start", "dec"), _line("dec", "stop")], shape="diamond")
+    flow = _flow([_start(ports=[_line("start", "dec")]), node, _stop()])
+    assert "CASE_INCOMPLETE" in _codes(flow)
+
+
+def test_decisional_case_complete_ok():
+    s = {"id": "11d4044a-8586-47f6-b3ce-1cae5da40f30", "type": "decisional-case",
+         "label": "Cases", "value": [{"name": "c1", "target": "stop", "condition": [
+             {"operator": "eq", "leftOperator": {"value": "a"},
+              "rightOperator": {"value": "b"}, "value": None}]}]}
+    node = _act("dec", "Decision", "Decisional", settings=[s],
+                ports=[_line("start", "dec"), _line("dec", "stop")], shape="diamond")
+    flow = _flow([_start(ports=[_line("start", "dec")]), node, _stop()])
+    assert "CASE_INCOMPLETE" not in _codes(flow)
+
+
+# -- type mismatch WARNING layer (ref DefaultControlValidator.doDataTypeCheck) --
+
+def test_type_mismatch_is_warning_not_error():
+    # setting expects INTEGER; value references a STRING variable -> mismatch (warning)
+    var = "11111111-2222-4333-8444-555555555555"
+    s = {"id": "s1", "type": "text", "label": "N", "isRequired": False,
+         "dataTypeId": fv.INTEGER, "isList": False, "value": var}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()],
+                 variables=[{"id": var, "name": "s", "dataType": fv.STRING, "isList": False}])
+    dts = [{"id": fv.STRING}, {"id": fv.INTEGER}]
+    all_w = validate_flow(flow, datatypes=dts, target_vars_of=lambda f: {})
+    errs, warns = split_severity(all_w)
+    assert any(w["code"] == "TYPE_MISMATCH" for w in warns)
+    assert all(e["code"] != "TYPE_MISMATCH" for e in errs)
+
+
+def test_type_checks_skipped_without_datatypes():
+    var = "11111111-2222-4333-8444-555555555555"
+    s = {"id": "s1", "type": "text", "label": "N", "dataTypeId": fv.INTEGER, "value": var}
+    flow = _flow([_start(ports=[_line("start", "mid")]),
+                  _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")]), _stop()],
+                 variables=[{"id": var, "name": "s", "dataType": fv.STRING}])
+    assert "TYPE_MISMATCH" not in _codes(flow, target_vars_of=lambda f: {})
+
+
+# -- disabled actions ignored --------------------------------------------------
+
+def test_disabled_action_skipped():
+    s = {"id": "s1", "type": "text", "label": "URL", "isRequired": True, "value": ""}
+    dead = _act("mid", "Mid", settings=[s], ports=[_line("mid", "stop")])
+    dead["isDisabled"] = True
+    # a disabled node must not raise REQUIRED; keep a live path so points/connectivity pass
+    flow = _flow([_start(ports=[_line("start", "stop")]), dead, _stop()])
+    assert "REQUIRED" not in _codes(flow)

procesio_cli/tools/procesio/tests/test_fieldpath_variables.py

@@ -0,0 +1,87 @@
+"""A RUN_PROCESS map row's FORM side can also be a form variable or a path into the form's own
+data model (instance.currentUser.email) - shapes real forms use (FORM_LOAD passes the signed-in
+user's email; a click passes a form variable such as an offer id). The resolver used to refuse
+both, so a correct event could not be written through form-set-element-event."""
+from __future__ import annotations
+
+import pytest
+
+from tools.procesio.dto.form import fieldpath
+from tools.procesio.errors import UsageError
+
+NS = fieldpath.FIELDS_NS
+
+
+def _live():
+    return fieldpath.LiveForm({"data": {
+        "dataModel": {"id": "dm", "attributes": [
+            {"id": NS, "name": "fields", "attributes": []},
+            {"id": "inst", "name": "instance", "attributes": [
+                {"id": "cu", "name": "currentUser", "attributes": [
+                    {"id": "em", "name": "email", "attributes": []},
+                    {"id": "nm", "name": "name", "attributes": []}]}]}]},
+        "variables": [
+            {"id": "dm", "name": "form", "type": 20},
+            {"id": "v-offer", "name": "Offer_ID", "type": 20},
+            {"id": "v-status", "name": "status", "type": 20}],
+        "elements": [
+            {"id": "E1", "type": "input", "configs": [{"key": "name", "value": "status"},
+                                                      {"key": "value", "id": "vc-E1"}]}]}})
+
+
+def test_a_form_variable_by_at_name_resolves_to_its_id():
+    live = _live()
+    assert live.resolve("@Offer_ID", "row") == "v-offer"
+    assert live.is_variable("v-offer")
+
+
+def test_a_bare_variable_name_resolves_when_no_field_has_that_name():
+    assert _live().resolve("Offer_ID", "row") == "v-offer"
+
+
+def test_a_field_name_still_wins_over_a_variable_of_the_same_name():
+    live = _live()
+    assert live.resolve("status", "row") == f"dm.{NS}.E1.vc-E1"
+    assert live.resolve("@status", "row") == "v-status"
+
+
+def test_the_form_handle_variable_is_not_a_value():
+    with pytest.raises(UsageError):
+        _live().resolve("@form", "row")
+
+
+def test_a_data_model_name_path_resolves_to_its_id_path():
+    assert _live().resolve("instance.currentUser.email", "row") == "dm.inst.cu.em"
+
+
+def test_an_id_path_into_the_instance_tree_passes_through():
+    assert _live().resolve("dm.inst.cu.nm", "row") == "dm.inst.cu.nm"
+
+
+def test_an_unknown_attribute_names_what_exists():
+    with pytest.raises(UsageError) as e:
+        _live().resolve("instance.currentUser.phone", "row")
+    assert "email" in str(e.value) and "name" in str(e.value)
+
+
+def _live_with_paragraph():
+    live = _live()
+    p = {"id": "P9", "type": "paragraph", "configs": [{"key": "name", "value": "Paragraph9"},
+                                                     {"key": "label", "id": "lbl-P9"},
+                                                     {"key": "visible", "id": "vis-P9"}]}
+    live.elements.append(p); live.by_id["P9"] = p; live.by_name["Paragraph9"] = [p]
+    return live
+
+
+def test_an_element_config_by_name_resolves_to_its_config_path():
+    assert _live_with_paragraph().resolve("Paragraph9.label", "row") == f"dm.{NS}.P9.lbl-P9"
+
+
+def test_a_path_to_any_config_of_the_element_passes_the_check():
+    live = _live_with_paragraph()
+    assert live.resolve(f"dm.{NS}.P9.vis-P9", "row") == f"dm.{NS}.P9.vis-P9"
+
+
+def test_a_config_id_of_another_element_is_still_refused():
+    with pytest.raises(UsageError):
+        _live_with_paragraph().resolve(f"dm.{NS}.P9.vc-E1", "row")

procesio_cli/tools/procesio/tests/test_files.py

@@ -0,0 +1,72 @@
+"""file-download action: header-based GET /api/File/download, --from-run derivation."""
+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
+
+APIKEY = {"type": "apikey", "key": "N", "value": "V"}
+PDF = b"%PDF-1.4 fake brief bytes"
+
+
+def _builder(session):
+    return lambda prof: ProcesioClient(profile=APIKEY, name="t", session=session)
+
+
+def test_file_download_sets_headers_and_writes_file(tmp_path):
+    sess = FakeSession(queue=[FakeResp(200, content=PDF, headers={
+        "content-type": "application/pdf",
+        "content-disposition": 'attachment; filename="brief.pdf"'})])
+    out = main.dispatch("file-download", [
+        "--workspace-id", "WS1",
+        "--file-path", "flow/flow-F/flow-instance-I/variable-V/FID",
+        "--variable-id", "V1", "--instance-id", "I1", "--flow-template-id", "FT1",
+        "--out", str(tmp_path)], client_builder=_builder(sess))
+    call = sess.calls[0]
+    assert call["method"] == "GET" and call["url"].endswith("/api/File/download")
+    assert call["params"] == {"isArchived": "false"}
+    h = call["headers"]
+    assert h["uploadFilePath"] == "flow/flow-F/flow-instance-I/variable-V/FID"
+    assert h["variableId"] == "V1" and h["instanceId"] == "I1"
+    assert h["flowTemplateId"] == "FT1" and h["workspaceId"] == "WS1"
+    assert out == {"downloaded": True, "path": str(tmp_path / "brief.pdf"),
+                   "size": len(PDF), "mimeType": "application/pdf", "name": "brief.pdf"}
+    assert (tmp_path / "brief.pdf").read_bytes() == PDF
+
+
+def test_file_download_from_run_derives_ids(tmp_path):
+    run = tmp_path / "run.json"
+    run.write_text(json.dumps({"result": {"instanceId": "INST", "variable": {"briefPdf": {
+        "name": "b.pdf", "size": "5",
+        "path": "flow/flow-11111111-1111-1111-1111-111111111111/"
+                "flow-instance-22222222-2222-2222-2222-222222222222/"
+                "variable-33333333-3333-3333-3333-333333333333/FID"}}}}), encoding="utf-8")
+    sess = FakeSession(queue=[FakeResp(200, content=PDF, headers={"content-type": "application/pdf"})])
+    out = main.dispatch("file-download", [
+        "--workspace-id", "WS1", "--from-run", str(run), "--out", str(tmp_path / "x.pdf")],
+        client_builder=_builder(sess))
+    h = sess.calls[0]["headers"]
+    assert h["flowTemplateId"] == "11111111-1111-1111-1111-111111111111"
+    assert h["instanceId"] == "INST"                                      # result.instanceId wins
+    assert h["variableId"] == "33333333-3333-3333-3333-333333333333"
+    assert out["downloaded"] is True and out["path"] == str(tmp_path / "x.pdf")
+
+
+def test_file_download_missing_ids_is_usage_error():
+    sess = FakeSession()
+    with pytest.raises(errors.UsageError):
+        main.dispatch("file-download", ["--workspace-id", "WS1", "--file-path", "p"],
+                      client_builder=_builder(sess))
+
+
+def test_file_download_http_error_raises(tmp_path):
+    sess = FakeSession(queue=[FakeResp(400, content=b'"Object reference not set"')])
+    with pytest.raises(errors.ProcesioAPIError):
+        main.dispatch("file-download", [
+            "--workspace-id", "WS1", "--file-path", "p", "--variable-id", "V",
+            "--instance-id", "I", "--flow-template-id", "F", "--out", str(tmp_path)],
+            client_builder=_builder(sess))