mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-10 19:27:14 +01:00
Krzysztof kuhy Rudnicki
26f1770090
Pulls the day's delivered dishes and their real per-portion macros out of
panel.kuchniavikinga.pl, so a catering meal is one keypress instead of five
retyped numbers.
A delivered meal is not an eaten meal, so nothing is ever logged unattended:
dishes land in the *curated* bank, and entries are written only after an
explicit confirmation. Auto-logging would let the gate satisfy its own
checkpoint from a delivery note, and would record what the courier dropped off
rather than what was eaten.
Three surfaces:
- `diet-guard kuchnia [--log] [--yes]`
- the lock screen's "Today's delivery" button, which prefills the meal form
dish by dish (the user still clicks Log & Continue)
- a warm-up after each logged meal, on the existing background thread
All event-driven; no new systemd timer. The two automatic paths go through
`refresh_delivery_once`, guarded to one fetch per day.
The panel is an undocumented white-labelled Dietly API; the endpoint map was
recovered from its JS bundles and confirmed against live responses. Notes,
including the traps, are in docs/kuchnia-wikinga.md.
Load-bearing details:
* Macros are per portion and `weight` is that portion in grams -- proven, not
assumed: 4P+4C+9F reproduces the stated calories within ~1% on every meal of
the captured day. `_energy_is_consistent` re-runs that check per dish and
drops any that fails; a per-100g mix-up is invisible in a payload and would
silently skew every logged meal by a factor of several.
* `bank_dishes` compares nutritional fields before calling `add_manual_entry`,
which restamps `t` unconditionally. Without the compare, every refresh
republishes the whole curated bank to every peer. Tests assert on call count.
* Duplicate log suppression reads today's synced log, not a local marker:
`log_meal` mints a fresh uuid, so a re-import after marker loss would merge
as duplicates on every peer.
* The gate hook is in `on_focus_ready`, not `_cli_gate._should_lock`:
`gate_is_due()` never reads the food bank, so a refresh there could not
change the lock decision while adding a third-party round trip to the ~105ms
`gate --check` fast path.
* `requests` is lazy-imported so the gate's not-due tick does not pay for it.
* Credentials and the cached session cookie live in ~/.config/diet_guard at
mode 600, outside the synced tree. The credentials file is written by hand,
never by the package -- the same contract as sync_token.
`_GateDashboard` is merged into `_GateMealFlow`, and both "pull it in from
elsewhere" flows share one `_PullFlows` mixin: pylint's max-parents counts
every MRO entry, so the gate's controller chain had no room for a new class.
Also adds a side-by-side row for the two pull buttons -- stacking them cost
42px and pushed the tab past the viewport at 1366x768.
989 tests, 100% branch coverage, pre-commit clean.
69 lines
2.7 KiB
Python
69 lines
2.7 KiB
Python
"""Tests for the gate's automatic catering fetch (trigger b).
|
|
|
|
Split from ``test_kuchnia_gate.py`` for the repo's 250-line cap; the button,
|
|
worker and field-formatting tests live there.
|
|
|
|
The property that matters: an *automatic* fetch stays quiet about bad news. The
|
|
gate has just told the user which slots to fill, and a caterer problem they
|
|
never asked about must not talk over that.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import queue
|
|
from unittest.mock import patch
|
|
|
|
from diet_guard import _gatelock_delivery
|
|
from diet_guard._gatelock_kuchnia import DeliveryResult
|
|
from diet_guard.tests.test_kuchnia_gate import _deliver, _dish, _Gate
|
|
|
|
|
|
class TestAutoload:
|
|
"""Trigger (b): the window opening fetches the day's delivery itself."""
|
|
|
|
def test_the_window_opening_starts_a_guarded_fetch(self) -> None:
|
|
gate = _Gate()
|
|
with patch.object(_gatelock_delivery, "start_delivery_fetch") as start:
|
|
start.return_value = queue.Queue(maxsize=1)
|
|
gate._autoload_delivery()
|
|
assert start.call_count == 1
|
|
# The guarded wrapper, not the raw refresh: several locks in one day
|
|
# must not each pay for a login plus a three-request walk.
|
|
assert start.call_args[0][0] is _gatelock_delivery.refresh_delivery_once
|
|
|
|
def test_demo_mode_does_not_autoload(self) -> None:
|
|
gate = _Gate()
|
|
gate.demo_mode = True
|
|
with patch.object(_gatelock_delivery, "start_delivery_fetch") as start:
|
|
gate._autoload_delivery()
|
|
assert start.call_count == 0
|
|
|
|
def test_it_does_not_stack_on_a_running_fetch(self) -> None:
|
|
gate = _Gate()
|
|
gate._delivery_result = queue.Queue(maxsize=1)
|
|
with patch.object(_gatelock_delivery, "start_delivery_fetch") as start:
|
|
gate._autoload_delivery()
|
|
assert start.call_count == 0
|
|
|
|
def test_an_automatic_outage_is_silent(self) -> None:
|
|
# The gate has just told the user which slots to fill; a caterer
|
|
# problem they never asked about must not talk over that.
|
|
gate = _Gate()
|
|
_deliver(gate, DeliveryResult(dishes=(), reason="panel down"), asked=False)
|
|
assert gate.statuses == []
|
|
|
|
def test_an_automatic_empty_day_is_silent(self) -> None:
|
|
gate = _Gate()
|
|
_deliver(gate, DeliveryResult(dishes=(), reason=None), asked=False)
|
|
assert gate.statuses == []
|
|
|
|
def test_an_automatic_fetch_still_offers_the_dishes(self) -> None:
|
|
gate = _Gate()
|
|
_deliver(gate, DeliveryResult(dishes=(_dish(),), reason=None), asked=False)
|
|
assert gate._descs == ["Kaszotto"]
|
|
|
|
def test_the_button_still_reports_both(self) -> None:
|
|
gate = _Gate()
|
|
_deliver(gate, DeliveryResult(dishes=(), reason="panel down"), asked=True)
|
|
assert "panel down" in gate.last_status
|