procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_schedule_cron_shape.py

@@ -0,0 +1,111 @@
+"""A cron schedule's recurrence block must carry the cron keys and NOTHING else.
+
+The defect: `--cron` overlaid the crontab keys on top of whatever recurrence the caller's
+`--payload` already had. That payload is normally cloned from a live schedule (the API's
+own documented advice, because the write body is validated for shape), so it arrives
+carrying the calendar-recurrence fields `every` / `onDay` / `onThe` / `isOnThe` /
+`isWeekendExcluded`. With those still present the create/update is refused with the
+generic
+
+    [{"statusCode":502,"value":"Invalid request due to missing or incorrect resource
+      parameters.","target":"schedules"}]
+
+which names no field, so the failure reads as "cron is not supported here" rather than
+"you sent five keys too many". `POST /api/Schedules/validate-crontab` accepts the very
+same expression happily, which makes the wrong conclusion easy to reach.
+
+The expected shape below was captured from the designer's own PUT.
+"""
+from __future__ import annotations
+
+import argparse
+
+from tools.procesio.handlers import schedules
+
+
+CRON_ONLY = {"recurrence", "cronExpression", "timeZone", "info", "isEndDate", "startDate",
+             "endDate"}
+CALENDAR_ONLY = {"every", "onDay", "onThe", "isOnThe", "isWeekendExcluded"}
+
+
+def _args(**kw):
+    base = {"cron": None, "timezone": None, "recurrence_info": None}
+    return argparse.Namespace(**{**base, **kw})
+
+
+def _legacy_payload() -> dict:
+    """A payload cloned from a live MINUTES schedule, as a caller would build one."""
+    return {"name": "S", "targetProcess": "p", "processInputs": [],
+            "recurrence": {"info": "every 2 minutes", "every": 2, "onDay": 0,
+                           "onThe": [2, 1], "endDate": "2027-12-31T00:00:00Z",
+                           "isOnThe": False, "isEndDate": False,
+                           "startDate": "2026-08-30T06:00:00", "recurrence": 2,
+                           "isWeekendExcluded": False}}
+
+
+def test_the_calendar_recurrence_fields_are_dropped():
+    body = schedules._apply_cron(_legacy_payload(),
+                                 _args(cron="*/2 * * * *", timezone="Europe/Bucharest"))
+    leftover = CALENDAR_ONLY & set(body["recurrence"])
+    assert not leftover, (
+        f"{sorted(leftover)} survived into a cron recurrence; the API refuses the whole "
+        f"body without naming them")
+
+
+def test_the_block_carries_the_cron_keys():
+    body = schedules._apply_cron(_legacy_payload(),
+                                 _args(cron="*/2 * * * *", timezone="Europe/Bucharest"))
+    rec = body["recurrence"]
+    assert rec["recurrence"] == 8
+    assert rec["cronExpression"] == "*/2 * * * *"
+    assert rec["timeZone"] == "Europe/Bucharest"
+
+
+def test_no_key_outside_the_captured_shape_is_emitted():
+    body = schedules._apply_cron(_legacy_payload(),
+                                 _args(cron="0 9 * * 1", timezone="UTC"))
+    assert set(body["recurrence"]) <= CRON_ONLY
+
+
+def test_the_activation_start_survives():
+    """The only calendar field a cron schedule legitimately keeps."""
+    body = schedules._apply_cron(_legacy_payload(), _args(cron="*/5 * * * *"))
+    assert body["recurrence"]["startDate"] == "2026-08-30T06:00:00"
+
+
+def test_an_end_date_is_dropped_unless_the_window_really_ends():
+    """isEndDate false with an endDate still set is the shape the designer never sends."""
+    body = schedules._apply_cron(_legacy_payload(), _args(cron="*/5 * * * *"))
+    assert body["recurrence"]["isEndDate"] is False
+    assert "endDate" not in body["recurrence"]
+
+
+def test_an_end_date_is_kept_when_the_window_does_end():
+    payload = _legacy_payload()
+    payload["recurrence"]["isEndDate"] = True
+    body = schedules._apply_cron(payload, _args(cron="*/5 * * * *"))
+    assert body["recurrence"]["endDate"] == "2027-12-31T00:00:00Z"
+
+
+def test_the_timezone_from_the_payload_is_used_when_no_flag_is_given():
+    payload = _legacy_payload()
+    payload["recurrence"]["timeZone"] = "Europe/Bucharest"
+    body = schedules._apply_cron(payload, _args(cron="*/5 * * * *"))
+    assert body["recurrence"]["timeZone"] == "Europe/Bucharest"
+
+
+def test_an_explicit_label_wins_over_the_payload_one():
+    body = schedules._apply_cron(_legacy_payload(),
+                                 _args(cron="*/2 * * * *", recurrence_info="Every 2 minutes"))
+    assert body["recurrence"]["info"] == "Every 2 minutes"
+
+
+def test_everything_outside_the_recurrence_is_untouched():
+    body = schedules._apply_cron(_legacy_payload(), _args(cron="*/2 * * * *"))
+    assert body["name"] == "S" and body["targetProcess"] == "p"
+
+
+def test_without_cron_the_payload_passes_through_verbatim():
+    payload = _legacy_payload()
+    before = dict(payload["recurrence"])
+    assert schedules._apply_cron(payload, _args())["recurrence"] == before

procesio_cli/tools/procesio/tests/test_schedules.py

@@ -0,0 +1,309 @@
+"""Scheduler curated actions — faked client boundary (zero live HTTP).
+
+Mirrors tests/test_transport.py / test_dispatch.py: a FakeSession records every
+HTTP call and serves canned responses, so we assert the method, URL, query, and
+body each curated schedule action emits.
+"""
+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"}
+
+
+def _last(sess):
+    return sess.calls[-1]
+
+
+# -- list / get -------------------------------------------------------------
+
+def test_list_schedules_hits_endpoint():
+    sess = FakeSession(queue=[FakeResp(200, {"pageItems": []})])
+    out = main.dispatch("list-schedules", [], client_builder=_builder(APIKEY, sess))
+    assert out["result"] == {"pageItems": []}
+    c = _last(sess)
+    assert c["method"] == "GET"
+    assert c["url"].endswith("/api/Schedules")
+
+
+def test_list_schedules_maps_paging():
+    sess = FakeSession(queue=[FakeResp(200, [])])
+    main.dispatch("list-schedules",
+                  ["--page", "2", "--page-size", "25", "--search", "nightly"],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["params"] == {"pageNumber": 2, "pageItemCount": 25,
+                                     "searchName": "nightly"}
+
+
+def test_get_schedule_uses_id_in_path():
+    sess = FakeSession(queue=[FakeResp(200, {"id": "S1"})])
+    out = main.dispatch("get-schedule", ["--id", "S1"],
+                        client_builder=_builder(APIKEY, sess))
+    assert out["result"] == {"id": "S1"}
+    c = _last(sess)
+    assert c["method"] == "GET"
+    assert c["url"].endswith("/api/Schedules/S1")
+
+
+def test_get_schedule_preserves_process_inputs_by_default():
+    payload = {"id": "S1", "processInputs": [{"id": "V1", "value": "clear"}]}
+    sess = FakeSession(queue=[FakeResp(200, payload)])
+
+    out = main.dispatch("get-schedule", ["--id", "S1"],
+                        client_builder=_builder(APIKEY, sess))
+
+    assert out["result"]["processInputs"][0]["value"] == "clear"
+
+
+def test_get_schedule_can_redact_process_inputs_without_losing_structure():
+    payload = {
+        "id": "S1",
+        "processInputs": [
+            {"id": "V1", "value": "clear", "type": 0},
+            {"id": "V2", "value": None, "type": 0},
+        ],
+        "nested": {"ProcessInputs": [{"Id": "V3", "Value": "also-clear"}]},
+    }
+    sess = FakeSession(queue=[FakeResp(200, payload)])
+
+    out = main.dispatch(
+        "get-schedule",
+        ["--id", "S1", "--redact-process-inputs"],
+        client_builder=_builder(APIKEY, sess),
+    )["result"]
+
+    assert out["id"] == "S1"
+    assert out["processInputs"] == [
+        {"id": "V1", "value": "[REDACTED]", "type": 0},
+        {"id": "V2", "value": None, "type": 0},
+    ]
+    assert out["nested"]["ProcessInputs"][0] == {
+        "Id": "V3",
+        "Value": "[REDACTED]",
+    }
+    assert payload["processInputs"][0]["value"] == "clear"
+
+
+@pytest.mark.parametrize("value", [False, 0, "", {"nested": "synthetic-value"}, ["synthetic-value"]])
+def test_redaction_masks_entire_non_null_value_without_mutating_source(value):
+    payload = {"ProcessInputs": [{"Id": "V1", "Value": value}], "name": "example"}
+    sess = FakeSession(queue=[FakeResp(200, payload)])
+    result = main.dispatch(
+        "get-schedule", ["--id", "S1", "--redact-process-inputs"],
+        client_builder=_builder(APIKEY, sess),
+    )["result"]
+    assert result == {"ProcessInputs": [{"Id": "V1", "Value": "[REDACTED]"}], "name": "example"}
+    assert payload["ProcessInputs"][0]["Value"] == value
+
+
+def test_projection_does_not_claim_arbitrary_field_sanitization():
+    payload = {"processInputs": ["synthetic-value", None, {"id": "V1"}],
+               "unrelated": "visible-metadata"}
+    sess = FakeSession(queue=[FakeResp(200, payload)])
+    result = main.dispatch(
+        "get-schedule", ["--id", "S1", "--redact-process-inputs"],
+        client_builder=_builder(APIKEY, sess),
+    )["result"]
+    assert result == {"processInputs": ["[REDACTED]", None, {"id": "V1"}],
+                      "unrelated": "visible-metadata"}
+
+
+def test_get_schedule_requires_id():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("get-schedule", [], client_builder=_builder(APIKEY, FakeSession()))
+
+
+# -- create / update --------------------------------------------------------
+
+def test_create_schedule_posts_payload():
+    sess = FakeSession(queue=[FakeResp(200, {"id": "NEW"})])
+    body = '{"name":"nightly","flowId":"P1","isActive":false}'
+    out = main.dispatch("create-schedule", ["--payload", body],
+                        client_builder=_builder(APIKEY, sess))
+    assert out["result"] == {"id": "NEW"}
+    c = _last(sess)
+    assert c["method"] == "POST"
+    assert c["url"].endswith("/api/Schedules")
+    assert c["json"] == {"name": "nightly", "flowId": "P1", "isActive": False}
+
+
+def test_update_schedule_puts_payload():
+    sess = FakeSession(queue=[FakeResp(200, {"ok": True})])
+    body = '{"id":"S1","name":"nightly-v2"}'
+    main.dispatch("update-schedule", ["--payload", body],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "PUT"
+    assert c["url"].endswith("/api/Schedules")
+    assert c["json"] == {"id": "S1", "name": "nightly-v2"}
+
+
+def test_create_schedule_cron_sets_recurrence_block():
+    sess = FakeSession(queue=[FakeResp(200, {"id": "NEW"})])
+    body = '{"name":"nightly","targetProcess":"P1"}'
+    main.dispatch("create-schedule",
+                  ["--payload", body, "--cron", "0 6 * * *", "--timezone", "Europe/Bucharest"],
+                  client_builder=_builder(APIKEY, sess))
+    rec = _last(sess)["json"]["recurrence"]
+    assert rec["recurrence"] == 8              # RecurrenceTypes.CRON
+    assert rec["cronExpression"] == "0 6 * * *"
+    assert rec["timeZone"] == "Europe/Bucharest"
+
+
+def test_create_schedule_cron_drops_the_calendar_recurrence_fields():
+    """This test asserted the OPPOSITE until the designer's own PUT was captured.
+
+    Carrying a calendar field such as `isWeekendExcluded` into a cron recurrence makes the
+    API refuse the whole body with a generic 400 that names no field. The contract is a
+    REPLACEMENT, not an overlay — see tests/test_schedule_cron_shape.py.
+    """
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    body = '{"name":"n","recurrence":{"isWeekendExcluded":true}}'
+    main.dispatch("create-schedule", ["--payload", body, "--cron", "*/5 * * * *"],
+                  client_builder=_builder(APIKEY, sess))
+    rec = _last(sess)["json"]["recurrence"]
+    assert "isWeekendExcluded" not in rec
+    assert rec["recurrence"] == 8
+
+
+def test_create_schedule_without_cron_posts_verbatim():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("create-schedule", ["--payload", '{"name":"n"}'],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["json"] == {"name": "n"}   # no recurrence injected
+
+
+def test_validate_crontab_posts_body():
+    sess = FakeSession(queue=[FakeResp(200, {"occurrences": []})])
+    main.dispatch("validate-crontab",
+                  ["--cron", "0 9 * * 1-5", "--timezone", "UTC", "--count", "3"],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "POST"
+    assert c["url"].endswith("/api/Schedules/validate-crontab")
+    assert c["json"] == {"cronExpression": "0 9 * * 1-5", "timeZone": "UTC", "count": 3}
+
+
+def test_create_schedule_requires_payload():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("create-schedule", [],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+def test_create_schedule_rejects_bad_json():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("create-schedule", ["--payload", "{bad"],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+# -- delete -----------------------------------------------------------------
+
+def test_delete_schedule_uses_id_in_path():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("delete-schedule", ["--id", "S9"],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "DELETE"
+    assert c["url"].endswith("/api/Schedules/S9")
+
+
+# -- enable / disable -------------------------------------------------------
+
+def test_set_status_maps_active_to_enable_query():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("set-schedule-status", ["--id", "S1", "--active", "false"],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "PATCH"
+    assert c["url"].endswith("/api/Schedules/S1/status")
+    assert c["params"] == {"enable": "false"}   # API param is `enable`
+    assert c["json"] is None
+
+
+def test_set_status_active_true():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    main.dispatch("set-schedule-status", ["--id", "S1", "--active", "true"],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["params"] == {"enable": "true"}
+
+
+def test_set_status_rejects_non_bool_active():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("set-schedule-status", ["--id", "S1", "--active", "yes"],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+# -- notifications ----------------------------------------------------------
+
+def test_get_notifications_uses_id_in_path():
+    sess = FakeSession(queue=[FakeResp(200, {"emails": []})])
+    main.dispatch("get-schedule-notifications", ["--id", "S1"],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "GET"
+    assert c["url"].endswith("/api/Schedules/notifications/S1")
+
+
+def test_set_notifications_posts_payload():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    body = '{"scheduleId":"S1","emails":["a@example.com"]}'
+    main.dispatch("set-schedule-notifications", ["--payload", body],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "POST"
+    assert c["url"].endswith("/api/Schedules/notifications")
+    assert c["json"] == {"scheduleId": "S1", "emails": ["a@example.com"]}
+
+
+# -- project schedules ------------------------------------------------------
+
+def test_list_project_schedules_uses_id_in_path():
+    sess = FakeSession(queue=[FakeResp(200, [])])
+    main.dispatch("list-project-schedules", ["--id", "P1"],
+                  client_builder=_builder(APIKEY, sess))
+    c = _last(sess)
+    assert c["method"] == "GET"
+    assert c["url"].endswith("/api/Projects/P1/restricted/schedules")
+
+
+def test_list_project_schedules_requires_id():
+    with pytest.raises(errors.UsageError):
+        main.dispatch("list-project-schedules", [],
+                      client_builder=_builder(APIKEY, FakeSession()))
+
+
+# -- time zone on calendar recurrences (Scheduler v3: rules run on the zone's local clock) --
+
+def test_timezone_is_set_on_a_daily_recurrence():
+    sess = FakeSession(queue=[FakeResp(200, {"id": "NEW"})])
+    body = '{"name":"n","recurrence":{"recurrence":4,"every":1}}'
+    main.dispatch("create-schedule", ["--payload", body, "--timezone", "Europe/Bucharest"],
+                  client_builder=_builder(APIKEY, sess))
+    rec = _last(sess)["json"]["recurrence"]
+    assert rec == {"recurrence": 4, "every": 1, "timeZone": "Europe/Bucharest"}
+
+
+def test_timezone_is_refused_on_a_recurrence_that_ignores_it():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    body = '{"name":"n","recurrence":{"recurrence":2,"every":15}}'
+    with pytest.raises(errors.UsageError, match="no effect"):
+        main.dispatch("update-schedule", ["--payload", body, "--timezone", "UTC"],
+                      client_builder=_builder(APIKEY, sess))
+    assert sess.calls == []
+
+
+def test_a_payload_timezone_is_left_alone_without_the_flag():
+    sess = FakeSession(queue=[FakeResp(200, {})])
+    body = '{"name":"n","recurrence":{"recurrence":5,"timeZone":"Europe/Berlin"}}'
+    main.dispatch("create-schedule", ["--payload", body],
+                  client_builder=_builder(APIKEY, sess))
+    assert _last(sess)["json"]["recurrence"]["timeZone"] == "Europe/Berlin"

procesio_cli/tools/procesio/tests/test_sqlconvert.py

@@ -0,0 +1,234 @@
+"""Execute Command <-> Execute Query family conversion + Output rebinding (flowmodel/sqlparam).
+
+Why this exists: a stored procedure that ends in SELECT returns a RESULT SET, and only the
+`Execute Query` family carries a result set back into a flow variable. `Execute Command` returns
+rows-affected (its Output property is typed `number`), so a Command node pointed at a SELECT-ing
+procedure silently discards everything the procedure returns and reports success. Converting the
+family is the only fix; the conversion is a role-based property-id remap, exactly like the legacy
+template migration, plus the Output setting's designer type.
+"""
+from __future__ import annotations
+
+import copy
+
+import pytest
+
+from tools.procesio.flowmodel import sqlparam as sp
+
+
+def _command_node() -> dict:
+    """A parameterized Execute Command node whose SQL is an EXEC of a SELECT-ing procedure."""
+    sql = "EXEC meet.sp_BookMeeting @MeetingTypeID=@p0, @ClientName=@p1;"
+    bind_runtime = [
+        {"id": 0, "source": {"value": "<%0%>", "variable": [{"id": 0, "variableId": "var-a", "attribute": None}]},
+         "destination": {"value": "p0", "variable": []}},
+        {"id": 1, "source": {"value": "<%1%>", "variable": [{"id": 1, "variableId": "var-b", "attribute": None}]},
+         "destination": {"value": "p1", "variable": []}},
+    ]
+    return {
+        "id": "node-1",
+        "templateId": sp.EC_TEMPLATE_ID,
+        "actionName": "meet.sp_BookMeeting",
+        "actionTemplateName": "Execute Command",
+        "parameters": [
+            {"tabPropertyId": sp.EC_PID_CRED, "variable": [], "value": "cred-1"},
+            {"tabPropertyId": sp.EC_PID_COMMAND, "variable": [], "value": sql},
+            {"tabPropertyId": sp.EC_PID_BIND, "variable": [], "value": bind_runtime},
+            {"tabPropertyId": sp.EC_PID_TIMEOUT, "variable": [], "value": "60"},
+            {"tabPropertyId": sp.EC_PID_OUTPUT,
+             "variable": [{"id": 7, "variableId": "scalar-result", "attribute": None}], "value": "<%7%>"},
+        ],
+        "customData": {
+            "name": "meet.sp_BookMeeting",
+            "description": "Execute a custom SQL Command on the target database.",
+            "icon": "icon-mssql",
+            "configuration": [{
+                "id": "cfg-1", "label": "Execute Command", "orderId": 0,
+                "settings": [
+                    {"id": sp.EC_PID_CRED, "label": "Select Database Server", "type": "credentials",
+                     "value": "cred-1"},
+                    {"id": sp.EC_PID_SIDEPANEL, "label": "Execute Command", "type": "side-pannel", "value": [
+                        {"id": sp.EC_PID_COMMAND, "label": "Command", "type": "code-editor",
+                         "language": "sql", "value": sql},
+                        {"id": sp.EC_PID_BIND, "label": "Parameters config tab", "type": "map-parameters",
+                         "value": [{"id": 0, "destination": "p0", "source": "var-a"},
+                                   {"id": 1, "destination": "p1", "source": "var-b"}]},
+                        {"id": sp.EC_PID_TIMEOUT, "label": "Time Out", "type": "number", "value": "60"},
+                        {"id": sp.EC_PID_OUTPUT, "label": "Output", "type": "number",
+                         "value": "scalar-result"},
+                    ]},
+                ],
+            }],
+        },
+    }
+
+
+def _pid_values(node: dict) -> dict:
+    return {p["tabPropertyId"]: p.get("value") for p in node["parameters"]}
+
+
+def _settings(node: dict) -> dict:
+    """{property id: setting} across the configuration, flattened through the side-pannel."""
+    out = {}
+    for cfg in node["customData"]["configuration"]:
+        for s in cfg["settings"]:
+            out[s["id"]] = s
+            if isinstance(s.get("value"), list):
+                for sub in s["value"]:
+                    if isinstance(sub, dict) and "id" in sub:
+                        out[sub["id"]] = sub
+    return out
+
+
+# --------------------------------------------------------------------------- convert_family
+
+def test_command_to_query_remaps_every_property_id_in_both_layers():
+    node = _command_node()
+    changed, msg = sp.convert_family(node, sp.EQ_TEMPLATE)
+
+    assert changed is True
+    assert "Execute Command -> Execute Query" in msg
+    assert node["templateId"] == sp.EQ_TEMPLATE_ID
+    assert node["actionTemplateName"] == sp.EQ_TEMPLATE
+
+    runtime = _pid_values(node)
+    assert sp.PID_CRED in runtime and sp.EC_PID_CRED not in runtime
+    assert sp.PID_QUERY in runtime and sp.EC_PID_COMMAND not in runtime
+    assert sp.PID_BIND in runtime and sp.EC_PID_BIND not in runtime
+    assert sp.PID_TIMEOUT in runtime and sp.EC_PID_TIMEOUT not in runtime
+    assert sp.PID_OUTPUT in runtime and sp.EC_PID_OUTPUT not in runtime
+
+    settings = _settings(node)
+    assert sp.PID_QUERY in settings and sp.EC_PID_COMMAND not in settings
+    assert sp.PID_BIND in settings and sp.EC_PID_BIND not in settings
+
+
+def test_conversion_preserves_sql_credential_timeout_and_binding():
+    node = _command_node()
+    sql_before = _pid_values(node)[sp.EC_PID_COMMAND]
+    bind_before = copy.deepcopy(_pid_values(node)[sp.EC_PID_BIND])
+
+    sp.convert_family(node, sp.EQ_TEMPLATE)
+
+    runtime = _pid_values(node)
+    assert runtime[sp.PID_QUERY] == sql_before
+    assert runtime[sp.PID_CRED] == "cred-1"
+    assert runtime[sp.PID_TIMEOUT] == "60"
+    assert runtime[sp.PID_BIND] == bind_before, "the @param binding must survive the family change"
+
+
+def test_conversion_relabels_the_designer_so_the_next_reader_is_not_misled():
+    node = _command_node()
+    sp.convert_family(node, sp.EQ_TEMPLATE)
+
+    settings = _settings(node)
+    assert settings[sp.PID_QUERY]["label"] == "Query"
+    assert settings[sp.PID_SIDEPANEL]["label"] == "Execute Query"
+    assert node["customData"]["configuration"][0]["label"] == "Execute Query"
+    assert "Query" in node["customData"]["description"]
+    assert "Command" not in node["customData"]["description"]
+
+
+def test_output_setting_is_retyped_because_a_query_returns_a_result_set_not_a_count():
+    node = _command_node()
+    assert _settings(node)[sp.EC_PID_OUTPUT]["type"] == "number"
+
+    sp.convert_family(node, sp.EQ_TEMPLATE)
+
+    assert _settings(node)[sp.PID_OUTPUT]["type"] == "any"
+
+
+def test_query_to_command_is_the_exact_inverse():
+    node = _command_node()
+    original = copy.deepcopy(node)
+
+    sp.convert_family(node, sp.EQ_TEMPLATE)
+    sp.convert_family(node, sp.EC_TEMPLATE)
+
+    assert node["templateId"] == original["templateId"]
+    assert _pid_values(node) == _pid_values(original)
+    assert _settings(node)[sp.EC_PID_OUTPUT]["type"] == "number"
+
+
+def test_converting_to_the_family_it_is_already_on_is_a_no_op():
+    node = _command_node()
+    before = copy.deepcopy(node)
+
+    changed, msg = sp.convert_family(node, sp.EC_TEMPLATE)
+
+    assert changed is False
+    assert "already" in msg
+    assert node == before
+
+
+def test_a_node_on_a_deprecated_template_is_refused_rather_than_half_converted():
+    node = _command_node()
+    node["templateId"] = "c2760ff2-cd9e-49b4-b751-c05c88e06dac"   # Execute Command V1
+    before = copy.deepcopy(node)
+
+    changed, msg = sp.convert_family(node, sp.EQ_TEMPLATE)
+
+    assert changed is False
+    assert "deprecated" in msg
+    assert node == before, "a refused conversion must not leave the node partly remapped"
+
+
+def test_a_non_sql_node_is_refused():
+    node = {"actionTemplateName": "Node", "templateId": "whatever", "parameters": [], "customData": {}}
+    changed, msg = sp.convert_family(node, sp.EQ_TEMPLATE)
+    assert changed is False
+    assert "SQL" in msg
+
+
+def test_an_unknown_target_family_raises_rather_than_silently_doing_nothing():
+    with pytest.raises(ValueError):
+        sp.convert_family(_command_node(), "Execute Something")
+
+
+# --------------------------------------------------------------------------- rebind_output
+
+def test_rebind_output_moves_both_layers_to_the_new_variable():
+    node = _command_node()
+    sp.convert_family(node, sp.EQ_TEMPLATE)
+
+    changed, _ = sp.rebind_output(node, "resultset-var")
+
+    assert changed is True
+    out = next(p for p in node["parameters"] if p["tabPropertyId"] == sp.PID_OUTPUT)
+    assert out["variable"][0]["variableId"] == "resultset-var"
+    assert _settings(node)[sp.PID_OUTPUT]["value"] == "resultset-var"
+
+
+def test_rebind_output_keeps_the_positional_slot_so_it_cannot_collide_with_a_param_bind():
+    node = _command_node()
+    sp.convert_family(node, sp.EQ_TEMPLATE)
+    slot_before = next(p for p in node["parameters"] if p["tabPropertyId"] == sp.PID_OUTPUT)["value"]
+
+    sp.rebind_output(node, "resultset-var")
+
+    out = next(p for p in node["parameters"] if p["tabPropertyId"] == sp.PID_OUTPUT)
+    assert out["value"] == slot_before == "<%7%>"
+    bound = {b["source"]["value"] for b in _pid_values(node)[sp.PID_BIND]}
+    assert out["value"] not in bound
+
+
+def test_rebind_output_to_the_same_variable_reports_no_change():
+    node = _command_node()
+    changed, msg = sp.rebind_output(node, "scalar-result")
+    assert changed is False
+    assert "already" in msg
+
+
+def test_rebind_output_seeds_the_binding_when_the_node_has_none():
+    node = _command_node()
+    out = next(p for p in node["parameters"] if p["tabPropertyId"] == sp.EC_PID_OUTPUT)
+    out["variable"] = []
+    out["value"] = None
+
+    changed, _ = sp.rebind_output(node, "fresh-var")
+
+    assert changed is True
+    out = next(p for p in node["parameters"] if p["tabPropertyId"] == sp.EC_PID_OUTPUT)
+    assert out["variable"][0]["variableId"] == "fresh-var"
+    # the slot must sit past every @param bind index, or the engine reads the wrong value
+    assert out["value"] == "<%2%>"