hermes-agent/tests/hermes_cli/test_desktop_cron_ticker_profiles.py
unsupportedpastels d565acef9f fix(desktop): route the fail-open cron ticker through the shared profile gate
The fail-open built-in path gated ticks via can_dispatch, so a skipped
tick still recorded a successful heartbeat and cleared the tick error on
the store a live gateway owns. Tick this backend's own store through the
multiplex loop with the same profile_gate instead: a gated-out profile is
neither ticked nor heartbeated.

One _gateway_owns_cron(name, home) predicate now backs every path, so the
fail-open and external-provider paths also stand down for a satellite
served by the live default multiplexer. The external-provider wait probes
once per interval.

Tests: split the external-provider stand-down test and drop the iterator
that hid over-probing; pin the fail-open start kwargs exactly; cover the
satellite gate and the heartbeat through the real built-in loop.

(cherry picked from commit b9250805e7)
2026-09-28 18:44:52 -04:00

178 lines
6.7 KiB
Python

"""Desktop cron ticker: every local profile's store must be ticked.
The desktop app pools per-profile backends and reaps them after ~10 idle
minutes, so a secondary profile's in-backend ticker dies with its backend and
that profile's cron jobs silently stop firing until the user next opens the
profile. The PRIMARY desktop backend outlives the pool, so its ticker must own
every profile's store — the desktop sibling of the multiplex-gateway fix for
#69377.
"""
from pathlib import Path
import threading
import pytest
import hermes_cli.web_server as ws
class _RecordingBuiltin:
"""Stands in for InProcessCronScheduler; records start() kwargs."""
name = "builtin"
def __init__(self):
self.start_kwargs = None
def start(self, stop_event, **kwargs):
self.start_kwargs = kwargs
class _RecordingExternal:
"""External provider double — must NOT receive profile_homes."""
name = "chronos-test"
def __init__(self):
self.start_kwargs = None
def start(self, stop_event, **kwargs):
self.start_kwargs = kwargs
@pytest.fixture()
def _providers(monkeypatch):
import cron.scheduler_provider as sp
builtin = _RecordingBuiltin()
# isinstance(provider, InProcessCronScheduler) gate: register our double
# as that class for the module under test.
monkeypatch.setattr(ws, "_log", ws._log)
monkeypatch.setattr(sp, "resolve_cron_scheduler", lambda: builtin)
monkeypatch.setattr(sp, "InProcessCronScheduler", _RecordingBuiltin)
return sp, builtin
def test_multi_profile_homes_passed_to_builtin(monkeypatch, _providers, tmp_path):
_sp, builtin = _providers
homes = [
("default", tmp_path / "root"),
("coder", tmp_path / "profiles" / "coder"),
]
import hermes_cli.profiles as profiles_mod
monkeypatch.setattr(profiles_mod, "profiles_to_serve", lambda **_kw: list(homes))
ws._start_desktop_cron_ticker(threading.Event(), interval=7)
assert builtin.start_kwargs is not None
assert builtin.start_kwargs["interval"] == 7
profile_homes = builtin.start_kwargs["profile_homes"]
assert callable(profile_homes)
assert profile_homes() == homes
homes.pop()
assert profile_homes() == homes
@pytest.mark.parametrize("gateway_running", [True, False])
def test_single_profile_ticks_only_without_gateway(monkeypatch, tmp_path, gateway_running):
"""Exercise Desktop startup through the real built-in scheduler loop."""
from cron.scheduler_provider import InProcessCronScheduler
from hermes_constants import get_hermes_home
import hermes_cli.profiles as profiles_mod
home = tmp_path / "root"
home.mkdir()
monkeypatch.setattr(profiles_mod, "profiles_to_serve", lambda **_kw: [("default", home)])
monkeypatch.setattr(profiles_mod, "_check_gateway_running", lambda _home: gateway_running)
monkeypatch.setattr(
"cron.scheduler_provider.resolve_cron_scheduler", InProcessCronScheduler
)
ticked = []
monkeypatch.setattr(
"cron.scheduler.tick", lambda **_kw: ticked.append(get_hermes_home())
)
stop = threading.Event()
# One real scheduler cycle, with no wall-clock wait or job dispatch.
monkeypatch.setattr(stop, "wait", lambda _timeout: stop.set())
ws._start_desktop_cron_ticker(stop, interval=0)
assert ticked == ([] if gateway_running else [home])
def test_enumeration_failure_fails_open(monkeypatch, _providers):
"""The active profile's jobs keep firing even if profile listing breaks."""
_sp, builtin = _providers
import hermes_cli.profiles as profiles_mod
def _boom(**_kw):
raise RuntimeError("profiles dir unreadable")
monkeypatch.setattr(profiles_mod, "profiles_to_serve", _boom)
ws._start_desktop_cron_ticker(threading.Event(), interval=11)
from hermes_constants import get_hermes_home
# This backend's own store only, behind the per-tick gateway gate (see the stand-down tests).
assert set(builtin.start_kwargs) == {"interval", "profile_homes", "profile_gate"}
assert builtin.start_kwargs["interval"] == 11
[(_name, home)] = builtin.start_kwargs["profile_homes"]()
assert home == Path(get_hermes_home())
def test_external_provider_never_gets_profile_homes(monkeypatch, tmp_path):
"""External registries are not profile-scoped; keep single-store semantics."""
import cron.scheduler_provider as sp
external = _RecordingExternal()
monkeypatch.setattr(sp, "resolve_cron_scheduler", lambda: external)
import hermes_cli.profiles as profiles_mod
monkeypatch.setattr(
profiles_mod,
"profiles_to_serve",
lambda **_kw: [("default", tmp_path / "a"), ("b", tmp_path / "b")],
)
ws._start_desktop_cron_ticker(threading.Event(), interval=13)
assert external.start_kwargs == {"interval": 13}
def test_desktop_ticker_serves_every_profile_and_yields_to_owning_gateway(monkeypatch, _providers, tmp_path):
"""The Desktop ticker mirrors the multiplexer's served set (default + every live profile dir)
and stands down, per tick, for a profile already owned by a gateway: its own running gateway,
or the live default multiplexer that already ticks it — such a satellite has no gateway.pid
of its own, so the per-home liveness check alone lets both tickers race for its fires
(#107485, #108428)."""
import hermes_cli.profiles as profiles_mod
import hermes_yaml as yaml
_sp, builtin = _providers
root = tmp_path / ".hermes"
for name in ("worker", "guest", "solo"):
(root / "profiles" / name).mkdir(parents=True)
(root / "profiles" / name / "config.yaml").write_text("{}\n") # identity marker: served
(root / "config.yaml").write_text(yaml.safe_dump({"gateway": {"multiplex_profiles": True}}))
monkeypatch.setattr("hermes_constants.get_default_hermes_root", lambda: root)
monkeypatch.setattr(profiles_mod, "_get_default_hermes_home", lambda: root)
monkeypatch.setattr(profiles_mod, "_get_profiles_root", lambda: root / "profiles")
monkeypatch.setattr(
profiles_mod, "_check_gateway_running", lambda home: home == root / "profiles" / "solo")
monkeypatch.setattr(profiles_mod, "_served_by_running_multiplexer", lambda name: name == "worker")
ws._start_desktop_cron_ticker(threading.Event(), interval=0)
profile_homes = builtin.start_kwargs["profile_homes"]
assert callable(profile_homes)
assert [name for name, _ in profile_homes()] == [
"default", "guest", "solo", "worker"]
gate = builtin.start_kwargs["profile_gate"]
assert gate("default", root) is True
assert gate("guest", root / "profiles" / "guest") is True
assert gate("worker", root / "profiles" / "worker") is False
assert gate("solo", root / "profiles" / "solo") is False