mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-19 05:54:33 +01:00
A meal logged on the phone while the gate window was up changed nothing until Fetch was pressed: the new credit watch only fires on a local write to the food log, and the PC never pulled on its own. While a non-demo window is open it now pulls peer logs every 30 s, with the Fetch button's own narrow pull on a worker thread. One pull is in flight at a time (shared with the button), failures are logged and retried, and the window stays up. The pull's write trips the watch, which closes through the usual reconcile path. gatelock moves to 0.14.0 for watch_credit. refresh_peer_logs also read the local log before the peer downloads and wrote it after, so a meal logged during the pull was overwritten. It now merges the peers first and reads the local log just before the write. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01WzxdWWfb63jncj9Lca2jeX
114 lines
4.4 KiB
Python
114 lines
4.4 KiB
Python
"""The open gate window pulls peer logs on its own every ~30 s.
|
|
|
|
2026-11-16: the credit watch only fires on a *local* write, and nothing on the PC
|
|
wrote while the window was up, so a meal logged on the phone waited for the user
|
|
to press Fetch. ``arm_peer_pull`` runs the Fetch button's own narrow pull
|
|
(``pull_peer_logs``) on a timer; the write it makes trips the watch, which owns
|
|
the close. So this path is silent and never unlocks anything itself.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import queue
|
|
from types import SimpleNamespace
|
|
from typing import TYPE_CHECKING
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from diet_guard import _gatelock_peerpull
|
|
from diet_guard._gatelock_fetch import FETCH_POLL_MS
|
|
from diet_guard._gatelock_peerpull import PEER_PULL_MS, arm_peer_pull
|
|
|
|
if TYPE_CHECKING:
|
|
import pytest
|
|
|
|
|
|
def _host() -> SimpleNamespace:
|
|
"""A stand-in gate: a recording Tk root and the shared in-flight slot."""
|
|
root = MagicMock()
|
|
return SimpleNamespace(
|
|
root=root, fetch_result=None, _reconcile_after_fetch=MagicMock()
|
|
)
|
|
|
|
|
|
def _fire(host: SimpleNamespace) -> None:
|
|
"""Run the callback most recently handed to ``root.after``."""
|
|
host.root.after.call_args.args[1]()
|
|
|
|
|
|
class TestTick:
|
|
"""What one interval does."""
|
|
|
|
def test_arms_the_first_pull_one_interval_out(self) -> None:
|
|
host = _host()
|
|
arm_peer_pull(host)
|
|
assert host.root.after.call_args.args[0] == PEER_PULL_MS == 30_000
|
|
|
|
def test_an_idle_tick_starts_the_narrow_pull_off_thread(self) -> None:
|
|
host, result = _host(), queue.Queue[str | None](maxsize=1)
|
|
with patch.object(
|
|
_gatelock_peerpull, "start_fetch", return_value=result
|
|
) as start:
|
|
arm_peer_pull(host)
|
|
_fire(host)
|
|
start.assert_called_once_with(_gatelock_peerpull.pull_peer_logs)
|
|
assert host.fetch_result is result
|
|
assert host.root.after.call_args.args[0] == FETCH_POLL_MS
|
|
|
|
def test_a_tick_during_a_button_fetch_starts_nothing(self) -> None:
|
|
"""One in-flight pull for both writers: the Fetch button's slot counts."""
|
|
host = _host()
|
|
host.fetch_result = busy = queue.Queue[str | None](maxsize=1)
|
|
with patch.object(_gatelock_peerpull, "start_fetch") as start:
|
|
arm_peer_pull(host)
|
|
_fire(host)
|
|
start.assert_not_called()
|
|
assert host.fetch_result is busy
|
|
assert host.root.after.call_args.args[0] == PEER_PULL_MS
|
|
|
|
def test_the_poll_waits_while_the_worker_runs(self) -> None:
|
|
host, result = _host(), queue.Queue[str | None](maxsize=1)
|
|
with patch.object(_gatelock_peerpull, "start_fetch", return_value=result):
|
|
arm_peer_pull(host)
|
|
_fire(host)
|
|
_fire(host) # worker still running: nothing on the queue
|
|
assert host.fetch_result is result
|
|
assert host.root.after.call_args.args[0] == FETCH_POLL_MS
|
|
|
|
|
|
class TestCompletion:
|
|
"""What a finished pull does -- and, above all, does not do."""
|
|
|
|
def _finish(self, reason: str | None) -> tuple[SimpleNamespace, int]:
|
|
host, result = _host(), queue.Queue[str | None](maxsize=1)
|
|
with patch.object(_gatelock_peerpull, "start_fetch", return_value=result):
|
|
arm_peer_pull(host)
|
|
_fire(host)
|
|
result.put(reason)
|
|
_fire(host)
|
|
return host, host.root.after.call_count
|
|
|
|
def test_success_is_silent_frees_the_slot_and_rearms(self) -> None:
|
|
host, _ = self._finish(None)
|
|
assert host.fetch_result is None
|
|
assert host.root.after.call_args.args[0] == PEER_PULL_MS
|
|
host._reconcile_after_fetch.assert_not_called() # the watch owns the close
|
|
|
|
def test_a_failure_is_logged_retried_and_never_unlocks(
|
|
self, caplog: pytest.LogCaptureFixture
|
|
) -> None:
|
|
with caplog.at_level(logging.WARNING, logger=_gatelock_peerpull.__name__):
|
|
host, _ = self._finish("sync unavailable (boom)")
|
|
assert "sync unavailable (boom)" in caplog.text
|
|
assert host.fetch_result is None
|
|
assert host.root.after.call_args.args[0] == PEER_PULL_MS
|
|
host._reconcile_after_fetch.assert_not_called()
|
|
|
|
def test_a_stray_poll_with_no_slot_does_nothing(self) -> None:
|
|
host = _host()
|
|
arm_peer_pull(host)
|
|
poll = _gatelock_peerpull._poll_closure(host, PEER_PULL_MS)
|
|
before = host.root.after.call_count
|
|
poll()
|
|
assert host.root.after.call_count == before
|