Files
breeze/tests/mesh_native_zi_test.py
T
waoziandClaude Opus 5.5 6f6d19f24d Rename account sync to Mesh
The codex-daochi-client-mesh-client-rename integration, committed as that
task staged it: mesh_client replaces daochi_client, account storage and
tests move to the Mesh names, and docs, locales and CI follow, with
existing accounts, encrypted records and local storage kept compatible.
The task stopped before its dependency versions were pushed; the next
commit moves Breeze to the pushed pins it needs.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-18 13:14:02 -03:00

204 lines
8.9 KiB
Python

#!/usr/bin/env python3
"""Exercise Inbe's Ziran Mesh adapter through a disposable HTTP server."""
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
import hashlib
import json
import os
import re
import subprocess
import sys
import tempfile
import threading
ROOT = Path(__file__).resolve().parent.parent
COMPILER = Path(sys.argv[1]) if len(sys.argv) > 1 else ROOT / "build/packages/ziran/build/bin/zi2c"
MESH_CLIENT = Path(os.environ.get("MESH_CLIENT_DIR", ROOT / "build/packages/mesh-client"))
USER_ID = "a" * 64
NONCE = "c" * 64
def GeneratedSource(generated, name):
"""A generated C file; package modules carry their package's prefix."""
path = generated / name
if path.exists():
return path
prefixed = sorted(path.parent.glob("p" + "[0-9a-f]" * 16 + "_" + path.name))
return prefixed[0] if len(prefixed) == 1 else path
def ResolveGeneratedAuthSessionType(header_text):
"""Resolve the common Session pointer in the generated account API."""
signatures = {
"LoginAccount": r"String base_url, AccountKeys\* account, String client_id, {session}\* session",
"RequestAccount": r"String base_url, AccountKeys\* account, String client_id, {session}\* session, int64_t now, String method, String path, String body, Slice output, int32_t\* status",
"SyncAccountPayload": r"String base_url, AccountKeys\* account, String client_id, {session}\* session, Device device, int64_t now, String body, Slice output, int32_t\* status",
}
types = set()
for name, parameters in signatures.items():
declarations = re.findall(r"\b" + name + r"\s*\([^;{}]*\)\s*;", header_text)
pattern = r"AuthResult\s+" + name + r"\s*\(\s*" + parameters.format(
session=r"(?P<session>[A-Za-z_]\w*)"
) + r"\s*\)\s*;"
matches = list(re.finditer(pattern, header_text))
if len(declarations) != 1 or len(matches) != 1:
raise ValueError(f"generated auth contract: missing, ambiguous or malformed {name} declaration")
types.add(matches[0].group("session"))
if len(types) != 1:
raise ValueError("generated auth contract: account functions use different Session types")
session_type = types.pop()
typedef = rf"\btypedef\s+struct\s+{re.escape(session_type)}\s+{re.escape(session_type)}\s*;"
if len(re.findall(typedef, header_text)) != 1:
raise ValueError(f"generated auth contract: missing or ambiguous typedef for {session_type}")
return session_type
class Handler(BaseHTTPRequestHandler):
friends_requests = 0
registrations = 0
syncs = 0
def log_message(self, *_args):
pass
def respond(self, status, body):
self.send_response(status)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_GET(self):
if self.path == f"/api/v1/sync/challenge?user_id={USER_ID}":
self.respond(200, json.dumps({"nonce": NONCE}).encode())
return
if self.path == "/api/v1/friends":
assert self.headers.get("Authorization") == "Bearer token-from-server"
assert self.headers.get("X-Daochi-User") == USER_ID
assert self.headers.get("X-Daochi-Client") == "client-1"
type(self).friends_requests += 1
if type(self).friends_requests == 1:
self.respond(401, b"{}")
else:
self.respond(200, b'{"friends":[]}')
return
self.respond(404, b"{}")
def do_POST(self):
body = self.rfile.read(int(self.headers.get("Content-Length", "0")))
if self.path == "/api/v1/account/devices":
data = json.loads(body)
assert self.headers.get("Authorization") == "Bearer token-from-server"
assert data["app_id"] == "inbe"
assert data["device_key_id"] == "b" * 64
assert data["public_key"] == "b" * 64
assert data["nonce"] == "01" * 32
assert data["expires_at"] == 1700000301
assert data["signature"] == "bb" * 2420
type(self).registrations += 1
self.respond(200, b"{}")
return
if self.path == "/api/v1/sync":
envelope = json.loads(self.headers["X-Daochi-Tx"])
assert self.headers.get("Authorization") == "Bearer token-from-server"
assert envelope["protocol_version"] == 6
assert envelope["app_id"] == "inbe"
assert envelope["device_key_id"] == "b" * 64
assert envelope["tx_id"] == "02" * 32
assert envelope["nonce"] == "03" * 32
assert envelope["expires_at"] == 1700000301
assert envelope["body_sha256"] == hashlib.sha256(body).hexdigest()
assert envelope["signature"] == "bb" * 2420
assert envelope["device_signature"] == "d" * 128
assert body == b'{"protocol_version":6}'
type(self).syncs += 1
self.respond(200, b'{"server_version":7}')
return
try:
data = json.loads(body)
signature = bytes.fromhex(self.headers.get("X-Daochi-Signature", ""))
except ValueError:
data = {}
signature = b""
valid = (self.path == "/api/v1/sync/login" and
self.headers.get("X-Daochi-User") == USER_ID and
self.headers.get("Content-Type") == "application/json" and
data.get("user_id_hash") == USER_ID and
data.get("public_key") == "pub" and
len(signature) == 2420 and
signature[:64] == hashlib.sha256(body).hexdigest().encode() and
signature[64:128] == NONCE.encode() and
signature[128:] == b"\xbb" * (2420 - 128))
if not valid:
self.respond(400, b"{}")
elif data.get("client_id") == "bad-client":
self.respond(401, b"{}")
elif data.get("client_id") == "client-1":
self.respond(200, json.dumps({
"auth_token": "token-from-server",
"expires_in_seconds": 1800,
"server_time": 1700000000,
}).encode())
else:
self.respond(400, b"{}")
(ROOT / "build/tests").mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(prefix="mesh-native-", dir=ROOT / "build/tests") as temporary:
generated = Path(temporary) / "generated"
executable = Path(temporary) / "client"
subprocess.run([
str(COMPILER), "--no-main", "--root", str(ROOT / "src"),
"--module-path", str(ROOT / "build/packages/ziran/std"),
"--module-path", str(MESH_CLIENT),
"--module-path", str(ROOT / "build/packages/kryon/src/ui"),
*subprocess.check_output(["sh", str(ROOT / "scripts/package-paths.sh"), str(ROOT / "build/packages")], text=True).split(),
"--module-path", str(ROOT / "build/packages/kryon/src/backend"),
"--module-path", str(ROOT / "build/packages/css/src"),
"--module-path", str(ROOT / "build/packages/game2d/src"),
"-o", str(generated), str(ROOT / "src/storage/mesh_native.zi"),
], check=True)
session_type = ResolveGeneratedAuthSessionType(
(generated / "storage/mesh_native.h").read_text()
+ "\n" + GeneratedSource(generated, "auth.h").read_text()
)
# Only the account path is linked; unused storage code is dropped.
sources = [
"storage/mesh_native.c", "mesh_account.c", "delegate_store.c",
"client.c", "auth.c", "url.c", "wire.c",
"sync.c", "transaction.c", "keys.c", "crypto.c", "sha256.c", "Oqs.c",
"net_http.c", "net_http_curl_linux.c", "json_scan.c", "json_bytes.c", "text.c", "text_buffer.c",
"byte_text_linux.c", "c_string.c",
]
subprocess.run([
os.environ.get("CC", "cc"), "-std=c11", "-O0", "-Wall", "-Wextra",
"-Werror", "-Wno-unused-function", "-Wno-unused-variable",
"-ffunction-sections", "-fdata-sections", "-Wl,--gc-sections",
f"-DMESH_FIXTURE_SESSION_TYPE={session_type}",
f"-I{ROOT / 'build/packages/ziran/include'}", f"-I{generated}",
f"-I{generated / 'storage'}",
str(ROOT / "tests/mesh_native_zi_test.c"),
*(str(GeneratedSource(generated, source)) for source in sources),
"-l:libcurl.so.4", "-lz", "-o", str(executable),
], check=True)
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
try:
environment = os.environ.copy()
environment.pop("DISPLAY", None)
environment.pop("WAYLAND_DISPLAY", None)
subprocess.run([
str(executable), f"127.0.0.1:{server.server_port}"
], check=True, env=environment)
assert Handler.friends_requests == 2
assert Handler.registrations == 1
assert Handler.syncs == 1
finally:
server.shutdown()
server.server_close()
thread.join()