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

"""Tests for ``_ctl_client``: the raw call and the typed per-op wrappers.

``call`` is exercised against a one-shot fake daemon on a Unix socket in a
short temp dir; the typed wrappers patch ``call`` and check what they send and
how they shape the answer.
"""

from __future__ import annotations

import json
from typing import TYPE_CHECKING
from unittest.mock import MagicMock, patch

import pytest

from steam_backlog_enforcer import _ctl_client
from steam_backlog_enforcer._ctl_protocol import (
    MAX_RESPONSE_BYTES,
    CtlError,
    DaemonUnreachableError,
)
from steam_backlog_enforcer._ctl_types import (
    BlockResult,
    DaemonInfo,
    FastInstallInfo,
    PendingReset,
    ResetResult,
    StoreWindow,
)
from steam_backlog_enforcer.tests._ctl_fixtures import serve_once, short_socket_dir

if TYPE_CHECKING:
    from collections.abc import Iterator
    from contextlib import AbstractContextManager
    from pathlib import Path


@pytest.fixture
def sock_path() -> Iterator[Path]:
    with short_socket_dir() as directory:
        yield directory / "c.sock"


def _line(obj: object) -> bytes:
    return json.dumps(obj).encode() + b"\n"


class TestCall:
    """The wire round trip."""

    def test_returns_data(self, sock_path: Path) -> None:
        thread = serve_once(sock_path, _line({"ok": True, "data": {"a": 1}}))
        assert _ctl_client.call("ping", {"x": 1}, path=sock_path) == {"a": 1}
        thread.join(5)

    def test_ok_without_object_data_is_empty(self, sock_path: Path) -> None:
        serve_once(sock_path, _line({"ok": True, "data": 5}))
        assert _ctl_client.call("ping", path=sock_path) == {}

    def test_error_reply_raises_ctl_error(self, sock_path: Path) -> None:
        reply = {"ok": False, "error": "locked", "message": "no", "data": {"k": 1}}
        serve_once(sock_path, _line(reply))
        with pytest.raises(CtlError) as caught:
            _ctl_client.call("ping", path=sock_path)
        assert (caught.value.code, caught.value.message) == ("locked", "no")
        assert caught.value.data == {"k": 1}

    def test_error_reply_defaults(self, sock_path: Path) -> None:
        serve_once(sock_path, _line({"ok": False}))
        with pytest.raises(CtlError) as caught:
            _ctl_client.call("ping", path=sock_path)
        assert (caught.value.code, caught.value.message) == ("op_failed", "")
        assert caught.value.data == {}

    def test_missing_socket(self, sock_path: Path) -> None:
        with pytest.raises(DaemonUnreachableError, match="control socket"):
            _ctl_client.call("ping", path=sock_path)

    def test_closed_without_answer(self, sock_path: Path) -> None:
        serve_once(sock_path, b"")
        with pytest.raises(DaemonUnreachableError, match="without answering"):
            _ctl_client.call("ping", path=sock_path)

    @pytest.mark.parametrize("reply", [b"{nope\n", b"[1]\n", b"\xff\n"])
    def test_malformed_reply(self, sock_path: Path, reply: bytes) -> None:
        serve_once(sock_path, reply)
        with pytest.raises(DaemonUnreachableError, match="malformed"):
            _ctl_client.call("ping", path=sock_path)

    def test_oversize_reply(self, sock_path: Path) -> None:
        serve_once(sock_path, b"x" * (MAX_RESPONSE_BYTES + 70000))
        with pytest.raises(DaemonUnreachableError, match="too large"):
            _ctl_client.call("ping", path=sock_path)


_PENDING = {
    "pending_id": "abc",
    "phrase": "p",
    "armed_at": "a",
    "ready_at": "r",
    "heartbeat_interval_seconds": 10,
}


class TestTypedWrappers:
    """Each wrapper sends the right op and shapes the reply."""

    def _call(self, data: dict[str, object]) -> AbstractContextManager[MagicMock]:
        return patch.object(_ctl_client, "call", return_value=data)

    def test_ping(self) -> None:
        with self._call({}) as call:
            _ctl_client.ping()
        call.assert_called_once_with("ping")

    def test_status(self) -> None:
        data = {
            "state": "running",
            "started_at": "t",
            "pid": 4,
            "restart_available_at": "x",
        }
        with self._call(data):
            assert _ctl_client.status() == DaemonInfo("running", "t", 4, "x")

    def test_status_no_restart_time(self) -> None:
        data = {"state": "running", "started_at": "t", "pid": 4}
        with self._call(data):
            info = _ctl_client.status()
        assert info.restart_available_at is None
        assert info.fast_installs == ()  # an older daemon sends none

    def test_status_fast_installs(self) -> None:
        run = {
            "app_id": 7,
            "name": "G",
            "phase": "downloading depot 1/8",
            "percent": 46.9,
            "elapsed_seconds": 60,
        }
        data = {"state": "running", "started_at": "t", "pid": 4, "fast_installs": [run]}
        with self._call(data):
            info = _ctl_client.status()
        assert info.fast_installs == (
            FastInstallInfo(7, "G", "downloading depot 1/8", 46.9, 60),
        )

    def test_status_failed_fast_install(self) -> None:
        run = {"app_id": 7, "name": "G", "phase": "failed", "percent": None}
        run |= {"elapsed_seconds": 0, "error": "exit 1"}
        data = {"state": "running", "started_at": "t", "pid": 4, "fast_installs": [run]}
        with self._call(data):
            info = _ctl_client.status()
        assert info.fast_installs[0].error == "exit 1"

    def test_journal_tail(self) -> None:
        with self._call({"lines": ["a", 2]}) as call:
            assert _ctl_client.journal_tail(9) == ["a", "2"]
        call.assert_called_once_with("journal_tail", {"lines": 9})

    def test_store_unblock(self) -> None:
        with self._call({"minutes": 5, "until": "u"}) as call:
            assert _ctl_client.store_unblock(5, "ph") == StoreWindow(5, "u")
        assert call.call_args.args == ("store_unblock", {"minutes": 5, "phrase": "ph"})

    def test_block_gaming(self) -> None:
        with self._call({"days": 3, "until": "u"}):
            assert _ctl_client.block_gaming(3, "ph") == BlockResult(3, "u")

    def test_block_gaming_no_until(self) -> None:
        with self._call({"days": 3, "until": None}):
            assert _ctl_client.block_gaming(3, "ph") == BlockResult(3, None)

    def test_gaming_unblock(self) -> None:
        with self._call({"released": ["/a"]}):
            assert _ctl_client.gaming_unblock("ph") == ["/a"]

    def test_reset_arm_and_heartbeat(self) -> None:
        expected = PendingReset("abc", "p", "a", "r", 10)
        with self._call(dict(_PENDING)):
            assert _ctl_client.gaming_reset_arm("ph") == expected
            assert _ctl_client.gaming_reset_heartbeat("abc") == expected

    def test_reset_commit(self) -> None:
        data = {
            "day_key": "d",
            "seconds_before": 1.5,
            "was_blocked": 1,
            "released": ["/m"],
        }
        with self._call(data):
            result = _ctl_client.gaming_reset_commit("abc", "ph")
        assert result == ResetResult("d", 1.5, was_blocked=True, released=["/m"])

    def test_reset_cancel(self) -> None:
        with self._call({}) as call:
            _ctl_client.gaming_reset_cancel("abc")
        call.assert_called_once_with("gaming_reset_cancel", {"pending_id": "abc"})

    def test_restart(self) -> None:
        with self._call({"restart_available_at": "x"}):
            assert _ctl_client.restart() == "x"

    def test_restart_no_time(self) -> None:
        with self._call({}):
            assert _ctl_client.restart() is None