diff --git a/steam_backlog_enforcer/_steam_client.py b/steam_backlog_enforcer/_steam_client.py index b3cd7a0..8982492 100644 --- a/steam_backlog_enforcer/_steam_client.py +++ b/steam_backlog_enforcer/_steam_client.py @@ -57,6 +57,26 @@ def is_game_installed(app_id: int) -> bool: return manifest.exists() +def steam_client_running() -> bool | None: + """Whether the Steam main client (``steam.sh``, not just helpers) runs. + + Returns: + None when pgrep is missing or fails: callers that delete on "not + running" must treat that as running. + """ + try: + result = subprocess.run( + ["/usr/bin/pgrep", "-f", "steam.sh"], + capture_output=True, + text=True, + check=False, + ) + except FileNotFoundError: + return None + # pgrep: 0 matched, 1 matched nothing, anything else is its own error. + return {0: True, 1: False}.get(result.returncode) + + def _ensure_steam_running() -> None: """Start the Steam client if it is not already running. @@ -70,19 +90,10 @@ def _ensure_steam_running() -> None: logger.info("steam-game-installer is running — leaving Steam closed.") return - # Check if any steam process is running (main client, not just helpers). - try: - result = subprocess.run( - ["/usr/bin/pgrep", "-f", "steam.sh"], - capture_output=True, - text=True, - check=False, - ) - if result.returncode == 0: - logger.debug("Steam client already running") - return - except FileNotFoundError: - pass + # None (pgrep cannot tell) falls through to a start, as it always has. + if steam_client_running(): + logger.debug("Steam client already running") + return real_user = _get_real_user() logger.info("Starting Steam client...") diff --git a/steam_backlog_enforcer/_tool_need.py b/steam_backlog_enforcer/_tool_need.py new file mode 100644 index 0000000..0bb9f08 --- /dev/null +++ b/steam_backlog_enforcer/_tool_need.py @@ -0,0 +1,130 @@ +"""Whether the three Steam tools Proton games lean on are still needed. + +Steamworks Common Redistributables, Steam Linux Runtime 4.0 and Proton +Experimental stay in :data:`PROTECTED_APP_IDS`, so no sweep or guard ever +treats them as an unauthorized game. This module names the one case where they +may still go (kuhy's rule): Steam is closed, and every installed game is mapped +to ``proton-cachyos-native``, which is itself installed. + +An earlier version removed Steam Linux Runtime 4.0 while a game needed it, so +every doubt (a read error, a malformed file, a missing key, an exception) +means "needed". Reads only; config.vdf holds private values, so a reason names +the file or an AppID, never a line of it. +""" + +from __future__ import annotations + +from dataclasses import dataclass +import re +from typing import TYPE_CHECKING, Final + +from steam_backlog_enforcer import _steam_state +from steam_backlog_enforcer._fail_safe import FAIL_SAFE_ERRORS +from steam_backlog_enforcer._protected_apps import PROTECTED_APP_IDS +from steam_backlog_enforcer._steam_client import steam_client_running +from steam_backlog_enforcer._vdf_text import VdfNode, lookup, parse_vdf + +if TYPE_CHECKING: + from pathlib import Path + +STEAM_TOOLS: Final = { + 228980: "Steamworks Common Redistributables", + 4183110: "Steam Linux Runtime 4.0", + 1493710: "Proton Experimental", +} +NATIVE_TOOL: Final = "proton-cachyos-native" +_MAPPING: Final = ("InstallConfigStore", "Software", "Valve", "Steam") +_MANIFEST: Final = re.compile(r"appmanifest_\d+\.acf") + + +@dataclass(frozen=True) +class ToolNeed: + """The verdict and its one-line reason; ``deferred`` means Steam runs.""" + + needed: bool + reason: str + deferred: bool = False + + +def _keep(reason: str) -> ToolNeed: + return ToolNeed(needed=True, reason=reason) + + +def _compat_mapping(steam_root: Path) -> dict[str, VdfNode] | ToolNeed: + """config.vdf's CompatToolMapping block, or the reason to keep the tools.""" + try: + text = (steam_root / "config" / "config.vdf").read_text(encoding="utf-8") + except OSError, UnicodeDecodeError: + return _keep("config.vdf unreadable") + try: + tree = parse_vdf(text) + except ValueError: + return _keep("config.vdf malformed") + mapping = lookup(tree, *_MAPPING, "CompatToolMapping") + if not isinstance(mapping, dict): + return _keep("config.vdf has no CompatToolMapping") + return mapping + + +def _unmapped(steamapps: Path, mapping: dict[str, VdfNode]) -> ToolNeed | int: + """The reason to keep the tools, or how many installed games are mapped.""" + games = 0 + # iterdir, not glob: glob reads an unlistable directory as empty, which + # would read as "no game installed". + for manifest in sorted(steamapps.iterdir()): + if not _MANIFEST.fullmatch(manifest.name): + continue + try: + tree = parse_vdf(manifest.read_text(encoding="utf-8")) + except OSError, ValueError: + return _keep(f"{manifest.name} unreadable") + app_id = lookup(tree, "AppState", "appid") + if not isinstance(app_id, str) or not app_id.isdigit(): + return _keep(f"{manifest.name} has no appid") + if int(app_id) in PROTECTED_APP_IDS: + continue + if lookup(mapping, app_id, "name") != NATIVE_TOOL: + return _keep(f"AppID={app_id} has no {NATIVE_TOOL} mapping") + games += 1 + return games + + +def _decide(steamapps: Path) -> ToolNeed: + running = steam_client_running() + if running is None: + return _keep("cannot tell whether Steam runs") + if running: + return ToolNeed(needed=True, reason="Steam running", deferred=True) + steam_root = steamapps.parent + mapping = _compat_mapping(steam_root) + if isinstance(mapping, ToolNeed): + return mapping + games = _unmapped(steamapps, mapping) + if isinstance(games, ToolNeed): + return games + toolmanifest = steam_root / "compatibilitytools.d" / NATIVE_TOOL + if not (toolmanifest / "toolmanifest.vdf").is_file(): + return _keep(f"{NATIVE_TOOL} toolmanifest.vdf missing") + # No game installed means no game needs them; the reason says so in the log. + reason = ( + f"every installed game runs on {NATIVE_TOOL}" if games else "no game installed" + ) + return ToolNeed(needed=False, reason=reason) + + +def tool_need(steamapps: Path | None = None) -> ToolNeed: + """Decide whether :data:`STEAM_TOOLS` must stay installed. + + Args: + steamapps: The library to judge; defaults to the canonical + ``_steam_state.STEAMAPPS_PATH`` (read at call time, so a test + fixture's redirect holds). Its parent is the Steam root. + + Returns: + ``needed=False`` only when every condition holds; anything else, + including an exception, keeps them. + """ + try: + return _decide(_steam_state.STEAMAPPS_PATH if steamapps is None else steamapps) + except FAIL_SAFE_ERRORS as exc: + return _keep(f"check failed ({type(exc).__name__})") diff --git a/steam_backlog_enforcer/_vdf_text.py b/steam_backlog_enforcer/_vdf_text.py new file mode 100644 index 0000000..461a229 --- /dev/null +++ b/steam_backlog_enforcer/_vdf_text.py @@ -0,0 +1,88 @@ +"""A read-only parser for Valve's KeyValues text (``config.vdf``, ``*.acf``). + +Stdlib only: the root daemon runs on the system interpreter, which carries no +``vdf`` package, and an import that failed there would quietly turn every +decision built on it into "keep". Malformed input raises ``ValueError`` rather +than returning part of a tree, so a caller deciding something destructive can +fail closed. Error messages carry an offset, never file content: config.vdf +holds private values. +""" + +from __future__ import annotations + +import re +from typing import Final + +type VdfNode = dict[str, VdfNode] | str + +# One token per match: whitespace, a // comment, a quoted string (group 1), a +# brace (group 2), a [$PLATFORM] conditional, or a bare word (group 3). +_TOKEN: Final = re.compile( + r'\s+|//[^\n]*|"((?:[^"\\]|\\.)*)"|([{}])|\[[^\]\n]*\]|([^\s"{}\[]+)', + re.DOTALL, +) +_ESCAPES: Final = {"n": "\n", "t": "\t", "\\": "\\", '"': '"'} +_ESCAPE: Final = re.compile(r"\\(.)", re.DOTALL) + + +def _malformed(offset: int) -> ValueError: + return ValueError(f"malformed KeyValues at offset {offset}") + + +def _unescape(raw: str) -> str: + return _ESCAPE.sub(lambda m: _ESCAPES.get(m.group(1), m.group(0)), raw) + + +def parse_vdf(text: str) -> dict[str, VdfNode]: + """Parse KeyValues *text* into nested dicts (a repeated key: last wins). + + Raises: + ValueError: on any unterminated string, stray or missing brace, or a + key with no value. + """ + root: dict[str, VdfNode] = {} + stack = [root] + key: str | None = None + pos = 0 + while pos < len(text): + match = _TOKEN.match(text, pos) + if match is None: + raise _malformed(pos) + quoted, brace, bare = match.groups() + if brace == "{": + if key is None: + raise _malformed(pos) + child: dict[str, VdfNode] = {} + stack[-1][key] = child + stack.append(child) + key = None + elif brace == "}": + if key is not None or len(stack) == 1: + raise _malformed(pos) + stack.pop() + elif quoted is not None or bare is not None: + word = _unescape(quoted) if quoted is not None else str(bare) + if key is None: + key = word + else: + stack[-1][key] = word + key = None + pos = match.end() + if key is not None or len(stack) != 1: + raise _malformed(pos) + return root + + +def lookup(node: VdfNode | None, *keys: str) -> VdfNode | None: + """Walk *keys* down from *node*, matching each one case-insensitively. + + Returns: + The node found, or None when a key is missing or the path runs + through a plain string. + """ + for key in keys: + if not isinstance(node, dict): + return None + wanted = key.casefold() + node = next((v for k, v in node.items() if k.casefold() == wanted), None) + return node diff --git a/steam_backlog_enforcer/game_uninstall.py b/steam_backlog_enforcer/game_uninstall.py index a6289e2..07ef949 100644 --- a/steam_backlog_enforcer/game_uninstall.py +++ b/steam_backlog_enforcer/game_uninstall.py @@ -13,12 +13,14 @@ import re import shutil from typing import TYPE_CHECKING +from steam_backlog_enforcer import _steam_state from steam_backlog_enforcer._achievement_skip import zero_achievement_ids from steam_backlog_enforcer._game_names import _is_protected_name from steam_backlog_enforcer._progress import tracked from steam_backlog_enforcer._protected_apps import PROTECTED_APP_IDS from steam_backlog_enforcer._research_game import kept_ids from steam_backlog_enforcer._steam_state import STEAMAPPS_PATH, _assert_not_real_steam +from steam_backlog_enforcer._tool_need import STEAM_TOOLS, tool_need from steam_backlog_enforcer._whitelist_locking import get_approved_exception_ids if TYPE_CHECKING: @@ -174,9 +176,34 @@ def uninstall_other_games(allowed_app_ids: set[int]) -> int: if uninstall_game(app_id, name): count += 1 + # After the games: what is left installed decides whether the tools stay. + remove_unneeded_tools() return count +def remove_unneeded_tools() -> int: + """Uninstall :data:`STEAM_TOOLS` when :func:`tool_need` says nothing needs them. + + Silent when none of them is installed; otherwise one line says what was + decided and why. Returns how many were removed. + """ + # The canonical binding, read now: the test suite redirects it for every + # test, so no test can reach a live Steam root through this step. + steamapps = _steam_state.STEAMAPPS_PATH + present = [a for a in STEAM_TOOLS if (steamapps / f"appmanifest_{a}.acf").exists()] + if not present: + return 0 + need = tool_need(steamapps) + if need.deferred: + logger.info("Steam running, deferring tool removal") + return 0 + if need.needed: + logger.info("kept Steam tools: %s", need.reason) + return 0 + logger.info("removing Steam tools: %s", need.reason) + return sum(uninstall_game(app_id, STEAM_TOOLS[app_id]) for app_id in present) + + def is_infrastructure_app(app_id: int) -> bool: """Return True if *app_id* is a Steam runtime or compatibility tool. diff --git a/steam_backlog_enforcer/tests/_tool_home.py b/steam_backlog_enforcer/tests/_tool_home.py new file mode 100644 index 0000000..9d34df4 --- /dev/null +++ b/steam_backlog_enforcer/tests/_tool_home.py @@ -0,0 +1,73 @@ +"""Fixture Steam homes for the Steam-tool removal tests. + +Builds ``/steamapps``, ``/config/config.vdf`` and +``/compatibilitytools.d`` under a tmp dir, never the real Steam root. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from steam_backlog_enforcer._tool_need import NATIVE_TOOL, STEAM_TOOLS + +if TYPE_CHECKING: + from pathlib import Path + + +def acf(app_id: int, name: str) -> str: + """A minimal fully-installed appmanifest.""" + return ( + f'"AppState"\n{{\n\t"appid"\t\t"{app_id}"\n\t"name"\t\t"{name}"\n' + f'\t"installdir"\t\t"dir{app_id}"\n\t"StateFlags"\t\t"4"\n}}\n' + ) + + +def config_vdf(mapping: dict[int, str]) -> str: + """A config.vdf with Steam's real nesting (and its lowercase ``valve``).""" + entries = "".join( + f'\t\t\t\t\t"{app_id}"\n\t\t\t\t\t{{\n\t\t\t\t\t\t"name"\t\t"{tool}"\n' + f'\t\t\t\t\t\t"config"\t\t""\n\t\t\t\t\t\t"priority"\t\t"250"\n' + "\t\t\t\t\t}\n" + for app_id, tool in mapping.items() + ) + return ( + '"InstallConfigStore"\n{\n\t"Software"\n\t{\n\t\t"valve"\n\t\t{\n' + '\t\t\t"Steam"\n\t\t\t{\n\t\t\t\t"CompatToolMapping"\n\t\t\t\t{\n' + '\t\t\t\t\t"0"\n\t\t\t\t\t{\n\t\t\t\t\t\t"name"\t\t"proton_experimental"\n' + f"\t\t\t\t\t}}\n{entries}\t\t\t\t}}\n\t\t\t}}\n\t\t}}\n\t}}\n}}\n" + ) + + +def make_home( + root: Path, + games: dict[int, str | None], + *, + tools: bool = True, + toolmanifest: bool = True, +) -> Path: + """Write a fixture Steam root; return its ``steamapps``. + + Args: + root: Directory to become the Steam root. + games: Installed game app id -> its CompatToolMapping tool name, or + None for a game with no mapping entry. + tools: Install the three Steam tools (manifest + files). + toolmanifest: Install proton-cachyos-native's toolmanifest.vdf. + """ + steamapps = root / "steamapps" + (steamapps / "common").mkdir(parents=True) + installed = {app_id: f"Game {app_id}" for app_id in games} + if tools: + installed |= STEAM_TOOLS + for app_id, name in installed.items(): + (steamapps / f"appmanifest_{app_id}.acf").write_text(acf(app_id, name)) + (steamapps / "common" / f"dir{app_id}").mkdir() + (steamapps / "common" / f"dir{app_id}" / "file.bin").write_text("x") + (root / "config").mkdir() + mapping = {app_id: tool for app_id, tool in games.items() if tool} + (root / "config" / "config.vdf").write_text(config_vdf(mapping)) + if toolmanifest: + tool_dir = root / "compatibilitytools.d" / NATIVE_TOOL + tool_dir.mkdir(parents=True) + (tool_dir / "toolmanifest.vdf").write_text('"manifest"\n{\n}\n') + return steamapps diff --git a/steam_backlog_enforcer/tests/test_game_uninstall_tools.py b/steam_backlog_enforcer/tests/test_game_uninstall_tools.py new file mode 100644 index 0000000..0502bfc --- /dev/null +++ b/steam_backlog_enforcer/tests/test_game_uninstall_tools.py @@ -0,0 +1,125 @@ +"""The uninstall path's Steam-tool step, on fixture homes.""" + +from __future__ import annotations + +import logging +from typing import TYPE_CHECKING +from unittest.mock import patch + +import pytest + +from steam_backlog_enforcer._tool_need import NATIVE_TOOL, STEAM_TOOLS +from steam_backlog_enforcer.game_uninstall import ( + remove_unneeded_tools, + uninstall_other_games, +) +from steam_backlog_enforcer.tests._tool_home import make_home + +if TYPE_CHECKING: + from collections.abc import Iterator + from pathlib import Path + +PKG = "steam_backlog_enforcer.game_uninstall" +RUNNING = "steam_backlog_enforcer._tool_need.steam_client_running" + + +@pytest.fixture(name="home") +def fixture_home(tmp_path: Path) -> Iterator[Path]: + """Point both steamapps bindings at a fixture Steam root.""" + steamapps = tmp_path / "Steam" / "steamapps" + with ( + patch("steam_backlog_enforcer._steam_state.STEAMAPPS_PATH", steamapps), + patch(f"{PKG}.STEAMAPPS_PATH", steamapps), + patch(RUNNING, return_value=False), + ): + yield tmp_path / "Steam" + + +def _tools_left(steamapps: Path) -> set[int]: + return { + app_id + for app_id in STEAM_TOOLS + if (steamapps / f"appmanifest_{app_id}.acf").exists() + or (steamapps / "common" / f"dir{app_id}").exists() + } + + +def _messages(caplog: pytest.LogCaptureFixture) -> list[str]: + return [r.getMessage() for r in caplog.records if r.name == PKG] + + +def test_mapped_games_remove_the_tools( + home: Path, caplog: pytest.LogCaptureFixture +) -> None: + """All mapped: the three tools go, the game stays, one line says why.""" + steamapps = make_home(home, {10: NATIVE_TOOL}) + with caplog.at_level(logging.INFO, logger=PKG): + assert remove_unneeded_tools() == 3 + assert _tools_left(steamapps) == set() + assert (steamapps / "appmanifest_10.acf").exists() + messages = _messages(caplog) + assert messages[0] == ( + f"removing Steam tools: every installed game runs on {NATIVE_TOOL}" + ) + assert "Removed manifest for Steam Linux Runtime 4.0 (AppID=4183110)" in messages + + +def test_unmapped_game_keeps_the_tools( + home: Path, caplog: pytest.LogCaptureFixture +) -> None: + """An unmapped game keeps them with one line naming it.""" + steamapps = make_home(home, {10: NATIVE_TOOL, 20: None}) + with caplog.at_level(logging.INFO, logger=PKG): + assert remove_unneeded_tools() == 0 + assert _tools_left(steamapps) == set(STEAM_TOOLS) + assert _messages(caplog) == [ + f"kept Steam tools: AppID=20 has no {NATIVE_TOOL} mapping" + ] + + +def test_steam_running_defers(home: Path, caplog: pytest.LogCaptureFixture) -> None: + """A running Steam defers the decision.""" + steamapps = make_home(home, {10: NATIVE_TOOL}) + with caplog.at_level(logging.INFO, logger=PKG), patch(RUNNING, return_value=True): + assert remove_unneeded_tools() == 0 + assert _tools_left(steamapps) == set(STEAM_TOOLS) + assert _messages(caplog) == ["Steam running, deferring tool removal"] + + +def test_unreadable_config_keeps_and_says_why( + home: Path, caplog: pytest.LogCaptureFixture +) -> None: + """C22: config.vdf unreadable -> tools kept, one line naming the reason.""" + steamapps = make_home(home, {10: NATIVE_TOOL}) + config = home / "config" / "config.vdf" + config.unlink() + config.mkdir() + with caplog.at_level(logging.INFO, logger=PKG): + assert remove_unneeded_tools() == 0 + assert _tools_left(steamapps) == set(STEAM_TOOLS) + assert _messages(caplog) == ["kept Steam tools: config.vdf unreadable"] + + +def test_no_tools_installed_is_silent( + home: Path, caplog: pytest.LogCaptureFixture +) -> None: + """No tool installed: no decision, no log line.""" + make_home(home, {10: None}, tools=False) + with ( + caplog.at_level(logging.INFO, logger=PKG), + patch(f"{PKG}.tool_need") as need, + ): + assert remove_unneeded_tools() == 0 + need.assert_not_called() + assert _messages(caplog) == [] + + +def test_uninstall_sweep_runs_the_step_after_removing_games(home: Path) -> None: + """The sweep removes the unmapped game first, then the now-unneeded tools. + + The game count it returns still counts games only. + """ + steamapps = make_home(home, {10: NATIVE_TOOL, 20: None}) + assert uninstall_other_games({10}) == 1 + assert not (steamapps / "appmanifest_20.acf").exists() + assert _tools_left(steamapps) == set() diff --git a/steam_backlog_enforcer/tests/test_steam_client_running.py b/steam_backlog_enforcer/tests/test_steam_client_running.py new file mode 100644 index 0000000..7124bda --- /dev/null +++ b/steam_backlog_enforcer/tests/test_steam_client_running.py @@ -0,0 +1,26 @@ +"""Tests for steam_client_running: yes, no, or cannot tell.""" + +from __future__ import annotations + +from unittest.mock import MagicMock, patch + +import pytest + +from steam_backlog_enforcer._steam_client import steam_client_running + +RUN = "steam_backlog_enforcer._steam_client.subprocess.run" + + +@pytest.mark.parametrize( + ("returncode", "expected"), [(0, True), (1, False), (2, None), (3, None)] +) +def test_pgrep_exit_code(returncode: int, *, expected: bool | None) -> None: + """0 is running, 1 is not, anything else cannot tell.""" + with patch(RUN, return_value=MagicMock(returncode=returncode)): + assert steam_client_running() is expected + + +def test_missing_pgrep_cannot_tell() -> None: + """A missing pgrep cannot tell.""" + with patch(RUN, side_effect=FileNotFoundError): + assert steam_client_running() is None diff --git a/steam_backlog_enforcer/tests/test_tool_need.py b/steam_backlog_enforcer/tests/test_tool_need.py new file mode 100644 index 0000000..51c1ed8 --- /dev/null +++ b/steam_backlog_enforcer/tests/test_tool_need.py @@ -0,0 +1,159 @@ +"""Tests for _tool_need: when the three Steam tools may go, on fixture homes.""" + +from __future__ import annotations + +import shutil +from typing import TYPE_CHECKING +from unittest.mock import patch + +import pytest + +from steam_backlog_enforcer._tool_need import NATIVE_TOOL, ToolNeed, tool_need +from steam_backlog_enforcer.tests._tool_home import make_home + +if TYPE_CHECKING: + from collections.abc import Iterator + from pathlib import Path + +PKG = "steam_backlog_enforcer._tool_need" +KEEP_UNMAPPED = ToolNeed(needed=True, reason=f"AppID=20 has no {NATIVE_TOOL} mapping") + + +@pytest.fixture(name="root") +def fixture_root(tmp_path: Path) -> Path: + """A fixture Steam root (conftest already owns tmp_path/steamapps).""" + return tmp_path / "Steam" + + +@pytest.fixture(autouse=True) +def _steam_closed() -> Iterator[None]: + """Steam is closed unless a test says otherwise: never ask the live pgrep.""" + with patch(f"{PKG}.steam_client_running", return_value=False): + yield + + +def test_all_mapped_means_not_needed(root: Path) -> None: + """Every game on proton-cachyos-native: the tools may go.""" + steamapps = make_home(root, {10: NATIVE_TOOL, 20: NATIVE_TOOL}) + assert tool_need(steamapps) == ToolNeed( + needed=False, reason=f"every installed game runs on {NATIVE_TOOL}" + ) + + +def test_one_unmapped_game_keeps(root: Path) -> None: + """One game with no mapping entry keeps them.""" + steamapps = make_home(root, {10: NATIVE_TOOL, 20: None}) + assert tool_need(steamapps) == KEEP_UNMAPPED + + +def test_mapping_naming_another_tool_keeps(root: Path) -> None: + """A game mapped to another tool keeps them.""" + steamapps = make_home(root, {10: NATIVE_TOOL, 20: "proton_experimental"}) + assert tool_need(steamapps) == KEEP_UNMAPPED + + +def test_mapping_entry_that_is_not_a_block_keeps(root: Path) -> None: + """A mapping entry with no name block keeps them.""" + steamapps = make_home(root, {20: NATIVE_TOOL}) + config = root / "config" / "config.vdf" + config.write_text( + '"InstallConfigStore" { "Software" { "Valve" { "Steam" {' + ' "CompatToolMapping" { "20" "proton-cachyos-native" } } } } }' + ) + assert tool_need(steamapps) == KEEP_UNMAPPED + + +def test_steam_running_defers(root: Path) -> None: + """A running Steam defers the decision.""" + steamapps = make_home(root, {10: NATIVE_TOOL}) + with patch(f"{PKG}.steam_client_running", return_value=True): + need = tool_need(steamapps) + assert need == ToolNeed(needed=True, reason="Steam running", deferred=True) + + +def test_unknown_steam_state_keeps(root: Path) -> None: + """pgrep that cannot tell keeps them.""" + steamapps = make_home(root, {10: NATIVE_TOOL}) + with patch(f"{PKG}.steam_client_running", return_value=None): + need = tool_need(steamapps) + assert need == ToolNeed(needed=True, reason="cannot tell whether Steam runs") + + +@pytest.mark.parametrize("damage", ["directory", "binary", "missing"]) +def test_unreadable_config_keeps(root: Path, damage: str) -> None: + """C22: an unreadable config.vdf keeps the tools and says why.""" + steamapps = make_home(root, {10: NATIVE_TOOL}) + config = root / "config" / "config.vdf" + config.unlink() + if damage == "directory": + config.mkdir() + elif damage == "binary": + config.write_bytes(b'"InstallConfigStore" { "\xff\xfe" }') + assert tool_need(steamapps) == ToolNeed(needed=True, reason="config.vdf unreadable") + + +def test_malformed_config_keeps(root: Path) -> None: + """A config.vdf that does not parse keeps them.""" + steamapps = make_home(root, {10: NATIVE_TOOL}) + (root / "config" / "config.vdf").write_text('"InstallConfigStore" { "a"') + assert tool_need(steamapps) == ToolNeed(needed=True, reason="config.vdf malformed") + + +def test_config_without_mapping_keeps(root: Path) -> None: + """A config.vdf with no CompatToolMapping keeps them.""" + steamapps = make_home(root, {10: NATIVE_TOOL}) + (root / "config" / "config.vdf").write_text( + '"InstallConfigStore" { "Software" { "Valve" { "Steam" { "x" "1" } } } }' + ) + assert tool_need(steamapps) == ToolNeed( + needed=True, reason="config.vdf has no CompatToolMapping" + ) + + +def test_missing_toolmanifest_keeps(root: Path) -> None: + """No proton-cachyos-native toolmanifest.vdf keeps them.""" + steamapps = make_home(root, {10: NATIVE_TOOL}, toolmanifest=False) + assert tool_need(steamapps) == ToolNeed( + needed=True, reason=f"{NATIVE_TOOL} toolmanifest.vdf missing" + ) + + +def test_no_game_installed_is_not_needed(root: Path) -> None: + """No game installed: no game needs them.""" + steamapps = make_home(root, {}) + assert tool_need(steamapps) == ToolNeed(needed=False, reason="no game installed") + + +def test_unreadable_manifest_keeps(root: Path) -> None: + """An unreadable appmanifest keeps them.""" + steamapps = make_home(root, {10: NATIVE_TOOL}) + (steamapps / "appmanifest_30.acf").mkdir() + assert tool_need(steamapps) == ToolNeed( + needed=True, reason="appmanifest_30.acf unreadable" + ) + + +def test_manifest_without_appid_keeps(root: Path) -> None: + """An appmanifest with no appid keeps them.""" + steamapps = make_home(root, {10: NATIVE_TOOL}) + (steamapps / "appmanifest_30.acf").write_text('"AppState" { "name" "x" }') + assert tool_need(steamapps) == ToolNeed( + needed=True, reason="appmanifest_30.acf has no appid" + ) + + +def test_unlistable_steamapps_keeps(root: Path) -> None: + """A steamapps that cannot be listed keeps them.""" + steamapps = make_home(root, {10: NATIVE_TOOL}) + shutil.rmtree(steamapps) + steamapps.write_text("not a directory") + assert tool_need(steamapps) == ToolNeed( + needed=True, reason="check failed (NotADirectoryError)" + ) + + +def test_defaults_to_the_canonical_steamapps(root: Path) -> None: + """With no argument it judges _steam_state.STEAMAPPS_PATH.""" + steamapps = make_home(root, {10: NATIVE_TOOL}) + with patch("steam_backlog_enforcer._steam_state.STEAMAPPS_PATH", steamapps): + assert not tool_need().needed diff --git a/steam_backlog_enforcer/tests/test_vdf_text.py b/steam_backlog_enforcer/tests/test_vdf_text.py new file mode 100644 index 0000000..d94d820 --- /dev/null +++ b/steam_backlog_enforcer/tests/test_vdf_text.py @@ -0,0 +1,61 @@ +"""Tests for the stdlib KeyValues (``.vdf`` / ``.acf``) parser.""" + +from __future__ import annotations + +import pytest + +from steam_backlog_enforcer._vdf_text import lookup, parse_vdf + +TREE = {"Outer": {"Inner": {"leaf": "v"}, "flat": "s"}} + + +class TestParse: + """parse_vdf builds the whole tree or raises.""" + + def test_nested_blocks(self) -> None: + """Blocks nest and empty strings survive.""" + text = '"A"\n{\n\t"b"\t\t"1"\n\t"C"\n\t{\n\t\t"d"\t""\n\t}\n}\n' + assert parse_vdf(text) == {"A": {"b": "1", "C": {"d": ""}}} + + def test_escapes_comments_conditionals_and_bare_tokens(self) -> None: + """Escapes, comments, conditionals and bare words parse.""" + text = ( + "// header comment\n" + '"root" {\n' + ' "path" "C:\\\\Games\\"x\\"\\n\\t" [$WIN32]\n' + " bare word // trailing\n" + "}\n" + ) + assert parse_vdf(text) == {"root": {"path": 'C:\\Games"x"\n\t', "bare": "word"}} + + @pytest.mark.parametrize( + "text", + [ + '"a" "unterminated', + '"a" "1" }', + '"a" { "b" "1"', + '{ "b" "1" }', + '"a" { "b" }', + '"dangling"', + ], + ) + def test_malformed_raises(self, text: str) -> None: + """Every malformed shape raises instead of returning part of a tree.""" + with pytest.raises(ValueError, match="malformed KeyValues"): + parse_vdf(text) + + +class TestLookup: + """lookup walks keys case-insensitively.""" + + def test_case_insensitive_path(self) -> None: + """Keys match regardless of case.""" + assert lookup(TREE, "outer", "INNER", "Leaf") == "v" + + def test_missing_key(self) -> None: + """A missing key returns None.""" + assert lookup(TREE, "outer", "nope") is None + + def test_through_a_string(self) -> None: + """A path through a plain string returns None.""" + assert lookup(TREE, "outer", "flat", "deeper") is None