steam-backlog-enforcer/steam_backlog_enforcer/tests/test_game_install.py
Krzysztof kuhy Rudnicki bfdd69453e
Some checks failed
pre-commit / pre-commit (push) Has been cancelled
Tests / test (3.10) (push) Has been cancelled
Tests / test (3.11) (push) Has been cancelled
Tests / test (3.12) (push) Has been cancelled
Pass XDG_RUNTIME_DIR when launching Steam as the desktop user
The enforcer runs as root under systemd and launches Steam via
`sudo -u <user> env DISPLAY=... XAUTHORITY=... DBUS_SESSION_BUS_ADDRESS=...`.
sudo uses env_reset, so that list is the child's entire environment - an
allowlist where every omission fails silently.

XDG_RUNTIME_DIR was missing. Without it Wine cannot reach
$XDG_RUNTIME_DIR/pulse/native, falls back from winepulse.drv to
winealsa.drv, and hands FMOD raw ALSA devices instead of the session sink.
Kingdom Come: Deliverance II died in its Bink startup video as a result.
Across 18 sessions the split was total: 9/9 runs logging "PulseAudio
Output" exited cleanly, 9/9 logging "HDA NVidia" crashed on the same line.

It presented as a corrupt install - the apparent cure was a 92GB reinstall -
but verify-integrity always passed. What actually fixed it was the Steam
restart the reinstall incidentally performed.

Extract the duplicated env construction into _desktop_env.desktop_env_args
and derive XDG_RUNTIME_DIR from the target uid, never from the ambient
environment: root's own value would point the child at /run/user/0.

PULSE_SERVER is deliberately not exported. pressure-vessel reads
XDG_RUNTIME_DIR to bind-mount the pulse socket into the Steam Linux Runtime
container, whereas a hardcoded unix:/run/user/<uid>/pulse/native names a
host path that need not resolve inside it.

Also gate the launch on the session existing. The enforcer is ordered only
After=network-online, while /run/user/<uid> is created by
user-runtime-dir@<uid>.service; on a measured boot the enforcer started 54ms
before that unit and won only by doing other work first. Launching in that
window would name a runtime dir that is not there and reintroduce the same
silent winealsa fallback for the whole session, so defer instead - the
enforce loop already retries every 3s, and DesktopSessionNotReadyError
subclasses SteamUnavailableError so existing callers degrade as before.
An ordering dependency would not be reliable here, since logind may start
user-runtime-dir outside the boot transaction.

Verified on the failing path rather than a dev shell: after restarting the
enforcer, the Steam it launched carried XDG_RUNTIME_DIR=/run/user/1000 and
KCD2 ran 15 minutes on "PulseAudio Output" with no crash artifacts.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-07-26 14:39:38 +02:00

347 lines
12 KiB
Python

"""Tests for game_install module."""
from __future__ import annotations
import os
from typing import TYPE_CHECKING
from unittest.mock import MagicMock, patch
import pytest
from steam_backlog_enforcer.game_install import (
_assert_not_real_steam,
_echo,
_ensure_steam_running,
_get_real_user,
_get_uid_gid_for_user,
_trigger_steam_install,
is_game_installed,
)
if TYPE_CHECKING:
from collections.abc import Iterator
from pathlib import Path
PKG = "steam_backlog_enforcer.game_install"
class TestAssertNotRealSteam:
"""Tests for the _assert_not_real_steam safety guard."""
def test_allows_tmp_path(self, tmp_path: Path) -> None:
"""Non-Steam paths pass through without raising."""
_assert_not_real_steam(tmp_path / "appmanifest_440.acf")
def test_raises_when_real_steam_not_redirected(self, tmp_path: Path) -> None:
"""Raises when path is under real Steam and STEAMAPPS_PATH is real."""
real = tmp_path / "real_steam"
real.mkdir()
fake_manifest = real / "appmanifest_440.acf"
fake_manifest.touch()
with (
patch(f"{PKG}._REAL_STEAMAPPS", real),
patch(f"{PKG}.STEAMAPPS_PATH", real),
pytest.raises(RuntimeError, match="SAFETY"),
):
_assert_not_real_steam(fake_manifest)
def test_allows_when_steamapps_redirected(self, tmp_path: Path) -> None:
"""No raise when STEAMAPPS_PATH differs from _REAL_STEAMAPPS."""
real = tmp_path / "real_steam"
real.mkdir()
fake_manifest = real / "appmanifest_440.acf"
fake_manifest.touch()
redirected = tmp_path / "fake_steam"
redirected.mkdir()
with (
patch(f"{PKG}._REAL_STEAMAPPS", real),
patch(f"{PKG}.STEAMAPPS_PATH", redirected),
):
_assert_not_real_steam(fake_manifest)
def test_noop_outside_pytest(self, tmp_path: Path) -> None:
"""In production (no PYTEST_CURRENT_TEST) the guard is a no-op."""
real = tmp_path / "real_steam"
real.mkdir()
fake_manifest = real / "appmanifest_440.acf"
fake_manifest.touch()
env = {k: v for k, v in os.environ.items() if k != "PYTEST_CURRENT_TEST"}
with (
patch.dict(os.environ, env, clear=True),
patch(f"{PKG}._REAL_STEAMAPPS", real),
patch(f"{PKG}.STEAMAPPS_PATH", real),
):
_assert_not_real_steam(fake_manifest)
class TestEcho:
"""Tests for _echo."""
def test_default(self, capsys: pytest.CaptureFixture[str]) -> None:
_echo("hello")
assert capsys.readouterr().out == "hello\n"
def test_custom_end(self, capsys: pytest.CaptureFixture[str]) -> None:
_echo("hi", end="")
assert capsys.readouterr().out == "hi"
def test_empty(self, capsys: pytest.CaptureFixture[str]) -> None:
_echo()
assert capsys.readouterr().out == "\n"
def test_flush(self, capsys: pytest.CaptureFixture[str]) -> None:
_echo("x", flush=True)
assert capsys.readouterr().out == "x\n"
class TestTriggerSteamInstall:
"""Tests for _trigger_steam_install."""
def test_success(self) -> None:
with patch("steam_backlog_enforcer.game_install.subprocess.run") as mock_run:
result = _trigger_steam_install(440, "TF2")
assert result is True
mock_run.assert_called_once()
def test_file_not_found(self) -> None:
with patch(
"steam_backlog_enforcer.game_install.subprocess.run",
side_effect=FileNotFoundError,
):
result = _trigger_steam_install(440, "TF2")
assert result is False
def test_os_error(self) -> None:
with patch(
"steam_backlog_enforcer.game_install.subprocess.run",
side_effect=OSError,
):
result = _trigger_steam_install(440, "TF2")
assert result is False
def test_timeout(self) -> None:
import subprocess
with patch(
"steam_backlog_enforcer.game_install.subprocess.run",
side_effect=subprocess.TimeoutExpired("cmd", 15),
):
result = _trigger_steam_install(440, "TF2")
assert result is False
class TestGetRealUser:
"""Tests for _get_real_user."""
def test_sudo_user(self) -> None:
with patch.dict(os.environ, {"SUDO_USER": "alice", "USER": "root"}):
assert _get_real_user() == "alice"
def test_regular_user(self) -> None:
with patch.dict(os.environ, {"USER": "bob"}, clear=False):
env = os.environ.copy()
env.pop("SUDO_USER", None)
with patch.dict(os.environ, env, clear=True):
assert _get_real_user() == "bob"
class TestGetUidGid:
"""Tests for _get_uid_gid_for_user."""
def test_known_user(self) -> None:
mock_pw = MagicMock()
mock_pw.pw_uid = 1001
mock_pw.pw_gid = 1001
with patch(
"steam_backlog_enforcer.game_install.pwd.getpwnam",
return_value=mock_pw,
):
assert _get_uid_gid_for_user("alice") == (1001, 1001)
def test_unknown_user(self) -> None:
with patch(
"steam_backlog_enforcer.game_install.pwd.getpwnam",
side_effect=KeyError,
):
assert _get_uid_gid_for_user("nobody") == (1000, 1000)
class TestIsGameInstalled:
"""Tests for is_game_installed."""
def test_installed(self, tmp_path: Path) -> None:
manifest = tmp_path / "appmanifest_440.acf"
manifest.touch()
with patch("steam_backlog_enforcer.game_install.STEAMAPPS_PATH", tmp_path):
assert is_game_installed(440) is True
def test_not_installed(self, tmp_path: Path) -> None:
with patch("steam_backlog_enforcer.game_install.STEAMAPPS_PATH", tmp_path):
assert is_game_installed(440) is False
class TestEnsureSteamRunning:
"""Tests for _ensure_steam_running."""
@pytest.fixture(autouse=True)
def _steam_present(self) -> Iterator[None]:
"""Pretend Steam is installed for every test in this class.
Without it the function returns before any launch, which on a test
machine without Steam would make the launch assertions vacuous. The
absent case is covered by test_skips_when_steam_absent.
"""
with patch(f"{PKG}.steam_is_installed", return_value=True):
yield
def test_skips_when_steam_absent(self) -> None:
"""With Steam uninstalled, do not try to launch a missing client.
Regression guard: this path used to exec a dead launcher wrapper and
then sleep 15s, leaving a zombie named "steam" behind each time.
"""
with (
patch(f"{PKG}.steam_is_installed", return_value=False),
patch(f"{PKG}.subprocess.Popen") as mock_popen,
patch(f"{PKG}.time.sleep") as mock_sleep,
):
_ensure_steam_running()
mock_popen.assert_not_called()
mock_sleep.assert_not_called()
def test_already_running(self) -> None:
mock_result = MagicMock(returncode=0)
with patch(
"steam_backlog_enforcer.game_install.subprocess.run",
return_value=mock_result,
):
_ensure_steam_running()
def test_not_running_starts_as_non_root(self) -> None:
mock_result = MagicMock(returncode=1)
with (
patch(
"steam_backlog_enforcer.game_install.subprocess.run",
return_value=mock_result,
),
patch("steam_backlog_enforcer.game_install.subprocess.Popen") as mock_popen,
patch(
"steam_backlog_enforcer.game_install.os.geteuid",
return_value=1000,
),
patch("steam_backlog_enforcer.game_install.time.sleep"),
):
_ensure_steam_running()
mock_popen.assert_called_once()
def test_not_running_starts_as_root(self) -> None:
mock_result = MagicMock(returncode=1)
mock_pw = MagicMock()
mock_pw.pw_uid = 1000
mock_pw.pw_gid = 1000
with (
patch(
"steam_backlog_enforcer.game_install.subprocess.run",
return_value=mock_result,
),
patch("steam_backlog_enforcer.game_install.subprocess.Popen") as mock_popen,
patch(
"steam_backlog_enforcer.game_install.os.geteuid",
return_value=0,
),
patch(
"steam_backlog_enforcer.game_install._get_real_user",
return_value="alice",
),
patch(
"steam_backlog_enforcer.game_install._get_uid_gid_for_user",
return_value=(1000, 1000),
),
patch(
"steam_backlog_enforcer.game_install.desktop_session_ready",
return_value=True,
),
patch("steam_backlog_enforcer.game_install.time.sleep"),
):
_ensure_steam_running()
mock_popen.assert_called_once()
# Assert the env vector, not just that a launch happened: dropping
# XDG_RUNTIME_DIR here is silent, and cost a Proton game its audio
# backend (winepulse -> winealsa) and a crash on startup.
cmd = mock_popen.call_args[0][0]
assert cmd[:4] == ["sudo", "-u", "alice", "env"]
assert "XDG_RUNTIME_DIR=/run/user/1000" in cmd
def test_defers_when_runtime_dir_missing(self) -> None:
"""Do not start Steam before the desktop session's runtime dir exists.
Launching in that window yields a Steam whose Wine children cannot
find PulseAudio, and it stays that way for the whole session. The
enforce loop retries every 3s, so deferring is nearly free.
"""
mock_result = MagicMock(returncode=1)
with (
patch(
"steam_backlog_enforcer.game_install.subprocess.run",
return_value=mock_result,
),
patch("steam_backlog_enforcer.game_install.subprocess.Popen") as mock_popen,
patch(
"steam_backlog_enforcer.game_install.os.geteuid",
return_value=0,
),
patch(
"steam_backlog_enforcer.game_install._get_real_user",
return_value="alice",
),
patch(
"steam_backlog_enforcer.game_install._get_uid_gid_for_user",
return_value=(1000, 1000),
),
patch(
"steam_backlog_enforcer.game_install.desktop_session_ready",
return_value=False,
),
patch("steam_backlog_enforcer.game_install.time.sleep") as mock_sleep,
):
_ensure_steam_running()
mock_popen.assert_not_called()
mock_sleep.assert_not_called()
def test_pgrep_not_found(self) -> None:
with (
patch(
"steam_backlog_enforcer.game_install.subprocess.run",
side_effect=FileNotFoundError,
),
patch("steam_backlog_enforcer.game_install.subprocess.Popen"),
patch(
"steam_backlog_enforcer.game_install.os.geteuid",
return_value=1000,
),
patch("steam_backlog_enforcer.game_install.time.sleep"),
):
_ensure_steam_running()
def test_steam_executable_not_found(self) -> None:
mock_result = MagicMock(returncode=1)
with (
patch(
"steam_backlog_enforcer.game_install.subprocess.run",
return_value=mock_result,
),
patch(
"steam_backlog_enforcer.game_install.subprocess.Popen",
side_effect=FileNotFoundError,
),
patch(
"steam_backlog_enforcer.game_install.os.geteuid",
return_value=1000,
),
):
_ensure_steam_running()