procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_normalize.py

@@ -0,0 +1,70 @@
+"""normalize_designer_layer: deterministic designer<-runtime mirror, pure-logic tests."""
+from tools.procesio.dto.process.normalize import normalize_designer_layer
+
+
+def _node(code_setting_value, param_value, param_variable, stype="code-editor", pid="S1"):
+    """A one-setting action: a designer setting (id=pid) mirrored by a runtime param (tabPropertyId=pid)."""
+    return {"actionName": "N", "id": "a1",
+            "parameters": [{"tabPropertyId": pid, "value": param_value, "variable": param_variable}],
+            "customData": {"configuration": [{"settings": [
+                {"id": pid, "type": stype, "label": "Code", "value": code_setting_value}]}]}}
+
+
+def _val(f):
+    return f["actions"][0]["customData"]["configuration"][0]["settings"][0]["value"]
+
+
+def test_placeholder_fixed_to_guid():
+    f = {"actions": [_node("var d = <%0%>;", "var d = <%0%>;", [{"id": 0, "variableId": "V1"}])]}
+    r = normalize_designer_layer(f)
+    assert r["changed"] and _val(f) == "var d = V1;"
+
+
+def test_noop_on_guid_form():
+    # designer already carries the GUID -> nothing to do
+    f = {"actions": [_node("var d = V1;", "var d = <%0%>;", [{"id": 0, "variableId": "V1"}])]}
+    assert not normalize_designer_layer(f)["changed"] and _val(f) == "var d = V1;"
+
+
+def test_idempotent():
+    f = {"actions": [_node("var d = <%0%>;", "var d = <%0%>;", [{"id": 0, "variableId": "V1"}])]}
+    normalize_designer_layer(f)
+    assert not normalize_designer_layer(f)["changed"]
+
+
+def test_attribute_chain_preserved():
+    f = {"actions": [_node("x=<%0%>;", "x=<%0%>;",
+                           [{"id": 0, "variableId": "V1", "attribute": {"attributeId": "A1", "nextAttribute": None}}])]}
+    normalize_designer_layer(f)
+    assert _val(f) == "x=V1.A1;"
+
+
+def test_multi_var_by_binding_id_not_position():
+    # <%N%> binds to variable[].id, not positional order
+    f = {"actions": [_node("f(<%1%>,<%0%>);", "f(<%1%>,<%0%>);",
+                           [{"id": 0, "variableId": "VA"}, {"id": 1, "variableId": "VB"}])]}
+    normalize_designer_layer(f)
+    assert _val(f) == "f(VB,VA);"
+
+
+def test_list_valued_setting_left_untouched():
+    # a process-outputs-like LIST value must NOT be regenerated (string-only scope avoids corruption)
+    lst = [{"id": 0, "subprocess": "S", "process": "V1.A1"}]
+    f = {"actions": [_node(lst, [{"id": 0, "source": {"variable": [{"variableId": "V1"}]},
+                                  "destination": {"variableId": "S"}}], [], stype="process-outputs")]}
+    r = normalize_designer_layer(f)
+    assert not r["changed"] and _val(f) == lst
+
+
+def test_unbound_placeholder_left_literal():
+    # a <%5%> with no matching variable id must be left as-is, never blanked
+    f = {"actions": [_node("keep <%5%>", "keep <%5%>", [{"id": 0, "variableId": "V1"}])]}
+    assert not normalize_designer_layer(f)["changed"] and _val(f) == "keep <%5%>"
+
+
+def test_warning_param_without_setting():
+    f = {"actions": [{"actionName": "N", "id": "a1",
+                      "parameters": [{"tabPropertyId": "NOPE", "value": "x", "variable": []}],
+                      "customData": {"configuration": [{"settings": []}]}}]}
+    r = normalize_designer_layer(f)
+    assert any(w["why"] == "param_without_setting" for w in r["warnings"])

procesio_cli/tools/procesio/tests/test_payload_docs.py

@@ -0,0 +1,86 @@
+"""A structured argument must publish the contract the tool actually enforces.
+
+`--config` carries the whole resource definition, but argparse can only give it a
+one-line `help=`, so the manifest described it as "a JSON object" and a caller holding
+only the manifest had to reverse-engineer the shape from validation errors - one layer
+per attempt, several turns per resource. The fix publishes the component's own schema
+and a working fixture, which means two things can now fall out of step, and these tests
+are what stop them:
+
+  * the published schema vs the file `validate_config` enforces - a schema edit that
+    is not regenerated would advertise a contract the tool no longer applies;
+  * the published example vs that schema - an example that does not validate is worse
+    than none, because it is the part a caller copies.
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+from jsonschema import Draft202012Validator
+
+from tools._lib.manifest import load_tool
+from tools.procesio import main
+from tools.procesio.dto import registry as dto_registry
+from pathlib import Path
+
+
+def _manifest():
+    return load_tool(Path(main.__file__).resolve().parent / "tool.yaml")
+
+
+def _config_actions():
+    """Every action whose real contract is a structured `--config`."""
+    m = _manifest()
+    return [a for a in m.actions if any(g.name == "config" for g in a.args)]
+
+
+def test_there_are_config_driven_actions_to_check():
+    """Guards the guard: if the discovery below ever returns nothing, the tests that
+    follow would pass vacuously."""
+    assert len(_config_actions()) >= 12
+
+
+@pytest.mark.parametrize("component", sorted(dto_registry.all_components()))
+def test_each_component_publishes_its_schema_and_an_example(component):
+    m = _manifest()
+    for verb in ("create", "edit"):
+        spec = m.get_action(f"{component}-{verb}")
+        assert spec is not None, f"{component}-{verb} missing from the manifest"
+        config_arg = next((g for g in spec.args if g.name == "config"), None)
+        assert config_arg is not None, f"{component}-{verb} has no --config"
+        assert config_arg.json_schema, (
+            f"{component}-{verb} --config publishes no schema; regenerate the manifest")
+        assert spec.examples, f"{component}-{verb} publishes no example"
+
+
+@pytest.mark.parametrize("component", sorted(dto_registry.all_components()))
+def test_published_schema_matches_the_file_the_tool_enforces(component):
+    """The manifest is generated and committed; the schema on disk is read at every
+    validate. Only this comparison keeps a schema edit from silently publishing a stale
+    contract until someone happens to regenerate."""
+    comp = dto_registry.all_components()[component]
+    if not comp.schema_path.exists():
+        pytest.skip(f"{component} ships no config schema")
+    on_disk = json.loads(comp.schema_path.read_text(encoding="utf-8"))
+    spec = _manifest().get_action(f"{component}-create")
+    published = next(g for g in spec.args if g.name == "config").json_schema
+    assert published == on_disk, (
+        f"{component}: the published schema differs from {comp.schema_path.name} - "
+        f"run tools/procesio/gen_manifest.py")
+
+
+@pytest.mark.parametrize("component", sorted(dto_registry.all_components()))
+def test_published_example_validates_against_published_schema(component):
+    """The example is the part a caller copies, so it has to satisfy the contract it
+    ships beside."""
+    spec = _manifest().get_action(f"{component}-create")
+    schema = next(g for g in spec.args if g.name == "config").json_schema
+    if not schema or not spec.examples:
+        pytest.skip(f"{component} publishes no schema/example pair")
+    errors = sorted(Draft202012Validator(schema).iter_errors(spec.examples[0]),
+                    key=lambda e: list(e.path))
+    assert not errors, (
+        f"{component}: the published example fails its own schema - "
+        + "; ".join(f"{'/'.join(str(p) for p in e.path) or '(root)'}: {e.message}"
+                    for e in errors[:5]))

procesio_cli/tools/procesio/tests/test_process_action_naming.py

@@ -0,0 +1,170 @@
+"""Build-time auto-naming of process actions + Decisional/AI Decisional branches.
+
+Two behaviours are locked here:
+  * an un-named action is labelled by what it DOES (derived from literal config),
+    never left as the generic template label when we can do better;
+  * a non-default Decisional case is labelled by its condition instead of "Case N".
+Both are cosmetic (wiring is by id) and both re-evaluate on every build/edit, so an
+edited process stays legible. An explicit name always wins; a param bound to a
+variable is unknowable at build time and falls back to the template label.
+"""
+from __future__ import annotations
+
+import itertools
+
+from tools.procesio.dto.process import builder as pb
+from tools.procesio.dto.process import naming
+
+
+def _ctx():
+    counter = itertools.count(1)
+    return {"new_id": lambda: f"00000000-0000-0000-0000-{next(counter):012d}"}
+
+
+def _names(dto):
+    return [a["ActionName"] for a in dto["Actions"]]
+
+
+def _template(dto, template_name):
+    return next(a for a in dto["Actions"] if a["ActionTemplateName"] == template_name)
+
+
+def _cases_config(node, ctype):
+    return next(s for tab in node["CustomData"]["configuration"]
+               for s in tab["settings"] if s.get("type") == ctype)["value"]
+
+
+# -- naming module (pure) -----------------------------------------------------
+
+def test_derive_action_name_enriches_high_value_templates():
+    assert naming.derive_action_name(
+        {"params": {"Verb": "get", "Endpoint": "https://api.x.com/v1/users?q=1"}},
+        "Call API") == "GET /v1/users"
+    assert naming.derive_action_name(
+        {"params": {"For Each Item": {"var": "items"}}}, "For Each") == "For each items"
+    assert naming.derive_action_name(
+        {"params": {"Code": "// resolve the period\nreturn 1;"}}, "Node") == "resolve the period"
+    assert naming.derive_action_name(
+        {"params": {"Query": "SELECT * FROM clients WHERE id=@id"}},
+        "Execute Query") == "SELECT clients"
+    assert naming.derive_action_name(
+        {"params": {"File Name": "invoice.pdf"}}, "Generate Document") == "Generate invoice.pdf"
+
+
+def test_derive_action_name_returns_none_when_it_cannot_beat_the_template():
+    # a variable-bound param is unknowable at build time
+    assert naming.derive_action_name({"params": {"Endpoint": {"var": "u"}}}, "Call API") is None
+    # a Node with no leading comment has nothing to summarise
+    assert naming.derive_action_name({"params": {"Code": "return 1;"}}, "Node") is None
+    # a template with no enricher
+    assert naming.derive_action_name({"params": {}}, "Generate GUID") is None
+
+
+def test_derive_branch_name_rule_based_and_ai():
+    assert naming.derive_branch_name(
+        {"when": [{"left": {"var": "amount"}, "op": "GREATER_THAN", "right": 1000}]},
+        is_ai=False) == "amount > 1000"
+    assert naming.derive_branch_name(
+        {"when": [{"left": {"var": "cod"}, "op": "IS_NOT_EMPTY"}]}, is_ai=False) == "cod present"
+    assert naming.derive_branch_name(
+        {"when": [{"left": {"var": "a"}, "op": "EQUALS", "right": 1},
+                  {"left": {"var": "b"}, "op": "IS_TRUE", "logic": "and"}]},
+        is_ai=False) == "a = 1 and b"
+    assert naming.derive_branch_name(
+        {"condition": "the client is a new customer"}, is_ai=True) == "the client is a new customer"
+
+
+def test_disambiguate_only_suffixes_collisions():
+    out = naming.disambiguate([("a", "GET /x", True), ("b", "GET /x", True),
+                               ("c", "Send Mail", False), ("d", "Send Mail", False)])
+    assert out == {"a": "GET /x", "b": "GET /x 2", "c": "Send Mail", "d": "Send Mail"}
+
+
+# -- build integration --------------------------------------------------------
+
+def test_unnamed_actions_are_auto_named_and_collisions_disambiguated():
+    cfg = {"title": "t", "variables": [{"name": "items", "type": "json", "direction": "input"}],
+           "actions": [
+               {"id": "c1", "action": "Call API",
+                "params": {"Verb": "GET", "Endpoint": "https://api.example.com/v1/users"}},
+               {"id": "c2", "action": "Call API",
+                "params": {"Verb": "GET", "Endpoint": "https://api.example.com/v1/users"}},
+               {"id": "loop", "action": "For Each", "params": {"For Each Item": {"var": "items"}}},
+           ]}
+    names = _names(pb.build(cfg, _ctx()))
+    assert "GET /v1/users" in names and "GET /v1/users 2" in names   # collision disambiguated
+    assert "For each items" in names
+
+
+def test_explicit_name_wins_over_derivation():
+    cfg = {"title": "t", "actions": [
+        {"id": "c", "action": "Call API", "name": "Fetch users",
+         "params": {"Verb": "GET", "Endpoint": "https://api.example.com/v1/users"}}]}
+    assert "Fetch users" in _names(pb.build(cfg, _ctx()))
+
+
+def test_template_fallback_names_are_shared_not_disambiguated():
+    """Two un-named Stops (no enricher) both stay 'Stop' — only ENRICHED names are made
+    unique, so template-label duplicates keep behaving exactly as before auto-naming."""
+    cfg = {"title": "t", "actions": [
+        {"id": "g", "action": "Generate GUID"},
+        {"id": "s1", "action": "Stop"}, {"id": "s2", "action": "Stop"}],
+        "edges": [["start", "g"], ["g", "s1"]]}
+    names = _names(pb.build(cfg, _ctx()))
+    assert names.count("Stop") == 2 and "Stop 2" not in names
+
+
+def test_regular_decisional_branch_named_from_condition_default_untouched():
+    cfg = {"title": "t",
+           "variables": [{"name": "amount", "type": "integer", "direction": "input"},
+                         {"name": "cod", "type": "string", "direction": "input"}],
+           "actions": [
+               {"id": "d", "action": "Decisional", "branches": [
+                   {"to": "a", "when": [{"left": {"var": "amount"}, "op": "GREATER_THAN", "right": 1000}]},
+                   {"name": "has code", "to": "b", "when": [{"left": {"var": "cod"}, "op": "IS_NOT_EMPTY"}]},
+                   {"to": "j", "default": True}]},
+               {"id": "a", "action": "Generate GUID"}, {"id": "b", "action": "Generate GUID"},
+               {"id": "j", "action": "Join"}],
+           "edges": [["start", "d"], ["a", "j"], ["b", "j"], ["j", "stop"]]}
+    dto = pb.build(cfg, _ctx())
+    dec = _template(dto, "Decisional")
+    branch_names = [c["name"] for c in _cases_config(dec, "decisional-case")]
+    assert branch_names == ["amount > 1000", "has code"]   # derived, then explicit-wins
+    # the default is a port, not a case, so it never gets a case label
+    assert any(p.get("Data", {}).get("isDefault") == "default" for p in dec["Ports"])
+
+
+def test_ai_decisional_branch_named_from_condition():
+    cfg = {"title": "t",
+           "variables": [{"name": "animal", "type": "string", "direction": "input"}],
+           "actions": [
+               {"id": "ai", "action": "AI Decisional",
+                "params": {"User Prompt": {"template": "which? <%0%>", "vars": ["animal"]}},
+                "branches": [
+                    {"name": "bear", "to": "a", "condition": "Is it a bear?"},
+                    {"to": "b", "condition": "Is it a fish?"},
+                    {"to": "d", "default": True}]},
+               {"id": "a", "action": "Generate GUID"}, {"id": "b", "action": "Generate GUID"},
+               {"id": "d", "action": "Generate GUID"}],
+           "edges": [["start", "ai"], ["a", "stop"], ["b", "stop"], ["d", "stop"]]}
+    dto = pb.build(cfg, _ctx())
+    ai = _template(dto, "AI Decisional")
+    names = [c["name"] for c in _cases_config(ai, "ai-decisional-case")]
+    assert names == ["bear", "Is it a fish?"]              # explicit wins, else condition
+
+
+def test_query_store_named_after_its_store_and_verb():
+    d = naming.derive_action_name
+    assert d({"queryStore": {"sql": "SELECT * FROM {{ds:OMN Units}}"}}, "Query Store") == "Read OMN Units"
+    assert d({"queryStore": {"sql": "REPLACE INTO {{ds:Leads}} (a) VALUES (1)"}}, "Query Store") == "Save to Leads"
+    assert d({"queryStore": {"sql": "UPDATE {{ds:Settings}} SET v = 1"}}, "Query Store") == "Update Settings"
+    assert d({"queryStore": {"sql": "DELETE FROM {{ds:Events}} WHERE 1"}}, "Query Store") == "Delete from Events"
+    assert d({"queryStore": {"sql": "SELECT a FROM {{ds:A}} JOIN {{ds:B}} ON 1"}}, "Query Store") == "Read A + 1 more"
+
+
+def test_node_named_from_template_comment_or_its_output():
+    d = naming.derive_action_name
+    tpl = {"Code": {"template": "// score the visitor\nreturn 1;", "vars": ["x"]}}
+    assert d({"params": tpl}, "Node") == "score the visitor"
+    out = {"Code": {"template": "const a = 1;", "vars": []}, "Single Result": {"var": "catalogueJson"}}
+    assert d({"params": out}, "Node") == "Compute catalogueJson"

procesio_cli/tools/procesio/tests/test_process_call_api_seed.py

@@ -0,0 +1,46 @@
+"""Process builder: Call API run-time-mandatory properties are seeded (verb guid + empty Request Parameters)."""
+from __future__ import annotations
+
+import itertools
+
+from tools.procesio.dto.process import builder as pb
+
+
+def _ctx():
+    counter = itertools.count(1)
+    return {"new_id": lambda: f"00000000-0000-0000-0000-{next(counter):012d}"}
+
+
+def _call_api_params(verb="GET", with_req=False):
+    params = {"Verb": verb, "Endpoint": "/zen", "Time Out": 30}
+    if with_req:
+        params["Request Parameters"] = {"body": {"type": "RAW", "value": {"BINARY": "", "FORM_DATA": [],
+                                                                            "RAW": {"format": "json", "value": "{}"},
+                                                                            "X_WWW_FORM_URLENCODED": []}},
+                                        "headers": [], "queryParams": []}
+    cfg = {"title": "t", "actions": [{"id": "c", "action": "Call API", "name": "c", "params": params}]}
+    dto = pb.build(cfg, _ctx())
+    node = [a for a in dto["Actions"] if a["ActionName"] == "c"][0]
+    return {str(p["TabPropertyId"])[-12:]: p for p in node["Parameters"]}
+
+
+def test_verb_word_resolves_to_platform_guid():
+    for word, guid in pb._CALL_API_VERB_GUIDS.items():
+        assert _call_api_params(word)["8420f7790001"]["Value"] == guid
+    assert _call_api_params("post")["8420f7790001"]["Value"] == pb._CALL_API_VERB_GUIDS["POST"]
+
+
+def test_verb_guid_passes_through():
+    guid = pb._CALL_API_VERB_GUIDS["DELETE"]
+    assert _call_api_params(guid)["8420f7790001"]["Value"] == guid
+
+
+def test_missing_request_parameters_is_seeded_empty():
+    p = _call_api_params()["8420f7790003"]
+    assert p["Variable"] == []
+    assert p["Value"]["body"]["type"] == "RAW" and p["Value"]["headers"] == [] and p["Value"]["queryParams"] == []
+
+
+def test_bound_request_parameters_are_kept():
+    p = _call_api_params(with_req=True)["8420f7790003"]
+    assert p["Value"]["body"]["value"]["RAW"]["value"] == "{}"