rsnarsna
feat(alli-backend): Wave-1 standardization, standalone sys.env node & vault crypto, and DEC-014 security hardening
8628c98 Download tests/test_dec010_runtime_and_codegen_parity.py from Rsnarsna/auto: direct link, hf CLI and curl.
- Browser
- Download file 14.1 kB
-
https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/tests/test_dec010_runtime_and_codegen_parity.py
- Command line
-
hf download hf://spaces/Rsnarsna/auto/tests/test_dec010_runtime_and_codegen_parity.py
-
curl -L -o test_dec010_runtime_and_codegen_parity.py https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/tests/test_dec010_runtime_and_codegen_parity.py
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" | |