mirror of
https://github.com/hanzoai/engine.git
synced 2026-11-20 14:17:52 +00:00
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]>
679 lines
27 KiB
Python
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()
|