claude-dev-env 1.79.0 → 1.81.0

package/_shared/pr-loop/scripts/tests/test_code_rules_gate.py

@@ -1953,3 +1953,342 @@ def test_main_staged_mode_passes_on_staged_deletion_of_clean_file(
         "a staged deletion has no staged blob; the gate must skip it cleanly "
         "rather than fail closed as if the file were unreadable"
     )
+
+
+def test_run_staged_test_files_passes_for_a_passing_staged_test(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(
+        temporary_git_repository / "test_ok.py",
+        "def test_ok() -> None:\n    assert True\n",
+    )
+    stage_file(temporary_git_repository, "test_ok.py")
+
+    exit_code = gate_module.run_staged_test_files(temporary_git_repository)
+
+    assert exit_code == 0
+
+
+def test_run_staged_test_files_fails_for_a_failing_staged_test(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(
+        temporary_git_repository / "test_bad.py",
+        "def test_bad() -> None:\n    assert False\n",
+    )
+    stage_file(temporary_git_repository, "test_bad.py")
+
+    exit_code = gate_module.run_staged_test_files(temporary_git_repository)
+
+    assert exit_code != 0
+
+
+def test_run_staged_test_files_zero_when_no_test_file_staged(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(temporary_git_repository / "helper.py", "first_value = 1\n")
+    stage_file(temporary_git_repository, "helper.py")
+
+    assert gate_module.run_staged_test_files(temporary_git_repository) == 0
+
+
+def test_run_staged_test_files_zero_when_staged_conftest_collects_no_tests(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(
+        temporary_git_repository / "conftest.py",
+        "import pytest\n\n\n@pytest.fixture()\ndef sample_fixture() -> int:\n"
+        "    return 1\n",
+    )
+    stage_file(temporary_git_repository, "conftest.py")
+
+    assert gate_module.run_staged_test_files(temporary_git_repository) == 0
+
+
+def test_hunk_header_pattern_captures_new_start_and_count() -> None:
+    header_match = gate_module.hunk_header_pattern().match("@@ -12,3 +45,6 @@ def scope")
+    assert header_match is not None
+    assert header_match.group(1) == "45"
+    assert header_match.group(2) == "6"
+
+
+def test_hunk_header_pattern_leaves_count_group_none_for_single_line_hunk() -> None:
+    header_match = gate_module.hunk_header_pattern().match("@@ -0,0 +7 @@")
+    assert header_match is not None
+    assert header_match.group(1) == "7"
+    assert header_match.group(2) is None
+
+
+def test_violation_line_pattern_captures_leading_line_number() -> None:
+    violation_match = gate_module.violation_line_pattern().match(
+        "Line 88: banned identifier"
+    )
+    assert violation_match is not None
+    assert violation_match.group(1) == "88"
+
+
+def test_violation_line_pattern_does_not_match_unprefixed_text() -> None:
+    assert gate_module.violation_line_pattern().match("Function foo is too long") is None
+
+
+def test_filter_paths_under_prefixes_keeps_only_nested_paths(tmp_path: Path) -> None:
+    kept_path = tmp_path / "packages" / "core" / "module.py"
+    dropped_path = tmp_path / "docs" / "guide.py"
+    kept_path.parent.mkdir(parents=True)
+    dropped_path.parent.mkdir(parents=True)
+    kept_path.write_text("kept = 1\n", encoding="utf-8")
+    dropped_path.write_text("dropped = 1\n", encoding="utf-8")
+
+    filtered_paths = gate_module.filter_paths_under_prefixes(
+        [kept_path, dropped_path], tmp_path, ["packages/core"]
+    )
+
+    assert filtered_paths == [kept_path]
+
+
+def test_filter_paths_under_prefixes_returns_input_when_no_prefixes(
+    tmp_path: Path,
+) -> None:
+    only_path = tmp_path / "anywhere.py"
+    only_path.write_text("value = 1\n", encoding="utf-8")
+
+    filtered_paths = gate_module.filter_paths_under_prefixes([only_path], tmp_path, [])
+
+    assert filtered_paths == [only_path]
+
+
+def test_is_code_path_accepts_python_and_typescript_suffixes() -> None:
+    assert gate_module.is_code_path(Path("pkg/module.py"))
+    assert gate_module.is_code_path(Path("pkg/component.tsx"))
+
+
+def test_is_code_path_rejects_non_code_suffix() -> None:
+    assert not gate_module.is_code_path(Path("docs/readme.md"))
+
+
+def test_parse_added_line_numbers_collects_every_added_line() -> None:
+    unified_diff_text = (
+        "diff --git a/target.py b/target.py\n"
+        "@@ -1,0 +2,3 @@\n"
+        "+second = 2\n"
+        "+third = 3\n"
+        "+fourth = 4\n"
+    )
+
+    added_line_numbers = gate_module.parse_added_line_numbers(unified_diff_text)
+
+    assert added_line_numbers == {2, 3, 4}
+
+
+def test_parse_added_line_numbers_ignores_zero_count_hunks() -> None:
+    unified_diff_text = "@@ -5,2 +5,0 @@\n"
+
+    assert gate_module.parse_added_line_numbers(unified_diff_text) == set()
+
+
+def test_is_file_new_at_base_true_for_file_added_after_base(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(temporary_git_repository / "original.py", "first_count = 1\n")
+    commit_all_files(temporary_git_repository, "baseline")
+    base_sha = run_git_in_repository(
+        temporary_git_repository, "rev-parse", "HEAD"
+    ).strip()
+    write_file(temporary_git_repository / "added.py", "second_count = 2\n")
+    commit_all_files(temporary_git_repository, "add second file")
+
+    assert gate_module.is_file_new_at_base(temporary_git_repository, base_sha, "added.py")
+    assert not gate_module.is_file_new_at_base(
+        temporary_git_repository, base_sha, "original.py"
+    )
+
+
+def test_added_lines_for_file_reports_lines_added_since_base(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(temporary_git_repository / "target.py", "first = 1\nsecond = 2\n")
+    commit_all_files(temporary_git_repository, "baseline")
+    base_sha = run_git_in_repository(
+        temporary_git_repository, "rev-parse", "HEAD"
+    ).strip()
+    write_file(
+        temporary_git_repository / "target.py",
+        "first = 1\nsecond = 2\nthird = 3\nfourth = 4\n",
+    )
+    commit_all_files(temporary_git_repository, "append lines")
+
+    added_line_numbers = gate_module.added_lines_for_file(
+        temporary_git_repository, base_sha, "target.py"
+    )
+
+    assert 3 in added_line_numbers
+    assert 4 in added_line_numbers
+    assert 1 not in added_line_numbers
+
+
+def test_extract_violation_line_number_returns_parsed_line() -> None:
+    assert gate_module.extract_violation_line_number("Line 17: magic value") == 17
+
+
+def test_extract_violation_line_number_returns_none_for_unprefixed_text() -> None:
+    assert gate_module.extract_violation_line_number("no line prefix here") is None
+
+
+def test_function_length_span_range_covers_declared_span() -> None:
+    violation_text = "Function 'compute_total' (defined at line 10) is 25 lines - split it"
+
+    span_range = gate_module.function_length_span_range(violation_text)
+
+    assert span_range == range(10, 35)
+
+
+def test_function_length_span_range_returns_none_for_other_message() -> None:
+    assert gate_module.function_length_span_range("Line 3: banned identifier") is None
+
+
+def test_isolation_span_range_covers_enclosing_test_span() -> None:
+    violation_text = (
+        "Line 5: Test 'test_probe' (defined at line 12, spanning 8 lines) probes HOME"
+    )
+
+    span_range = gate_module.isolation_span_range(violation_text)
+
+    assert span_range == range(12, 20)
+
+
+def test_isolation_span_range_returns_none_for_other_message() -> None:
+    assert gate_module.isolation_span_range("Function foo is 5 lines") is None
+
+
+def test_enclosing_span_range_dispatches_to_function_length_extractor() -> None:
+    violation_text = "Function 'render' (defined at line 4) is 6 lines - too long"
+
+    span_range = gate_module.enclosing_span_range(violation_text)
+
+    assert span_range == range(4, 10)
+
+
+def test_enclosing_span_range_returns_none_when_no_span_fragment() -> None:
+    assert gate_module.enclosing_span_range("Line 9: plain violation") is None
+
+
+def test_print_violation_section_writes_header_and_grouped_paths(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    offending_path = tmp_path / "package" / "module.py"
+    offending_path.parent.mkdir(parents=True)
+    offending_path.write_text("value = 1\n", encoding="utf-8")
+
+    gate_module.print_violation_section(
+        "BLOCKING violations:",
+        {offending_path.resolve(): ["Line 3: magic value", "Line 4: banned name"]},
+        tmp_path,
+    )
+
+    captured = capsys.readouterr()
+    assert "BLOCKING violations:" in captured.err
+    assert "package/module.py" in captured.err.replace("\\", "/")
+    assert "Line 3: magic value" in captured.err
+    assert "Line 4: banned name" in captured.err
+
+
+def test_read_prior_committed_content_returns_head_version(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(temporary_git_repository / "tracked.py", "committed = 1\n")
+    commit_all_files(temporary_git_repository, "commit tracked")
+    write_file(temporary_git_repository / "tracked.py", "working_tree_edit = 2\n")
+
+    committed_content = gate_module.read_prior_committed_content(
+        temporary_git_repository, "tracked.py"
+    )
+
+    assert committed_content == "committed = 1\n"
+
+
+def test_read_prior_committed_content_returns_empty_for_untracked_path(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(temporary_git_repository / "anchor.py", "anchor = 1\n")
+    commit_all_files(temporary_git_repository, "baseline")
+
+    assert (
+        gate_module.read_prior_committed_content(temporary_git_repository, "missing.py")
+        == ""
+    )
+
+
+def test_read_staged_content_returns_staged_blob(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(temporary_git_repository / "staged.py", "staged_value = 1\n")
+    stage_file(temporary_git_repository, "staged.py")
+
+    staged_content = gate_module.read_staged_content(
+        temporary_git_repository, "staged.py"
+    )
+
+    assert staged_content == "staged_value = 1\n"
+
+
+def test_read_staged_content_returns_none_for_unstaged_path(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(temporary_git_repository / "anchor.py", "anchor = 1\n")
+    commit_all_files(temporary_git_repository, "baseline")
+
+    assert (
+        gate_module.read_staged_content(temporary_git_repository, "never_staged.py")
+        is None
+    )
+
+
+def test_staged_blob_exists_true_for_staged_file(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(temporary_git_repository / "present.py", "present_value = 1\n")
+    stage_file(temporary_git_repository, "present.py")
+
+    assert gate_module.staged_blob_exists(temporary_git_repository, "present.py")
+
+
+def test_staged_blob_exists_false_for_staged_deletion(
+    temporary_git_repository: Path,
+) -> None:
+    write_file(temporary_git_repository / "removable.py", "first_count = 1\n")
+    commit_all_files(temporary_git_repository, "initial")
+    run_git_in_repository(temporary_git_repository, "rm", "--", "removable.py")
+
+    assert not gate_module.staged_blob_exists(temporary_git_repository, "removable.py")
+
+
+def test_parse_arguments_reads_staged_base_and_prefix_flags() -> None:
+    parsed_arguments = gate_module.parse_arguments(
+        [
+            "--staged",
+            "--base",
+            "main",
+            "--repo-root",
+            "some/root",
+            "--only-under",
+            "packages/core",
+            "explicit_file.py",
+        ]
+    )
+
+    assert parsed_arguments.staged is True
+    assert parsed_arguments.base == "main"
+    assert parsed_arguments.repo_root == Path("some/root")
+    assert parsed_arguments.only_under == ["packages/core"]
+    assert parsed_arguments.paths == [Path("explicit_file.py")]
+
+
+def test_parse_arguments_applies_documented_defaults() -> None:
+    parsed_arguments = gate_module.parse_arguments([])
+
+    assert parsed_arguments.staged is False
+    assert parsed_arguments.base == "origin/main"
+    assert parsed_arguments.repo_root is None
+    assert parsed_arguments.only_under == []
+    assert parsed_arguments.paths == []

package/_shared/pr-loop/scripts/tests/test_copilot_quota.py

@@ -0,0 +1,242 @@
+"""Direct unit tests for the copilot_quota pre-check.
+
+Every case drives the production ``main`` / ``evaluate_copilot_quota`` path with
+only the ``gh`` subprocess boundary (``_run_gh``) stubbed, fed a captured
+``copilot_internal/user`` JSON fixture in the jonecho shape.
+"""
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+
+def _load_copilot_quota_module() -> ModuleType:
+    scripts_directory = Path(__file__).parent.parent
+    if str(scripts_directory) not in sys.path:
+        sys.path.insert(0, str(scripts_directory))
+    module_path = scripts_directory / "copilot_quota.py"
+    specification = importlib.util.spec_from_file_location("copilot_quota", module_path)
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    sys.modules[specification.name] = module
+    specification.loader.exec_module(module)
+    return module
+
+
+copilot_quota = _load_copilot_quota_module()
+
+FIXTURE_PATH = Path(__file__).parent / "fixtures" / "copilot_internal_user_jonecho.json"
+AVAILABLE_USER_JSON = FIXTURE_PATH.read_text(encoding="utf-8")
+FAKE_TOKEN_RESULT = (0, "ghp_faketoken_value\n")
+
+
+def _exhausted_user_json() -> str:
+    user = json.loads(AVAILABLE_USER_JSON)
+    premium = user["quota_snapshots"]["premium_interactions"]
+    premium["remaining"] = 0
+    premium["quota_remaining"] = 0.0
+    premium["percent_remaining"] = 0.0
+    return json.dumps(user)
+
+
+def _user_json_without_premium_snapshot() -> str:
+    user = json.loads(AVAILABLE_USER_JSON)
+    del user["quota_snapshots"]
+    return json.dumps(user)
+
+
+def _gh_stub(token_result: tuple[int, str], api_result: tuple[int, str]):
+    def _fake_run_gh(
+        command_arguments: list[str],
+        extra_environment: dict[str, str] | None = None,
+    ) -> tuple[int, str]:
+        if command_arguments and command_arguments[0] == "auth":
+            return token_result
+        if command_arguments and command_arguments[0] == "api":
+            return api_result
+        raise AssertionError(f"unexpected gh command {command_arguments}")
+
+    return _fake_run_gh
+
+
+@pytest.fixture(autouse=True)
+def _isolate_account_sources(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.delenv("COPILOT_QUOTA_ACCOUNT", raising=False)
+    monkeypatch.setattr(
+        copilot_quota, "COPILOT_QUOTA_DEFAULT_ENV_FILE_PATH", tmp_path / ".env"
+    )
+
+
+def test_main_runs_copilot_when_premium_quota_available(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "jonecho")
+    monkeypatch.setattr(
+        copilot_quota,
+        "_run_gh",
+        _gh_stub(FAKE_TOKEN_RESULT, (0, AVAILABLE_USER_JSON)),
+    )
+    exit_code = copilot_quota.main([])
+    captured = capsys.readouterr()
+    assert exit_code == 0
+    assert "running Copilot" in captured.out
+    assert "6817" in captured.out
+
+
+def test_main_exits_out_of_quota_when_premium_exhausted(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "jonecho")
+    monkeypatch.setattr(
+        copilot_quota,
+        "_run_gh",
+        _gh_stub(FAKE_TOKEN_RESULT, (0, _exhausted_user_json())),
+    )
+    exit_code = copilot_quota.main([])
+    captured = capsys.readouterr()
+    assert exit_code == 1
+    assert "scenario A" in captured.err
+
+
+def test_main_exits_api_down_on_non_json_response(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "jonecho")
+    monkeypatch.setattr(
+        copilot_quota,
+        "_run_gh",
+        _gh_stub(FAKE_TOKEN_RESULT, (0, "not json at all")),
+    )
+    exit_code = copilot_quota.main([])
+    captured = capsys.readouterr()
+    assert exit_code == 2
+    assert "scenario B" in captured.err
+
+
+def test_main_exits_api_down_on_missing_premium_snapshot(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "jonecho")
+    monkeypatch.setattr(
+        copilot_quota,
+        "_run_gh",
+        _gh_stub(FAKE_TOKEN_RESULT, (0, _user_json_without_premium_snapshot())),
+    )
+    exit_code = copilot_quota.main([])
+    captured = capsys.readouterr()
+    assert exit_code == 2
+    assert "scenario B" in captured.err
+
+
+def test_main_exits_api_down_when_gh_token_unresolved(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "jonecho")
+    monkeypatch.setattr(
+        copilot_quota,
+        "_run_gh",
+        _gh_stub((1, ""), (0, AVAILABLE_USER_JSON)),
+    )
+    exit_code = copilot_quota.main([])
+    captured = capsys.readouterr()
+    assert exit_code == 2
+    assert "scenario B" in captured.err
+
+
+def test_main_exits_no_config_and_names_env_path_and_key(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    def _fail_if_called(
+        command_arguments: list[str],
+        extra_environment: dict[str, str] | None = None,
+    ) -> tuple[int, str]:
+        raise AssertionError("gh must not run when no account is configured")
+
+    monkeypatch.setattr(copilot_quota, "_run_gh", _fail_if_called)
+    exit_code = copilot_quota.main([])
+    captured = capsys.readouterr()
+    assert exit_code == 3
+    assert "scenario C" in captured.err
+    assert "COPILOT_QUOTA_ACCOUNT" in captured.err
+    assert ".env" in captured.err
+
+
+@pytest.mark.parametrize(
+    ("api_result", "expected_exit_code", "expected_scenario"),
+    [
+        ((0, _exhausted_user_json()), 1, "scenario A"),
+        ((0, "not json at all"), 2, "scenario B"),
+    ],
+)
+def test_every_gh_backed_skip_writes_a_log_line_naming_the_scenario(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    api_result: tuple[int, str],
+    expected_exit_code: int,
+    expected_scenario: str,
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "jonecho")
+    monkeypatch.setattr(
+        copilot_quota, "_run_gh", _gh_stub(FAKE_TOKEN_RESULT, api_result)
+    )
+    exit_code = copilot_quota.main([])
+    captured = capsys.readouterr()
+    assert exit_code == expected_exit_code
+    assert captured.out == ""
+    assert expected_scenario in captured.err
+    assert captured.err.strip() != ""
+
+
+def test_cli_account_takes_precedence_over_env_var(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "env-user")
+    accounts_seen: list[str] = []
+
+    def _fake_run_gh(
+        command_arguments: list[str],
+        extra_environment: dict[str, str] | None = None,
+    ) -> tuple[int, str]:
+        if command_arguments[0] == "auth":
+            accounts_seen.append(command_arguments[-1])
+            return FAKE_TOKEN_RESULT
+        return (0, AVAILABLE_USER_JSON)
+
+    monkeypatch.setattr(copilot_quota, "_run_gh", _fake_run_gh)
+    decision = copilot_quota.evaluate_copilot_quota(
+        cli_account="cli-user", env_file_path=tmp_path / ".env"
+    )
+    assert decision.exit_code == 0
+    assert accounts_seen == ["cli-user"]
+
+
+def test_account_resolves_from_env_file_when_flag_and_env_absent(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    env_file = tmp_path / ".env"
+    env_file.write_text(
+        "# local copilot quota account\nCOPILOT_QUOTA_ACCOUNT=file-user\n",
+        encoding="utf-8",
+    )
+    accounts_seen: list[str] = []
+
+    def _fake_run_gh(
+        command_arguments: list[str],
+        extra_environment: dict[str, str] | None = None,
+    ) -> tuple[int, str]:
+        if command_arguments[0] == "auth":
+            accounts_seen.append(command_arguments[-1])
+            return FAKE_TOKEN_RESULT
+        return (0, AVAILABLE_USER_JSON)
+
+    monkeypatch.setattr(copilot_quota, "_run_gh", _fake_run_gh)
+    decision = copilot_quota.evaluate_copilot_quota(
+        cli_account=None, env_file_path=env_file
+    )
+    assert decision.exit_code == 0
+    assert accounts_seen == ["file-user"]

package/_shared/pr-loop/scripts/tests/test_copilot_quota_constants.py

@@ -0,0 +1,63 @@
+"""Tests for copilot_quota_constants.py extracted constant set."""
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_constants_module() -> ModuleType:
+    module_path = (
+        Path(__file__).parent.parent
+        / "pr_loop_shared_constants"
+        / "copilot_quota_constants.py"
+    )
+    specification = importlib.util.spec_from_file_location(
+        "pr_loop_shared_constants.copilot_quota_constants", module_path
+    )
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    specification.loader.exec_module(module)
+    return module
+
+
+constants_module = _load_constants_module()
+
+
+def test_copilot_quota_account_env_var_name() -> None:
+    assert (
+        constants_module.COPILOT_QUOTA_ACCOUNT_ENV_VAR_NAME == "COPILOT_QUOTA_ACCOUNT"
+    )
+
+
+def test_gh_token_env_var_name() -> None:
+    assert constants_module.GH_TOKEN_ENV_VAR_NAME == "GH_TOKEN"
+
+
+def test_copilot_internal_user_api_path() -> None:
+    assert constants_module.COPILOT_INTERNAL_USER_API_PATH == "copilot_internal/user"
+
+
+def test_premium_interactions_gating_field_names() -> None:
+    assert constants_module.QUOTA_SNAPSHOTS_FIELD_NAME == "quota_snapshots"
+    assert constants_module.PREMIUM_INTERACTIONS_FIELD_NAME == "premium_interactions"
+    assert constants_module.PREMIUM_UNLIMITED_FIELD_NAME == "unlimited"
+    assert constants_module.PREMIUM_REMAINING_FIELD_NAME == "remaining"
+    assert constants_module.PREMIUM_OVERAGE_PERMITTED_FIELD_NAME == "overage_permitted"
+
+
+def test_exit_codes_are_the_four_distinct_scenarios() -> None:
+    all_exit_codes = (
+        constants_module.EXIT_CODE_QUOTA_AVAILABLE,
+        constants_module.EXIT_CODE_OUT_OF_QUOTA,
+        constants_module.EXIT_CODE_QUOTA_API_DOWN,
+        constants_module.EXIT_CODE_NO_ACCOUNT_CONFIGURED,
+    )
+    assert all_exit_codes == (0, 1, 2, 3)
+    assert len(set(all_exit_codes)) == len(all_exit_codes)
+
+
+def test_default_env_file_path_sits_at_the_package_root() -> None:
+    default_env_file_path = constants_module.COPILOT_QUOTA_DEFAULT_ENV_FILE_PATH
+    assert default_env_file_path.name == ".env"
+    assert default_env_file_path.parent.name == "claude-dev-env"