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.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
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.pyindex 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 annotationsimport jsonfrom pathlib import Path+import pytest++from headroom import fsutilfrom headroom.mcp_registry.antigravity import AntigravityRegistrarfrom headroom.mcp_registry.base import RegisterStatus, ServerSpecfrom 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.pyindex 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 tomllibdiff --git a/tests/test_mcp_registry_antigravity.py b/tests/test_mcp_registry_antigravity.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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.pyindex 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 stoppedasyncio.run(registry.stop_all())+ assert after.stopped is Truedef 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 Noneasyncio.run(registry.start_all())+ assert registry.get_all_stats() == {"passive": {"passive": True}}+ assert asyncio.run(t.stop()) is Noneasyncio.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.pydeleted file mode 100644index 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}