auto / tests /test_dec010_runtime_and_codegen_parity.py
rsnarsna
feat(alli-backend): Wave-1 standardization, standalone sys.env node & vault crypto, and DEC-014 security hardening
8628c98
Raw History Blame Contribute Delete
14.1 kB
"""DEC-010 Track A: Runtime Dispatch, Node Parity, and Scoped Control-Flow Parity Tests."""
import ast
import io
import json
import subprocess
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent.parent))
from lambdas.codegen_handler import generate_code_logic
from language_core import workflow_executor
from language_core.node_schema import CANONICAL_NODE_COUNT
from language_core.executor import node_dispatch
from language_core.nodes import nodes_data, nodes_files, nodes_io, nodes_math, nodes_oop, nodes_structured_data
from language_core.workflow_executor import execute_workflow_graph
def _run_py(code: str, stdin_text: str | None = "") -> str:
ast.parse(code)
p = subprocess.run([sys.executable, "-c", code], input=stdin_text, capture_output=True, text=True, timeout=10, check=True)
return p.stdout.strip()
def test_canonical_count_and_zero_eval():
assert CANONICAL_NODE_COUNT == 47
oop_path = Path(__file__).parent.parent / "language_core" / "nodes" / "nodes_oop.py"
tree = ast.parse(oop_path.read_text(encoding="utf-8"))
eval_calls = [n for n in ast.walk(tree) if isinstance(n, ast.Call) and isinstance(n.func, ast.Name) and n.func.id == "eval"]
assert eval_calls == []
def test_dispatch_priority_hooks_and_settings(monkeypatch):
monkeypatch.setattr(workflow_executor, "_execute_variable_node", lambda d, p: {"hooked": True, "val": p.get("var_name")}, raising=False)
out_var = node_dispatch.dispatch_node_handler({}, {"var_name": "alpha"}, "core.variable", "n_var", "Var", None, {}, {"var_name": "alpha"}, {}, 5.0, [])
assert out_var == {"hooked": True, "val": "alpha"}
out_cat = node_dispatch.dispatch_node_handler({}, {"text": "alli", "operation": "upper"}, "cat_strings_collections", "n_cat", "Str", None, {}, {"text": "alli", "operation": "upper"}, {}, 5.0, [])
assert out_cat["result"] == "ALLI"
out_reg = node_dispatch.dispatch_node_handler({}, {}, "math.sqrt", "n_sqrt", "Sqrt", None, {"x": 25}, {"x": 25}, {}, 5.0, [])
assert out_reg["result"] == 5.0
try:
node_dispatch.dispatch_node_handler({}, {}, "control.for_loop", "n_for", "For", None, {"iterable": [1, 2, 3, 4]}, {"iterable": [1, 2, 3, 4]}, {"max_iterations": 2}, 5.0, [])
raise AssertionError("Expected overflow")
except Exception as exc:
assert "ERR-LOOP-OVERFLOW" in str(exc)
def test_math_domain_and_io_nontty_parity(monkeypatch):
try:
nodes_math._exec_math_sqrt({"x": -4}, {})
raise AssertionError("Expected math domain error")
except ValueError as exc:
assert "math domain error" in str(exc)
assert not str(exc).endswith("math domain error.")
monkeypatch.setattr(sys, "stdin", type("FakeTTY", (), {"isatty": staticmethod(lambda: False)})())
rt = nodes_io._exec_io_input({}, {"prompt": "Age: ", "default_value": 21, "input_type": "int"})
assert rt["value"] == 21
graph = {
"nodes": [
{"id": "n1", "node_type": "io.input", "data": {"prompt": "Enter float: ", "default_value": 3.5, "input_type": "float"}},
{"id": "n2", "node_type": "io.print", "data": {"prefix": ""}},
],
"edges": [{"source": "n1", "target": "n2", "source_handle": "value", "target_handle": "value"}],
}
cg = generate_code_logic(nodes=graph["nodes"], edges=graph["edges"], graph_name="InputNonTTY")
assert cg["success"] and _run_py(cg["python_code"]) == "3.5"
def test_safe_literal_collection_and_file_aliases(tmp_path, monkeypatch):
s_out = nodes_data._exec_data_set({}, {"initial_elements": '["a", "b"]', "operation": "add", "add_item": "c"})
assert s_out["count"] == 3 and set(s_out["result"]) == {"a", "b", "c"}
t_out = nodes_data._exec_data_tuple({}, {"items": "[10, 20, 30]"})
assert t_out["count"] == 3 and t_out["result"] == (10, 20, 30)
c_out = nodes_structured_data._exec_csv_stringify({}, {"rows": '[{"name":"Ada","score":99}]', "headers": '["name","score"]'})
assert "Ada,99" in (c_out.get("text") or c_out.get("csv_string") or c_out.get("csv") or c_out["result"])
h_res = nodes_io._exec_api_http_request({"headers": '{"Authorization": "Bearer t"}'}, {"url": "https://example.com"})
assert h_res["status_code"] == 200
http_cg = generate_code_logic(
nodes=[{"id": "h1", "node_type": "api.http_request", "data": {"url": "https://example.com", "headers": '{"Authorization": "Bearer t"}'}}],
edges=[],
graph_name="HttpHdr",
)
assert http_cg["success"] and "ast.literal_eval(" in http_cg["python_code"] and "Authorization" in http_cg["python_code"]
ast.parse(http_cg["python_code"])
monkeypatch.setenv("ALLI_SANDBOX_DIR", str(tmp_path))
w_out = nodes_files._exec_file_write({"data": "hello alli"}, {"file_path": "note.txt"})
assert w_out["success"] and (tmp_path / "note.txt").read_text() == "hello alli"
try:
nodes_files._exec_file_write({"content": "bad"}, {"file_path": "../escape.txt"})
raise AssertionError("Traversal must fail")
except Exception as exc:
assert "SEC-001" in str(exc) or "Security" in str(exc)
def test_oop_signature_method_ops_and_do_while_parity():
cls_res = nodes_oop._exec_oop_class_def({}, {"class_name": "Dog", "attributes": "name='Rex', score=0"})
inst_res = nodes_oop._exec_oop_instance({"class_in": cls_res["class_ref"]}, {"class_name": "Dog"})
assert inst_res["instance"]["name"] == "Rex"
m1 = nodes_oop._exec_oop_method_call({"instance_in": inst_res["instance"], "arg": 5}, {"operation": "set_attr", "attribute_to_modify": "score"})
assert m1["result"] == 5
nodes = [
{"id": "w1", "node_type": "control.while_loop", "data": {"initial_value": 10.0, "operator": "<", "compare_value": 5.0, "step": 1.0, "loop_mode": "do_while"}},
{"id": "p1", "node_type": "io.print", "data": {"prefix": ""}},
]
edges = [{"source": "w1", "target": "p1", "source_handle": "final_value", "target_handle": "value"}]
rt = execute_workflow_graph({"nodes": nodes, "edges": edges})
assert rt["success"] and rt["node_results"]["w1"]["outputs"]["iterations"] == 1
cg = generate_code_logic(nodes=nodes, edges=edges, graph_name="DoWhile")
assert cg["success"] and _run_py(cg["python_code"]) == rt["stdout"].strip() == "11.0"
def test_scoped_if_else_diamond_parity():
for cond_val, exp_out, skip_id in ((True, "15", "f_op"), (False, "105", "t_op")):
nodes = [
{"id": "c_cond", "node_type": "constant.bool", "data": {"value": cond_val}},
{"id": "if_1", "node_type": "control.if_else", "data": {"then_val": 5, "else_val": 5}},
{"id": "t_op", "node_type": "core.binary_op", "data": {"operator": "+", "b": 10}},
{"id": "f_op", "node_type": "core.binary_op", "data": {"operator": "+", "b": 100}},
{"id": "merge_n", "node_type": "core.binary_op", "data": {"operator": "+", "a": 0, "b": 0}},
{"id": "p_out", "node_type": "io.print", "data": {"prefix": ""}},
]
edges = [
{"source": "c_cond", "target": "if_1", "source_handle": "val", "target_handle": "condition"},
{"source": "if_1", "target": "t_op", "source_handle": "then", "target_handle": "a"},
{"source": "if_1", "target": "f_op", "source_handle": "else", "target_handle": "a"},
{"source": "t_op", "target": "merge_n", "source_handle": "result", "target_handle": "a"},
{"source": "f_op", "target": "merge_n", "source_handle": "result", "target_handle": "b"},
{"source": "merge_n", "target": "p_out", "source_handle": "result", "target_handle": "value"},
]
rt = execute_workflow_graph({"nodes": nodes, "edges": edges})
assert rt["success"] and rt["stdout"].strip() == exp_out
assert rt["node_results"][skip_id]["status"] == "skipped"
cg = generate_code_logic(nodes=nodes, edges=edges, graph_name=f"If_{cond_val}")
assert cg["success"] and _run_py(cg["python_code"]) == exp_out
def test_scoped_for_loop_with_break_parity():
nodes = [
{"id": "l1", "node_type": "control.for_loop", "data": {"iterable": "[1, 2, 3, 4]"}},
{"id": "p_item", "node_type": "io.print", "data": {"prefix": ""}},
{"id": "cmp1", "node_type": "core.compare", "data": {"operator": "==", "b": 3}},
{"id": "brk1", "node_type": "control.loop_control", "data": {"action": "break"}},
]
edges = [
{"source": "l1", "target": "p_item", "source_handle": "body", "target_handle": "value"},
{"source": "p_item", "target": "cmp1", "source_handle": "out", "target_handle": "a"},
{"source": "cmp1", "target": "brk1", "source_handle": "result", "target_handle": "condition"},
]
rt = execute_workflow_graph({"nodes": nodes, "edges": edges})
assert rt["success"]
cg = generate_code_logic(nodes=nodes, edges=edges, graph_name="LoopBreak")
assert cg["success"]
assert rt["stdout"].strip() == _run_py(cg["python_code"])
assert _run_py(cg["python_code"]).splitlines() == ["1", "2", "3"]
def test_scoped_try_except_upstream_zero_div_parity():
nodes = [
{"id": "c_num", "node_type": "constant.int", "data": {"value": 10}},
{"id": "c_zero", "node_type": "constant.int", "data": {"value": 0}},
{"id": "div_op", "node_type": "core.binary_op", "data": {"operator": "/"}},
{"id": "try_n", "node_type": "control.try_except", "data": {"default_fallback": 999}},
{"id": "p_res", "node_type": "io.print", "data": {"prefix": ""}},
]
edges = [
{"source": "c_num", "target": "div_op", "source_handle": "val", "target_handle": "a"},
{"source": "c_zero", "target": "div_op", "source_handle": "val", "target_handle": "b"},
{"source": "div_op", "target": "try_n", "source_handle": "result", "target_handle": "try_val"},
{"source": "try_n", "target": "p_res", "source_handle": "result", "target_handle": "value"},
]
rt = execute_workflow_graph({"nodes": nodes, "edges": edges})
assert rt["success"]
assert rt["node_results"]["try_n"]["outputs"]["has_error"] is True
assert rt["stdout"].strip() == "999"
cg = generate_code_logic(nodes=nodes, edges=edges, graph_name="TryUpstreamZero")
assert cg["success"] and _run_py(cg["python_code"]) == "999"
def test_scoped_while_body_and_for_continue_parity():
w_nodes = [
{"id": "w1", "node_type": "control.while_loop", "data": {"initial_value": 0, "operator": "<", "compare_value": 3, "step": 1}},
{"id": "p_iter", "node_type": "io.print", "data": {"prefix": ""}},
{"id": "p_done", "node_type": "io.print", "data": {"prefix": "done:"}},
]
w_edges = [
{"source": "w1", "target": "p_iter", "source_handle": "body", "target_handle": "exec"},
{"source": "w1", "target": "p_iter", "source_handle": "final_value", "target_handle": "value"},
{"source": "w1", "target": "p_done", "source_handle": "done", "target_handle": "exec"},
{"source": "w1", "target": "p_done", "source_handle": "final_value", "target_handle": "value"},
]
rt_w = execute_workflow_graph({"nodes": w_nodes, "edges": w_edges})
cg_w = generate_code_logic(nodes=w_nodes, edges=w_edges, graph_name="WhileBodyDone")
assert rt_w["success"] and cg_w["success"]
assert rt_w["stdout"].strip() == _run_py(cg_w["python_code"]) == "0\n1\n2\ndone: 3"
f_nodes = [
{"id": "f1", "node_type": "control.for_loop", "data": {"iterable": "[1, 2, 3]"}},
{"id": "a_cmp", "node_type": "core.compare", "data": {"operator": "==", "b": 2}},
{"id": "if_loop", "node_type": "control.if_else", "data": {"then_val": True, "else_val": False}},
{"id": "b_cont", "node_type": "control.loop_control", "data": {"action": "continue"}},
{"id": "c_print", "node_type": "io.print", "data": {"prefix": ""}},
]
f_edges = [
{"source": "f1", "target": "a_cmp", "source_handle": "body", "target_handle": "a"},
{"source": "a_cmp", "target": "if_loop", "source_handle": "result", "target_handle": "condition"},
{"source": "if_loop", "target": "b_cont", "source_handle": "then", "target_handle": "condition"},
{"source": "if_loop", "target": "c_print", "source_handle": "false", "target_handle": "exec"},
{"source": "f1", "target": "c_print", "source_handle": "body", "target_handle": "value"},
]
rt_f = execute_workflow_graph({"nodes": f_nodes, "edges": f_edges})
cg_f = generate_code_logic(nodes=f_nodes, edges=f_edges, graph_name="ForContinue")
assert rt_f["success"] and cg_f["success"]
assert rt_f["stdout"].strip() == _run_py(cg_f["python_code"]) == "1\n3"
def test_input_transform_math_alias_fallback_and_do_while_parity():
from lambdas.validate_handler import validate_workflow_protocol_logic
from language_core.input_transforms import get_effective_transform_type
assert get_effective_transform_type({"math_op": "add", "math_operand": "3"}) == "int"
nodes = [
{"id": "dw", "node_type": "control.while_loop", "data": {
"loop_variant": "do_while", "operator": "<", "compare_value": 5, "step": 1,
"_input_transforms": {"initial_value": {"fallback": "5", "math_op": "add", "math_operand": "3"}},
}},
{"id": "p", "node_type": "io.print", "data": {"prefix": "dw:"}},
]
edges = [{"source": "dw", "target": "p", "source_handle": "body", "target_handle": "exec"},
{"source": "dw", "target": "p", "source_handle": "final_value", "target_handle": "value"}]
val_res = validate_workflow_protocol_logic({"nodes": nodes, "edges": edges})
assert val_res["valid"] and not val_res.get("errors"), val_res
rt = execute_workflow_graph({"nodes": nodes, "edges": edges})
cg = generate_code_logic(nodes=nodes, edges=edges, graph_name="DoWhileTransform")
assert rt["success"] and cg["success"]
assert rt["node_results"]["dw"]["outputs"]["iteration_count"] == 1
assert rt["stdout"].strip() == _run_py(cg["python_code"]) == "dw: 8"