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

"""Tests for _web_views — the read-only API projections."""

from __future__ import annotations

from unittest.mock import patch

import pytest

from steam_backlog_enforcer import _steam_state, _web_views
from steam_backlog_enforcer._backups import StateBackup
from steam_backlog_enforcer._web_views import _manual_pick, _size_on_disk
from steam_backlog_enforcer.config import Config
from steam_backlog_enforcer.tests._web_request import make_request, payload_of

_PKG = "steam_backlog_enforcer._web_views"


class TestStatus:
    """The status view reshapes manual picks for the UI."""

    def test_manual_pick_fields(self) -> None:
        """A manual pick maps to id, name and age rounded to a tenth."""
        full = _manual_pick({"app_id": 1, "game_name": "One", "age_days": 2.345})
        assert full == {"app_id": 1, "name": "One", "age_days": 2.3}

    def test_unknown_name_and_age(self) -> None:
        """A pick without name or age falls back to the id and 0."""
        bare = _manual_pick({"app_id": 2, "age_days": None})
        assert bare == {"app_id": 2, "name": "2", "age_days": 0.0}

    def test_status_view_reshapes_the_payload(self) -> None:
        """status_view fills install state and reshapes picks, keeping the rest."""
        raw = {
            "assigned_game_installed": None,
            "manual_picks": [{"app_id": 3, "game_name": "G", "age_days": 1.0}],
            "other": "kept",
        }
        with patch(f"{_PKG}.status_payload", return_value=raw):
            body = payload_of(_web_views.status_view(make_request()))
        assert body["assigned_game_installed"] is False
        assert body["manual_picks"] == [{"app_id": 3, "name": "G", "age_days": 1.0}]
        assert body["other"] == "kept"


class TestDatasetViews:
    """The stats, dataset and budget views project their sources."""

    def test_stats_projects_two_keys(self) -> None:
        """stats_view keeps only the summary and pace keys."""
        full = {"default_summary": {"a": 1}, "pace_vs_hltb": [2], "games": []}
        with (
            patch(f"{_PKG}.build_web_dataset"),
            patch(f"{_PKG}.dataset_to_payload", return_value=full),
        ):
            reply = _web_views.stats_view(make_request())
        assert reply.payload == {"default_summary": {"a": 1}, "pace_vs_hltb": [2]}

    def test_dataset_view(self) -> None:
        """dataset_view returns the whole dataset payload."""
        with (
            patch(f"{_PKG}.build_web_dataset"),
            patch(f"{_PKG}.dataset_to_payload", return_value={"games": []}),
        ):
            assert _web_views.dataset_view(make_request()).payload == {"games": []}

    @pytest.mark.parametrize(("query", "demo"), [({}, False), ({"demo": "1"}, True)])
    def test_budget_view(self, query: dict[str, str], *, demo: bool) -> None:
        """budget_view builds the snapshot with the demo flag from the query."""
        with patch(f"{_PKG}.build_budget_snapshot", return_value={"x": 1}) as build:
            reply = _web_views.budget_view(make_request(query=query))
        build.assert_called_once_with(demo=demo)
        assert reply.payload == {"x": 1}


class TestInstalled:
    """The installed view lists games with size and flags."""

    def test_size_read_from_the_manifest(self) -> None:
        """The size comes from SizeOnDisk in the manifest."""
        manifest = _steam_state.STEAMAPPS_PATH / "appmanifest_5.acf"
        manifest.write_text('"AppState"\n{\n\t"SizeOnDisk"\t\t"1234"\n}', "utf-8")
        assert _size_on_disk(5) == 1234

    def test_size_unknown_without_a_match_or_a_file(self) -> None:
        """A manifest without the field, or no manifest, gives size 0."""
        manifest = _steam_state.STEAMAPPS_PATH / "appmanifest_6.acf"
        manifest.write_text('"AppState" {}', encoding="utf-8")
        assert _size_on_disk(6) == 0
        assert _size_on_disk(7) == 0

    def test_installed_view(self) -> None:
        """installed_view lists each game with size, assigned and protected flags."""
        with (
            patch(f"{_PKG}.get_installed_games", return_value=[(5, "Five")]),
            patch(f"{_PKG}.allowed_app_ids", return_value={5}),
            patch(f"{_PKG}.is_protected_app", return_value=False),
            patch(f"{_PKG}._size_on_disk", return_value=9),
        ):
            reply = _web_views.installed_view(make_request())
        assert payload_of(reply) == {
            "games": [
                {
                    "app_id": 5,
                    "name": "Five",
                    "size_bytes": 9,
                    "assigned": True,
                    "protected": False,
                }
            ]
        }


class TestSimpleViews:
    """Views that pass a single source through."""

    def test_commands(self) -> None:
        """commands_view returns the command specs."""
        with patch(f"{_PKG}.command_specs", return_value=[{"name": "scan"}]):
            assert _web_views.commands_view(make_request()).payload == [
                {"name": "scan"}
            ]

    def test_setup_status_never_carries_the_key(self) -> None:
        """setup_status reports whether a key is set, never the key."""
        unset = _web_views.setup_status(Config())
        assert unset == {"configured": False, "has_api_key": False, "steam_id": None}
        done = _web_views.setup_status(Config(steam_api_key="k", steam_id="7"))
        assert done == {"configured": True, "has_api_key": True, "steam_id": "7"}

    def test_setup_view(self) -> None:
        """setup_view reports the setup status."""
        body = payload_of(_web_views.setup_view(make_request()))
        assert body["configured"] is False

    def test_backups(self) -> None:
        """backups_view lists the backups as JSON."""
        backup = StateBackup("id1", "t", "r", 4)
        with patch(f"{_PKG}.list_backups", return_value=[backup]):
            reply = _web_views.backups_view(make_request())
        assert reply.payload == [backup.to_json()]