diet-guard/diet_guard/tests/test_gate.py

"""Tests for _gate.py — the slot/state composition that decides locking.

The slot arithmetic and the logged-slot state are both exercised elsewhere, so
here the logged set is mocked and ``now`` is injected to drive each decision.
"""

from __future__ import annotations

from datetime import UTC, date, datetime, time, timedelta
from typing import TYPE_CHECKING
from unittest.mock import patch

import freedays
import sickdays

from diet_guard._estimator import Nutrition
from diet_guard._gate import due_slots, gate_is_due, gate_message
from diet_guard._state import log_meal, now_local
from diet_guard._state_today import logged_slots_today, today_total_kcal

if TYPE_CHECKING:
    from pathlib import Path


def _at(hour: int) -> datetime:
    """Return a fixed local datetime at ``hour``."""
    return datetime(2026, 1, 1, hour, 0, tzinfo=UTC)


def _logged(slots: set[int]) -> object:
    """Patch the logged-slots source so the decision is deterministic."""
    return patch(
        "diet_guard._gate.logged_slots_today",
        return_value=slots,
    )


class TestDueSlots:
    """Elapsed-but-unlogged slots."""

    def test_injected_now(self) -> None:
        """With 08:00 logged at 13:00, only 12:00 is due."""
        with _logged({480}):
            assert due_slots(_at(13)) == (720,)

    def test_default_now_uses_clock(self) -> None:
        """Omitting ``now`` reads the real clock (mocked here for determinism)."""
        with (
            _logged(set()),
            patch(
                "diet_guard._gate.now_local",
                return_value=_at(9),
            ),
        ):
            assert due_slots() == (480,)


class TestGateIsDue:
    """The boolean lock decision."""

    def test_due_when_a_slot_is_missing(self) -> None:
        """A missing elapsed slot warrants a lock."""
        with _logged(set()):
            assert gate_is_due(_at(13)) is True

    def test_not_due_when_all_logged(self) -> None:
        """Everything elapsed is logged -> no lock."""
        with _logged({480, 720}):
            assert gate_is_due(_at(13)) is False


class TestGateMessage:
    """The human-readable reason line."""

    def test_all_logged(self) -> None:
        """Nothing missing -> the up-to-date message."""
        with _logged({480, 720}):
            assert "up to date" in gate_message(_at(13))

    def test_single_missing(self) -> None:
        """One missing slot -> singular phrasing."""
        with _logged({480}):
            assert gate_message(_at(13)) == "Log your 12:00 meal to unlock."

    def test_multiple_missing(self) -> None:
        """Several missing slots -> plural phrasing listing them."""
        with _logged(set()):
            message = gate_message(_at(17))
        assert message == "Log your meals for 08:00, 12:00, 16:00 to unlock."


class TestFreeDays:
    """The shared pool stands the gate down entirely."""

    def test_a_free_day_leaves_nothing_due(self, tmp_path: Path) -> None:
        with _logged(set()):
            assert due_slots(_at(20)), "precondition: slots are due without a free day"
            freedays.mark(
                _at(20).date(),
                paths=freedays.Paths.under(tmp_path / "freedays"),
                now=_at(20).date(),
            )
            assert due_slots(_at(20)) == ()
            assert not gate_is_due(_at(20))

    def test_a_free_day_on_another_date_changes_nothing(self, tmp_path: Path) -> None:
        with _logged(set()):
            freedays.mark(
                date(2026, 12, 24),
                paths=freedays.Paths.under(tmp_path / "freedays"),
                now=_at(20).date(),
            )
            assert due_slots(_at(20))
            assert gate_is_due(_at(20))

    def test_an_unreadable_pool_leaves_the_gate_armed(self, tmp_path: Path) -> None:
        """Fail closed: a corrupt pool must not switch the gate off."""
        pool_dir = tmp_path / "freedays"
        pool_dir.mkdir(exist_ok=True)
        (pool_dir / "free_days.json").write_text("{ not json", encoding="utf-8")
        with _logged(set()):
            assert gate_is_due(_at(20))


def _mark_sick(tmp_path: Path, day: date, keep: tuple[str, ...] = ()) -> None:
    """Put ``day`` in the (temp) sick-day pool; the redirect lives in conftest."""
    sickdays.add_sick_day(
        day,
        keep=keep,
        is_free=lambda _day: False,
        paths=sickdays.Paths.under(tmp_path / "sickdays"),
        now=day,
    )


class TestSickDays:
    """The sick-day pool stands the gate down, like a free day."""

    def test_a_sick_day_leaves_nothing_due(self, tmp_path: Path) -> None:
        with _logged(set()):
            assert due_slots(_at(20)), "precondition: slots are due without a sick day"
            _mark_sick(tmp_path, _at(20).date())
            assert due_slots(_at(20)) == ()
            assert not gate_is_due(_at(20))
            assert gate_message(_at(20)) == "All meals are logged. You're up to date."

    def test_a_sick_day_that_keeps_diet_stays_armed(self, tmp_path: Path) -> None:
        """A kept locker behaves exactly as on a normal day."""
        with _logged(set()):
            _mark_sick(tmp_path, _at(20).date(), keep=(sickdays.LOCKER_DIET,))
            assert due_slots(_at(20))
            assert gate_is_due(_at(20))

    def test_a_sick_day_keeping_another_locker_still_stands_down(
        self, tmp_path: Path
    ) -> None:
        with _logged(set()):
            _mark_sick(
                tmp_path,
                _at(20).date(),
                keep=(sickdays.LOCKER_WORKOUT, sickdays.LOCKER_ALARM),
            )
            assert due_slots(_at(20)) == ()

    def test_a_sick_day_on_another_date_changes_nothing(self, tmp_path: Path) -> None:
        with _logged(set()):
            _mark_sick(tmp_path, date(2026, 12, 24))
            assert due_slots(_at(20))
            assert gate_is_due(_at(20))

    def test_the_day_after_a_sick_day_is_armed_again(self, tmp_path: Path) -> None:
        _mark_sick(tmp_path, _at(20).date())
        tomorrow = _at(20) + timedelta(days=1)
        with _logged(set()):
            assert gate_is_due(tomorrow)

    def test_an_unreadable_pool_leaves_the_gate_armed(self, tmp_path: Path) -> None:
        """Fail closed: a corrupt pool must not switch the gate off."""
        pool_dir = tmp_path / "sickdays"
        pool_dir.mkdir(exist_ok=True)
        (pool_dir / "sick_days.json").write_text("{ not json", encoding="utf-8")
        with _logged(set()):
            assert gate_is_due(_at(20))

    def test_logging_still_works_on_a_sick_day(self, tmp_path: Path) -> None:
        """The gate stands down; the log does not: a meal is still recorded."""
        today = now_local().date()
        _mark_sick(tmp_path, today)
        log_meal("soup", Nutrition(300, 10, 30, 5, 250, "manual"), slot=480)
        assert logged_slots_today() == {480}
        assert today_total_kcal() == 300
        late = datetime.combine(today, time(23, 0), tzinfo=now_local().tzinfo)
        assert not gate_is_due(late)