test: raise subscription coverage

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: JerrettDavis

tests/test_copilot_quota.py

@@ -2,14 +2,21 @@
 
 from __future__ import annotations
 
+import asyncio
+import sys
 import time
+from types import SimpleNamespace
 
 import pytest
 
+import headroom.subscription.copilot_quota as quota_module
 from headroom.subscription.copilot_quota import (
     CopilotQuotaCategory,
     CopilotQuotaSnapshot,
+    CopilotQuotaState,
+    _CopilotQuotaTracker,
     discover_github_token,
+    get_copilot_quota_tracker,
     parse_copilot_quota,
 )
 
@@ -65,6 +72,10 @@ def test_used_percent_clipped_at_zero(self):
         cat = CopilotQuotaCategory(name="chat", percent_remaining=110.0)
         assert cat.used_percent == pytest.approx(0.0)
 
+    def test_used_percent_none_when_entitlement_is_zero(self):
+        cat = CopilotQuotaCategory(name="chat", entitlement=0, remaining=0)
+        assert cat.used_percent is None
+
 
 # ---------------------------------------------------------------------------
 # parse_copilot_quota
@@ -329,3 +340,129 @@ def _count_event_wait() -> int:
         assert residual <= baseline, (
             f"CopilotQuotaTracker left residual Event.wait: baseline={baseline} residual={residual}"
         )
+
+
+def test_copilot_quota_state_to_dict_and_tracker_get_stats() -> None:
+    state = CopilotQuotaState()
+    tracker = _CopilotQuotaTracker()
+
+    assert state.to_dict()["latest"] is None
+    assert tracker.get_stats() is None
+
+    state.latest = CopilotQuotaSnapshot(login="octocat")
+    state.last_error = "boom"
+    state.last_updated = 123.0
+    tracker._state = state
+
+    assert tracker.get_stats()["last_error"] == "boom"
+
+
+@pytest.mark.asyncio
+async def test_tracker_stop_cancels_when_wait_times_out(monkeypatch: pytest.MonkeyPatch) -> None:
+    tracker = _CopilotQuotaTracker()
+    tracker._stop_event = asyncio.Event()
+    tracker._task = asyncio.create_task(asyncio.sleep(60))
+
+    async def fake_wait_for(awaitable, timeout):  # noqa: ANN001, ANN202
+        raise asyncio.TimeoutError
+
+    monkeypatch.setattr(quota_module.asyncio, "wait_for", fake_wait_for)
+
+    await tracker.stop()
+    await asyncio.sleep(0)
+
+    assert tracker._task.cancelled() is True
+
+
+def _install_fake_aiohttp(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    payload: dict | None = None,
+    status: int = 200,
+    ok: bool = True,
+    exc: Exception | None = None,
+) -> None:
+    class FakeTimeout:
+        def __init__(self, total: float) -> None:
+            self.total = total
+
+    class FakeResponse:
+        def __init__(self) -> None:
+            self.status = status
+            self.ok = ok
+
+        async def __aenter__(self):
+            if exc is not None:
+                raise exc
+            return self
+
+        async def __aexit__(self, exc_type, exc_value, traceback) -> bool:
+            return False
+
+        async def json(self):
+            return payload or {}
+
+    class FakeSession:
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, exc_type, exc_value, traceback) -> bool:
+            return False
+
+        def get(self, url: str, headers: dict[str, str], timeout: FakeTimeout):
+            assert url.endswith("/copilot_internal/user")
+            assert headers["Authorization"].startswith("Bearer ")
+            assert timeout.total == 10
+            return FakeResponse()
+
+    monkeypatch.setitem(
+        sys.modules,
+        "aiohttp",
+        SimpleNamespace(ClientTimeout=FakeTimeout, ClientSession=lambda: FakeSession()),
+    )
+
+
+@pytest.mark.asyncio
+async def test_maybe_poll_covers_response_and_singleton_paths(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    tracker = _CopilotQuotaTracker()
+    monkeypatch.setattr(quota_module, "discover_github_token", lambda: "ghp-test")
+
+    _install_fake_aiohttp(monkeypatch, status=401)
+    await tracker._maybe_poll()
+    assert tracker._state.last_error == "unauthorized — check GITHUB_TOKEN"
+
+    _install_fake_aiohttp(monkeypatch, status=404)
+    await tracker._maybe_poll()
+    assert tracker._state.last_error == "endpoint not found (non-Copilot account?)"
+
+    _install_fake_aiohttp(monkeypatch, status=500, ok=False)
+    await tracker._maybe_poll()
+    assert tracker._state.last_error == "HTTP 500"
+
+    _install_fake_aiohttp(monkeypatch, exc=RuntimeError("network down"))
+    await tracker._maybe_poll()
+    assert tracker._state.last_error == "network down"
+
+    _install_fake_aiohttp(monkeypatch, payload={"quota_snapshots": {}})
+    monkeypatch.setattr(
+        quota_module,
+        "parse_copilot_quota",
+        lambda data: (_ for _ in ()).throw(ValueError("bad")),
+    )
+    await tracker._maybe_poll()
+    assert tracker._state.last_error == "parse error: bad"
+
+    monkeypatch.setattr(quota_module, "parse_copilot_quota", parse_copilot_quota)
+    _install_fake_aiohttp(monkeypatch, payload=_SAMPLE_RESPONSE)
+    await tracker._maybe_poll()
+    assert tracker._state.latest is not None
+    assert tracker._state.latest.login == "octocat"
+    assert tracker._state.last_error is None
+    assert tracker._state.last_updated is not None
+
+    quota_module._singleton = None
+    first = get_copilot_quota_tracker()
+    second = get_copilot_quota_tracker()
+    assert first is second

tests/test_release_version.py

@@ -10,14 +10,20 @@
 
 from headroom.release_version import (
     CommitInfo,
+    ReleaseVersionInfo,
+    SemVer,
     classify_commit_bump,
+    commit_height_since,
     compute_release_version,
     determine_bump_level,
     find_latest_release_tag,
     get_canonical_version,
     list_release_commits,
+    list_release_tags,
+    main,
     normalize_release_tag,
     parse_release_tag,
+    write_github_outputs,
 )
 
 ROOT = Path(__file__).resolve().parent.parent
@@ -107,6 +113,46 @@ def test_parse_release_tag_preserves_legacy_height_for_sorting() -> None:
     assert tag.legacy_height == 3
 
 
+def test_semver_helpers_cover_parse_bump_and_str() -> None:
+    version = SemVer.parse("1.2.3")
+
+    assert str(version) == "1.2.3"
+    assert version.bump("major") == SemVer(2, 0, 0)
+    assert version.bump("minor") == SemVer(1, 3, 0)
+    assert version.bump("patch") == SemVer(1, 2, 4)
+
+    with pytest.raises(ValueError, match="Invalid semantic version"):
+        SemVer.parse("v1.2.3")
+
+    with pytest.raises(ValueError, match="Unsupported bump level"):
+        version.bump("build")
+
+
+def test_release_version_info_as_outputs() -> None:
+    info = ReleaseVersionInfo(
+        version="1.2.4",
+        npm_version="1.2.4",
+        canonical="1.2.3",
+        height="7",
+        bump="patch",
+        previous_tag="v1.2.3",
+    )
+
+    assert info.as_outputs() == {
+        "version": "1.2.4",
+        "npm_version": "1.2.4",
+        "canonical": "1.2.3",
+        "height": "7",
+        "bump": "patch",
+        "previous_tag": "v1.2.3",
+    }
+
+
+def test_parse_release_tag_rejects_invalid_input() -> None:
+    with pytest.raises(ValueError, match="Invalid release tag"):
+        parse_release_tag("release-1.2.3")
+
+
 def test_classify_commit_bump_treats_breaking_change_as_major() -> None:
     assert (
         classify_commit_bump(
@@ -116,6 +162,24 @@ def test_classify_commit_bump_treats_breaking_change_as_major() -> None:
     )
 
 
+def test_classify_commit_bump_uses_merge_summary_and_breaking_body() -> None:
+    assert (
+        classify_commit_bump(
+            CommitInfo(
+                subject="Merge pull request #1 from feature/thing",
+                body="\n\nfeat(api): add window export\n\nmore detail",
+            )
+        )
+        == "minor"
+    )
+    assert (
+        classify_commit_bump(
+            CommitInfo(subject="Merge branch 'topic'", body="BREAKING CHANGE: drop support"),
+        )
+        == "major"
+    )
+
+
 def test_determine_bump_level_uses_greatest_commit_level() -> None:
     commits = [
         CommitInfo(subject="fix: patch one", body=""),
@@ -156,6 +220,89 @@ def test_list_release_commits_parses_empty_body_entries(
     ]
 
 
+def test_list_release_tags_filters_blank_lines(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        "headroom.release_version.subprocess.run",
+        lambda *args, **kwargs: Mock(stdout="v0.1.0\n\nv0.2.0\n"),
+    )
+
+    assert list_release_tags(ROOT) == ["v0.1.0", "v0.2.0"]
+
+
+def test_commit_height_since_handles_empty_and_missing_tag(monkeypatch: pytest.MonkeyPatch) -> None:
+    assert commit_height_since(ROOT, "") == "0"
+
+    monkeypatch.setattr(
+        "headroom.release_version.subprocess.run",
+        lambda *args, **kwargs: Mock(stdout="\n"),
+    )
+
+    assert commit_height_since(ROOT, "v0.1.0") == "0"
+
+
+def test_write_github_outputs_appends_all_values(tmp_path: Path) -> None:
+    output_path = tmp_path / "github-output.txt"
+    info = ReleaseVersionInfo(
+        version="1.0.1",
+        npm_version="1.0.1",
+        canonical="1.0.0",
+        height="2",
+        bump="patch",
+        previous_tag="v1.0.0",
+    )
+
+    write_github_outputs(info, str(output_path))
+
+    assert output_path.read_text(encoding="utf-8").splitlines() == [
+        "version=1.0.1",
+        "npm_version=1.0.1",
+        "canonical=1.0.0",
+        "height=2",
+        "bump=patch",
+        "previous_tag=v1.0.0",
+    ]
+
+
+def test_main_prints_outputs_when_github_output_is_unset(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.delenv("GITHUB_OUTPUT", raising=False)
+    monkeypatch.setenv("LEVEL", "")
+    monkeypatch.setattr("headroom.release_version.list_release_tags", lambda root: ["v1.2.3"])
+    monkeypatch.setattr("headroom.release_version.find_latest_release_tag", lambda tags: "v1.2.3")
+    monkeypatch.setattr(
+        "headroom.release_version.list_release_commits",
+        lambda root, previous_tag: [CommitInfo(subject="feat: add thing", body="")],
+    )
+    monkeypatch.setattr("headroom.release_version.determine_bump_level", lambda commits: "minor")
+    monkeypatch.setattr("headroom.release_version.get_canonical_version", lambda root: "1.2.3")
+    monkeypatch.setattr(
+        "headroom.release_version.compute_release_version",
+        lambda canonical_version, level, tags, manual_version="": ReleaseVersionInfo(
+            version="1.3.0",
+            npm_version="1.3.0",
+            canonical="1.2.3",
+            height="0",
+            bump="minor",
+            previous_tag="v1.2.3",
+        ),
+    )
+    monkeypatch.setattr(
+        "headroom.release_version.commit_height_since", lambda root, previous_tag: "4"
+    )
+
+    main()
+
+    assert capsys.readouterr().out.splitlines() == [
+        "version=1.3.0",
+        "npm_version=1.3.0",
+        "canonical=1.2.3",
+        "height=4",
+        "bump=minor",
+        "previous_tag=v1.2.3",
+    ]
+
+
 def test_release_version_script_runs_directly_without_importing_headroom_package(
     tmp_path: Path,
 ) -> None: