Skip to content

Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.

test: drop duplicate quota-registry and registrar test files (#4126)

Tejas Chopra415fed07bc75
diff --git a/tests/test_mcp_registry/test_antigravity_registrar.py b/tests/test_mcp_registry/test_antigravity_registrar.py
index f24999ab0..8d8f6da71 100644
--- a/tests/test_mcp_registry/test_antigravity_registrar.py
+++ b/tests/test_mcp_registry/test_antigravity_registrar.py
@@ -5,6 +5,9 @@ from __future__ import annotations
import json
from pathlib import Path
+import pytest
+
+from headroom import fsutil
from headroom.mcp_registry.antigravity import AntigravityRegistrar
from headroom.mcp_registry.base import RegisterStatus, ServerSpec
from headroom.mcp_registry.install import get_all_registrars, install_everywhere
@@ -227,6 +230,31 @@ def test_unregister_removes_entry_from_all_locations(tmp_path: Path) -> None:
assert payload["mcpServers"]["other"] == {"command": "other-server"}
+def test_unregister_reports_failure_when_a_write_fails(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ registrar = _make_registrar(tmp_path)
+ current, legacy = _config_path(tmp_path), _legacy_config_path(tmp_path)
+ for path in (current, legacy):
+ path.parent.mkdir(parents=True)
+ path.write_text(json.dumps({"mcpServers": {"headroom": {"command": "headroom"}}}))
+
+ real_write = fsutil.write_text
+
+ def fail_current(path: Path, content: str) -> None:
+ if path == current:
+ raise OSError("read-only filesystem")
+ return real_write(path, content)
+
+ monkeypatch.setattr(fsutil, "write_text", fail_current)
+
+ # The legacy config was cleaned up, but the failed one still registers the
+ # server — so this must not report success.
+ assert registrar.unregister_server("headroom") is False
+ assert "headroom" in json.loads(current.read_text())["mcpServers"]
+ assert "headroom" not in json.loads(legacy.read_text())["mcpServers"]
+
+
def test_registrar_name_and_display_name() -> None:
registrar = AntigravityRegistrar(home_dir=Path("/nonexistent"))
assert registrar.name == "antigravity"
diff --git a/tests/test_mcp_registry/test_grok_registrar.py b/tests/test_mcp_registry/test_grok_registrar.py
index 611e2773d..06c636d28 100644
--- a/tests/test_mcp_registry/test_grok_registrar.py
+++ b/tests/test_mcp_registry/test_grok_registrar.py
@@ -43,6 +43,27 @@ def test_register_uses_grok_home_env(monkeypatch: pytest.MonkeyPatch, tmp_path:
assert "[mcp_servers.headroom]" in config.read_text()
+def test_register_writes_marker_block(tmp_path: Path) -> None:
+ reg = _make_registrar(tmp_path)
+
+ result = reg.register_server(_spec(), force=True)
+
+ assert result.status == RegisterStatus.REGISTERED
+ content = (tmp_path / ".grok" / "config.toml").read_text(encoding="utf-8")
+ assert "[mcp_servers.headroom]" in content
+ assert "# --- Headroom MCP server ---" in content
+
+
+def test_unregister_removes_marker_block(tmp_path: Path) -> None:
+ reg = _make_registrar(tmp_path)
+ reg.register_server(_spec(), force=True)
+ cfg = tmp_path / ".grok" / "config.toml"
+
+ assert reg.unregister_server("headroom") is True
+
+ assert not cfg.exists() or "Headroom MCP server" not in cfg.read_text(encoding="utf-8")
+
+
def test_unregister_keeps_foreign_table_inside_span(tmp_path: Path) -> None:
"""A table another writer appended before our end marker survives unregister."""
import tomllib
diff --git a/tests/test_mcp_registry_antigravity.py b/tests/test_mcp_registry_antigravity.py
deleted file mode 100644
index 2750a59bb..000000000
--- a/tests/test_mcp_registry_antigravity.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import pytest
-
-from headroom import fsutil
-from headroom.mcp_registry.antigravity import AntigravityRegistrar, _config_candidates
-from headroom.mcp_registry.install import build_headroom_spec
-
-
-def _write_config(path: Path, servers: dict) -> None:
- path.parent.mkdir(parents=True, exist_ok=True)
- path.write_text(json.dumps({"mcpServers": servers}), encoding="utf-8")
-
-
-def _servers(path: Path) -> dict:
- return json.loads(path.read_text(encoding="utf-8"))["mcpServers"]
-
-
-def test_antigravity_registrar_register_writes_current_location(tmp_path: Path) -> None:
- registrar = AntigravityRegistrar(home_dir=tmp_path)
-
- result = registrar.register_server(build_headroom_spec("http://127.0.0.1:9999"))
-
- assert result.status.value == "registered"
- assert "headroom" in _servers(_config_candidates(tmp_path)[0])
-
-
-def test_antigravity_unregister_removes_entry_from_every_candidate(
- tmp_path: Path,
-) -> None:
- registrar = AntigravityRegistrar(home_dir=tmp_path)
- for candidate in _config_candidates(tmp_path):
- _write_config(candidate, {"headroom": {"command": "headroom"}})
-
- assert registrar.unregister_server("headroom") is True
- for candidate in _config_candidates(tmp_path):
- assert "headroom" not in _servers(candidate)
-
-
-def test_antigravity_unregister_reports_failure_when_a_write_fails(
- tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
- registrar = AntigravityRegistrar(home_dir=tmp_path)
- candidates = _config_candidates(tmp_path)
- for candidate in candidates:
- _write_config(candidate, {"headroom": {"command": "headroom"}})
-
- real_write = fsutil.write_text
-
- def fail_first(path: Path, content: str) -> None:
- if path == candidates[0]:
- raise OSError("read-only filesystem")
- return real_write(path, content)
-
- monkeypatch.setattr(fsutil, "write_text", fail_first)
-
- # The second config was cleaned up, but the failed one still registers the
- # server — so this must not report success.
- assert registrar.unregister_server("headroom") is False
- assert "headroom" in _servers(candidates[0])
- assert "headroom" not in _servers(candidates[1])
diff --git a/tests/test_mcp_registry_grok.py b/tests/test_mcp_registry_grok.py
deleted file mode 100644
index 2544d8b5c..000000000
--- a/tests/test_mcp_registry_grok.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from headroom.mcp_registry.grok import GrokRegistrar
-from headroom.mcp_registry.install import build_headroom_spec
-
-
-def test_grok_registrar_writes_marker_block(tmp_path: Path) -> None:
- registrar = GrokRegistrar(home_dir=tmp_path)
- spec = build_headroom_spec("http://127.0.0.1:9999")
-
- result = registrar.register_server(spec, force=True)
-
- assert result.status.value == "registered"
- content = registrar._config_file.read_text(encoding="utf-8")
- assert "[mcp_servers.headroom]" in content
- assert "# --- Headroom MCP server ---" in content
-
-
-def test_grok_registrar_unregister_removes_marker_block(tmp_path: Path) -> None:
- registrar = GrokRegistrar(home_dir=tmp_path)
- spec = build_headroom_spec()
- registrar.register_server(spec, force=True)
-
- removed = registrar.unregister_server("headroom")
-
- assert removed is True
- assert (
- not registrar._config_file.exists() or "Headroom MCP server" not in registrar._read_text()
- )
diff --git a/tests/test_quota_registry.py b/tests/test_quota_registry.py
index 8a3f37bd8..70f2273d3 100644
--- a/tests/test_quota_registry.py
+++ b/tests/test_quota_registry.py
@@ -158,8 +158,17 @@ def test_stop_all_calls_stop_on_all_registered():
unavailable = _UnavailableTracker()
registry.register(t)
registry.register(unavailable)
+
+ stopped = []
+
+ async def _stop() -> None:
+ stopped.append(True)
+
+ unavailable.stop = _stop # type: ignore[method-assign]
asyncio.run(registry.stop_all())
assert t.stopped is True
+ # stop() runs regardless of availability
+ assert stopped == [True]
def test_stop_all_continues_on_exception():
@@ -175,18 +184,25 @@ def test_stop_all_continues_on_exception():
def get_stats(self) -> dict | None:
return None
+ after = _AlwaysOnTracker()
registry.register(_BrokenTracker())
- # Should not raise
+ registry.register(after)
+ # Should not raise, and trackers after the failing one are still stopped
asyncio.run(registry.stop_all())
+ assert after.stopped is True
def test_passive_tracker_start_stop_are_noops():
registry = QuotaTrackerRegistry()
t = _PassiveTracker()
registry.register(t)
+ assert t.is_available() is True
+ assert asyncio.run(t.start()) is None
asyncio.run(registry.start_all())
+ assert registry.get_all_stats() == {"passive": {"passive": True}}
+ assert asyncio.run(t.stop()) is None
asyncio.run(registry.stop_all())
- # No assertions needed — we verify no exception is raised
+ assert registry.get_stats("passive") == {"passive": True}
# ---------------------------------------------------------------------------
diff --git a/tests/test_subscription_base.py b/tests/test_subscription_base.py
deleted file mode 100644
index 6f233a6e6..000000000
--- a/tests/test_subscription_base.py
+++ /dev/null
@@ -1,140 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-import headroom.subscription.base as base_module
-from headroom.subscription.base import (
- QuotaTracker,
- QuotaTrackerRegistry,
- get_quota_registry,
- reset_quota_registry,
-)
-
-
-class DummyTracker(QuotaTracker):
- def __init__(
- self,
- key: str,
- *,
- label: str = "Dummy",
- available: bool = True,
- stats: dict | None = None,
- stop_error: Exception | None = None,
- ) -> None:
- self._key = key
- self._label = label
- self._available = available
- self._stats = stats
- self._stop_error = stop_error
- self.started = 0
- self.stopped = 0
-
- @property
- def key(self) -> str:
- return self._key
-
- @property
- def label(self) -> str:
- return self._label
-
- def is_available(self) -> bool:
- return self._available
-
- async def start(self) -> None:
- self.started += 1
-
- async def stop(self) -> None:
- self.stopped += 1
- if self._stop_error:
- raise self._stop_error
-
- def get_stats(self) -> dict | None:
- return self._stats
-
-
-class PassiveTracker(QuotaTracker):
- @property
- def key(self) -> str:
- return "passive"
-
- @property
- def label(self) -> str:
- return "Passive"
-
- def get_stats(self) -> dict | None:
- return {"passive": True}
-
-
-def test_register_get_trackers_and_duplicate_keys() -> None:
- registry = QuotaTrackerRegistry()
- tracker = DummyTracker("alpha", stats={"ok": True})
- registry.register(tracker)
-
- assert registry.get("alpha") is tracker
- assert registry.get("missing") is None
- assert registry.trackers == [tracker]
- assert registry.get_stats("alpha") == {"ok": True}
- assert registry.get_stats("missing") is None
-
- snapshot = registry.trackers
- snapshot.clear()
- assert registry.trackers == [tracker]
-
- with pytest.raises(ValueError, match="already registered"):
- registry.register(DummyTracker("alpha"))
-
-
-async def test_start_all_stop_all_and_stats_filtering() -> None:
- registry = QuotaTrackerRegistry()
- enabled = DummyTracker("enabled", label="Enabled", stats={"value": 1})
- disabled = DummyTracker("disabled", label="Disabled", available=False, stats={"skip": True})
- empty = DummyTracker("empty", label="Empty", stats=None)
- broken = DummyTracker(
- "broken", label="Broken", stats={"value": 2}, stop_error=RuntimeError("boom")
- )
-
- for tracker in (enabled, disabled, empty, broken):
- registry.register(tracker)
-
- await registry.start_all()
- assert enabled.started == 1
- assert disabled.started == 0
- assert empty.started == 1
- assert broken.started == 1
-
- assert registry.get_all_stats() == {
- "enabled": {"value": 1},
- "broken": {"value": 2},
- }
-
- await registry.stop_all()
- assert enabled.stopped == 1
- assert disabled.stopped == 1
- assert empty.stopped == 1
- assert broken.stopped == 1
-
-
-def test_quota_registry_singleton_reset() -> None:
- reset_quota_registry()
- base_module._registry = None
- first = get_quota_registry()
- second = get_quota_registry()
- assert first is second
-
- first.register(DummyTracker("singleton"))
- assert get_quota_registry().get("singleton") is not None
-
- reset_quota_registry()
- refreshed = get_quota_registry()
- assert refreshed is not first
- assert refreshed.trackers == []
-
-
-async def test_quota_tracker_default_methods() -> None:
- tracker = PassiveTracker()
- assert tracker.is_available() is True
- await tracker.start()
- await tracker.stop()
- assert tracker.get_stats() == {"passive": True}