steam-backlog-enforcer/steam_backlog_enforcer/tests/test_first_credits.py

"""Tests for _ledger_earners.first_credits: maturity only delays a penalty.

A stand-in earner (``piano``) is registered with a penalty. Its signed ledger
lives under the suite's redirected ``LEDGER_HOME``; whether it has ever paid
out decides the first day its cut applies (earned_time 0.6.0), and on an
earned_time without ``maturity`` the budget resolves exactly as 0.5.0 did.
"""

from __future__ import annotations

from dataclasses import replace
from datetime import datetime, time, timedelta
from typing import TYPE_CHECKING
from unittest.mock import patch

import earned_time
import pytest

from steam_backlog_enforcer import _ledger_earners, _leetcode_bonus, _workout_budget
from steam_backlog_enforcer._budget_resolve import resolve_budget
from steam_backlog_enforcer._ledger_earners import first_credits
from steam_backlog_enforcer.config import Config
from steam_backlog_enforcer.tests._budget_dates import AFTER_CUT, pin_today
from steam_backlog_enforcer.tests._ledger_fixtures import KEY, credit, write_ledger

if TYPE_CHECKING:
    from collections.abc import Iterator
    from datetime import date
    from pathlib import Path

_WORKOUT = "steam_backlog_enforcer._workout_budget._fetch_workout_today"
_LEETCODE = "steam_backlog_enforcer._leetcode_bonus.read_ledger_solved_today"
_ANSWER = "steam_backlog_enforcer._budget_resolve.ledger_answer"
_HOUR = 3600.0
_DAY = timedelta(days=1)


def _any_credit(_row: dict[str, object], _window: tuple[float, float]) -> bool:
    """Count every verified credit: the reader's own dating is earned_time's."""
    return True


# Penalised since well before the suite's pinned day, never confirmed by kuhy:
# without a real credit it is a new gate and costs nothing.
PIANO = earned_time.Earner(
    name="piano",
    label="Piano",
    gaming_minutes=30,
    shutdown_minutes=30,
    ledger=".local/share/piano_guard/ledger.json",
    match=_any_credit,
    penalty_from=AFTER_CUT - 5 * _DAY,
)


@pytest.fixture(autouse=True)
def _clear_caches() -> Iterator[None]:
    """Keep every earner memo from leaking answers between tests.

    Yields:
        None, with the caches empty before and after.
    """
    for module in (_ledger_earners, _workout_budget, _leetcode_bonus):
        module.reset_cache()
    yield
    for module in (_ledger_earners, _workout_budget, _leetcode_bonus):
        module.reset_cache()


@pytest.fixture
def key(tmp_path: Path) -> Iterator[Path]:
    """Sign and verify the stand-in's ledger with a throwaway key.

    Args:
        tmp_path: pytest's temporary directory (also ``LEDGER_HOME``).

    Yields:
        The key path, patched into ``_ledger_earners``.
    """
    path = tmp_path / "hmac.key"
    path.write_bytes(KEY)
    with patch.object(_ledger_earners, "HMAC_KEY_FILE", path):
        yield path


def _credit_on(home: Path, day: date) -> None:
    """Write the stand-in's ledger with one signed credit at noon on ``day``."""
    ledger = home / str(PIANO.ledger)
    ledger.parent.mkdir(parents=True)
    when = datetime.combine(day, time(12)).astimezone()
    write_ledger(ledger.parent, [credit(when=when, entry_id="piano:1")])


def _base(day: date) -> float:
    """``resolve_budget``'s floor on ``day`` with ``piano`` registered, all "no"."""
    with (
        pin_today(day),
        patch("earned_time.EARNERS", (*earned_time.EARNERS, PIANO)),
        patch(_WORKOUT, return_value=False),
        patch(_LEETCODE, return_value=False),
        patch(_ANSWER, return_value=False),
    ):
        return resolve_budget(Config()).base_seconds


class TestTheMap:
    """Only penalised, ledger-backed earners, keyed by name."""

    def test_maps_each_penalised_reader_to_its_first_credit(
        self, tmp_path: Path, key: Path
    ) -> None:
        """A bonus, a ledger-less earner and a matcher-less one are left out.

        Args:
            tmp_path: The suite's ``LEDGER_HOME``.
            key: The patched signing key.
        """
        assert key.exists()
        _credit_on(tmp_path, AFTER_CUT - _DAY)
        registry = (
            PIANO,
            replace(PIANO, name="bonus", penalty_from=None),
            replace(PIANO, name="no-ledger", ledger=None),
            replace(PIANO, name="no-match", match=None),
        )
        assert first_credits(registry, AFTER_CUT) == {"piano": AFTER_CUT - _DAY}

    def test_an_unreadable_ledger_is_no_first_credit(self) -> None:
        """No ledger and no key on record: ``None``, which resolve treats closed."""
        assert first_credits((PIANO,), AFTER_CUT) == {"piano": None}

    def test_an_old_earned_time_gets_no_map(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        """Without ``maturity`` (< 0.6) there is nothing to pass on.

        Args:
            monkeypatch: pytest's attribute patcher.
        """
        monkeypatch.delattr(earned_time, "maturity")
        assert first_credits((PIANO,), AFTER_CUT) is None


class TestTheBudget:
    """The cut waits for the day after the first real credit."""

    def test_a_gate_that_never_paid_out_costs_nothing(self) -> None:
        assert _base(AFTER_CUT) == 4 * _HOUR

    def test_the_cut_starts_the_day_after_the_first_credit(
        self, tmp_path: Path, key: Path
    ) -> None:
        """Credited on the pinned day: free that day, penalised the next.

        Args:
            tmp_path: The suite's ``LEDGER_HOME``.
            key: The patched signing key.
        """
        assert key.exists()
        _credit_on(tmp_path, AFTER_CUT)
        assert _base(AFTER_CUT) == 4 * _HOUR
        assert _base(AFTER_CUT + _DAY) == 3.5 * _HOUR

    def test_an_old_earned_time_resolves_as_before(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        """No ``maturity``, no ``first_credits``: ``penalty_from`` alone cuts.

        Args:
            monkeypatch: pytest's attribute patcher.
        """
        monkeypatch.delattr(earned_time, "maturity")
        assert _base(AFTER_CUT) == 3.5 * _HOUR