mirror of
https://github.com/kuhyx/steam-backlog-enforcer.git
synced 2026-11-22 03:42:20 +01:00
A running game process was treated as proof of play. On 2026-08-28 the budget
billed ~2h23m while a gatelock screen locker covered the display and the
machine could not be touched at all -- the game was simply still resident.
A tick now bills only when all three hold, evaluated together rather than
short-circuited so the audit log can answer "was the screen ALSO locked?":
* no gatelock guard owns the screen (_screen_hold, via /proc/locks)
* the focused window belongs to a qualifying process or its ancestry
* some input source has been used within idle_grace_seconds (default 300)
Any probe that cannot answer BILLS the tick and is recorded in `degraded`.
A broken detector must never become an unlimited-gaming exploit.
Three findings from measuring this machine rather than assuming:
* /dev/input/js0 here is an *ASRock LED Controller* -- the kernel exposes
the motherboard RGB device as a joystick. A presence check would have
disabled the idle criterion permanently, so _controller_input watches for
real events instead (skipping joydev's synthetic open burst).
* Aseprite's window carries no _NET_WM_PID at all, so focus attribution
falls back to XRes, which asks the server who owns the window rather than
trusting the client to have announced itself.
* /proc/locks reports gatelock's hold without taking it; gatelock's own
read_claim_if_held detects held-ness by acquiring, which would race a
guard every 3 seconds.
Idle pauses also refund the grace period once per walk-away, on the
engaged->paused edge only, never across a day rollover, and never on the first
tick after a restart -- the only place the counter moves backwards.
Everything is recorded to /var/log/steam-backlog-enforcer/budget.jsonl, on
change plus a heartbeat rather than one line per 3s tick. Records name the
qualifying PIDs: reconstructing this incident from journald alone was only
possible by inferring accrual from the spacing of two warning notifications.
Also: refuse to bounce Steam while a game is running. ensure_steam_debug_port
relaunches Steam when the CDP port is closed, which kills the running game --
that is how restarting the daemon to deploy this change ended a live session.
It now defers exactly as it already did for in-flight game updates.
Talks to X through ctypes over one cached connection: at a 3s tick, forking
xprintidle and xprop would cost ~40 forks a minute.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019CEsG6BzHtYR9cHcdxPZqG
250 lines
9.4 KiB
Python
250 lines
9.4 KiB
Python
"""Tests for the playtime tick state machine and cutoff sequence."""
|
|
|
|
from contextlib import ExitStack
|
|
from datetime import (
|
|
datetime,
|
|
timedelta,
|
|
timezone,
|
|
)
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from steam_backlog_enforcer._playtime import (
|
|
_policy,
|
|
_state_or_recover,
|
|
playtime_tick,
|
|
)
|
|
from steam_backlog_enforcer._playtime_state import (
|
|
PlaytimeState,
|
|
load_state,
|
|
rules_for,
|
|
save_state,
|
|
)
|
|
from steam_backlog_enforcer.config import Config
|
|
from steam_backlog_enforcer.tests._fake_session import fake_session
|
|
|
|
PKG = "steam_backlog_enforcer._playtime"
|
|
LOCAL = timezone(timedelta(hours=2))
|
|
NOW = datetime(2026, 7, 27, 20, 0, tzinfo=LOCAL)
|
|
TODAY = "2026-07-27"
|
|
|
|
|
|
@pytest.fixture
|
|
def quiet_tick() -> object:
|
|
"""Neutralise every side effect the tick can produce."""
|
|
with ExitStack() as stack:
|
|
# Each name is patched in the module that *resolves* it, not in the
|
|
# package that re-exports it -- otherwise the patch never bites.
|
|
cutoff = "steam_backlog_enforcer._playtime_cutoff"
|
|
mocks = {
|
|
name: stack.enter_context(patch(f"{where}.{name}"))
|
|
for name, where in (
|
|
("reconcile", PKG),
|
|
("request_steam_shutdown", cutoff),
|
|
("kill_gaming_processes", cutoff),
|
|
("notify_desktop_user", cutoff),
|
|
("mounted_targets", PKG),
|
|
)
|
|
}
|
|
mocks["mounted_targets"].return_value = set()
|
|
stack.enter_context(patch(f"{PKG}.is_total_block_active", return_value=False))
|
|
yield mocks
|
|
|
|
|
|
def _rules(*, demo: bool = False, **cfg: object) -> object:
|
|
return rules_for(Config(**cfg), demo=demo)
|
|
|
|
|
|
class TestStateOrRecover:
|
|
def test_loads_existing_state(self) -> None:
|
|
save_state(PlaytimeState(day_key=TODAY, seconds=42.0), demo=False)
|
|
with patch(f"{PKG}.mounted_targets", return_value=set()):
|
|
out = _state_or_recover(_rules(), now=NOW)
|
|
assert out.seconds == 42.0
|
|
|
|
def test_fresh_state_when_nothing_stored_and_nothing_mounted(self) -> None:
|
|
with patch(f"{PKG}.mounted_targets", return_value=set()):
|
|
out = _state_or_recover(_rules(), now=NOW)
|
|
assert out.seconds == 0.0
|
|
assert out.is_blocked() is False
|
|
assert out.day_key == TODAY
|
|
|
|
def test_fails_closed_when_state_is_gone_but_mounts_remain(self) -> None:
|
|
"""Deleting the state file must not be a way to lift the block."""
|
|
rules = _rules(daily_gaming_seconds=100)
|
|
with patch(f"{PKG}.mounted_targets", return_value={"/usr/bin/steam"}):
|
|
out = _state_or_recover(rules, now=NOW)
|
|
assert out.seconds == 100.0
|
|
assert out.is_blocked() is True
|
|
|
|
def test_fails_closed_on_corrupt_state(self) -> None:
|
|
from steam_backlog_enforcer._playtime_state import state_path
|
|
|
|
state_path(demo=False).write_text("{bad", encoding="utf-8")
|
|
with patch(f"{PKG}.mounted_targets", return_value={"/usr/bin/steam"}):
|
|
out = _state_or_recover(_rules(daily_gaming_seconds=50), now=NOW)
|
|
assert out.is_blocked() is True
|
|
|
|
|
|
class TestPolicyBelowBudget:
|
|
def test_releases_and_warns(self) -> None:
|
|
state = PlaytimeState(day_key=TODAY, seconds=8 * 3600 - 3600)
|
|
with (
|
|
patch("steam_backlog_enforcer._playtime.reconcile") as mock_rec,
|
|
patch(
|
|
"steam_backlog_enforcer._playtime_cutoff.notify_desktop_user"
|
|
) as mock_notify,
|
|
):
|
|
out = _policy(state, _rules(), now=NOW)
|
|
mock_rec.assert_called_once_with(should_block=False)
|
|
mock_notify.assert_called_once()
|
|
assert out.warned_seconds == [3600]
|
|
|
|
def test_no_warning_when_far_from_budget(self) -> None:
|
|
state = PlaytimeState(day_key=TODAY, seconds=0.0)
|
|
with (
|
|
patch("steam_backlog_enforcer._playtime.reconcile"),
|
|
patch(
|
|
"steam_backlog_enforcer._playtime_cutoff.notify_desktop_user"
|
|
) as mock_notify,
|
|
):
|
|
out = _policy(state, _rules(), now=NOW)
|
|
mock_notify.assert_not_called()
|
|
assert out.warned_seconds == []
|
|
|
|
|
|
class TestPolicyAtOrOverBudget:
|
|
def test_engages_the_cutoff_when_not_yet_blocked(self) -> None:
|
|
state = PlaytimeState(day_key=TODAY, seconds=10**6)
|
|
with (
|
|
patch("steam_backlog_enforcer._playtime._begin_cutoff") as mock_begin,
|
|
patch("steam_backlog_enforcer._playtime._sustain_block") as mock_sustain,
|
|
):
|
|
_policy(state, _rules(), now=NOW)
|
|
mock_begin.assert_called_once()
|
|
mock_sustain.assert_not_called()
|
|
|
|
def test_sustains_the_block_once_engaged(self) -> None:
|
|
state = PlaytimeState(day_key=TODAY, seconds=10**6, blocked_at=1.0)
|
|
with (
|
|
patch("steam_backlog_enforcer._playtime._begin_cutoff") as mock_begin,
|
|
patch("steam_backlog_enforcer._playtime._sustain_block") as mock_sustain,
|
|
):
|
|
_policy(state, _rules(), now=NOW)
|
|
mock_begin.assert_not_called()
|
|
mock_sustain.assert_called_once()
|
|
|
|
|
|
class TestPolicyEnforcementDisabled:
|
|
def test_releases_but_does_not_block(self) -> None:
|
|
"""Disabling must never come to mean 'blocked forever'."""
|
|
state = PlaytimeState(day_key=TODAY, seconds=10**6)
|
|
with (
|
|
patch("steam_backlog_enforcer._playtime.reconcile") as mock_rec,
|
|
patch(
|
|
"steam_backlog_enforcer._playtime_cutoff.request_steam_shutdown"
|
|
) as mock_shutdown,
|
|
):
|
|
out = _policy(state, _rules(playtime_enforcement=False), now=NOW)
|
|
mock_rec.assert_called_once_with(should_block=False)
|
|
mock_shutdown.assert_not_called()
|
|
assert out.is_blocked() is False
|
|
|
|
|
|
class TestPlaytimeTick:
|
|
def test_accumulates_while_a_game_runs(self, quiet_tick: dict) -> None:
|
|
save_state(
|
|
PlaytimeState(day_key=TODAY, last_tick_at=NOW.timestamp() - 3.0),
|
|
demo=False,
|
|
)
|
|
with (
|
|
patch(f"{PKG}.qualifying_pids", return_value={7}),
|
|
patch(f"{PKG}.datetime") as mock_dt,
|
|
):
|
|
mock_dt.now.return_value = NOW
|
|
playtime_tick(Config(), interval=3.0, session=fake_session())
|
|
assert load_state(demo=False).seconds == 3.0
|
|
|
|
def test_total_block_releases_and_stops_accruing(self, quiet_tick: dict) -> None:
|
|
"""Our mounts would make the total block's `pacman -R steam` fail."""
|
|
save_state(
|
|
PlaytimeState(
|
|
day_key=TODAY, seconds=5.0, last_tick_at=NOW.timestamp() - 3.0
|
|
),
|
|
demo=False,
|
|
)
|
|
with (
|
|
patch(f"{PKG}.is_total_block_active", return_value=True),
|
|
patch(f"{PKG}.qualifying_pids", return_value={7}),
|
|
patch(f"{PKG}.datetime") as mock_dt,
|
|
):
|
|
mock_dt.now.return_value = NOW
|
|
playtime_tick(Config(), interval=3.0, session=fake_session())
|
|
quiet_tick["reconcile"].assert_called_once_with(should_block=False)
|
|
assert load_state(demo=False).seconds == 5.0
|
|
|
|
def test_rollover_clears_a_stale_block(self, quiet_tick: dict) -> None:
|
|
save_state(
|
|
PlaytimeState(
|
|
day_key="2026-07-26",
|
|
seconds=10**6,
|
|
blocked_at=1.0,
|
|
last_tick_at=NOW.timestamp() - 3.0,
|
|
),
|
|
demo=False,
|
|
)
|
|
with (
|
|
patch(f"{PKG}.qualifying_pids", return_value=set()),
|
|
patch(f"{PKG}.datetime") as mock_dt,
|
|
):
|
|
mock_dt.now.return_value = NOW
|
|
playtime_tick(Config(), interval=3.0, session=fake_session())
|
|
stored = load_state(demo=False)
|
|
assert stored.day_key == TODAY
|
|
assert stored.seconds == 0.0
|
|
assert stored.is_blocked() is False
|
|
quiet_tick["reconcile"].assert_called_with(should_block=False)
|
|
|
|
def test_cutoff_engages_at_the_budget(self, quiet_tick: dict) -> None:
|
|
save_state(
|
|
PlaytimeState(
|
|
day_key=TODAY, seconds=59.0, last_tick_at=NOW.timestamp() - 3.0
|
|
),
|
|
demo=True,
|
|
)
|
|
with (
|
|
patch(f"{PKG}.qualifying_pids", return_value={7}),
|
|
patch(
|
|
"steam_backlog_enforcer._playtime_cutoff._kill_set", return_value={7}
|
|
),
|
|
patch(f"{PKG}.datetime") as mock_dt,
|
|
):
|
|
mock_dt.now.return_value = NOW
|
|
playtime_tick(Config(), interval=3.0, session=fake_session(), demo=True)
|
|
stored = load_state(demo=True)
|
|
assert stored.is_blocked() is True
|
|
quiet_tick["request_steam_shutdown"].assert_called_once()
|
|
|
|
def test_demo_uses_a_separate_state_file(self, quiet_tick: dict) -> None:
|
|
"""A demo run must never consume the real day's budget."""
|
|
with (
|
|
patch(f"{PKG}.qualifying_pids", return_value={7}),
|
|
patch(f"{PKG}.datetime") as mock_dt,
|
|
):
|
|
mock_dt.now.return_value = NOW
|
|
playtime_tick(Config(), interval=3.0, session=fake_session(), demo=True)
|
|
assert load_state(demo=True) is not None
|
|
assert load_state(demo=False) is None
|
|
|
|
def test_first_tick_writes_state(self, quiet_tick: dict) -> None:
|
|
with (
|
|
patch(f"{PKG}.qualifying_pids", return_value=set()),
|
|
patch(f"{PKG}.datetime") as mock_dt,
|
|
):
|
|
mock_dt.now.return_value = NOW
|
|
playtime_tick(Config(), interval=3.0, session=fake_session())
|
|
stored = load_state(demo=False)
|
|
assert stored is not None
|
|
assert stored.day_key == TODAY
|