Ryth Azhur
3aafec6dd4
The IR called them react-message and django-message, so a FastAPI channel had to declare a DjangoMessage. They are client-message and server-message now, and the direction words hold wherever a channel is declared: Params / ClientMessage / ServerMessage, with mizan-core deriving <Pascal>Params and friends so no backend names a type itself. Django's ReactChannel and FastAPI's ReactChannel are both Channel. mizan-fastapi never registered a channels extension, so build_ir() emitted no channel at all and every payload type was invisible to codegen. It registers one now. RegistryExtension is an ABC requiring all(), which is what the IR reads — an extension that cannot enumerate its registrations no longer exists. The gate that should have caught the rename could not: tests/afi registered no channel because mizan-rust had no channel registry to register one in, so a five-package rename of the wire contract passed byte-parity without a channel byte crossing it. mizan-rust grows ChannelSlotKind, a CHANNELS slice, a #[mizan::channel] macro, and KDL emission whose wire_to_pascal matches Python's split; the AFI fixture now carries a channel with every slot and one with a single slot, so all three backends prove the contract byte for byte. MizanChannel held three Option<String> beside three has_*() predicates and unwrapped them with defaults; it holds an ordered slot vector, so an absent slot is absent rather than defaulted. The channels target emitted a React hooks file that a stage1-only consumer could not compile — react emits that now. The codegen's parity tests byte-compared emitted source against baselines without ever compiling it: they compile the generated crate and run its tests, import the generated Python package and call every method, and typecheck each TypeScript target against a consumer. Also fixed at source: app_visitor printed its import diagnostic to stdout, the stream export_mizan_ir writes KDL to, so a failed import silently corrupted the IR; the apps root was hardcoded to "apps"; _default_literal crashed build_ir on any non-JSON-serializable field default; Django and mizan-core derived Pascal names two different ways, disagreeing on every dotted channel name. ir.py builds a document and renders templates/ir/document.kdl.j2 rather than appending KDL strings with hand-tracked indentation, and named types resolve to a fixed point — a model reachable only through a union branch was referenced by a ref that no type block ever defined. The rest is the write-gate's own classifiers run over the standing tree: relative imports, silent swallows, Protocol contracts that should be ABCs, emitters hand-rendering target source, catch-all arms over closed enums, and comments narrating the project rather than the code. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
107 lines
2.8 KiB
Python
107 lines
2.8 KiB
Python
"""Byte-equivalence of the Mizan IR (KDL) that mizan-django, mizan-fastapi,
|
|
and the Rust mizan-axum backend emit for one shared fixture.
|
|
|
|
Each adapter is reached the way its own runtime reaches it: Django through
|
|
its management command in a subprocess, FastAPI in-process against a cleared
|
|
registry, Rust through the `export-ir` bin.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
|
|
HERE = Path(__file__).parent
|
|
DJANGO_MANAGE = HERE / "django_app" / "manage.py"
|
|
RUST_APP_DIR = HERE / "rust_app"
|
|
|
|
|
|
def _fetch_django_ir() -> str:
|
|
result = subprocess.run(
|
|
[sys.executable, str(DJANGO_MANAGE), "export_mizan_ir"],
|
|
capture_output=True,
|
|
text=True,
|
|
check=False,
|
|
env={**os.environ, "PYTHONDONTWRITEBYTECODE": "1"},
|
|
)
|
|
if result.returncode != 0:
|
|
pytest.fail(
|
|
f"export_mizan_ir failed:\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}",
|
|
)
|
|
return result.stdout
|
|
|
|
|
|
def _fetch_fastapi_ir() -> str:
|
|
# tests/afi/ must be importable for `fixture` and `fastapi_app` to resolve.
|
|
sys.path.insert(0, str(HERE))
|
|
try:
|
|
from mizan_core.registry import clear_registry
|
|
from mizan_core.ir import build_ir
|
|
from fastapi_app import make_app
|
|
|
|
clear_registry()
|
|
make_app()
|
|
return build_ir()
|
|
finally:
|
|
sys.path.remove(str(HERE))
|
|
|
|
|
|
def _fetch_rust_ir() -> str:
|
|
result = subprocess.run(
|
|
[
|
|
"cargo", "run",
|
|
"--quiet", "--release",
|
|
"--manifest-path", str(RUST_APP_DIR / "Cargo.toml"),
|
|
"--bin", "export-ir",
|
|
],
|
|
capture_output=True,
|
|
text=True,
|
|
check=False,
|
|
)
|
|
if result.returncode != 0:
|
|
pytest.fail(
|
|
f"Rust export-ir failed:\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}",
|
|
)
|
|
return result.stdout
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def fastapi_ir() -> str:
|
|
return _fetch_fastapi_ir()
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def rust_ir() -> str:
|
|
return _fetch_rust_ir()
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def django_ir() -> str:
|
|
return _fetch_django_ir()
|
|
|
|
|
|
def test_fastapi_matches_rust(fastapi_ir: str, rust_ir: str) -> None:
|
|
assert fastapi_ir == rust_ir, (
|
|
"FastAPI and Rust emit divergent Mizan IR for the same registered "
|
|
"functions and channels."
|
|
)
|
|
|
|
|
|
def test_django_matches_fastapi(django_ir: str, fastapi_ir: str) -> None:
|
|
assert django_ir == fastapi_ir, (
|
|
"Django and FastAPI emit divergent Mizan IR for the same registered "
|
|
"functions and channels."
|
|
)
|
|
|
|
|
|
def test_all_three_match(django_ir: str, fastapi_ir: str, rust_ir: str) -> None:
|
|
assert django_ir == fastapi_ir == rust_ir, (
|
|
"Three-way IR divergence — see test_django_matches_fastapi and "
|
|
"test_fastapi_matches_rust for which pair drifts."
|
|
)
|