Files
engine/engine-guard/test_engine_guard.py
zeekayandHanzo Dev 42e34c2d41 refactor: name only Hanzo Engine in code, comments and docs
Every mention of another inference engine is rewritten to say what our code
does, or the math it computes. Reference values are "the reference value
from the published config" or "the recorded reference output", line
citations into another engine's source become the rule itself, comparisons
with other engines are dropped, and asides about other engines' bugs go.

Identifiers follow:
- CUDA: hanzo-paged-attn's `namespace vllm` is `pagedattn`, hanzo-engine's
  MoE helpers `moe_dtype` and `moe_detail`, the rotary kernels'
  `hanzo_rotary`; the shuffle/ldg macros are HANZO_*.
- GPTQ: the shuffled-layout path (`reconstruct_exllama`, `use_exllama`) is
  `reconstruct_shuffled` / `is_shuffled`, on the kernel and the FFI side.
- Tests: `*_matches_vllm` and friends name what they compare against (the
  reference fixture, the tile rule).
- MiniCPM-o's vision-LLM embedding is `vlm_embedding`; the rotary custom op
  is `rotary-embedding`.
- hanzo-bench's board scores ours against a "rival" whose name comes from
  the manifest: `rival_<tag>.json`, `--rival*` manifest flags, `rival t/s`
  columns; dossier.sh and spec_decode.sh take `--rival-bench`.
- install.ps1 installs this repository's hanzo-cli, as install.sh does,
  with HANZO_INSTALL_NCCL / HANZO_INSTALL_NO_NCCL.
- bench_http.py reads only the hanzo: metric families.

Kept, because they are what they are: LICENSE, LICENSE-APACHE, NOTICE and
tools/upstream-map.sh; each ported file's copyright/licence/provenance
header; Cargo.toml dependency names; data identifiers (Hugging Face repo
IDs, fixture file names and fixture metadata keys the tests read, on-disk
paths, executable names the GPU and engine guards match on a host); model
and format names.

LLM.md says the rule once, under "One name: Hanzo Engine".


Co-authored-by: Hanzo Dev <[email protected]>
2026-10-16 20:59:50 -07:00

679 lines
27 KiB
Python

"""Unit tests for hanzo-engine-guard.
The daemon is a single hyphenated, extension-less script, so it cannot be
imported by name - it is loaded by path via importlib. Every test drives the
pure policy fns directly, or one mocked `_tick` cycle with all I/O monkeypatched;
no real processes, sockets, or sleeps are ever touched.
"""
import importlib.util
import os
import sys
from importlib.machinery import SourceFileLoader
import pytest
SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "hanzo-engine-guard")
_spec = importlib.util.spec_from_file_location(
"hanzo_engine_guard", SCRIPT,
loader=SourceFileLoader("hanzo_engine_guard", SCRIPT))
eg = importlib.util.module_from_spec(_spec)
sys.modules[_spec.name] = eg # register so coverage can resolve it by name
_spec.loader.exec_module(eg)
BOMB = eg.BOMB_PAT # the legacy binary's name, as the guard matches it
# ----------------------------------------------------------------- fakes
class FakeProc:
"""Stands in for a psutil process (process_iter entry / Process(pid))."""
def __init__(self, pid, name=None, exe=None, cmdline=None,
cwd=None, environ=None, raises=False, kill_raises=False):
self.info = {"pid": pid, "name": name, "exe": exe, "cmdline": cmdline}
self._cwd = cwd
self._environ = environ or {}
self._raises = raises
self._kill_raises = kill_raises
self.killed = False
def kill(self):
self.killed = True
if self._kill_raises:
raise RuntimeError("process vanished before kill")
def cwd(self):
if self._raises:
raise RuntimeError("process is gone")
return self._cwd
def environ(self):
if self._raises:
raise RuntimeError("process is gone")
return dict(self._environ)
class FakePsutil:
def __init__(self, procs):
self._by_pid = {p.info["pid"]: p for p in procs}
def process_iter(self, attrs=None):
return list(self._by_pid.values())
def Process(self, pid):
return self._by_pid[pid]
class FakeCompleted:
def __init__(self, stdout=""):
self.stdout = stdout
# ----------------------------------------------------------------- parse_port
@pytest.mark.parametrize("cmdline,expected", [
("/x/release/hanzo serve -p 36900", 36900),
("hanzo serve --model m -p 36901 --foo", 36901),
("hanzo serve -p 42", 42), # tolerates extra whitespace
("hanzo serve", None), # no -p at all
("hanzo serve -p", None), # -p with no value
("hanzo serve -p 100 -p 200", 100), # first -p wins
("hanzo serve --port 36910", None), # only -p is parsed, not --port
])
def test_parse_port(cmdline, expected):
assert eg.parse_port(cmdline) == expected
# ----------------------------------------------------------------- is_bomb
@pytest.mark.parametrize("name,exe,argv0,expected", [
(None, f"/opt/hanzo/bin/{BOMB}", None, True), # exe basename
(None, None, f"/usr/local/bin/{BOMB}", True), # argv0 basename
(BOMB, None, None, True), # full comm
(BOMB[:15], None, None, True), # 15-char truncated comm
# critical false-positive guard: cmd/binary merely *mentions* the name
("bash", "/bin/bash", "/bin/bash", False),
("python3", "/usr/bin/python3", "python3", False),
("grep", "/usr/bin/grep", "grep", False),
# the native engine itself is never a bomb
("hanzo", "/x/target/release/hanzo", "/x/target/release/hanzo", False),
(None, None, None, False), # nothing known
(BOMB[:14], None, None, False), # 14 chars: not a match
])
def test_is_bomb(name, exe, argv0, expected):
assert eg.is_bomb(name, exe, argv0) is expected
# ----------------------------------------------------------------- backoff_seconds
@pytest.mark.parametrize("fails,expected", [
(0, 15), (1, 30), (2, 60), (3, 120), (4, 300),
(5, 300), (8, 300), (100, 300), # clamps at the last entry
])
def test_backoff_seconds(fails, expected):
assert eg.backoff_seconds(fails) == expected
# ----------------------------------------------------------------- over_ceiling
@pytest.mark.parametrize("count,ceiling,expected", [
(255, 256, False), (256, 256, False), (257, 256, True), # boundary == not over
(0, 0, False), (1, 0, True),
])
def test_over_ceiling(count, ceiling, expected):
assert eg.over_ceiling(count, ceiling) is expected
# ----------------------------------------------------------------- keepalive_decision
def test_keepalive_healthy_regardless_of_owner():
assert eg.keepalive_decision({}, 1000, True, True, True) == "healthy"
assert eg.keepalive_decision({"fails": 3}, 1000, False, True, True) == "healthy"
def test_keepalive_no_owner():
assert eg.keepalive_decision({"cmd": ["x"]}, 1e9, False, False, False) == "no-owner"
def test_keepalive_health_without_proc_is_not_healthy():
# answers /health but no matching engine proc -> NOT 'healthy'; with an owner
# and elapsed backoff it is respawned (this matches the daemon's behavior).
st = {"cmd": ["x"], "fails": 0, "last": 0}
assert eg.keepalive_decision(st, 1e9, True, True, False) == "respawn"
def test_keepalive_in_backoff_then_respawn_at_boundary():
st = {"cmd": ["x"], "fails": 1, "last": 1000} # backoff(1) == 30s
assert eg.keepalive_decision(st, 1029, True, False, False) == "in-backoff"
assert eg.keepalive_decision(st, 1030, True, False, False) == "respawn"
def test_keepalive_respawn():
st = {"cmd": ["x"], "fails": 0, "last": 0}
assert eg.keepalive_decision(st, 1e9, True, False, False) == "respawn"
def test_keepalive_gaveup_by_flag():
st = {"cmd": ["x"], "gaveup": True, "fails": 2}
assert eg.keepalive_decision(st, 1e9, True, False, False) == "gaveup"
def test_keepalive_gaveup_by_count():
st = {"cmd": ["x"], "fails": eg.MAX_FAILS, "last": 0}
assert eg.keepalive_decision(st, 1e9, True, False, False) == "gaveup"
def test_keepalive_no_owner_precedes_gaveup():
# a quit desktop yields 'no-owner' even past the fail cap (never hammered)
st = {"cmd": ["x"], "fails": eg.MAX_FAILS}
assert eg.keepalive_decision(st, 1e9, False, False, False) == "no-owner"
# ----------------------------------------------------------------- _tick fixture
class TickEnv:
def __init__(self):
self.logs = []
self.spawns = [] # (argv, cwd, env)
self.kill_all = [] # patterns passed to _kill_matching
self.procs = [] # what _procs_matching(ENGINE_PAT) returns
self.desktop = False
self.healthy_ports = set()
@pytest.fixture
def env(monkeypatch):
e = TickEnv()
monkeypatch.setattr(eg, "_log", lambda m: e.logs.append(m))
monkeypatch.setattr(eg, "_kill_bomb", lambda: None)
monkeypatch.setattr(eg, "_kill_matching", lambda pat: e.kill_all.append(pat))
monkeypatch.setattr(eg, "_procs_matching", lambda pat: list(e.procs))
monkeypatch.setattr(eg, "_any_running", lambda pats: e.desktop)
monkeypatch.setattr(eg, "_health", lambda port: port in e.healthy_ports)
monkeypatch.setattr(eg, "_proc_context", lambda pid: ("/captured/cwd", {"CAP": "1"}))
monkeypatch.setattr(eg, "_spawn_detached",
lambda argv, cwd=None, env=None: e.spawns.append((argv, cwd, env)))
return e
# ----------------------------------------------------------------- circuit breaker
def test_kill_bomb_kills_only_the_real_binary(monkeypatch):
"""The critical guard: kill the real legacy binary, never an innocent
process whose command line merely CONTAINS its name."""
bomb = FakeProc(101, name=BOMB[:15], exe=f"/opt/{BOMB}",
cmdline=[f"/opt/{BOMB}", "-p", "1234"])
innocent = FakeProc(202, name="bash", exe="/bin/bash",
cmdline=["/bin/bash", "-c", f"tail -f {BOMB}.log"])
grep = FakeProc(303, name="grep", exe="/usr/bin/grep",
cmdline=["grep", BOMB, "/var/log/syslog"])
monkeypatch.setattr(eg, "psutil", FakePsutil([bomb, innocent, grep]))
eg._kill_bomb()
assert bomb.killed is True
assert innocent.killed is False
assert grep.killed is False
def test_bomb_procs_detects_by_exe_argv0_comm(monkeypatch):
procs = [
FakeProc(1, exe=f"/x/{BOMB}", cmdline=[f"/x/{BOMB}"]), # exe
FakeProc(2, name=BOMB[:15], cmdline=["python", "run"]), # comm
FakeProc(3, exe="/bin/sh", cmdline=[f"/x/{BOMB}", "-p", "1"]), # argv0
FakeProc(4, name="bash", exe="/bin/bash", cmdline=["bash", "-c", f"echo {BOMB}"]),
]
monkeypatch.setattr(eg, "psutil", FakePsutil(procs))
assert {pid for pid, _ in eg._bomb_procs()} == {1, 2, 3}
def test_tick_kills_bomb_not_innocent(monkeypatch):
"""One real _tick cycle: its first act precisely kills the bomb, spares others."""
bomb = FakeProc(101, name=BOMB[:15], exe=f"/opt/{BOMB}",
cmdline=[f"/opt/{BOMB}"])
innocent = FakeProc(202, name="vim", exe="/usr/bin/vim",
cmdline=["vim", f"{BOMB}.rs"])
monkeypatch.setattr(eg, "psutil", FakePsutil([bomb, innocent]))
monkeypatch.setattr(eg, "_procs_matching", lambda pat: []) # no engines
monkeypatch.setattr(eg, "_any_running", lambda pats: False)
monkeypatch.setattr(eg, "_log", lambda m: None)
eg._tick({}, set())
assert bomb.killed is True
assert innocent.killed is False
def test_kill_bomb_swallows_kill_errors(monkeypatch):
"""A bomb that vanishes between detection and kill must not crash the guard."""
bomb = FakeProc(101, exe=f"/opt/{BOMB}",
cmdline=[f"/opt/{BOMB}"], kill_raises=True)
monkeypatch.setattr(eg, "psutil", FakePsutil([bomb]))
eg._kill_bomb() # must not raise
assert bomb.killed is True # attempted
def test_kill_matching_swallows_kill_errors(monkeypatch):
target = FakeProc(7, cmdline=["release/hanzo", "serve"], kill_raises=True)
monkeypatch.setattr(eg, "psutil", FakePsutil([target]))
eg._kill_matching("release/hanzo serve") # must not raise
assert target.killed is True
def test_tick_runaway_kills_all(env, monkeypatch):
monkeypatch.setattr(eg, "RUNAWAY_CEILING", 2)
env.procs = [(10, "release/hanzo serve -p 36900"),
(11, "release/hanzo serve -p 36901"),
(12, "release/hanzo serve -p 36902")] # 3 > ceiling 2
env.desktop = True
env.healthy_ports = {36900, 36901, 36902}
state = {}
eg._tick(state, set())
assert env.kill_all == [eg.ENGINE_PAT] # kill-all path taken
assert env.spawns == [] # keepalive never ran
assert state == {} # bailed before the loops
# ----------------------------------------------------------------- keepalive cycle
def test_tick_healthy_resets_state_and_captures_context(env):
env.procs = [(500, "/x/release/hanzo serve -p 36900")]
env.desktop = True
env.healthy_ports = {36900}
state = {36900: {"cmd": ["old"], "fails": 5, "gaveup": True}}
gaveup_logged = {36900}
eg._tick(state, gaveup_logged)
st = state[36900]
assert st["fails"] == 0 and st["gaveup"] is False
assert st["cmd"] == ["/x/release/hanzo", "serve", "-p", "36900"]
assert st["cwd"] == "/captured/cwd" and st["env"] == {"CAP": "1"}
assert 36900 not in gaveup_logged # cleared on recovery
assert env.spawns == [] # healthy -> no respawn
def test_tick_respawns_down_port_with_owner(env):
snap = {"cmd": ["/x/release/hanzo", "serve", "-p", "36900"],
"cwd": "/work/engine", "env": {"HF_HOME": "/cache"},
"fails": 0, "last": 0.0}
state = {36900: dict(snap)}
env.procs = [] # the engine process is gone
env.desktop = True # but a desktop/node owns it
env.healthy_ports = set()
eg._tick(state, set())
assert env.spawns == [(snap["cmd"], snap["cwd"], snap["env"])] # exact replay
assert state[36900]["fails"] == 1 # attempt counted
assert state[36900]["last"] > 0 # backoff clock started
def test_tick_skips_state_entry_without_cmd(env):
state = {36900: {"fails": 0}} # malformed: never captured a command
env.procs = []
env.desktop = True
eg._tick(state, set()) # the guard skips it -> no spawn, no crash
assert env.spawns == []
assert state[36900] == {"fails": 0}
def test_tick_no_respawn_without_owner(env):
state = {36900: {"cmd": ["e"], "fails": 0, "last": 0}}
env.procs = []
env.desktop = False # no desktop/node -> never respawn
eg._tick(state, set())
assert env.spawns == []
assert state[36900]["fails"] == 0
def test_tick_respects_backoff(env):
import time
state = {36900: {"cmd": ["e"], "fails": 1, "last": time.time()}} # just tried
env.procs = []
env.desktop = True
eg._tick(state, set())
assert env.spawns == [] # still within 30s backoff
assert state[36900]["fails"] == 1 # unchanged
def test_tick_gaveup_sets_flag_then_logs_once(env):
state = {36900: {"cmd": ["e"], "fails": eg.MAX_FAILS, "last": 0}}
env.procs = []
env.desktop = True
gaveup_logged = set()
eg._tick(state, gaveup_logged) # 1st: mark gaveup, NO log yet
assert state[36900]["gaveup"] is True
assert env.spawns == [] and gaveup_logged == set()
eg._tick(state, gaveup_logged) # 2nd: already gaveup -> log once
assert 36900 in gaveup_logged
assert sum("gave up" in m for m in env.logs) == 1
eg._tick(state, gaveup_logged) # 3rd: no duplicate log
assert sum("gave up" in m for m in env.logs) == 1
def test_tick_full_respawn_to_giveup_sequence(env, monkeypatch):
"""End-to-end safety: a permanently-broken port is respawned exactly
MAX_FAILS times (never more), each gated by backoff, then given up."""
clock = [1_000_000.0]
monkeypatch.setattr(eg.time, "time", lambda: clock[0])
state = {36900: {"cmd": ["e"], "fails": 0, "last": 0.0}}
env.procs = []
env.desktop = True
env.healthy_ports = set()
for _ in range(eg.MAX_FAILS + 3):
clock[0] += 10_000 # always skip past the 300s ceiling backoff
eg._tick(state, set())
assert len(env.spawns) == eg.MAX_FAILS # respawned 8x, never a 9th
assert state[36900]["gaveup"] is True
# ----------------------------------------------------------------- I/O layer
def test_procs_matching_psutil(monkeypatch):
procs = [FakeProc(1, cmdline=["release/hanzo", "serve", "-p", "36900"]),
FakeProc(2, cmdline=["vim", "notes.txt"]),
FakeProc(3, cmdline=None)]
monkeypatch.setattr(eg, "psutil", FakePsutil(procs))
assert eg._procs_matching("release/hanzo serve") == [(1, "release/hanzo serve -p 36900")]
def test_procs_matching_pgrep_fallback(monkeypatch):
monkeypatch.setattr(eg, "psutil", None)
seen = {}
def fake_run(argv, **kw):
seen["argv"] = argv
return FakeCompleted("123 release/hanzo serve -p 36900\n"
"456 pgrep -af release/hanzo serve\n") # pgrep's own line filtered
monkeypatch.setattr(eg.subprocess, "run", fake_run)
assert eg._procs_matching("release/hanzo serve") == [(123, "release/hanzo serve -p 36900")]
assert seen["argv"][0] == "pgrep"
def test_kill_matching_psutil(monkeypatch):
target = FakeProc(7, cmdline=["release/hanzo", "serve"])
monkeypatch.setattr(eg, "psutil", FakePsutil([target]))
eg._kill_matching("release/hanzo serve")
assert target.killed is True
def test_kill_matching_pgrep_fallback(monkeypatch):
monkeypatch.setattr(eg, "psutil", None)
seen = []
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: seen.append(argv) or FakeCompleted())
eg._kill_matching("release/hanzo serve")
assert seen == [["pkill", "-9", "-f", "release/hanzo serve"]]
def test_bomb_procs_pgrep_fallback(monkeypatch):
monkeypatch.setattr(eg, "psutil", None)
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: FakeCompleted("111\n222\n"))
assert eg._bomb_procs() == [(111, ""), (222, "")]
def test_kill_bomb_pgrep_fallback(monkeypatch):
monkeypatch.setattr(eg, "psutil", None)
seen = []
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: seen.append(argv) or FakeCompleted())
eg._kill_bomb()
assert seen == [["pkill", "-9", "-x", eg.BOMB_PAT[:15]]]
def test_any_running(monkeypatch):
monkeypatch.setattr(eg, "_procs_matching",
lambda pat: [(1, pat)] if pat == "hanzo-node" else [])
assert eg._any_running(("zoo-desktop", "hanzo-node")) is True
monkeypatch.setattr(eg, "_procs_matching", lambda pat: [])
assert eg._any_running(eg.DESKTOP_PATS) is False
def test_proc_context_ok(monkeypatch):
monkeypatch.setattr(eg, "psutil", FakePsutil([FakeProc(7, cwd="/w", environ={"A": "B"})]))
assert eg._proc_context(7) == ("/w", {"A": "B"})
def test_proc_context_dead_proc(monkeypatch):
monkeypatch.setattr(eg, "psutil", FakePsutil([FakeProc(7, raises=True)]))
assert eg._proc_context(7) == (None, None)
def test_spawn_detached_unix(monkeypatch):
cap = {}
monkeypatch.setattr(eg, "IS_WIN", False)
monkeypatch.setattr(eg.subprocess, "Popen",
lambda argv, **kw: cap.update(argv=argv, kw=kw))
eg._spawn_detached(["e", "-p", "1"], cwd="/w", env={"X": "1"})
assert cap["argv"] == ["e", "-p", "1"]
assert cap["kw"]["start_new_session"] is True
assert cap["kw"]["cwd"] == "/w" and cap["kw"]["env"] == {"X": "1"}
assert cap["kw"]["stdout"] == eg.subprocess.DEVNULL
def test_spawn_detached_windows(monkeypatch):
cap = {}
monkeypatch.setattr(eg, "IS_WIN", True)
monkeypatch.setattr(eg.subprocess, "DETACHED_PROCESS", 0x8, raising=False)
monkeypatch.setattr(eg.subprocess, "CREATE_NEW_PROCESS_GROUP", 0x200, raising=False)
monkeypatch.setattr(eg.subprocess, "Popen", lambda argv, **kw: cap.update(kw))
eg._spawn_detached(["e"])
assert cap["creationflags"] == 0x208
assert "start_new_session" not in cap
def test_health_up(monkeypatch):
class R:
status = 200
def __enter__(self):
return self
def __exit__(self, *a):
return False
monkeypatch.setattr(eg.urllib.request, "urlopen", lambda url, timeout=1: R())
assert eg._health(36900) is True
def test_health_non_200(monkeypatch):
class R:
status = 503
def __enter__(self):
return self
def __exit__(self, *a):
return False
monkeypatch.setattr(eg.urllib.request, "urlopen", lambda url, timeout=1: R())
assert eg._health(36900) is False
def test_health_down(monkeypatch):
def boom(url, timeout=1):
raise OSError("connection refused")
monkeypatch.setattr(eg.urllib.request, "urlopen", boom)
assert eg._health(36900) is False
def test_log_unix(monkeypatch):
seen = []
monkeypatch.setattr(eg, "IS_WIN", False)
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: seen.append(argv))
eg._log("hello")
assert seen == [["logger", "-t", eg.APP, "hello"]]
def test_log_windows(monkeypatch, capsys):
monkeypatch.setattr(eg, "IS_WIN", True)
eg._log("hello")
assert "[hanzo-engine-guard] hello" in capsys.readouterr().out
# ----------------------------------------------------------------- run loop
def test_run_ticks_then_sleeps(monkeypatch):
ticks = []
monkeypatch.setattr(eg, "_log", lambda m: None)
monkeypatch.setattr(eg, "_tick", lambda s, g: ticks.append((s, g)))
def stop(_):
raise KeyboardInterrupt
monkeypatch.setattr(eg.time, "sleep", stop)
with pytest.raises(KeyboardInterrupt):
eg.run()
assert len(ticks) == 1
assert ticks[0][0] == {} and ticks[0][1] == set() # fresh state + gaveup set
# ----------------------------------------------------------------- install dispatch
def test_self_cmd():
cmd = eg._self_cmd()
assert cmd[-1] == "run" and len(cmd) == 3
assert os.path.isabs(cmd[0]) and os.path.isabs(cmd[1])
def test_dispatch_linux(monkeypatch):
monkeypatch.setattr(eg, "IS_WIN", False)
monkeypatch.setattr(eg.sys, "platform", "linux")
called = []
monkeypatch.setattr(eg, "install_linux", lambda: called.append("linux"))
eg._dispatch("install")
assert called == ["linux"]
def test_dispatch_macos(monkeypatch):
monkeypatch.setattr(eg, "IS_WIN", False)
monkeypatch.setattr(eg.sys, "platform", "darwin")
called = []
monkeypatch.setattr(eg, "install_macos", lambda: called.append("macos"))
eg._dispatch("install")
assert called == ["macos"]
def test_dispatch_windows(monkeypatch):
monkeypatch.setattr(eg, "IS_WIN", True)
called = []
monkeypatch.setattr(eg, "uninstall_windows", lambda: called.append("win"))
eg._dispatch("uninstall")
assert called == ["win"]
def test_dispatch_unsupported(monkeypatch):
monkeypatch.setattr(eg, "IS_WIN", False)
monkeypatch.setattr(eg.sys, "platform", "linux")
with pytest.raises(SystemExit):
eg._dispatch("frobnicate") # no frobnicate_linux exists
# ----------------------------------------------------------------- installers
def test_install_linux_writes_unit_and_enables(monkeypatch, tmp_path):
monkeypatch.setenv("HOME", str(tmp_path))
monkeypatch.setenv("USER", "tester")
runs = []
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: runs.append(argv))
monkeypatch.setattr(eg, "_self_cmd", lambda: ["/py", "/script", "run"])
eg.install_linux()
unit = tmp_path / ".config/systemd/user/hanzo-engine-guard.service"
text = unit.read_text()
# unit content is part of the contract - lock it down
assert "ExecStart=/py /script run" in text
assert "Restart=always" in text and "RestartSec=3" in text
assert "KillMode=process" in text
assert "OOMScoreAdjust=-700" in text
assert "MemoryMax=" not in text # no memory cap directive (only the comment)
assert "WantedBy=default.target" in text
assert ["loginctl", "enable-linger", "tester"] in runs
assert ["systemctl", "--user", "daemon-reload"] in runs
assert ["systemctl", "--user", "enable", "--now", "hanzo-engine-guard.service"] in runs
def test_uninstall_linux(monkeypatch, tmp_path):
monkeypatch.setenv("HOME", str(tmp_path))
unit = tmp_path / ".config/systemd/user/hanzo-engine-guard.service"
unit.parent.mkdir(parents=True)
unit.write_text("x")
runs = []
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: runs.append(argv))
eg.uninstall_linux()
assert not unit.exists()
assert ["systemctl", "--user", "disable", "--now", "hanzo-engine-guard.service"] in runs
def test_install_macos_writes_plist(monkeypatch, tmp_path):
monkeypatch.setenv("HOME", str(tmp_path))
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: None)
monkeypatch.setattr(eg, "_self_cmd", lambda: ["/py", "/script", "run"])
eg.install_macos()
plist = tmp_path / "Library/LaunchAgents/ai.hanzo.engine-guard.plist"
text = plist.read_text()
assert "<key>Label</key><string>ai.hanzo.engine-guard</string>" in text
assert "<string>/py</string>" in text and "<string>/script</string>" in text
assert "<key>RunAtLoad</key><true/>" in text
assert "<key>KeepAlive</key><true/>" in text
def test_uninstall_macos(monkeypatch, tmp_path):
monkeypatch.setenv("HOME", str(tmp_path))
plist = tmp_path / "Library/LaunchAgents/ai.hanzo.engine-guard.plist"
plist.parent.mkdir(parents=True)
plist.write_text("x")
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: None)
eg.uninstall_macos()
assert not plist.exists()
def test_install_windows(monkeypatch):
runs = []
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: runs.append(argv))
eg.install_windows()
assert runs[0][0] == "schtasks" and runs[0][1] == "/Create"
assert any(a[1] == "/Run" for a in runs)
def test_uninstall_windows(monkeypatch):
runs = []
monkeypatch.setattr(eg.subprocess, "run", lambda argv, **kw: runs.append(argv))
eg.uninstall_windows()
assert ["schtasks", "/End", "/TN", "HanzoEngineGuard"] in runs
assert ["schtasks", "/Delete", "/F", "/TN", "HanzoEngineGuard"] in runs
# ----------------------------------------------------------------- status + main
def test_status_reports_ports_and_bomb_warning(monkeypatch, capsys):
monkeypatch.setattr(eg, "_procs_matching",
lambda pat: [(1, "release/hanzo serve -p 36900"),
(2, "release/hanzo serve -p 36901")]
if pat == eg.ENGINE_PAT else [])
monkeypatch.setattr(eg, "_health", lambda port: port == 36900)
monkeypatch.setattr(eg, "_any_running", lambda pats: True)
monkeypatch.setattr(eg, "_bomb_procs", lambda: [(99, BOMB)])
eg.status()
out = capsys.readouterr().out
assert "ports [36900, 36901]" in out
assert ":36900 health=UP" in out
assert ":36901 health=down" in out
assert "desktop/node running: True" in out
assert "WARNING 1" in out
def test_status_no_engines_no_bomb(monkeypatch, capsys):
monkeypatch.setattr(eg, "_procs_matching", lambda pat: [])
monkeypatch.setattr(eg, "_any_running", lambda pats: False)
monkeypatch.setattr(eg, "_bomb_procs", lambda: [])
eg.status()
out = capsys.readouterr().out
assert "0 engine proc(s); ports -" in out
assert "WARNING" not in out
def test_main_default_is_run(monkeypatch):
called = []
monkeypatch.setattr(eg, "run", lambda: called.append("run"))
monkeypatch.setattr(eg.sys, "argv", ["hanzo-engine-guard"])
eg.main()
assert called == ["run"]
def test_main_status(monkeypatch):
called = []
monkeypatch.setattr(eg, "status", lambda: called.append("status"))
monkeypatch.setattr(eg.sys, "argv", ["hanzo-engine-guard", "status"])
eg.main()
assert called == ["status"]
def test_main_install_and_uninstall(monkeypatch):
seen = []
monkeypatch.setattr(eg, "_dispatch", lambda a: seen.append(a))
monkeypatch.setattr(eg.sys, "argv", ["hanzo-engine-guard", "install"])
eg.main()
monkeypatch.setattr(eg.sys, "argv", ["hanzo-engine-guard", "uninstall"])
eg.main()
assert seen == ["install", "uninstall"]
def test_main_unknown_action_exits(monkeypatch):
monkeypatch.setattr(eg.sys, "argv", ["hanzo-engine-guard", "bogus"])
with pytest.raises(SystemExit):
eg.main()