Files
headroom/tests/test_subscription_tracker.py
Tejas Chopra f30d330682 refactor(install,subscription): share manifest parsing and warn on corrupt manifests (#4125)
## Description

This PR shares the manifest parsing that was written twice, logs corrupt
manifests instead of skipping them silently, and pins the owner-only
mode of two state files with tests.

- `load_manifest` and `list_manifests` had the same payload-to-manifest
code, including the retired-image migration. They now share
`_manifest_from_payload`.
- `list_manifests` used to skip a corrupt manifest with no log. It now
logs `Skipping corrupt deployment manifest <path>: <error>. Fix or
delete the file to restore that profile.` at warning level. The returned
list is the same as before.
- A manifest that cannot be read (permissions, non-UTF-8 bytes) is no
longer called corrupt. `list_manifests` logs `Skipping unreadable
deployment manifest <path>: <error>. Check the file's permissions and
that it is UTF-8.`, and `load_manifest` raises
`ManifestError("deployment profile '<name>' could not be read (<path>):
<error>. Check the file's permissions and that it is UTF-8.")`. Only a
JSON or schema failure keeps the "is corrupt" text.
- `subscription/client.py` `_credentials_path` reuses
`session_tracking._claude_config_dir()`. Both resolve
`CLAUDE_CONFIG_DIR`, falling back to `~/.claude`, with identical code.
- New tests pin the deployment manifest and the subscription state file
at 0600, both when the file is created and when a 0644 file is
overwritten. The current writers already do this, because the temp file
they rename into place is created 0600.

Refs #4136

## Type of Change

- [ ] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [x] Code refactoring (no functional changes)

## Changes Made

- `headroom/install/state.py`: add `_manifest_from_payload`, use it in
`load_manifest` and `list_manifests`, warn on corrupt manifests in
`list_manifests`, and report read failures separately from malformed
JSON in both.
- `headroom/subscription/client.py`: `_credentials_path` uses
`_claude_config_dir()`.
- `tests/test_install/test_state.py`:
`test_list_manifests_ignores_invalid_payloads` now asserts that the
warning names the broken file and does not name the valid one. Add
`test_save_manifest_keeps_manifest_owner_only` and
`test_unreadable_and_malformed_manifests_get_distinct_messages` (a
PermissionError on read and a malformed file get different messages in
`list_manifests` and `load_manifest`).
- `tests/test_subscription_tracker.py`: add
`test_persist_state_keeps_file_owner_only`.

## Testing

- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [x] Type checking passes (`mypy headroom`)
- [x] New tests added for new functionality
- [ ] Manual testing performed

### Test Output

```text
$ pytest -q -p no:cacheprovider tests/test_install/test_state.py tests/test_subscription_tracker.py tests/test_subscription_client.py tests/test_subscription_session_tracking.py tests/test_cli/test_install_cli.py tests/test_quota_registry.py tests/test_mcp_registry tests/test_stateless_no_disk.py tests/test_telemetry_context.py tests/test_cli_doctor.py tests/test_fsutil.py
# on origin/main (a9815bbb):
502 passed, 1 warning in 18.30s
# on this branch (2 new mode tests + 1 read-vs-malformed test):
505 passed, 1 warning in 18.29s
# the read-vs-malformed test against the previous commit (828b107a): 1 failed (both called corrupt)
# the 2 mode tests run against a variant that writes both files with fsutil.write_text:
2 failed in 0.76s
$ uvx ruff@0.16.8 check <4 touched files>
All checks passed!
$ mypy headroom/install/state.py headroom/subscription/client.py --ignore-missing-imports
Success: no issues found in 2 source files
```

## Real Behavior Proof

- Environment: macOS, Python 3.12, repo `.venv`, this branch's worktree.
Temp `HOME`, `HEADROOM_WORKSPACE_DIR` and `CODEX_HOME`.
- Exact command / steps:
1. Shared smoke harness: a real proxy from this checkout against a local
fake upstream (`smoke.sh <worktree>`).
2. Real CLI against two broken profiles in the temp workspace:
`malformed` holds `{not json`, and `unreadable` is a valid manifest with
mode 000. `headroom install status` with each `--profile`, then without
one, which falls back to `list_manifests()`.
3. File modes were measured directly, as before: the manifest and
tracker writers give 0600 on create and 0600 on overwrite of a 0644
file.
- Observed result:

```text
branch: cleanup/cli-integrations-fsutil-state-writes @ 71e669eb
health: 200
POST /v1/messages        -> HTTP200 smoke-ok
POST /v1/chat/completions -> HTTP200 smoke-ok
stats: requests=2 failed=0 tokens_saved=13574 savings_percent=99.82
proxy.log WARNING/ERROR lines ($SMOKE/ws/logs/proxy-50695.log):
   2 headroom.proxy - WARNING - event=proxy_offline_mode air-gap active — every connection Headroom initiates is refused (telemetry, update check, license reporter, model/tokenizer/binary/dataset downloads, remote Kompress, OTLP/Langfuse export, Copilot auth, subscription polling, OpenAI embedders, Headroom Cloud compression). Still allowed on purpose: forwarding your requests to the upstream you configured, operator-configured local endpoints, loopback health probes.
   4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch found no usable file for chopratejas/kompress-v2-base
   4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch refused for chopratejas/kompress-v2-base (HEADROOM_OFFLINE is set): HEADROOM_OFFLINE is set: refusing outbound network access for HuggingFace download of chopratejas/kompress-v2-base/onnx/kompress-int8-wo.onnx to huggingface.co. Unset HEADROOM_OFFLINE, or turn off the feature that needs this connection.
(smoke dir: $SMOKE)
```

```text
$ headroom install status --profile malformed
Error: deployment profile 'malformed' is corrupt ($TMP/ws/deploy/malformed/manifest.json): Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
exit=1
$ headroom install status --profile unreadable
Error: deployment profile 'unreadable' could not be read ($TMP/ws/deploy/unreadable/manifest.json): [Errno 13] Permission denied: '$TMP/ws/deploy/unreadable/manifest.json'. Check the file's permissions and that it is UTF-8.
exit=1
$ headroom install status   # no --profile: falls back to list_manifests()
Skipping corrupt deployment manifest $TMP/ws/deploy/malformed/manifest.json: Expecting property name enclosed in double quotes: line 1 column 2 (char 1). Fix or delete the file to restore that profile.
Skipping unreadable deployment manifest $TMP/ws/deploy/unreadable/manifest.json: [Errno 13] Permission denied: '$TMP/ws/deploy/unreadable/manifest.json'. Check the file's permissions and that it is UTF-8.
Error: No deployment profile named 'default' is installed. No deployments are installed; run `headroom init` or `headroom install apply`.
exit=1
```

- Not tested: Windows, where mode bits do not decide access; the mode
tests skip there.

## Runtime Rollout Safety

- Rollout-managed feature(s): None.
- Minimum rollout channel: N/A; internal refactor plus one warning log.
- Stable/default behavior changed: No. The only visible change is a new
warning when a corrupt manifest is skipped.
- Kill switch / disable path: N/A.
- Unsafe override required: No.
- Qualification impact: None.
- Rollback path: Revert this commit.

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)

## Screenshots (if applicable)

N/A

## Additional Notes

Part of maintainer-requested cleanup #4136 (dead code, duplication,
debuggability), split into small PRs for review.

Not done, on purpose: the cleanup plan proposed replacing
`install/state.py` `_atomic_write_text` and the tracker's
`_persist_state` writer with `fsutil.write_text`. That would weaken file
permissions. `fsutil.write_text` copies an existing file's mode onto the
replacement, so a manifest or subscription state file that is 0644 today
would stay readable by other users. The current writers reset it to 0600
on every write. Both writers stay, and the new tests pin that behaviour.
Two follow-ups for the maintainer:
- `_persist_state` has no fsync and leaves its `.tmp` file behind if
`os.replace` fails.
- Either an owner-only mode option on `fsutil.write_text`, or an atomic
writer in `headroom/fileperms.py`, would let these writers share code.

The new `list_manifests` warning fires once per corrupt file per call.
The callers are CLI commands, doctor, port discovery, and the telemetry
install-mode check. None of them is on the per-request path.

🤖 Generated with [Claude Code](https://claude.com/claude-code)
2026-10-12 18:58:51 -07:00

499 lines
19 KiB
Python

from __future__ import annotations
import json
import os
import stat
import sys
import threading
from datetime import datetime, timedelta
from pathlib import Path
from types import SimpleNamespace
import pytest
import headroom.subscription.tracker as tracker_module
from headroom.subscription.models import (
HeadroomContribution,
RateLimitWindow,
SubscriptionSnapshot,
WindowDiscrepancy,
WindowTokens,
_utc_now,
)
from headroom.subscription.tracker import SubscriptionTracker
def _make_snapshot(
*,
token_prefix: str = "token123",
reset_offset_hours: int = 5,
resets_at: datetime | None = None,
) -> SubscriptionSnapshot:
return SubscriptionSnapshot(
five_hour=RateLimitWindow(
used=10,
limit=100,
utilization_pct=10.0,
resets_at=(
resets_at
if resets_at is not None
else _utc_now() + timedelta(hours=reset_offset_hours)
),
),
seven_day=RateLimitWindow(used=20, limit=200, utilization_pct=10.0),
token_prefix=token_prefix,
)
def test_tracker_notify_active_update_and_basic_state(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker(enabled=False)
assert tracker.is_available() is False
assert tracker.latest_snapshot is None
assert tracker.is_active() is False
assert isinstance(tracker.get_stats(), dict)
tracker.notify_active("")
tracker.notify_active("Basic token")
tracker.notify_active("Bearer sk-ant-api-key")
assert tracker._current_token is None
tracker.notify_active("Bearer oauth-token-123", from_local_operator=True)
assert tracker._current_token == "oauth-token-123"
assert tracker.is_active() is True
tracker.update_contribution(
tokens_submitted=10,
tokens_saved_compression=5,
tokens_saved_cache_reads=3,
compression_savings_usd=1.25,
cache_savings_usd=-2.0,
)
contribution = tracker._state.contribution
assert contribution.tokens_submitted == 10
assert contribution.tokens_saved_compression == 5
assert contribution.tokens_saved_cache_reads == 3
assert contribution.to_dict()["tokens_saved"]["compression"] == 5
assert contribution.to_dict()["tokens_saved"]["proxy_compression"] == 5
assert contribution.compression_savings_usd == 1.25
assert contribution.cache_savings_usd == 0.0
@pytest.mark.asyncio
async def test_tracker_start_stop_and_rollover_reset(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker(persist_path=tmp_path / "state.json")
async def fake_poll_loop() -> None:
assert tracker._stop_event is not None
await tracker._stop_event.wait()
tracker._poll_loop = fake_poll_loop # type: ignore[method-assign]
await tracker.start()
first_task = tracker._poll_task
assert first_task is not None
await tracker.start()
assert tracker._poll_task is first_task
await tracker.stop()
assert tracker._stop_event is not None and tracker._stop_event.is_set()
assert tracker._persist_path.exists()
tracker._state.history = [
_make_snapshot(reset_offset_hours=5),
_make_snapshot(reset_offset_hours=6),
]
tracker._state.contribution = HeadroomContribution(tokens_submitted=99)
tracker._maybe_reset_contribution(tracker._state.history[-1])
assert tracker._state.contribution.tokens_submitted == 0
def test_second_level_reset_jitter_does_not_reset_contribution(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
"""Regression: the usage API reports ``resets_at`` with second-level jitter
within a single window (observed flapping between ``01:59:59Z`` and
``02:00:00Z`` on consecutive polls). That must NOT be treated as a rollover,
or the contribution counters get zeroed every poll and the dashboard sticks
at ~0% savings.
"""
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker(persist_path=tmp_path / "state.json")
base = _utc_now() + timedelta(hours=3)
tracker._state.history = [
_make_snapshot(resets_at=base),
_make_snapshot(resets_at=base + timedelta(seconds=1)),
]
tracker._state.contribution = HeadroomContribution(tokens_submitted=99)
tracker._maybe_reset_contribution(tracker._state.history[-1])
assert tracker._state.contribution.tokens_submitted == 99
def test_genuine_five_hour_rollover_resets_contribution(
monkeypatch: pytest.MonkeyPatch, tmp_path: Path
) -> None:
"""A real rollover advances ``resets_at`` by ~5 hours and still resets."""
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker(persist_path=tmp_path / "state.json")
base = _utc_now()
tracker._state.history = [
_make_snapshot(resets_at=base),
_make_snapshot(resets_at=base + timedelta(hours=5)),
]
tracker._state.contribution = HeadroomContribution(tokens_submitted=99)
tracker._maybe_reset_contribution(tracker._state.history[-1])
assert tracker._state.contribution.tokens_submitted == 0
@pytest.mark.asyncio
async def test_maybe_poll_handles_inactive_and_none_snapshot(
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker()
monkeypatch.setattr("headroom.subscription.client.read_cached_oauth_token", lambda: None)
await tracker._maybe_poll()
assert tracker._state.poll_count == 0
monkeypatch.setattr(
"headroom.subscription.client.read_cached_oauth_token", lambda: "cached-token"
)
async def fetch_none(token: str | None):
return None
tracker._client = SimpleNamespace(fetch=fetch_none)
await tracker._maybe_poll()
assert tracker._state.last_error == "fetch returned None"
assert tracker._state.poll_errors == 1
@pytest.mark.asyncio
async def test_maybe_poll_prefers_refreshed_credentials_token_over_stale_header(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""Regression (#3913): the credentials file is where Claude Code writes the
*refreshed* OAuth token. Polling the remembered Authorization-header token
first pinned every poll to an expired credential, so `/stats` reported
permanent `poll_errors` and a `polled_at` that never advanced."""
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker()
# Token captured from a proxied local-operator request, before Claude Code rotated it.
tracker.notify_active("Bearer stale-header-token", from_local_operator=True)
monkeypatch.setattr(
"headroom.subscription.client.read_cached_oauth_token", lambda: "refreshed-file-token"
)
snapshot = _make_snapshot()
attempted: list[str | None] = []
async def fetch_snapshot(token: str | None):
attempted.append(token)
# The stale header token is what Anthropic rejects with 401 -> None.
if token == "stale-header-token":
return None
return snapshot
tracker._client = SimpleNamespace(fetch=fetch_snapshot)
monkeypatch.setattr(tracker, "_persist_state", lambda: None)
await tracker._maybe_poll()
assert attempted == ["refreshed-file-token"]
assert tracker.latest_snapshot is snapshot
assert tracker._state.poll_errors == 0
assert tracker._state.last_error is None
@pytest.mark.asyncio
async def test_maybe_poll_falls_back_to_header_token_when_file_token_rejected(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""The remembered header token is still the only credential when no
credentials file exists, so a rejection of the file token must fall back to
it rather than mark the tracker errored."""
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker()
tracker.notify_active("Bearer header-only-token", from_local_operator=True)
monkeypatch.setattr(
"headroom.subscription.client.read_cached_oauth_token", lambda: "revoked-file-token"
)
snapshot = _make_snapshot()
attempted: list[str | None] = []
async def fetch_snapshot(token: str | None):
attempted.append(token)
if token == "revoked-file-token":
return None
return snapshot
tracker._client = SimpleNamespace(fetch=fetch_snapshot)
monkeypatch.setattr(tracker, "_persist_state", lambda: None)
await tracker._maybe_poll()
assert attempted == ["revoked-file-token", "header-only-token"]
assert tracker.latest_snapshot is snapshot
assert tracker._state.poll_errors == 0
@pytest.mark.asyncio
async def test_maybe_poll_single_request_when_file_token_matches_header(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""Identical tokens must not be spent twice — the common case for a proxy
session whose credentials file holds the same token as the header."""
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker()
tracker.notify_active("Bearer shared-token", from_local_operator=True)
monkeypatch.setattr(
"headroom.subscription.client.read_cached_oauth_token", lambda: "shared-token"
)
attempted: list[str | None] = []
async def fetch_snapshot(token: str | None):
attempted.append(token)
return _make_snapshot()
tracker._client = SimpleNamespace(fetch=fetch_snapshot)
monkeypatch.setattr(tracker, "_persist_state", lambda: None)
await tracker._maybe_poll()
assert attempted == ["shared-token"]
@pytest.mark.asyncio
async def test_maybe_poll_success_updates_state_and_metrics(
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker()
tracker.notify_active("Bearer live-oauth-token", from_local_operator=True)
# Pin the credentials-file/env source so this exercises the adopted
# local-operator header path, not whatever token the host happens to hold.
monkeypatch.setattr("headroom.subscription.client.read_cached_oauth_token", lambda: None)
snapshot = _make_snapshot()
discrepancies = [WindowDiscrepancy(kind="cache_miss", description="miss", severity="warning")]
metrics_calls: list[dict] = []
async def fetch_snapshot(token: str | None):
assert token == "live-oauth-token"
return snapshot
tracker._client = SimpleNamespace(fetch=fetch_snapshot)
monkeypatch.setattr(
tracker_module, "_compute_window_tokens_for_snapshot", lambda snap: WindowTokens(input=7)
)
monkeypatch.setattr(tracker_module, "_detect_discrepancies", lambda snap, tokens: discrepancies)
monkeypatch.setattr(
tracker, "_persist_state", lambda: metrics_calls.append({"persisted": True})
)
monkeypatch.setitem(
sys.modules,
"headroom.observability.metrics",
SimpleNamespace(
get_otel_metrics=lambda: SimpleNamespace(
record_subscription_window=lambda state: metrics_calls.append(state)
)
),
)
await tracker._maybe_poll()
assert tracker.latest_snapshot is snapshot
assert tracker._state.window_tokens.input == 7
assert tracker._state.discrepancies[-1].kind == "cache_miss"
assert tracker._state.last_error is None
assert tracker._state.poll_count == 1
assert metrics_calls[0] == {"persisted": True}
assert isinstance(metrics_calls[1], dict)
@pytest.mark.asyncio
async def test_maybe_poll_runs_transcript_scan_off_event_loop(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""Regression: the transcript scan must run off the event-loop thread, or a
multi-second ~/.claude/projects scan wedges the proxy every poll interval."""
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker()
tracker.notify_active("Bearer live-oauth-token", from_local_operator=True)
monkeypatch.setattr("headroom.subscription.client.read_cached_oauth_token", lambda: None)
snapshot = _make_snapshot()
async def fetch_snapshot(token: str | None) -> SubscriptionSnapshot:
return snapshot
tracker._client = SimpleNamespace(fetch=fetch_snapshot)
loop_thread_id = threading.get_ident()
seen: dict[str, int] = {}
def recording_compute(snap: SubscriptionSnapshot) -> WindowTokens:
seen["thread_id"] = threading.get_ident()
return WindowTokens(input=7)
monkeypatch.setattr(tracker_module, "_compute_window_tokens_for_snapshot", recording_compute)
monkeypatch.setattr(tracker_module, "_detect_discrepancies", lambda snap, tokens: [])
monkeypatch.setattr(tracker, "_persist_state", lambda: None)
monkeypatch.setitem(
sys.modules,
"headroom.observability.metrics",
SimpleNamespace(
get_otel_metrics=lambda: SimpleNamespace(record_subscription_window=lambda state: None)
),
)
await tracker._maybe_poll()
# The blocking scan ran on a worker thread, not the event-loop thread.
assert seen["thread_id"] != loop_thread_id
@pytest.mark.skipif(os.name != "posix", reason="mode bits decide access only on POSIX")
def test_persist_state_keeps_file_owner_only(tmp_path: Path) -> None:
persist_path = tmp_path / "tracker-state.json"
tracker = SubscriptionTracker(persist_path=persist_path)
tracker._persist_state()
assert stat.S_IMODE(persist_path.stat().st_mode) == 0o600
# A state file left group/world-readable is tightened on the next write.
persist_path.chmod(0o644)
tracker._persist_state()
assert stat.S_IMODE(persist_path.stat().st_mode) == 0o600
@pytest.mark.asyncio
async def test_maybe_poll_logs_a_failed_otel_update(
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
) -> None:
"""A broken OTEL exporter must not break polling, but must leave a trace."""
monkeypatch.setattr(SubscriptionTracker, "_load_persisted_state", lambda self: None)
tracker = SubscriptionTracker()
tracker.notify_active("Bearer live-oauth-token", from_local_operator=True)
monkeypatch.setattr("headroom.subscription.client.read_cached_oauth_token", lambda: None)
snapshot = _make_snapshot()
async def fetch_snapshot(token: str | None) -> SubscriptionSnapshot:
return snapshot
def broken_exporter(state: dict) -> None:
raise RuntimeError("exporter down")
tracker._client = SimpleNamespace(fetch=fetch_snapshot)
monkeypatch.setattr(
tracker_module, "_compute_window_tokens_for_snapshot", lambda snap: WindowTokens(input=7)
)
monkeypatch.setattr(tracker_module, "_detect_discrepancies", lambda snap, tokens: [])
monkeypatch.setattr(tracker, "_persist_state", lambda: None)
monkeypatch.setitem(
sys.modules,
"headroom.observability.metrics",
SimpleNamespace(
get_otel_metrics=lambda: SimpleNamespace(record_subscription_window=broken_exporter)
),
)
with caplog.at_level("DEBUG", logger="headroom.subscription.tracker"):
await tracker._maybe_poll()
assert tracker.latest_snapshot is snapshot
assert tracker._state.last_error is None
assert "Subscription OTEL metrics update failed: exporter down" in [
r.getMessage() for r in caplog.records if r.name == "headroom.subscription.tracker"
]
def test_persist_and_load_state_round_trip(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
persist_path = tmp_path / "tracker-state.json"
tracker = SubscriptionTracker(persist_path=persist_path)
tracker.update_contribution(
tokens_submitted=11,
tokens_saved_compression=2,
tokens_saved_cache_reads=4,
compression_savings_usd=1.5,
cache_savings_usd=2.5,
)
tracker._state.poll_count = 7
tracker._persist_state()
loader = SubscriptionTracker(persist_path=persist_path)
assert loader._state.contribution.tokens_submitted == 11
assert loader._state.contribution.tokens_saved_compression == 2
assert loader._state.contribution.tokens_saved_cache_reads == 4
assert loader._state.contribution.to_dict()["tokens_saved"]["compression"] == 2
assert loader._state.contribution.to_dict()["tokens_saved"]["proxy_compression"] == 2
assert loader._state.contribution.compression_savings_usd == 1.5
assert loader._state.contribution.cache_savings_usd == 2.5
assert loader._state.poll_count == 7
persist_path.write_text("{invalid", encoding="utf-8")
broken = SubscriptionTracker(persist_path=persist_path)
assert broken._state.poll_count == 0
missing = SubscriptionTracker(persist_path=tmp_path / "missing.json")
assert missing._state.poll_count == 0
def test_load_state_written_before_cli_context_tools_were_removed(tmp_path: Path) -> None:
"""A pre-removal state file must still load; the retired keys are ignored.
Older releases persisted ``cli_filtering`` / ``cli_filtering_raw`` / ``rtk``
/ ``rtk_raw`` counters, and wrote the dashboard-facing ``compression`` as
proxy-compression *plus* CLI filtering. Those files are still on users'
disks, so the loader must neither raise on the extra keys nor double-count
the inflated ``compression`` value — it prefers ``proxy_compression``.
"""
persist_path = tmp_path / "tracker-state.json"
persist_path.write_text(
json.dumps(
{
"poll_count": 7,
"contribution": {
"tokens_submitted": 11,
"tokens_saved": {
# 2 (proxy) + 9 (retired CLI layer) as older code wrote it.
"compression": 11,
"proxy_compression": 2,
"cli_filtering": 9,
"cli_filtering_raw": 3,
"rtk": 9,
"rtk_raw": 9,
"cache_reads": 4,
"total": 15,
},
"savings_usd": {"compression": 1.5, "cache": 2.5},
},
}
),
encoding="utf-8",
)
loader = SubscriptionTracker(persist_path=persist_path)
assert loader._state.poll_count == 7
assert loader._state.contribution.tokens_submitted == 11
# The raw proxy field wins, so the retired layer's tokens are not counted.
assert loader._state.contribution.tokens_saved_compression == 2
assert loader._state.contribution.tokens_saved_cache_reads == 4
assert loader._state.contribution.compression_savings_usd == 1.5
assert loader._state.contribution.cache_savings_usd == 2.5
# The retired keys are gone from what the tracker now emits.
emitted = loader._state.contribution.to_dict()["tokens_saved"]
assert "cli_filtering" not in emitted
assert "rtk" not in emitted