Spaces:
Running
Running
Download tests/test_compiler.py from warenterprise/trace2mcp: direct link, hf CLI and curl.
- Browser
- Download file 12 kB
-
https://huggingface.co/spaces/warenterprise/trace2mcp/resolve/main/tests/test_compiler.py
- Command line
-
hf download hf://spaces/warenterprise/trace2mcp/tests/test_compiler.py
-
curl -L -o test_compiler.py https://huggingface.co/spaces/warenterprise/trace2mcp/resolve/main/tests/test_compiler.py
12 kB
| import json | |
| import time | |
| from pathlib import Path | |
| import pytest | |
| from trace2mcp.codegen import generate_handlers_py, generate_project, generate_server_py | |
| from trace2mcp.compiler import compile_trace, topological_layers | |
| from trace2mcp.models import ( | |
| CycleError, | |
| Reference, | |
| Trace, | |
| TraceEvent, | |
| UnsafeTraceError, | |
| WorkflowNode, | |
| ) | |
| from trace2mcp.parsers import parse_sts_jsonl, parse_trace | |
| def event( | |
| event_id, | |
| tool, | |
| arguments, | |
| result, | |
| *, | |
| status="success", | |
| side_effect="read", | |
| idempotency="unknown", | |
| ): | |
| return TraceEvent( | |
| id=event_id, | |
| tool=tool, | |
| arguments=arguments, | |
| result=result, | |
| status=status, | |
| side_effect=side_effect, | |
| idempotency=idempotency, | |
| ) | |
| def test_compiler_infers_inputs_dependencies_and_ignores_failures(): | |
| trace = Trace( | |
| inputs={"company": "OpenAI", "options": {"limit": 3}}, | |
| events=[ | |
| event("failed", "search", {"q": "bad"}, None, status="error"), | |
| event("profile", "company", {"name": "OpenAI"}, {"company_id": 42}), | |
| event("news", "news", {"company_id": 42, "limit": 3}, ["launch"]), | |
| ], | |
| ) | |
| workflow = compile_trace(trace, name="company_report") | |
| assert [node.id for node in workflow.nodes] == ["profile", "news"] | |
| assert workflow.ignored_failed_events == ("failed",) | |
| assert workflow.nodes[0].arguments["name"] == Reference("input", ("company",)) | |
| assert workflow.nodes[1].arguments["limit"] == Reference("input", ("options", "limit")) | |
| assert workflow.nodes[1].arguments["company_id"] == Reference( | |
| "node", ("company_id",), node_id="profile" | |
| ) | |
| assert workflow.nodes[1].depends_on == ("profile",) | |
| assert topological_layers(workflow.nodes) == [["profile"], ["news"]] | |
| def test_compiler_deduplicates_only_identical_reads_and_redirects_edges(): | |
| trace = Trace( | |
| inputs={"query": "agents"}, | |
| events=[ | |
| event( | |
| "first", | |
| "search", | |
| {"q": "agents"}, | |
| {"result_id": 7}, | |
| idempotency="idempotent", | |
| ), | |
| event( | |
| "duplicate", | |
| "search", | |
| {"q": "agents"}, | |
| {"result_id": 7}, | |
| idempotency="idempotent", | |
| ), | |
| event("detail", "fetch", {"id": 7}, {"title": "A"}), | |
| ], | |
| ) | |
| workflow = compile_trace(trace) | |
| assert [node.id for node in workflow.nodes] == ["first", "detail"] | |
| assert workflow.deduplicated_events == {"duplicate": "first"} | |
| detail = workflow.nodes[-1] | |
| assert detail.depends_on == ("first",) | |
| assert detail.arguments["id"].node_id == "first" | |
| def test_mutable_reads_are_not_deduplicated_without_explicit_idempotency(): | |
| workflow = compile_trace( | |
| Trace( | |
| inputs={}, | |
| events=[ | |
| event("first", "clock", {}, "10:00"), | |
| event("second", "clock", {}, "10:01"), | |
| ], | |
| ) | |
| ) | |
| assert [node.id for node in workflow.nodes] == ["first", "second"] | |
| assert workflow.deduplicated_events == {} | |
| def test_explicit_dependencies_are_preserved_without_value_flow(): | |
| trace = Trace( | |
| inputs={}, | |
| events=[ | |
| TraceEvent("first", "prepare", {}, "ready", side_effect="read"), | |
| TraceEvent( | |
| "second", | |
| "consume", | |
| {"mode": "fixed"}, | |
| "done", | |
| side_effect="read", | |
| dependencies=("first",), | |
| ), | |
| ], | |
| ) | |
| workflow = compile_trace(trace) | |
| assert workflow.nodes[1].depends_on == ("first",) | |
| assert workflow.nodes[1].inference["dependencies"]["first"] == ("explicit trace dependency") | |
| def test_identical_values_from_multiple_producers_are_not_guessed(): | |
| workflow = compile_trace( | |
| Trace( | |
| inputs={}, | |
| events=[ | |
| event("a", "one", {}, {"value": 0}), | |
| event("b", "two", {}, {"value": 0}), | |
| event("c", "use", {"value": 0}, "done"), | |
| ], | |
| ) | |
| ) | |
| assert workflow.nodes[2].arguments["value"] == 0 | |
| assert workflow.nodes[2].depends_on == () | |
| def test_composite_results_create_dependency_on_the_whole_result(): | |
| profile = {"name": "OpenAI", "facts": ["AI lab"]} | |
| workflow = compile_trace( | |
| Trace( | |
| inputs={}, | |
| events=[ | |
| event("profile", "profile", {}, profile), | |
| event("report", "report", {"profile": profile}, "done"), | |
| ], | |
| ) | |
| ) | |
| report = workflow.nodes[1] | |
| assert report.arguments["profile"] == Reference("node", (), node_id="profile") | |
| assert report.depends_on == ("profile",) | |
| def test_writes_are_never_deduplicated_and_require_explicit_opt_in(): | |
| trace = Trace( | |
| inputs={}, | |
| events=[ | |
| event("w1", "send", {"body": "hello"}, {"ok": True}, side_effect="write"), | |
| event("w2", "send", {"body": "hello"}, {"ok": True}, side_effect="write"), | |
| ], | |
| ) | |
| with pytest.raises(UnsafeTraceError, match=r"w1\(write\)"): | |
| compile_trace(trace) | |
| workflow = compile_trace(trace, allow_side_effects=True) | |
| assert workflow.safety == "unsafe" | |
| assert [node.id for node in workflow.nodes] == ["w1", "w2"] | |
| assert workflow.deduplicated_events == {} | |
| def test_cycle_detection_is_explicit(): | |
| nodes = [ | |
| WorkflowNode("a", "one", {}, ("b",)), | |
| WorkflowNode("b", "two", {}, ("a",)), | |
| ] | |
| with pytest.raises(CycleError, match="cycle"): | |
| topological_layers(nodes) | |
| def test_workflow_serialization_round_trip_preserves_references(): | |
| workflow = compile_trace( | |
| Trace( | |
| inputs={"q": "hello"}, | |
| events=[event("a", "search", {"q": "hello"}, {"id": "r1"})], | |
| ) | |
| ) | |
| encoded = workflow.to_dict() | |
| assert encoded["nodes"][0]["arguments"]["q"] == {"$ref": "inputs.q"} | |
| assert type(workflow).from_dict(encoded).nodes[0].arguments["q"] == Reference("input", ("q",)) | |
| def test_reference_serialization_round_trips_dotted_keys(): | |
| reference = Reference("input", ("company.name", "items[0]")) | |
| assert reference.to_dict() == {"$ref": "inputs.company%2Ename.items%5B0%5D"} | |
| node = WorkflowNode("a", "echo", {"value": reference}) | |
| assert WorkflowNode.from_dict(node.to_dict()).arguments["value"] == reference | |
| def test_official_hugging_face_sts_envelope_is_detected(): | |
| content = "\n".join( | |
| [ | |
| json.dumps({"type": "session", "metadata": {"inputs": {"q": "weather"}}}), | |
| json.dumps( | |
| { | |
| "type": "message", | |
| "message": { | |
| "role": "assistant", | |
| "timestamp": "2026-08-24T00:00:00Z", | |
| "toolCalls": [ | |
| { | |
| "id": "call-1", | |
| "function": { | |
| "name": "search", | |
| "arguments": json.dumps({"q": "weather"}), | |
| }, | |
| "metadata": {"side_effect": "read"}, | |
| } | |
| ], | |
| }, | |
| } | |
| ), | |
| json.dumps( | |
| { | |
| "type": "message", | |
| "message": { | |
| "role": "tool", | |
| "toolCallId": "call-1", | |
| "content": json.dumps({"temperature": 20}), | |
| }, | |
| } | |
| ), | |
| ] | |
| ) | |
| trace = parse_sts_jsonl(content) | |
| assert trace.inputs == {"q": "weather"} | |
| assert len(trace.events) == 1 | |
| assert trace.events[0].tool == "search" | |
| assert trace.events[0].arguments == {"q": "weather"} | |
| assert trace.events[0].result == {"temperature": 20} | |
| assert trace.events[0].side_effect == "read" | |
| assert parse_trace(content).events[0].id == "call-1" | |
| def test_codegen_never_embeds_trace_values_as_executable_source(): | |
| workflow = compile_trace( | |
| Trace( | |
| inputs={}, | |
| events=[event("a", "search'); __import__('os').system('bad') #", {}, {})], | |
| ) | |
| ) | |
| generated = generate_handlers_py(workflow) | |
| compile(generated, "handlers.py", "exec") | |
| assert "async def search___import___os_system_bad" in generated | |
| assert "raise NotImplementedError" in generated | |
| def test_generated_server_targets_current_mcp_sdk_v2(): | |
| workflow = compile_trace(Trace(inputs={}, events=[event("a", "search", {}, {"ok": True})])) | |
| generated = generate_server_py(workflow) | |
| assert "from mcp.server import MCPServer" in generated | |
| assert "MCP = MCPServer(" in generated | |
| assert "mcp.server.fastmcp" not in generated | |
| workflow.name = 'workflow"""; raise RuntimeError("injected") #' | |
| compile(generate_server_py(workflow), "server.py", "exec") | |
| def test_codegen_writes_manifest_test_and_preserves_reviewed_handlers(tmp_path: Path): | |
| workflow = compile_trace( | |
| Trace( | |
| inputs={"customer_id": 7}, | |
| events=[event("a", "lookup", {"customer_id": 7}, {"name": "A"})], | |
| ), | |
| name="customer_report", | |
| ) | |
| generated = generate_project(workflow, tmp_path) | |
| assert {"contracts", "manifest", "provenance", "frozen_test"} <= set(generated) | |
| manifest = json.loads((tmp_path / "manifest.json").read_text(encoding="utf-8")) | |
| assert manifest["workflow_hash"] == workflow.workflow_hash | |
| assert manifest["contracts"] == "contracts.py" | |
| assert manifest["contract_review_required"] is True | |
| assert manifest["runtime_guard"] == { | |
| "default": "disabled", | |
| "provider": "hol_guard_cli", | |
| "enable_with": "TRACE2MCP_HOL_GUARD_EXECUTABLE", | |
| } | |
| server = (tmp_path / "server.py").read_text(encoding="utf-8") | |
| assert "customer_id: int" in server | |
| assert "return result.output" in server | |
| assert "require_contracts=True" in server | |
| assert "require_reviewed_contracts=True" in server | |
| contracts = (tmp_path / "contracts.py").read_text(encoding="utf-8") | |
| assert "reviewed=False" in contracts | |
| reviewed = "# reviewed handler\n" | |
| reviewed_contracts = "# reviewed contracts\n" | |
| (tmp_path / "handlers.py").write_text(reviewed, encoding="utf-8") | |
| (tmp_path / "contracts.py").write_text(reviewed_contracts, encoding="utf-8") | |
| generate_project(workflow, tmp_path) | |
| assert (tmp_path / "handlers.py").read_text(encoding="utf-8") == reviewed | |
| assert (tmp_path / "contracts.py").read_text(encoding="utf-8") == reviewed_contracts | |
| generate_project(workflow, tmp_path, force_handlers=True) | |
| assert "NotImplementedError" in (tmp_path / "handlers.py").read_text(encoding="utf-8") | |
| def test_python_compiler_matches_static_golden_graph(): | |
| root = Path(__file__).resolve().parents[1] | |
| trace = parse_trace((root / "examples" / "sample_trace.json").read_text(encoding="utf-8")) | |
| golden = json.loads( | |
| (root / "tests" / "golden" / "sample_graph.json").read_text(encoding="utf-8") | |
| ) | |
| workflow = compile_trace(trace) | |
| assert [node.id for node in workflow.nodes] == golden["nodes"] | |
| assert {node.id: list(node.depends_on) for node in workflow.nodes} == golden["dependencies"] | |
| assert topological_layers(workflow.nodes) == golden["layers"] | |
| assert workflow.output_schema == workflow.nodes[-1].output_schema | |
| def test_compiler_handles_one_thousand_independent_nodes_without_quadratic_regression(): | |
| trace = Trace( | |
| inputs={}, | |
| events=[event(str(index), "noop", {}, index, side_effect="pure") for index in range(1000)], | |
| ) | |
| started = time.perf_counter() | |
| workflow = compile_trace(trace) | |
| elapsed = time.perf_counter() - started | |
| assert len(workflow.nodes) == 1000 | |
| assert topological_layers(workflow.nodes) == [[str(index) for index in range(1000)]] | |
| assert elapsed < 5.0 | |