mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-10 18:07:20 +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.
120 lines
4.4 KiB
Python
120 lines
4.4 KiB
Python
"""Tests for the panel's three-call walk to a day's menu.
|
|
|
|
Split from ``test_kuchnia_client.py`` for the repo's 250-line cap; the session,
|
|
credential and cookie-cache behaviour lives there.
|
|
|
|
The endpoint shape here is not the obvious one: ``.../deliveries/{id}/details``
|
|
404s despite its name, so the menu comes from
|
|
``company/general/menus/delivery/{deliveryId}/new``, keyed by the opaque id.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import datetime
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from diet_guard import _kuchnia_client, _kuchnia_config
|
|
from diet_guard._kuchnia_client import PanelSession
|
|
from diet_guard._kuchnia_errors import KuchniaError
|
|
from diet_guard._kuchnia_orders import fetch_dishes
|
|
from diet_guard.tests._kuchnia_fakes import (
|
|
FakeResponse,
|
|
FakeSession,
|
|
fake_requests,
|
|
menu_payload,
|
|
order_payload,
|
|
write_credentials,
|
|
)
|
|
|
|
DAY = datetime.date(2026, 8, 22)
|
|
|
|
|
|
@pytest.fixture
|
|
def creds() -> None:
|
|
"""Write a credentials file at the (redirected) config path."""
|
|
write_credentials(_kuchnia_config.KUCHNIA_CREDENTIALS_FILE)
|
|
|
|
|
|
def _session_with(responses: list[FakeResponse]) -> FakeSession:
|
|
return FakeSession(responses)
|
|
|
|
|
|
class TestFetchDishes:
|
|
def _panel(self, responses: list[FakeResponse]) -> tuple[PanelSession, FakeSession]:
|
|
session = _session_with(responses)
|
|
with patch.object(_kuchnia_client, "requests", fake_requests(session)):
|
|
return PanelSession(), session
|
|
|
|
def test_walks_to_the_days_menu(self, creds: None) -> None:
|
|
panel, session = self._panel(
|
|
[
|
|
FakeResponse(200, [1]),
|
|
FakeResponse(200, order_payload(delivery_id=111)),
|
|
FakeResponse(200, menu_payload(2)),
|
|
],
|
|
)
|
|
with patch.object(_kuchnia_client, "requests", fake_requests(session)):
|
|
dishes = fetch_dishes(panel, DAY)
|
|
assert len(dishes) == 2
|
|
# The menu endpoint is keyed by the opaque deliveryId, never the date:
|
|
# the date form 400s and the obvious `.../details` path 404s.
|
|
assert any("menus/delivery/111/new" in url for _, url in session.calls)
|
|
|
|
def test_no_active_order_is_not_an_error(self, creds: None) -> None:
|
|
panel, session = self._panel([FakeResponse(200, [])])
|
|
with patch.object(_kuchnia_client, "requests", fake_requests(session)):
|
|
assert fetch_dishes(panel, DAY) == []
|
|
|
|
def test_no_delivery_that_day_is_not_an_error(self, creds: None) -> None:
|
|
panel, session = self._panel(
|
|
[
|
|
FakeResponse(200, [1]),
|
|
FakeResponse(200, order_payload(date="2026-01-01")),
|
|
],
|
|
)
|
|
with patch.object(_kuchnia_client, "requests", fake_requests(session)):
|
|
assert fetch_dishes(panel, DAY) == []
|
|
|
|
def test_a_cancelled_delivery_is_skipped(self, creds: None) -> None:
|
|
order = {
|
|
"orderId": 1,
|
|
"deliveries": [
|
|
{"deliveryId": 111, "date": "2026-08-22", "deleted": True},
|
|
],
|
|
}
|
|
panel, session = self._panel([FakeResponse(200, [1]), FakeResponse(200, order)])
|
|
with patch.object(_kuchnia_client, "requests", fake_requests(session)):
|
|
assert fetch_dishes(panel, DAY) == []
|
|
|
|
@pytest.mark.parametrize(
|
|
"order",
|
|
["nope", {}, {"deliveries": "x"}, {"deliveries": [None]}],
|
|
)
|
|
def test_a_malformed_order_yields_nothing(self, creds: None, order: object) -> None:
|
|
panel, session = self._panel([FakeResponse(200, [1]), FakeResponse(200, order)])
|
|
with patch.object(_kuchnia_client, "requests", fake_requests(session)):
|
|
assert fetch_dishes(panel, DAY) == []
|
|
|
|
def test_an_unpublished_menu_is_reported_not_silently_empty(
|
|
self, creds: None
|
|
) -> None:
|
|
panel, session = self._panel(
|
|
[
|
|
FakeResponse(200, [1]),
|
|
FakeResponse(200, order_payload()),
|
|
FakeResponse(200, {"deliveryMenuMeal": []}),
|
|
],
|
|
)
|
|
with (
|
|
patch.object(_kuchnia_client, "requests", fake_requests(session)),
|
|
pytest.raises(KuchniaError, match="no usable dishes"),
|
|
):
|
|
fetch_dishes(panel, DAY)
|
|
|
|
def test_active_ids_may_be_junk(self, creds: None) -> None:
|
|
panel, session = self._panel([FakeResponse(200, {"not": "a list"})])
|
|
with patch.object(_kuchnia_client, "requests", fake_requests(session)):
|
|
assert fetch_dishes(panel, DAY) == []
|