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

"""Tests for _web_art — the cover lookup order and the CDN fetch fence."""

from __future__ import annotations

import time
from unittest.mock import MagicMock, patch

import pytest
import requests

from steam_backlog_enforcer import _web_art
from steam_backlog_enforcer._web_art import (
    _CDN,
    _FAILED_RETRY_S,
    _MAX_BYTES,
    _cache_file,
    _fetch,
    _local_cover,
    _miss_active,
    _miss_file,
    _record_miss,
    _store,
)
from steam_backlog_enforcer._web_errors import ApiError
from steam_backlog_enforcer.tests._web_request import make_request

_PKG = "steam_backlog_enforcer._web_art"


def _response(
    status: int = 200, ctype: str = "image/jpeg", content: bytes = b"JPEG"
) -> MagicMock:
    resp = MagicMock()
    resp.status_code = status
    resp.headers = {"Content-Type": ctype}
    resp.content = content
    return resp


class TestLocalCover:
    """Steam's own librarycache is searched for a portrait cover."""

    def test_none_when_steam_cached_nothing(self) -> None:
        """An app with no librarycache entry has no local cover."""
        assert _local_cover(10) is None

    def test_top_level_portrait(self) -> None:
        """A portrait in the app's top-level cache dir is found."""
        base = _web_art.LIBRARYCACHE / "10"
        base.mkdir(parents=True)
        (base / "library_600x900.jpg").write_bytes(b"A")
        assert _local_cover(10) == base / "library_600x900.jpg"

    def test_hashed_subdirectory_portrait(self) -> None:
        """A portrait inside a hashed subdirectory is found."""
        sub = _web_art.LIBRARYCACHE / "10" / "abc123"
        sub.mkdir(parents=True)
        (sub / "library_capsule.jpg").write_bytes(b"B")
        assert _local_cover(10) == sub / "library_capsule.jpg"


class TestMissMarker:
    """The miss marker suppresses refetches until it lapses."""

    def test_absent_marker_is_not_active(self) -> None:
        """No marker file means no active miss."""
        assert _miss_active(1) is False

    def test_garbage_marker_is_not_active(self) -> None:
        """An unparsable marker is treated as no miss."""
        _web_art.ART_CACHE_DIR.mkdir(parents=True)
        _miss_file(1).write_text("not a number", encoding="utf-8")
        assert _miss_active(1) is False

    def test_recorded_miss_is_active_until_it_lapses(self) -> None:
        """A recorded miss is active, then lapses after its wait."""
        _record_miss(1, 60)
        assert _miss_active(1) is True
        with patch(f"{_PKG}.time.time", return_value=time.time() + 120):
            assert _miss_active(1) is False


class TestStore:
    """Storing a cover writes the cache file."""

    def test_store_writes_and_clears_the_miss(self) -> None:
        """Storing writes the bytes and removes any miss marker."""
        _record_miss(2, 60)
        _store(2, b"IMG")
        assert _cache_file(2).read_bytes() == b"IMG"
        assert not _miss_file(2).exists()

    def test_store_without_a_miss_marker(self) -> None:
        """Storing works when there was no miss marker."""
        _store(3, b"IMG")
        assert _cache_file(3).read_bytes() == b"IMG"


class TestFetch:
    """The CDN fetch is fenced by the cache and the miss marker."""

    def test_returns_a_cover_stored_while_waiting(self) -> None:
        """A cover stored meanwhile is returned without a request."""
        _store(4, b"EARLY")
        with patch(f"{_PKG}.requests.get") as get:
            assert _fetch(4) == b"EARLY"
        get.assert_not_called()

    def test_active_miss_skips_the_network(self) -> None:
        """An active miss returns None without a request."""
        _record_miss(4, 60)
        with patch(f"{_PKG}.requests.get") as get:
            assert _fetch(4) is None
        get.assert_not_called()

    def test_network_failure_is_remembered_briefly(self) -> None:
        """A connection error records a short miss."""
        with patch(f"{_PKG}.requests.get", side_effect=requests.ConnectionError):
            assert _fetch(5) is None
        retry_at = float(_miss_file(5).read_text(encoding="utf-8"))
        assert retry_at - time.time() <= _FAILED_RETRY_S

    def test_success_is_cached(self) -> None:
        """A good answer comes from the CDN URL and is cached."""
        with patch(f"{_PKG}.requests.get", return_value=_response()) as get:
            assert _fetch(6) == b"JPEG"
        assert get.call_args.args == (_CDN.format(app_id=6),)
        assert _cache_file(6).read_bytes() == b"JPEG"

    @pytest.mark.parametrize(
        ("status", "ctype", "long_retry"),
        [
            (404, "text/html", True),
            (403, "text/html", True),
            (500, "text/html", False),
            (200, "text/html", False),
        ],
    )
    def test_unusable_answer_is_a_remembered_miss(
        self, status: int, ctype: str, *, long_retry: bool
    ) -> None:
        """Bad answers record a miss; only 403/404 get the long wait."""
        resp = _response(status, ctype)
        with patch(f"{_PKG}.requests.get", return_value=resp):
            assert _fetch(7) is None
        wait = float(_miss_file(7).read_text(encoding="utf-8")) - time.time()
        assert (wait > _FAILED_RETRY_S) is long_retry

    def test_oversized_cover_is_a_long_miss(self) -> None:
        """A cover over the size cap records a long miss."""
        big = _response(content=b"x" * (_MAX_BYTES + 1))
        with patch(f"{_PKG}.requests.get", return_value=big):
            assert _fetch(8) is None
        wait = float(_miss_file(8).read_text(encoding="utf-8")) - time.time()
        assert wait > _FAILED_RETRY_S


class TestCoverBytes:
    """cover_bytes tries Steam's cache, the server cache, then the CDN."""

    def test_prefers_steams_own_cache(self) -> None:
        """Steam's local cover wins over everything else."""
        base = _web_art.LIBRARYCACHE / "9"
        base.mkdir(parents=True)
        (base / "library_600x900.jpg").write_bytes(b"LOCAL")
        assert _web_art.cover_bytes(9) == b"LOCAL"

    def test_then_the_server_cache(self) -> None:
        """The server cache is used when Steam has nothing."""
        _store(9, b"CACHED")
        assert _web_art.cover_bytes(9) == b"CACHED"

    def test_active_miss_means_no_cover(self) -> None:
        """An active miss yields no cover."""
        _record_miss(9, 60)
        assert _web_art.cover_bytes(9) is None

    def test_falls_through_to_the_cdn(self) -> None:
        """With nothing cached, the CDN fetch is asked once."""
        with patch(f"{_PKG}._fetch", return_value=b"NET") as fetch:
            assert _web_art.cover_bytes(9) == b"NET"
        fetch.assert_called_once_with(9)


class TestArtView:
    """The /art endpoint serves covers of owned games only."""

    def test_serves_an_owned_cover(self) -> None:
        """An owned game's cover is served as a cacheable JPEG."""
        with (
            patch(f"{_PKG}.owned_app_ids", return_value={42}),
            patch(f"{_PKG}.cover_bytes", return_value=b"JPG"),
        ):
            reply = _web_art.art_view(make_request("42"))
        assert reply.raw == b"JPG"
        assert reply.ctype == "image/jpeg"
        assert "max-age" in reply.headers["Cache-Control"]

    @pytest.mark.parametrize("raw", ["abc", "7"])
    def test_refuses_what_is_not_owned(self, raw: str) -> None:
        """A non-numeric or unowned id is not_found."""
        with (
            patch(f"{_PKG}.owned_app_ids", return_value={42}),
            pytest.raises(ApiError) as err,
        ):
            _web_art.art_view(make_request(raw))
        assert err.value.code == "not_found"

    def test_no_cover_is_not_found(self) -> None:
        """An owned game without a cover is not_found."""
        with (
            patch(f"{_PKG}.owned_app_ids", return_value={42}),
            patch(f"{_PKG}.cover_bytes", return_value=None),
            pytest.raises(ApiError) as err,
        ):
            _web_art.art_view(make_request("42"))
        assert err.value.code == "not_found"