Files
hermes-agent/tests/tools/test_mcp_enabled_reader.py
kshitij a6596515ab fix(config): config set clears a legacy disabled on a dotted server name too
Second-model review of 4fa5119686: `hermes config set mcp_servers.s.example.enabled true`
on an existing server named `s.example` printed success and left it off. `_set_nested`
resolves an existing dotted name greedily (`s.example` is one entry), but the cleanup
split the key by length and looked for a server named `s`. The cleanup now resolves the
written key with the same `_locate_nested` walk, so it reaches the entry the write landed
on, escaped or not. `hermes mcp list` escapes the dots in the command it suggests.
2026-11-12 14:09:07 +05:30

149 lines
6.3 KiB
Python

"""Every reader of ``mcp_servers.<name>.enabled`` gives one answer per value.
The MCP client, the toolset resolver, the profile editor, the catalog and the list/status
surfaces used to parse the key four different ways, so ``enabled: 0`` was off for the resolver
and on for the client, and ``enabled: "false"`` was on in the server list. The case table is
shared with the desktop (``apps/desktop/src/lib/mcp-enabled-cases.json``).
"""
from __future__ import annotations
import json
from pathlib import Path
import pytest
CASES = json.loads(
(Path(__file__).resolve().parents[2] / "apps/desktop/src/lib/mcp-enabled-cases.json").read_text(encoding="utf-8"))
def _readers():
from hermes_cli.mcp_catalog import server_enabled
from hermes_cli.tools_config import enabled_mcp_server_names
from tools.mcp_tool_common import mcp_server_enabled
from tui_gateway.mcp_rpc_helpers import summarize_server
from tui_gateway.methods_profiles import _mcp_entry_enabled
return {
"mcp client": mcp_server_enabled,
"toolset resolver": lambda cfg: "s" in enabled_mcp_server_names({"mcp_servers": {"s": cfg}}),
"profile editor": _mcp_entry_enabled,
"catalog": server_enabled,
"server list": lambda cfg: summarize_server("s", cfg)["enabled"],
}
@pytest.mark.parametrize("case", CASES, ids=lambda c: repr({k: v for k, v in c.items() if k != "on"}))
def test_every_reader_agrees_with_the_shared_table(case):
entry = {k: v for k, v in case.items() if k != "on"}
answers = {name: bool(read({"command": "x", **entry})) for name, read in _readers().items()}
assert answers == dict.fromkeys(answers, case["on"])
def _spawned(monkeypatch) -> list:
import tools.mcp_tool as core
from tools import mcp_tool_discovery as discovery
spawned: list = []
monkeypatch.setattr(core, "_ensure_mcp_sdk", lambda: True)
monkeypatch.setattr(discovery._loop, "_ensure_mcp_loop", lambda: None)
monkeypatch.setattr(discovery, "_run_discovery_pass", lambda servers: spawned.extend(sorted(servers)))
monkeypatch.setattr(discovery, "_acquire_discovery_lock_with_retry", lambda: None)
monkeypatch.setattr(discovery, "_register_lazy_from_cache", lambda s: (s, 0, 0))
for state in ("_servers", "_server_connecting", "_lazy_server_configs", "_server_scope_keys"):
monkeypatch.setattr(core, state, type(getattr(core, state))())
discovery.discover_mcp_tools()
return spawned
def _picker(name):
from hermes_cli.mcp_picker import _enable_disable
_enable_disable(name, enable=True)
def _route(name):
import asyncio
from hermes_cli.web_models import MCPEnabledToggle
from hermes_cli.web_routers.mcp import set_mcp_server_enabled
asyncio.run(set_mcp_server_enabled(name, MCPEnabledToggle(enabled=True)))
def _connector(name):
from tools.connectors.mcp import _CatalogBackend
_CatalogBackend().enable(name)
def _config_set(name):
from hermes_cli.config import set_config_value
set_config_value(f"mcp_servers.{name}.enabled", "true")
@pytest.mark.parametrize("enable", [_picker, _route, _connector, _config_set],
ids=["picker", "PUT route", "connector", "config set"])
def test_enable_clears_a_legacy_disabled_so_the_server_spawns(enable, tmp_path, monkeypatch):
"""The reader lets a legacy `disabled: true` win over `enabled`, so an enable that only set
`enabled` reported success and left the server off. Every enable writer drops the key."""
import hermes_yaml as yaml
from hermes_cli.config import DEFAULT_CONFIG, load_config
from tools.mcp_tool_common import mcp_server_enabled
config_path = tmp_path / "config.yaml"
config_path.write_text(yaml.safe_dump({
"_config_version": DEFAULT_CONFIG["_config_version"],
"mcp_servers": {"s": {"command": "true", "disabled": True}},
}), encoding="utf-8")
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
assert _spawned(monkeypatch) == []
enable("s")
entry = yaml.safe_load(config_path.read_text(encoding="utf-8"))["mcp_servers"]["s"]
assert "disabled" not in entry and entry["enabled"] is True
assert mcp_server_enabled(load_config()["mcp_servers"]["s"]) is True
assert _spawned(monkeypatch) == ["s"]
@pytest.mark.parametrize("case", [c for c in CASES if set(c) == {"disabled", "on"}], ids=lambda c: repr(c["disabled"]))
def test_v46_turns_off_exactly_what_the_reader_reads_as_off(case, tmp_path, monkeypatch):
"""v46 runs on every pass (stamp-independent) because it resolves `disabled` as the reader
does; a value the two parse differently (a float) would flip a server on a re-run."""
import hermes_yaml as yaml
from hermes_cli.config_migrations import run_migrations
config_path = tmp_path / "config.yaml"
config_path.write_text(yaml.safe_dump({
"_config_version": 45, "mcp_servers": {"s": {"command": "x", "disabled": case["disabled"]}},
}), encoding="utf-8")
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
run_migrations(45, {"env_added": [], "config_added": [], "warnings": []}, quiet=True)
entry = yaml.safe_load(config_path.read_text(encoding="utf-8"))["mcp_servers"]["s"]
assert (entry.get("enabled") is False) is (not case["on"])
@pytest.mark.parametrize("key", ["mcp_servers.s.example.enabled", "mcp_servers.s\\.example.enabled"],
ids=["unescaped", "escaped"])
def test_config_set_enable_clears_disabled_on_a_dotted_server_name(key, tmp_path, monkeypatch):
"""`config set` resolves an existing dotted server name greedily; the cleanup must reach the
same entry, or the server stays off after a printed success."""
import hermes_yaml as yaml
from hermes_cli.config import DEFAULT_CONFIG, load_config, set_config_value
from tools.mcp_tool_common import mcp_server_enabled
config_path = tmp_path / "config.yaml"
config_path.write_text(yaml.safe_dump({
"_config_version": DEFAULT_CONFIG["_config_version"],
"mcp_servers": {"s.example": {"command": "true", "disabled": True}},
}), encoding="utf-8")
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
set_config_value(key, "true")
entry = yaml.safe_load(config_path.read_text(encoding="utf-8"))["mcp_servers"]["s.example"]
assert "disabled" not in entry and entry["enabled"] is True
assert mcp_server_enabled(load_config()["mcp_servers"]["s.example"]) is True