claude-dev-env 8.43.4 → 8.43.6

package/scripts/test_claude_account_worker.py

@@ -1,446 +1,201 @@
 from __future__ import annotations
 
 import json
-import subprocess
-from collections.abc import Callable
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any
 
 import pytest
 
-import claude_account_choice
-import claude_account_worker
-from claude_chain_usage import AccountUsageMeters
-from claude_account_worker import (
-    AccountSelection,
-    WorkerDependencies,
-    build_argument_parser,
-    select_account,
-    run_worker,
-)
-from dev_env_scripts_constants.claude_account_worker_constants import (
-    CHOICE_MAIN,
-    CHOICE_SECOND,
-    CHOICE_WAIT,
-    CLAUDE_CONFIG_DIR_ENV_VAR,
-    STDOUT_TAIL_CHARACTER_LIMIT,
-    TIMEOUT_EXIT_CODE,
+import claude_account_worker as worker
+from dev_env_scripts_constants.account_broker_constants import (
+    BrokerConfigurationError,
+    JobOutcome,
+    Product,
     WAIT_EXIT_CODE,
 )
-
-NOW = datetime(2026, 9, 22, 21, 0, tzinfo=timezone.utc)
-
-
-class FakeProcess:
-    def __init__(
-        self,
-        *,
-        stdout: str = '{"result":"ready","is_error":false}',
-        returncode: int = 0,
-        timeout_first: bool = False,
-        timeout_output: str = "",
-        drain_timeout_count: int = 0,
-    ) -> None:
-        self.stdout = stdout
-        self.returncode = returncode
-        self.timeout_first = timeout_first
-        self.timeout_output = timeout_output
-        self.drain_timeout_count = drain_timeout_count
-        self.pid = 42
-        self.communicate_calls: list[tuple[str | None, float | None]] = []
-        self.terminated = False
-
-    def communicate(
-        self,
-        input: str | None = None,
-        timeout: float | None = None,
-    ) -> tuple[str, str]:
-        self.communicate_calls.append((input, timeout))
-        if self.timeout_first and len(self.communicate_calls) == 1:
-            raise subprocess.TimeoutExpired(
-                cmd="claude",
-                timeout=timeout,
-                output=self.timeout_output,
-            )
-        if self.drain_timeout_count:
-            self.drain_timeout_count -= 1
-            raise subprocess.TimeoutExpired(
-                cmd="claude",
-                timeout=timeout,
-                output=self.timeout_output,
-            )
-        return self.stdout, ""
-
-    def poll(self) -> int | None:
-        return self.returncode if self.terminated else None
-
-    def kill(self) -> None:
-        self.terminated = True
-        self.returncode = -9
-
-
-def _selection(
-    account: str,
-    *,
-    config_dir: Path | None = None,
-    reason: str = "selected by test",
-) -> AccountSelection:
-    return AccountSelection(account=account, config_dir=config_dir, reason=reason)
+from dev_env_scripts_constants.claude_account_worker_constants import STDOUT_TAIL_CHARACTER_LIMIT
 
 
-def _make_runner(
-    process: FakeProcess,
-    captured: dict[str, Any],
-) -> Callable[..., FakeProcess]:
-    def run(arguments: list[str], **options: Any) -> FakeProcess:
-        captured["arguments"] = arguments
-        captured.update(options)
-        return process
-
-    return run
+def _outcome(
+    *,
+    stdout: str = '{"result":"ready","is_error":false}',
+    returncode: int = 0,
+    account_name: str | None = "extra_2",
+    status: str = "served",
+    wait_reset_at: datetime | None = None,
+) -> JobOutcome:
+    return JobOutcome(
+        returncode,
+        stdout,
+        "",
+        account_name,
+        ((account_name, status),) if account_name else (),
+        status,
+        None,
+        wait_reset_at,
+    )
 
 
 def _run_worker(
+    monkeypatch: pytest.MonkeyPatch,
     tmp_path: Path,
+    outcome: JobOutcome | Exception,
     *,
-    selection: AccountSelection,
-    process: FakeProcess,
-    parent_environment: dict[str, str] | None = None,
-    process_terminator: Callable[[FakeProcess], None] | None = None,
     model: str | None = None,
     permission_mode: str = "auto",
-) -> tuple[int, dict[str, Any], dict[str, Any]]:
+) -> tuple[int, dict[str, object], dict[str, object]]:
     prompt_file = tmp_path / "brief.md"
     prompt_file.write_text("standalone brief", encoding="utf-8")
     report_file = tmp_path / "report.json"
-    captured: dict[str, Any] = {}
-    runner = _make_runner(process, captured)
-    dependencies = WorkerDependencies(
-        process_factory=runner,
-        all_parent_environment_variables=(
-            {"KEEP_ME": "present"} if parent_environment is None else parent_environment
-        ),
-        binary_resolver=lambda _: "claude.exe",
-        process_terminator=(
-            process_terminator if process_terminator is not None else lambda _: None
-        ),
-        monotonic_clock=lambda: 1.0,
-    )
-    exit_code = run_worker(
+    captured: dict[str, object] = {}
+
+    def run_job(product: Product, argv: list[str], **options: object) -> JobOutcome:
+        captured.update(product=product, argv=argv, **options)
+        if isinstance(outcome, Exception):
+            raise outcome
+        return outcome
+
+    monkeypatch.setattr(worker, "worker_job_runner", run_job)
+    exit_code = worker.run_worker(
         prompt_file=prompt_file,
         cwd=tmp_path,
         report_file=report_file,
         model=model,
         permission_mode=permission_mode,
         timeout_minutes=60,
-        decision_selector=lambda: selection,
-        dependencies=dependencies,
     )
     return exit_code, json.loads(report_file.read_text(encoding="utf-8")), captured
 
 
-def test_should_set_second_profile_and_pass_parent_environment(
-    tmp_path: Path,
+def test_should_send_prompt_and_flags_to_broker(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    profile_dir = tmp_path / "second-profile"
-    process = FakeProcess()
     exit_code, report, captured = _run_worker(
-        tmp_path,
-        selection=_selection(CHOICE_SECOND, config_dir=profile_dir),
-        process=process,
-        parent_environment={
-            CLAUDE_CONFIG_DIR_ENV_VAR: "inherited-profile",
-            "KEEP_ME": "present",
-        },
-        model="sonnet",
-        permission_mode="plan",
+        monkeypatch, tmp_path, _outcome(), model="sonnet", permission_mode="plan"
     )
 
     assert exit_code == 0
-    assert report["account"] == CHOICE_SECOND
-    assert captured["env"][CLAUDE_CONFIG_DIR_ENV_VAR] == str(profile_dir)
-    assert captured["env"]["KEEP_ME"] == "present"
-    assert captured["arguments"] == [
-        "claude.exe",
-        "-p",
-        "--output-format",
-        "json",
-        "--permission-mode",
-        "plan",
-        "--model",
-        "sonnet",
+    assert report["account"] == "extra_2"
+    assert report["result"] == "ready"
+    assert captured["product"] is Product.CLAUDE
+    assert captured["argv"] == [
+        "claude", "-p", "--output-format", "json", "--permission-mode", "plan", "--model", "sonnet"
     ]
-    assert captured["cwd"] == str(tmp_path)
-    assert process.communicate_calls[0][0] == "standalone brief"
+    assert captured["stdin_text"] == "standalone brief"
+    assert captured["cwd"] == tmp_path
+    assert captured["timeout_seconds"] == 3600
 
 
-def test_should_remove_inherited_profile_for_main_account(tmp_path: Path) -> None:
-    process = FakeProcess()
+def test_should_report_wait_with_reset_and_exit_three(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    reset_at = datetime(2026, 10, 4, 12, tzinfo=timezone.utc)
     exit_code, report, captured = _run_worker(
+        monkeypatch,
         tmp_path,
-        selection=_selection(CHOICE_MAIN, config_dir=tmp_path / "main-profile"),
-        process=process,
-        parent_environment={
-            CLAUDE_CONFIG_DIR_ENV_VAR: "inherited-profile",
-            "KEEP_ME": "present",
-        },
-    )
-
-    assert exit_code == 0
-    assert report["account"] == CHOICE_MAIN
-    assert CLAUDE_CONFIG_DIR_ENV_VAR not in captured["env"]
-    assert captured["env"]["KEEP_ME"] == "present"
-
-
-def test_should_write_wait_reason_and_start_no_process(tmp_path: Path) -> None:
-    report_file = tmp_path / "wait-report.json"
-    process_started = False
-
-    def forbidden_runner(*_: Any, **__: Any) -> FakeProcess:
-        nonlocal process_started
-        process_started = True
-        raise AssertionError("wait must not start a process")
-
-    exit_code = run_worker(
-        prompt_file=tmp_path / "missing-brief.md",
-        cwd=tmp_path,
-        report_file=report_file,
-        model=None,
-        permission_mode="auto",
-        timeout_minutes=60,
-        decision_selector=lambda: _selection(
-            CHOICE_WAIT,
-            reason="second account resets at 2026-09-24T12:00:00Z",
-        ),
-        dependencies=WorkerDependencies(
-            process_factory=forbidden_runner,
-            all_parent_environment_variables={},
-            binary_resolver=lambda _: (_ for _ in ()).throw(
-                AssertionError("wait must not resolve a binary")
-            ),
-            process_terminator=lambda _: None,
-            monotonic_clock=lambda: 1.0,
-        ),
+        _outcome(stdout="", returncode=WAIT_EXIT_CODE, account_name=None, status="wait", wait_reset_at=reset_at),
     )
-    report = json.loads(report_file.read_text(encoding="utf-8"))
 
     assert exit_code == WAIT_EXIT_CODE
-    assert process_started is False
-    assert report["account"] == CHOICE_WAIT
-    assert report["reason"] == "second account resets at 2026-09-24T12:00:00Z"
-    assert report["is_error"] is True
+    assert report["account"] == "wait"
+    assert report["wait_reset_at"] == reset_at.isoformat()
+    assert report["reason"] == f"no account has room; next reset at {reset_at.isoformat()}"
+    assert report["is_error"] is False
+    assert captured["product"] is Product.CLAUDE
 
 
-def test_should_kill_child_on_timeout_and_exit_124(tmp_path: Path) -> None:
-    process = FakeProcess(
-        stdout='{"result":"partial"}',
-        returncode=-9,
-        timeout_first=True,
-        timeout_output='{"result":"partial"}',
-    )
-    termination_calls: list[FakeProcess] = []
+def test_should_preserve_exhausted_wait_exit_code(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
     exit_code, report, _ = _run_worker(
+        monkeypatch,
         tmp_path,
-        selection=_selection(CHOICE_SECOND, config_dir=tmp_path / "profile"),
-        process=process,
-        process_terminator=lambda child: termination_calls.append(child),
+        _outcome(stdout="", returncode=WAIT_EXIT_CODE, account_name=None, status="exhausted"),
     )
 
-    assert exit_code == TIMEOUT_EXIT_CODE
-    assert termination_calls == [process]
-    assert len(process.communicate_calls) == 2
-    assert report["exit_code"] == TIMEOUT_EXIT_CODE
-    assert report["is_error"] is True
+    assert exit_code == WAIT_EXIT_CODE
+    assert report["reason"] == "no account has room"
 
 
-def test_should_copy_parsed_result_into_report(tmp_path: Path) -> None:
-    process = FakeProcess(stdout='{"result":"ready","is_error":false}')
+def test_should_copy_json_error_flag_into_report(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
     exit_code, report, _ = _run_worker(
-        tmp_path,
-        selection=_selection(CHOICE_SECOND, config_dir=tmp_path / "profile"),
-        process=process,
+        monkeypatch, tmp_path, _outcome(stdout='{"result":"failed","is_error":true}')
     )
 
     assert exit_code == 0
-    assert report["result"] == "ready"
-    assert report["is_error"] is False
+    assert report["result"] == "failed"
+    assert report["is_error"] is True
 
 
-def test_should_write_raw_stdout_tail_when_output_is_not_json(tmp_path: Path) -> None:
-    stdout_text = "x" * (STDOUT_TAIL_CHARACTER_LIMIT - 4) + "tail"
-    process = FakeProcess(stdout=stdout_text)
-    exit_code, report, _ = _run_worker(
-        tmp_path,
-        selection=_selection(CHOICE_SECOND, config_dir=tmp_path / "profile"),
-        process=process,
-    )
+def test_should_keep_stdout_tail_when_output_is_not_json(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    stdout_text = "x" * (STDOUT_TAIL_CHARACTER_LIMIT + 4)
+    exit_code, report, _ = _run_worker(monkeypatch, tmp_path, _outcome(stdout=stdout_text))
 
     assert exit_code == 0
     assert report["result"] == stdout_text[-STDOUT_TAIL_CHARACTER_LIMIT:]
     assert report["is_error"] is True
 
 
-def test_should_preserve_child_exit_code_three_for_selected_account(
-    tmp_path: Path,
+def test_should_preserve_served_failure_code(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    process = FakeProcess(returncode=3)
     exit_code, report, _ = _run_worker(
-        tmp_path,
-        selection=_selection(CHOICE_SECOND, config_dir=tmp_path / "profile"),
-        process=process,
+        monkeypatch, tmp_path, _outcome(returncode=3, status="advisor_blocked")
     )
 
     assert exit_code == 3
-    assert report["account"] == CHOICE_SECOND
-    assert report["exit_code"] == 3
-    assert report["is_error"] is True
-
-
-def test_should_keep_claude_json_error_flag(tmp_path: Path) -> None:
-    process = FakeProcess(stdout='{"result":"failed","is_error":true}')
-    exit_code, report, _ = _run_worker(
-        tmp_path,
-        selection=_selection(CHOICE_SECOND, config_dir=tmp_path / "profile"),
-        process=process,
-    )
-
-    assert exit_code == 0
-    assert report["result"] == "failed"
+    assert report["account"] == "extra_2"
     assert report["is_error"] is True
 
 
-def test_should_pick_second_account_when_neither_meter_is_readable(
+def test_should_write_report_for_unreadable_prompt(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    main_home = tmp_path / "main-home"
-    second_home = tmp_path / "second-home"
-    monkeypatch.setattr(Path, "home", lambda: main_home)
-    monkeypatch.setattr(claude_account_worker, "default_profile_home", lambda: second_home)
-
-    selection = select_account()
-
-    assert selection.account == CHOICE_SECOND
-    assert selection.config_dir == second_home
-
-
-def test_should_read_profile_list_and_pick_later_extra(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    main_home = tmp_path / ".claude"
-    main_home.mkdir()
-    (main_home / "extra-profiles.json").write_text(
-        json.dumps(["profile_a", "profile_b"]), encoding="utf-8"
-    )
-    profiles_root = tmp_path / "profiles"
-    monkeypatch.setattr(Path, "home", lambda: tmp_path)
-    monkeypatch.setenv("LLM_SETTINGS_PROFILES_ROOT", str(profiles_root))
-    readings = {
-        profiles_root / "profile_a": AccountUsageMeters(
-            session_utilization=90.0,
-            session_resets_at=NOW + timedelta(hours=2),
-            weekly_utilization=95.0,
-            weekly_resets_at=NOW + timedelta(days=2),
-        ),
-        profiles_root / "profile_b": AccountUsageMeters(
-            session_utilization=10.0,
-            session_resets_at=NOW + timedelta(hours=2),
-            weekly_utilization=20.0,
-            weekly_resets_at=NOW + timedelta(days=2),
-        ),
-    }
-
-    def read_meters(path: Path) -> AccountUsageMeters | None:
-        return readings.get(path.parent)
-
-    monkeypatch.setattr(claude_account_choice, "read_account_meters", read_meters)
-    monkeypatch.setattr(claude_account_worker, "read_account_meters", read_meters)
-
-    selection = select_account()
-
-    assert selection.account == "extra_2"
-    assert selection.config_dir == profiles_root / "profile_b"
-
-
-def test_should_exit_three_when_every_listed_profile_is_full(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    main_home = tmp_path / ".claude"
-    main_home.mkdir()
-    (main_home / "extra-profiles.json").write_text(
-        json.dumps(["profile_a", "profile_b"]), encoding="utf-8"
-    )
-    monkeypatch.setattr(Path, "home", lambda: tmp_path)
-    monkeypatch.setenv("LLM_SETTINGS_PROFILES_ROOT", str(tmp_path / "profiles"))
-    blocked = AccountUsageMeters(
-        session_utilization=90.0,
-        session_resets_at=NOW + timedelta(hours=2),
-        weekly_utilization=95.0,
-        weekly_resets_at=NOW + timedelta(days=2),
-    )
-
-    def read_meters(path: Path) -> AccountUsageMeters | None:
-        return None if path.parent == main_home else blocked
-
-    monkeypatch.setattr(claude_account_choice, "read_account_meters", read_meters)
-    monkeypatch.setattr(claude_account_worker, "read_account_meters", read_meters)
     report_file = tmp_path / "report.json"
+    monkeypatch.setattr(worker, "worker_job_runner", lambda *args, **kwargs: pytest.fail("broker ran"))
 
-    exit_code = run_worker(
-        prompt_file=tmp_path / "unused.md",
+    exit_code = worker.run_worker(
+        prompt_file=tmp_path / "missing.md",
         cwd=tmp_path,
         report_file=report_file,
         model=None,
         permission_mode="auto",
         timeout_minutes=60,
-        decision_selector=select_account,
-        dependencies=WorkerDependencies(
-            process_factory=lambda *args, **kwargs: (_ for _ in ()).throw(
-                AssertionError("wait must not start a process")
-            ),
-            all_parent_environment_variables={},
-            binary_resolver=lambda _: None,
-            process_terminator=lambda _: None,
-            monotonic_clock=lambda: 1.0,
-        ),
     )
-    report = json.loads(report_file.read_text(encoding="utf-8"))
 
-    assert exit_code == WAIT_EXIT_CODE
-    assert report["account"] == CHOICE_WAIT
-    assert (NOW + timedelta(days=2)).isoformat() in report["reason"]
+    report = json.loads(report_file.read_text(encoding="utf-8"))
+    assert exit_code == report["exit_code"]
+    assert report["reason"] == "prompt file is unreadable"
 
 
-def test_should_set_later_extra_profile_environment(tmp_path: Path) -> None:
-    profile_dir = tmp_path / "profile_b"
-    exit_code, report, captured = _run_worker(
-        tmp_path,
-        selection=_selection("extra_2", config_dir=profile_dir),
-        process=FakeProcess(),
+def test_should_report_broker_configuration_error(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    exit_code, report, _ = _run_worker(
+        monkeypatch, tmp_path, BrokerConfigurationError("account list is invalid")
     )
 
-    assert exit_code == 0
-    assert report["account"] == "extra_2"
-    assert captured["env"][CLAUDE_CONFIG_DIR_ENV_VAR] == str(profile_dir)
+    assert exit_code == 2
+    assert report["reason"] == "account list is invalid"
 
 
-@pytest.mark.parametrize(
-    "contents",
-    ['{', '{}', '[]', '["profile_a", "PROFILE_A"]', '["../outside"]', '["main"]'],
-)
-def test_should_reject_invalid_profile_lists(tmp_path: Path, contents: str) -> None:
-    main_home = tmp_path / ".claude"
-    main_home.mkdir()
-    (main_home / "extra-profiles.json").write_text(contents, encoding="utf-8")
+def test_should_ignore_extra_profile_list(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    (tmp_path / "extra-profiles.json").write_text("{", encoding="utf-8")
 
-    with pytest.raises(ValueError):
-        claude_account_worker.extra_config_directories(main_home)
+    exit_code, report, _ = _run_worker(monkeypatch, tmp_path, _outcome())
 
+    assert exit_code == 0
+    assert report["account"] == "extra_2"
 
-def test_should_require_prompt_file_and_report_file_flags() -> None:
-    parser = build_argument_parser()
 
-    arguments = parser.parse_args(
+def test_should_require_prompt_and_report_flags() -> None:
+    arguments = worker.build_argument_parser().parse_args(
         ["--prompt-file", "brief.md", "--report-file", "report.json"]
     )