diet-guard/diet_guard/tests/test_claude_sdk.py
Krzysztof kuhy Rudnicki 642467dc1d Add the Claude relay worker
python -m diet_guard claude-worker serves the phone's meal requests from
RTDB (rtdb_relay RequestServer, one SSE stream, reconnects with backoff):
validate, estimate with Claude, log through the signed log with
source=claude under the oldest due slot (normal mode: nearest slot of the
phone's hint), write the sealed result, delete only the request payload,
then publish in the background. diet-guard-claude.service (Restart=on-failure,
WantedBy=default.target) is installed by install.sh and started once the
worker's own Firebase session exists. Nothing is deployed by this commit.

Failure paths:
- narrow peer pull fails (sync locked/unreachable): fail closed, no claim, no
  answer, no model call; the request stays pending, retried every 30 s
- e2e key locked, no passphrase, no session: fail closed, nothing read or
  written; the worker waits and retries every 60 s
- bad body, request older than 24 h (or no created): fail closed, an error
  result, nothing logged
- Claude failure/timeout/invalid JSON: fail closed, an error result with
  retry, nothing logged
- crash between log and result, or a duplicate event: idempotent, the entry
  id is uuid5 of the rid and is looked up (tombstones included) before the
  model call
- request payload delete, old-answer cleanup and the post-answer publish
  failing: fail open on purpose (logged only); the answer and the local
  entry are already durable
- due mode with nothing due: falls back to slot_for_log, not an error

New log helpers log_meal_as / find_entry; log_meal's body is split into
_entry_fields / _store_entry with the same output. The gate and CLI import
none of the worker's dependencies at load time.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzxdWZHWP4KZ6x5TcXDBFC
2026-11-17 21:15:08 +01:00

220 lines
8.1 KiB
Python

"""The model call and its sandbox, against a fake ``claude_agent_sdk``."""
from __future__ import annotations
import asyncio
import json
import subprocess
from typing import TYPE_CHECKING, Any
from unittest.mock import AsyncMock, Mock, patch
import pytest
from diet_guard import _claude_sandbox as sandbox
from diet_guard import _claude_sdk as sdk
from diet_guard.tests._claude_fakes import (
FakeResult,
FakeSdk,
fresh,
write_host_login,
)
if TYPE_CHECKING:
from pathlib import Path
FAR = 4_000_000_000_000 # an expiry far in the future, in ms
@pytest.fixture
def login() -> None:
"""A readable host login that is not about to expire."""
write_host_login(sandbox.HOST_LOGIN_FILE, FAR)
def _ask(fake: FakeSdk, budget_s: float = 5) -> dict[str, Any]:
content = [{"type": "text", "text": "banan"}]
with patch("diet_guard._claude_sdk.import_module", return_value=fake):
return asyncio.run(
sdk.bounded_ask("PROMPT", content, {"s": 1}, budget_s=budget_s)
)
@pytest.mark.usefixtures("login")
def test_answer_and_isolation_options() -> None:
"""The structured answer returns; the call is tool-less and sandboxed."""
fake = FakeSdk([FakeResult({"kcal": 1})])
assert _ask(fake) == {"kcal": 1}
options = fake.calls[0]["options"]
assert options.tools == []
assert options.mcp_servers == {}
assert options.setting_sources == []
assert options.system_prompt == "PROMPT"
assert options.output_format == {"type": "json_schema", "schema": {"s": 1}}
assert options.env["CLAUDE_CONFIG_DIR"] == str(sandbox.SANDBOX_DIR)
assert options.cwd == sandbox.SANDBOX_DIR / "work"
message = fake.calls[0]["sent"][0]["message"]
assert message["content"] == [{"type": "text", "text": "banan"}]
@pytest.mark.usefixtures("login")
def test_other_stream_messages_are_skipped() -> None:
"""Assistant/system chatter before the result does not matter."""
fake = FakeSdk([object(), FakeResult({"kcal": 2}), object()])
assert _ask(fake) == {"kcal": 2}
@pytest.mark.usefixtures("login")
@pytest.mark.parametrize(
"messages",
[
[FakeResult(None, is_error=True)],
[FakeResult(None)],
[FakeResult(["not", "an", "object"])],
[],
],
)
def test_no_usable_answer_is_a_model_error(messages: list[object]) -> None:
"""An API error or an answer that is not an object fails closed."""
with pytest.raises(sdk.ModelError):
_ask(FakeSdk(messages))
def test_missing_login_is_a_model_error() -> None:
"""No host login: nothing is sent to the model at all."""
fake = FakeSdk([FakeResult({"kcal": 1})])
with pytest.raises(sdk.ModelError, match="no Claude login"):
_ask(fake)
assert fake.calls == []
@pytest.mark.usefixtures("login")
def test_a_hung_model_times_out() -> None:
"""A call past its budget is a ModelTimeoutError."""
with pytest.raises(sdk.ModelTimeoutError):
_ask(FakeSdk([], hang=True), budget_s=0.05)
@pytest.mark.usefixtures("login")
def test_any_other_failure_is_wrapped() -> None:
"""A CLI/transport exception becomes a ModelError naming only its type."""
fake = FakeSdk([])
fake.query = Mock(side_effect=OSError("secret path"))
with pytest.raises(sdk.ModelError, match="OSError") as caught:
_ask(fake)
assert "secret path" not in str(caught.value)
def test_run_model_delegates_to_bounded_ask() -> None:
"""The seam is a thin wrapper: same arguments, same result."""
real = fresh(sdk)
with patch.object(real, "bounded_ask", AsyncMock(return_value={"ok": 1})) as ask:
out = asyncio.run(real.run_model("p", [], {}, budget_s=3))
assert out == {"ok": 1}
ask.assert_awaited_once_with("p", [], {}, budget_s=3)
# -- the sandbox ---------------------------------------------------------------
def test_login_copy_drops_the_refresh_token_and_mcp_tokens(login: None) -> None:
"""Only claudeAiOauth minus refreshToken reaches the sandbox, mode 0600."""
assert sandbox.copy_login() == FAR
target = sandbox.SANDBOX_DIR / ".credentials.json"
text = target.read_text(encoding="utf-8")
assert "SECRET" not in text
assert json.loads(text) == {
"claudeAiOauth": {"accessToken": "tok", "expiresAt": FAR}
}
assert target.stat().st_mode & 0o777 == 0o600
@pytest.mark.parametrize("raw", [None, "not json", "{}", '{"claudeAiOauth": 3}'])
def test_unreadable_host_login_copies_nothing(raw: str | None) -> None:
"""A missing, broken or empty login writes nothing and reports None."""
if raw is not None:
sandbox.HOST_LOGIN_FILE.write_text(raw, encoding="utf-8")
assert sandbox.copy_login() is None
assert not sandbox.SANDBOX_DIR.exists()
def test_expiry_missing_is_none_but_copied() -> None:
"""A login without expiresAt is copied; its expiry is unknown."""
sandbox.HOST_LOGIN_FILE.write_text(
json.dumps({"claudeAiOauth": {"accessToken": "t"}}), encoding="utf-8"
)
assert sandbox.copy_login() is None
assert (sandbox.SANDBOX_DIR / ".credentials.json").is_file()
def test_prepare_installs_the_skill_and_work_dir(login: None) -> None:
"""A fresh login: no refresh, skill copied, work dir ready."""
refresh = Mock()
assert sandbox.prepare(refresh=refresh) == sandbox.SANDBOX_DIR
refresh.assert_not_called()
skill = sandbox.SANDBOX_DIR / "skills" / "diet-food" / "SKILL.md"
assert skill.read_text(encoding="utf-8").startswith("---\nname: diet-food")
assert (sandbox.SANDBOX_DIR / "work").is_dir()
def test_prepare_without_login_is_none() -> None:
"""No host login: no sandbox."""
assert sandbox.prepare() is None
def test_prepare_refreshes_an_expiring_login_then_recopies() -> None:
"""Within the margin the host CLI refreshes first; the new token is copied."""
write_host_login(sandbox.HOST_LOGIN_FILE, 1_000)
refresh = Mock(side_effect=lambda: write_host_login(sandbox.HOST_LOGIN_FILE, FAR))
assert sandbox.prepare(now=lambda: 1.0, refresh=refresh) == sandbox.SANDBOX_DIR
refresh.assert_called_once_with()
fresh_login = json.loads((sandbox.SANDBOX_DIR / ".credentials.json").read_text())
assert fresh_login["claudeAiOauth"]["expiresAt"] == FAR
def test_failed_refresh_is_logged_and_the_old_copy_stays() -> None:
"""A refresh that fails does not raise; the call then fails in the CLI."""
write_host_login(sandbox.HOST_LOGIN_FILE, 1_000)
refresh = Mock(side_effect=subprocess.SubprocessError("nope"))
assert sandbox.prepare(now=lambda: 1.0, refresh=refresh) == sandbox.SANDBOX_DIR
def test_refresh_host_login_runs_the_host_cli_with_nothing_loaded() -> None:
"""The refresh is one tiny, tool-less, settings-less CLI call."""
with (
patch(
"diet_guard._claude_sandbox.host_cli",
return_value=sandbox.Path("/x/claude"),
),
patch("diet_guard._claude_sandbox.subprocess.run") as run,
):
sandbox.refresh_host_login()
cmd = run.call_args.args[0]
assert cmd[0] == "/x/claude"
assert "--setting-sources=" in cmd
assert "--tools=" in cmd
assert run.call_args.kwargs["cwd"] == sandbox.SANDBOX_DIR / "refresh"
def test_refresh_without_a_host_cli_is_a_noop() -> None:
"""No claude binary on PATH: nothing to refresh with, nothing raised."""
with (
patch("diet_guard._claude_sandbox.host_cli", return_value=None),
patch("diet_guard._claude_sandbox.subprocess.run") as run,
):
sandbox.refresh_host_login()
run.assert_not_called()
def test_host_cli_follows_path() -> None:
"""host_cli is whatever ``claude`` resolves to, or None."""
with patch("diet_guard._claude_sandbox.shutil.which", return_value="/bin/claude"):
assert str(sandbox.host_cli()) == "/bin/claude"
with patch("diet_guard._claude_sandbox.shutil.which", return_value=None):
assert sandbox.host_cli() is None
def test_skill_text_without_front_matter(tmp_path: Path) -> None:
"""A skill file with no front matter is returned whole."""
skill = tmp_path / "SKILL.md"
skill.write_text("body only\n", encoding="utf-8")
with patch("diet_guard._claude_sandbox.SKILL_DIR", tmp_path):
assert sandbox.skill_text() == "body only"