mirror of
https://github.com/kuhyx/steam-backlog-enforcer.git
synced 2026-11-11 18:53:48 +01:00
Krzysztof kuhy Rudnicki
05e070ca27
The enforcer allowed exactly one game: `current_app_id` was the single
"allowed" id threaded through the uninstall guard, the process killer, the
library hider and the auto-installer. Picking a second game manually meant
the first was uninstalled and hidden.
Manual picks are now a set, capped by `Config.max_manual_picks` (default 2).
Every active pick stays installed, visible and un-killed; the lock releases
only when all of them are finished or past their own 14-day deadline.
- `State.manual_picks` holds `{app_id, game_name, started_at}` entries. The
legacy single-slot `manual_pick_*` fields are still read on load, migrated
into the list and cleared, so a live lock survives the upgrade.
- `_actions.allowed_app_ids` / `allowed_games` are the single source of truth
for "may exist". `uninstall_other_games`, `hide_other_games` (incl. its
injected JS), `enforce_allowed_game` and `_guard_installed_games` now take
that set instead of one app id; every call site passes it.
- `pick-manual` joins `_MANUAL_LOCK_EXEMPT_COMMANDS` so a second game can be
added while the first holds the lock — the cap is what limits it, not the
lock check. Its post-pick cascade operates on the whole allowed set, so
adding a pick never tears down an earlier one.
- `abandon-pick <app_id>` drops only that pick; a survivor inherits the
assignment and keeps the lock. Grace and deadline are per pick.
- `cmd_done` is unchanged: it finishes `current_app_id` and auto-picks a
replacement, so two games stay queued. A finished pick leaves the active
set automatically via `finished_app_ids`.
Deployment note, learned the hard way during development: the daemon holds
the allowed set in code, so it MUST be restarted after upgrading. A
pre-upgrade daemon knows only `current_app_id` and uninstalled the other pick
as "unauthorized" within seconds of the second pick being made.
Verified live: legacy KCD2 lock migrated on load; a second pick (Vampire
Survivors) was accepted while the first was locked, with both kept by the
uninstall pass; a third was refused at the cap; abandoning one pick left the
other locked and handed it the assignment; the restarted daemon reports
"KEEPING allowed game" for both. 1060 tests pass at 100% coverage.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
196 lines
6.3 KiB
Python
196 lines
6.3 KiB
Python
"""Tests for enforcer module."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING
|
|
from unittest.mock import patch
|
|
|
|
from steam_backlog_enforcer.enforcer import (
|
|
enforce_allowed_game,
|
|
get_running_steam_game_pids,
|
|
kill_process,
|
|
send_notification,
|
|
)
|
|
|
|
if TYPE_CHECKING:
|
|
from pathlib import Path
|
|
|
|
|
|
class TestGetRunningPids:
|
|
"""Tests for get_running_steam_game_pids."""
|
|
|
|
def test_finds_steam_pid(self, tmp_path: Path) -> None:
|
|
proc_dir = tmp_path / "proc"
|
|
pid_dir = proc_dir / "12345"
|
|
pid_dir.mkdir(parents=True)
|
|
environ = b"HOME=/home/user\x00SteamAppId=440\x00PATH=/usr/bin"
|
|
(pid_dir / "environ").write_bytes(environ)
|
|
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.Path",
|
|
return_value=proc_dir,
|
|
):
|
|
result = get_running_steam_game_pids()
|
|
assert result == {12345: 440}
|
|
|
|
def test_skips_non_digit_entries(self, tmp_path: Path) -> None:
|
|
proc_dir = tmp_path / "proc"
|
|
proc_dir.mkdir(parents=True)
|
|
(proc_dir / "self").mkdir()
|
|
(proc_dir / "cpuinfo").touch()
|
|
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.Path",
|
|
return_value=proc_dir,
|
|
):
|
|
result = get_running_steam_game_pids()
|
|
assert result == {}
|
|
|
|
def test_handles_permission_error(self, tmp_path: Path) -> None:
|
|
proc_dir = tmp_path / "proc"
|
|
pid_dir = proc_dir / "99"
|
|
pid_dir.mkdir(parents=True)
|
|
# No environ file -> OSError when reading
|
|
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.Path",
|
|
return_value=proc_dir,
|
|
):
|
|
result = get_running_steam_game_pids()
|
|
assert result == {}
|
|
|
|
def test_skips_non_digit_steam_app_id(self, tmp_path: Path) -> None:
|
|
proc_dir = tmp_path / "proc"
|
|
pid_dir = proc_dir / "100"
|
|
pid_dir.mkdir(parents=True)
|
|
environ = b"SteamAppId=notanumber\x00"
|
|
(pid_dir / "environ").write_bytes(environ)
|
|
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.Path",
|
|
return_value=proc_dir,
|
|
):
|
|
result = get_running_steam_game_pids()
|
|
assert result == {}
|
|
|
|
def test_no_steam_env(self, tmp_path: Path) -> None:
|
|
proc_dir = tmp_path / "proc"
|
|
pid_dir = proc_dir / "200"
|
|
pid_dir.mkdir(parents=True)
|
|
environ = b"HOME=/home/user\x00PATH=/usr/bin\x00"
|
|
(pid_dir / "environ").write_bytes(environ)
|
|
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.Path",
|
|
return_value=proc_dir,
|
|
):
|
|
result = get_running_steam_game_pids()
|
|
assert result == {}
|
|
|
|
|
|
class TestEnforceAllowedGame:
|
|
"""Tests for enforce_allowed_game."""
|
|
|
|
def test_no_violations(self) -> None:
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.get_running_steam_game_pids",
|
|
return_value={100: 440},
|
|
):
|
|
result = enforce_allowed_game({440})
|
|
assert result == []
|
|
|
|
def test_kills_unauthorized(self) -> None:
|
|
with (
|
|
patch(
|
|
"steam_backlog_enforcer.enforcer.get_running_steam_game_pids",
|
|
return_value={100: 570, 200: 440},
|
|
),
|
|
patch("steam_backlog_enforcer.enforcer.kill_process") as mock_kill,
|
|
):
|
|
result = enforce_allowed_game({440}, kill_unauthorized=True)
|
|
assert result == [(100, 570)]
|
|
mock_kill.assert_called_once_with(100, 570)
|
|
|
|
def test_skips_app_id_zero(self) -> None:
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.get_running_steam_game_pids",
|
|
return_value={100: 0},
|
|
):
|
|
result = enforce_allowed_game({440})
|
|
assert result == []
|
|
|
|
def test_detects_without_killing(self) -> None:
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.get_running_steam_game_pids",
|
|
return_value={100: 570},
|
|
):
|
|
result = enforce_allowed_game({440}, kill_unauthorized=False)
|
|
assert result == [(100, 570)]
|
|
|
|
def test_allowed_none(self) -> None:
|
|
result = enforce_allowed_game(set(), kill_unauthorized=True)
|
|
assert result == []
|
|
|
|
def test_skips_protected_app_id(self) -> None:
|
|
"""Protected IDs must never be killed even if not the assigned game."""
|
|
with (
|
|
patch(
|
|
"steam_backlog_enforcer.enforcer.get_running_steam_game_pids",
|
|
return_value={100: 1331550, 200: 440},
|
|
),
|
|
patch(
|
|
"steam_backlog_enforcer.enforcer.is_protected_app",
|
|
side_effect=lambda aid: aid == 1331550,
|
|
),
|
|
patch("steam_backlog_enforcer.enforcer.kill_process") as mock_kill,
|
|
):
|
|
result = enforce_allowed_game({440}, kill_unauthorized=True)
|
|
assert result == []
|
|
mock_kill.assert_not_called()
|
|
|
|
|
|
class TestKillProcess:
|
|
"""Tests for kill_process."""
|
|
|
|
def test_kill_success(self) -> None:
|
|
with patch("steam_backlog_enforcer.enforcer.os.kill") as mock_kill:
|
|
kill_process(123, 440)
|
|
mock_kill.assert_called_once()
|
|
|
|
def test_process_already_gone(self) -> None:
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.os.kill",
|
|
side_effect=ProcessLookupError,
|
|
):
|
|
kill_process(123, 440) # Should not raise
|
|
|
|
def test_permission_error(self) -> None:
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.os.kill",
|
|
side_effect=PermissionError,
|
|
):
|
|
kill_process(123, 440) # Should not raise
|
|
|
|
|
|
class TestSendNotification:
|
|
"""Tests for send_notification."""
|
|
|
|
def test_sends(self) -> None:
|
|
with patch("steam_backlog_enforcer.enforcer.subprocess.run") as mock_run:
|
|
send_notification("Title", "Body")
|
|
mock_run.assert_called_once()
|
|
|
|
def test_handles_missing_notify_send(self) -> None:
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.subprocess.run",
|
|
side_effect=FileNotFoundError,
|
|
):
|
|
send_notification("Title", "Body") # Should not raise
|
|
|
|
def test_handles_os_error(self) -> None:
|
|
with patch(
|
|
"steam_backlog_enforcer.enforcer.subprocess.run",
|
|
side_effect=OSError,
|
|
):
|
|
send_notification("Title", "Body") # Should not raise
|