claude-dev-env 8.7.0 → 8.9.0

package/scripts/test_claude_account_choice.py

@@ -0,0 +1,245 @@
+"""Tests for the picker that names which Claude account a runner job uses."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pytest
+
+import claude_account_choice as choice
+from claude_chain_usage import AccountUsageMeters, WeeklyUtilizationProbeError
+
+NOW = datetime(2026, 9, 22, 21, 0, tzinfo=timezone.utc)
+
+
+def meters(
+    *,
+    session_used: float | None,
+    weekly_used: float | None,
+    weekly_resets_in: timedelta | None,
+    session_resets_in: timedelta = timedelta(hours=2),
+) -> AccountUsageMeters:
+    return AccountUsageMeters(
+        session_utilization=session_used,
+        session_resets_at=NOW + session_resets_in,
+        weekly_utilization=weekly_used,
+        weekly_resets_at=None if weekly_resets_in is None else NOW + weekly_resets_in,
+    )
+
+
+class TestChooseAccount:
+    def should_pick_main_in_jons_example(self) -> None:
+        main_meters = meters(
+            session_used=10.0, weekly_used=80.0, weekly_resets_in=timedelta(hours=5)
+        )
+        second_meters = meters(
+            session_used=10.0, weekly_used=82.0, weekly_resets_in=timedelta(days=4)
+        )
+        decision = choice.choose_account(
+            main_meters=main_meters, second_meters=second_meters, now=NOW
+        )
+        assert decision.account == choice.CHOICE_MAIN
+
+    def should_pick_second_when_main_week_resets_later_than_a_day(self) -> None:
+        main_meters = meters(
+            session_used=0.0, weekly_used=5.0, weekly_resets_in=timedelta(hours=30)
+        )
+        second_meters = meters(
+            session_used=10.0, weekly_used=40.0, weekly_resets_in=timedelta(days=4)
+        )
+        decision = choice.choose_account(
+            main_meters=main_meters, second_meters=second_meters, now=NOW
+        )
+        assert decision.account == choice.CHOICE_SECOND
+
+    def should_keep_main_once_it_nears_its_weekly_ceiling(self) -> None:
+        main_meters = meters(
+            session_used=0.0, weekly_used=90.0, weekly_resets_in=timedelta(hours=3)
+        )
+        second_meters = meters(
+            session_used=0.0, weekly_used=10.0, weekly_resets_in=timedelta(days=4)
+        )
+        decision = choice.choose_account(
+            main_meters=main_meters, second_meters=second_meters, now=NOW
+        )
+        assert decision.account == choice.CHOICE_SECOND
+
+    def should_keep_main_when_its_five_hour_window_is_half_spent(self) -> None:
+        main_meters = meters(
+            session_used=50.0, weekly_used=20.0, weekly_resets_in=timedelta(hours=3)
+        )
+        second_meters = meters(
+            session_used=0.0, weekly_used=10.0, weekly_resets_in=timedelta(days=4)
+        )
+        decision = choice.choose_account(
+            main_meters=main_meters, second_meters=second_meters, now=NOW
+        )
+        assert decision.account == choice.CHOICE_SECOND
+
+    def should_never_pick_main_when_its_meter_is_unread(self) -> None:
+        second_meters = meters(
+            session_used=95.0, weekly_used=99.0, weekly_resets_in=timedelta(days=4)
+        )
+        decision = choice.choose_account(
+            main_meters=None, second_meters=second_meters, now=NOW
+        )
+        assert decision.account == choice.CHOICE_WAIT
+
+    def should_never_pick_main_when_its_reset_time_is_missing(self) -> None:
+        main_meters = meters(session_used=0.0, weekly_used=0.0, weekly_resets_in=None)
+        second_meters = meters(
+            session_used=95.0, weekly_used=99.0, weekly_resets_in=timedelta(days=4)
+        )
+        decision = choice.choose_account(
+            main_meters=main_meters, second_meters=second_meters, now=NOW
+        )
+        assert decision.account == choice.CHOICE_WAIT
+
+    def should_pick_second_when_its_meter_is_unread(self) -> None:
+        decision = choice.choose_account(main_meters=None, second_meters=None, now=NOW)
+        assert decision.account == choice.CHOICE_SECOND
+        assert decision.reason == choice.REASON_SECOND_UNREAD
+
+    def should_wait_and_name_the_session_reset_when_the_five_hour_window_blocks(
+        self,
+    ) -> None:
+        second_meters = meters(
+            session_used=90.0,
+            weekly_used=50.0,
+            weekly_resets_in=timedelta(days=4),
+            session_resets_in=timedelta(hours=1),
+        )
+        decision = choice.choose_account(
+            main_meters=None, second_meters=second_meters, now=NOW
+        )
+        assert decision.account == choice.CHOICE_WAIT
+        assert (NOW + timedelta(hours=1)).isoformat() in decision.reason
+
+    def should_wait_and_name_the_weekly_reset_when_the_week_blocks(self) -> None:
+        second_meters = meters(
+            session_used=10.0, weekly_used=95.0, weekly_resets_in=timedelta(days=2)
+        )
+        decision = choice.choose_account(
+            main_meters=None, second_meters=second_meters, now=NOW
+        )
+        assert decision.account == choice.CHOICE_WAIT
+        assert (NOW + timedelta(days=2)).isoformat() in decision.reason
+
+
+class TestReadAccountMeters:
+    def should_return_none_when_the_probe_cannot_read_the_account(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        def failing_probe(credentials_path: Path) -> AccountUsageMeters:
+            raise WeeklyUtilizationProbeError(f"no token in {credentials_path}")
+
+        monkeypatch.setattr(choice, "probe_account_meters", failing_probe)
+        assert choice.read_account_meters(tmp_path / ".credentials.json") is None
+
+    def should_return_the_probed_meters(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        probed = meters(
+            session_used=1.0, weekly_used=2.0, weekly_resets_in=timedelta(days=1)
+        )
+        monkeypatch.setattr(choice, "probe_account_meters", lambda credentials_path: probed)
+        assert choice.read_account_meters(tmp_path / ".credentials.json") == probed
+
+
+class TestDecisionPayload:
+    def should_name_no_config_directory_for_a_wait(self) -> None:
+        decision = choice.AccountDecision(account=choice.CHOICE_WAIT, reason="full")
+        assert choice.decision_payload(decision, config_directory=None) == {
+            "account": "wait",
+            "config_dir": None,
+            "reason": "full",
+        }
+
+
+class TestMetersPayload:
+    def should_name_no_meters_for_an_unread_account(self) -> None:
+        assert choice.meters_payload(None) is None
+
+    def should_carry_each_used_percent_and_reset_time(self) -> None:
+        read_meters = meters(
+            session_used=12.0,
+            weekly_used=34.0,
+            weekly_resets_in=timedelta(days=3),
+            session_resets_in=timedelta(hours=1),
+        )
+        assert choice.meters_payload(read_meters) == {
+            "session_used_percent": 12.0,
+            "session_resets_at": "2026-09-22T22:00:00+00:00",
+            "weekly_used_percent": 34.0,
+            "weekly_resets_at": "2026-09-25T21:00:00+00:00",
+        }
+
+    def should_name_no_reset_time_the_meter_left_out(self) -> None:
+        read_meters = meters(session_used=1.0, weekly_used=None, weekly_resets_in=None)
+        payload = choice.meters_payload(read_meters)
+        assert payload is not None
+        assert payload["weekly_used_percent"] is None
+        assert payload["weekly_resets_at"] is None
+
+
+class TestMain:
+    def should_print_the_choice_and_the_config_directory_of_the_chosen_account(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        main_home = tmp_path / "main"
+        second_home = tmp_path / "second"
+        meters_by_credentials_path = {
+            main_home / ".credentials.json": None,
+            second_home / ".credentials.json": meters(
+                session_used=0.0, weekly_used=10.0, weekly_resets_in=timedelta(days=4)
+            ),
+        }
+        monkeypatch.setattr(
+            choice,
+            "read_account_meters",
+            lambda credentials_path: meters_by_credentials_path[credentials_path],
+        )
+        exit_code = choice.main(
+            [
+                "--main-config-dir",
+                str(main_home),
+                "--second-config-dir",
+                str(second_home),
+            ]
+        )
+        printed = json.loads(capsys.readouterr().out)
+        assert exit_code == 0
+        assert printed["account"] == choice.CHOICE_SECOND
+        assert printed["config_dir"] == str(second_home)
+        assert printed["meters"]["main"] is None
+        assert printed["meters"]["second"]["weekly_used_percent"] == 10.0
+
+    def should_print_no_config_directory_when_the_job_waits(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        blocked_meters = meters(
+            session_used=99.0, weekly_used=99.0, weekly_resets_in=timedelta(days=4)
+        )
+        monkeypatch.setattr(
+            choice, "read_account_meters", lambda credentials_path: blocked_meters
+        )
+        exit_code = choice.main(
+            [
+                "--main-config-dir",
+                str(tmp_path / "main"),
+                "--second-config-dir",
+                str(tmp_path / "second"),
+            ]
+        )
+        printed = json.loads(capsys.readouterr().out)
+        assert exit_code == 0
+        assert printed["account"] == choice.CHOICE_WAIT
+        assert printed["config_dir"] is None

package/scripts/test_claude_account_profile.py

@@ -0,0 +1,220 @@
+"""Tests for the second-account profile sync and its launcher."""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+import claude_account_profile as profile
+
+NOW = datetime(2026, 9, 22, 21, 0, tzinfo=timezone.utc)
+
+
+def build_main_home(tmp_path: Path) -> Path:
+    main_home = tmp_path / "main"
+    (main_home / "skills" / "tdd").mkdir(parents=True)
+    (main_home / "rules").mkdir()
+    (main_home / "projects").mkdir()
+    (main_home / "CLAUDE.md").write_text("main instructions", encoding="utf-8")
+    (main_home / "settings.json").write_text("{}", encoding="utf-8")
+    (main_home / ".credentials.json").write_text("main sign-in", encoding="utf-8")
+    (main_home / ".claude.json").write_text("main state", encoding="utf-8")
+    (main_home / ".claude.json.backup").write_text("main backup", encoding="utf-8")
+    return main_home
+
+
+def sync(main_home: Path, profile_home: Path) -> profile.ProfileSyncReport:
+    return profile.sync_profile(main_home=main_home, profile_home=profile_home, now=NOW)
+
+
+class TestDefaultProfileHome:
+    def should_use_the_profiles_root_the_environment_names(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("LLM_SETTINGS_PROFILES_ROOT", str(tmp_path))
+        assert profile.default_profile_home() == tmp_path / "ev"
+
+    def should_fall_back_to_the_profiles_root_in_the_user_home(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("LLM_SETTINGS_PROFILES_ROOT", raising=False)
+        monkeypatch.setattr(Path, "home", lambda: tmp_path)
+        assert profile.default_profile_home() == tmp_path / ".claude-profiles" / "ev"
+
+
+class TestIsAccountLocal:
+    def should_keep_sign_in_state_and_history_local(self) -> None:
+        for each_name in (
+            ".credentials.json",
+            ".credentials.json.bak-session-dashboard",
+            ".claude.json",
+            ".claude.json.backup",
+            "projects",
+        ):
+            assert profile.is_account_local(each_name)
+
+    def should_share_skills_rules_and_settings(self) -> None:
+        for each_name in ("skills", "rules", "CLAUDE.md", "settings.json", "plugins"):
+            assert not profile.is_account_local(each_name)
+
+
+class TestSyncProfile:
+    def should_link_every_shared_entry_to_the_main_home(self, tmp_path: Path) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        sync(main_home, profile_home)
+        assert (profile_home / "skills" / "tdd").is_dir()
+        assert (profile_home / "CLAUDE.md").read_text(
+            encoding="utf-8"
+        ) == "main instructions"
+        assert profile.links_to(profile_home / "rules", main_home / "rules")
+        assert profile.links_to(
+            profile_home / "settings.json", main_home / "settings.json"
+        )
+
+    def should_keep_the_accounts_own_sign_in_state_and_history_apart(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        (profile_home / ".credentials.json").write_text(
+            "second sign-in", encoding="utf-8"
+        )
+        sync(main_home, profile_home)
+        assert (profile_home / ".credentials.json").read_text(
+            encoding="utf-8"
+        ) == "second sign-in"
+        assert not (profile_home / ".claude.json").exists()
+        assert not (profile_home / ".claude.json.backup").exists()
+        assert not (profile_home / "projects").exists()
+
+    def should_move_a_stale_copy_aside_and_keep_its_content(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        (profile_home / "CLAUDE.md").write_text("stale copy", encoding="utf-8")
+        report = sync(main_home, profile_home)
+        moved_copy = (
+            profile_home / ".replaced" / NOW.strftime("%Y%m%dT%H%M%SZ") / "CLAUDE.md"
+        )
+        assert moved_copy.read_text(encoding="utf-8") == "stale copy"
+        assert profile.links_to(profile_home / "CLAUDE.md", main_home / "CLAUDE.md")
+        assert report.all_moved_aside == ("CLAUDE.md",)
+
+    def should_remove_a_same_content_copy_without_moving_it_aside(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        (profile_home / "CLAUDE.md").write_text("main instructions", encoding="utf-8")
+        report = sync(main_home, profile_home)
+        assert report.all_moved_aside == ()
+        assert not (profile_home / ".replaced").exists()
+        assert profile.links_to(profile_home / "CLAUDE.md", main_home / "CLAUDE.md")
+
+    def should_move_aside_a_link_that_points_somewhere_else(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        elsewhere = tmp_path / "old-shared" / "rules"
+        elsewhere.mkdir(parents=True)
+        (elsewhere / "keep.md").write_text("old rule", encoding="utf-8")
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        (profile_home / "rules").symlink_to(elsewhere, target_is_directory=True)
+        report = sync(main_home, profile_home)
+        assert (elsewhere / "keep.md").read_text(encoding="utf-8") == "old rule"
+        assert profile.links_to(profile_home / "rules", main_home / "rules")
+        assert report.all_moved_aside == ("rules",)
+
+    def should_change_nothing_on_a_second_run(self, tmp_path: Path) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        sync(main_home, profile_home)
+        second_report = sync(main_home, profile_home)
+        assert second_report.all_linked == ()
+        assert second_report.all_moved_aside == ()
+        assert second_report.all_unlinked == ()
+
+    def should_unlink_an_entry_the_main_home_no_longer_has(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        sync(main_home, profile_home)
+        (main_home / "rules").rmdir()
+        report = sync(main_home, profile_home)
+        assert not os.path.lexists(profile_home / "rules")
+        assert report.all_unlinked == ("rules",)
+
+
+    def should_remove_a_main_link_left_under_an_account_local_name(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        (main_home / ".credentials.json.bak").write_text("main backup", encoding="utf-8")
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        os.link(main_home / ".credentials.json.bak", profile_home / ".credentials.json.bak")
+        report = sync(main_home, profile_home)
+        assert not os.path.lexists(profile_home / ".credentials.json.bak")
+        assert (main_home / ".credentials.json.bak").read_text(
+            encoding="utf-8"
+        ) == "main backup"
+        assert report.all_unlinked == (".credentials.json.bak",)
+
+
+class TestWriteLauncher:
+    def should_point_claude_at_the_profile_and_pass_every_argument(
+        self, tmp_path: Path
+    ) -> None:
+        profile_home = tmp_path / "ev"
+        launcher_path = profile.write_launcher(
+            launcher_directory=tmp_path / "bin", profile_home=profile_home, now=NOW
+        )
+        launcher_text = launcher_path.read_text(encoding="utf-8")
+        assert f'set "CLAUDE_CONFIG_DIR={profile_home}"' in launcher_text
+        assert "claude %*" in launcher_text
+
+    def should_move_an_older_launcher_aside(self, tmp_path: Path) -> None:
+        launcher_directory = tmp_path / "bin"
+        launcher_directory.mkdir()
+        (launcher_directory / "claude-ev.cmd").write_text(
+            "old launcher", encoding="utf-8"
+        )
+        profile.write_launcher(
+            launcher_directory=launcher_directory, profile_home=tmp_path / "ev", now=NOW
+        )
+        moved_launcher = launcher_directory / (
+            "claude-ev.cmd.replaced-" + NOW.strftime("%Y%m%dT%H%M%SZ")
+        )
+        assert moved_launcher.read_text(encoding="utf-8") == "old launcher"
+
+
+class TestMain:
+    def should_print_what_the_sync_changed(
+        self, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        exit_code = profile.main(
+            [
+                "--main-home",
+                str(main_home),
+                "--profile-home",
+                str(tmp_path / "ev"),
+                "--launcher-directory",
+                str(tmp_path / "bin"),
+            ]
+        )
+        printed = json.loads(capsys.readouterr().out)
+        assert exit_code == 0
+        assert "CLAUDE.md" in printed["linked"]
+        assert printed["launcher"] == str(tmp_path / "bin" / "claude-ev.cmd")

package/scripts/test_claude_chain_usage.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import subprocess
 import sys
+from datetime import datetime
 from pathlib import Path
 
 import pytest
@@ -372,7 +373,10 @@ def test_probe_weekly_utilization_reuses_resolver_windows(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     class _FakeWindows:
+        session_utilization = None
+        session_resets_at = None
         weekly_utilization = 37.5
+        weekly_resets_at = None
 
     class _FakeResolver:
         def read_oauth_access_token(self, credentials_path: Path, now: object) -> str:
@@ -401,6 +405,42 @@ def test_probe_weekly_utilization_reuses_resolver_windows(
     assert weekly_utilization == pytest.approx(37.5)
 
 
+def should_read_both_meters_and_their_resets_for_one_account(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    session_reset = datetime(2026, 9, 22, 23, 0).astimezone()
+    weekly_reset = datetime(2026, 9, 26, 9, 0).astimezone()
+
+    class _FakeWindows:
+        session_utilization = 12.0
+        session_resets_at = session_reset
+        weekly_utilization = 64.0
+        weekly_resets_at = weekly_reset
+
+    class _FakeResolver:
+        def read_oauth_access_token(self, credentials_path: Path, now: object) -> str:
+            return "token-value"
+
+        def _fetch_usage_payload(self, access_token: str) -> dict[str, object]:
+            return {}
+
+        def extract_usage_windows(
+            self, usage_payload: dict[str, object]
+        ) -> _FakeWindows:
+            return _FakeWindows()
+
+    monkeypatch.setattr(
+        usage, "_load_resolve_usage_window_module", lambda: _FakeResolver()
+    )
+    account_meters = usage.probe_account_meters(Path(PLACEHOLDER_CREDENTIALS_PRIMARY))
+    assert account_meters == usage.AccountUsageMeters(
+        session_utilization=12.0,
+        session_resets_at=session_reset,
+        weekly_utilization=64.0,
+        weekly_resets_at=weekly_reset,
+    )
+
+
 def test_probe_weekly_utilization_raises_when_token_missing(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

package/scripts/test_durable_post_lint.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import hashlib
 import subprocess
 import sys
 from pathlib import Path
@@ -13,6 +14,7 @@ if str(_SCRIPTS_DIRECTORY) not in sys.path:
     sys.path.insert(0, str(_SCRIPTS_DIRECTORY))
 
 import durable_post_lint
+from dev_env_scripts_constants.private_term_constants import PrivateTermDigest
 
 SCRIPT_PATH = _SCRIPTS_DIRECTORY / "durable_post_lint.py"
 VALID_PR_BODY = """## Why
@@ -506,3 +508,91 @@ def test_a_release_body_carrying_a_contrast_stays_accepted() -> None:
     )
 
     assert all_findings == ()
+
+
+_PRIVATE_FIXTURE_TERM = "acmewidget"
+_ALL_PRIVATE_FIXTURE_DIGESTS = frozenset(
+    {
+        PrivateTermDigest(
+            length=len(_PRIVATE_FIXTURE_TERM),
+            sha256=hashlib.sha256(_PRIVATE_FIXTURE_TERM.encode("utf-8")).hexdigest(),
+        )
+    }
+)
+
+
+@pytest.fixture
+def private_fixture_terms(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        durable_post_lint, "ALL_PRIVATE_TERM_DIGESTS", _ALL_PRIVATE_FIXTURE_DIGESTS
+    )
+
+
+@pytest.mark.usefixtures("private_fixture_terms")
+def test_a_body_naming_a_private_organization_reports_its_line() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-comment",
+        title=None,
+        body_text="Fixed.\nSee Acme-Widgets-Inc/tools#12.\n",
+    )
+
+    assert [each_finding.code for each_finding in all_findings] == ["private-term"]
+    assert "Line 2" in all_findings[0].message
+    assert "Acme" not in all_findings[0].message
+
+
+@pytest.mark.usefixtures("private_fixture_terms")
+def test_a_title_naming_a_private_organization_reports() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-create",
+        title="fix: handle the acme widgets upload",
+        body_text=VALID_PR_BODY,
+    )
+
+    assert [each_finding.code for each_finding in all_findings] == ["private-term"]
+
+
+@pytest.mark.usefixtures("private_fixture_terms")
+def test_a_post_inside_the_private_organization_may_name_it() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-comment",
+        title=None,
+        body_text="See Acme-Widgets-Inc/tools#12.\n",
+        repository="Acme-Widgets-Inc/tools",
+    )
+
+    assert all_findings == ()
+
+
+@pytest.mark.usefixtures("private_fixture_terms")
+def test_a_post_to_a_public_repository_may_not_name_it() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-comment",
+        title=None,
+        body_text="See Acme-Widgets-Inc/tools#12.\n",
+        repository="pat/public-tools",
+    )
+
+    assert [each_finding.code for each_finding in all_findings] == ["private-term"]
+
+
+def test_cli_accepts_a_repository(tmp_path: Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_text("Comment body.\n", encoding="utf-8")
+    completed_process = subprocess.run(
+        [
+            sys.executable,
+            str(SCRIPT_PATH),
+            "--action",
+            "pr-comment",
+            "--repository",
+            "pat/public-tools",
+            "--body-file",
+            str(body_file),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert completed_process.returncode == 0
+    assert completed_process.stderr == ""