The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Regression: ``_evict_modules`` must survive concurrent mutation of ``sys.modules``."""
from __future__ import annotations
import sys
import threading
import types
from collections.abc import Iterator
import pytest
from hermes_cli import plugins_loader
# Enough entries that the filtering pass spans several GIL switches.
_MODULE_COUNT = 5000
_EVICTIONS = 300
# Batched so the mapping's *size* genuinely differs across the eviction's iteration window.
_CHURN_BATCH = 50
@pytest.fixture
def isolated_modules(monkeypatch: pytest.MonkeyPatch) -> dict:
"""Point the loader at a private ``sys.modules`` stand-in.
A real dict, because the fix rests on ``list(dict)`` being one atomic C-level copy —
a Python-level mapping stub would not exercise that property.
The whole ``sys`` reference is swapped (the real ``sys.modules`` cannot be replaced
without breaking the process), so only ``_evict_modules`` may be called under this
fixture: any loader path that reaches ``sys.path``/``sys.executable`` would fail with
``AttributeError`` on the stand-in.
"""
modules: dict[str, object] = {
f"unrelated_{i}": types.ModuleType(f"unrelated_{i}") for i in range(_MODULE_COUNT)
}
monkeypatch.setattr(plugins_loader, "sys", types.SimpleNamespace(modules=modules))
return modules
@pytest.fixture
def fast_thread_switching() -> Iterator[None]:
"""Force frequent GIL handoffs so the eviction/import interleaving actually happens.
The switch interval is process-global, but CI runs one pytest subprocess per test file
(``run_tests_parallel.py``), so the blast radius is this file. Restored via the fixture
rather than an inline ``finally`` so a failure mid-setup cannot leak it.
"""
previous = sys.getswitchinterval()
sys.setswitchinterval(1e-6)
try:
yield
finally:
sys.setswitchinterval(previous)
def test_evict_modules_drops_module_and_submodules(isolated_modules: dict) -> None:
for name in ("hermes_plugins.aop", "hermes_plugins.aop.client", "hermes_plugins.aop_other"):
isolated_modules[name] = types.ModuleType(name)
plugins_loader._evict_modules("hermes_plugins.aop")
assert "hermes_plugins.aop" not in isolated_modules
assert "hermes_plugins.aop.client" not in isolated_modules
# A sibling sharing the prefix without the dot boundary must survive.
assert "hermes_plugins.aop_other" in isolated_modules
def test_evict_modules_tolerates_concurrent_imports(
isolated_modules: dict, fast_thread_switching: None,
) -> None:
"""A concurrent import must not abort the plugin load.
Iterating the live mapping raised ``RuntimeError: dictionary changed size during
iteration``; ``PluginLoader._load`` catches it and degrades to
``Failed to load plugin '<name>': ...``, so none of that plugin's tools ever register
and every later lookup reports the tool as unknown.
"""
stop = threading.Event()
failures: list[BaseException] = []
churn_rounds = 0
def churn() -> None:
nonlocal churn_rounds
while not stop.is_set():
batch = [f"late_import_{churn_rounds}_{j}" for j in range(_CHURN_BATCH)]
for key in batch:
isolated_modules[key] = None
for key in batch:
isolated_modules.pop(key, None)
churn_rounds += 1
def evict() -> None:
try:
for i in range(_EVICTIONS):
name = f"hermes_plugins.victim_{i}"
isolated_modules[name] = None
isolated_modules[f"{name}.sub"] = None
plugins_loader._evict_modules(name)
except BaseException as exc: # recorded for the assertion below
failures.append(exc)
churner = threading.Thread(target=churn, daemon=True)
churner.start()
try:
evictor = threading.Thread(target=evict)
evictor.start()
evictor.join(timeout=60)
assert not evictor.is_alive(), "eviction thread hung"
finally:
stop.set()
churner.join(timeout=10)
assert not failures, f"eviction raised under concurrent import: {failures[0]!r}"
# Without these two, the test passes vacuously: a churner that never got scheduled leaves
# the eviction running against a mapping it has to itself, which is the case the fix is
# not about. A silent pass here would mean the regression stopped being covered at all.
assert churn_rounds > 0, "churn thread never ran — the race window was never opened"
leftover = [name for name in isolated_modules if name.startswith("hermes_plugins.victim_")]
assert not leftover, f"eviction left entries behind: {leftover[:5]}"