mirror of
https://github.com/kuhyx/testsAndMisc.git
synced 2026-07-04 20:03:12 +02:00
Krzysztof kuhy Rudnicki
cec80c0cb0
- Remove skip_app_ids from user-editable Config; callers updated - Split PROTECTED_APP_IDS: only Steam infra/Proton IDs remain; game IDs moved to a new time-locked exception system - Add _whitelist.py: 24-hour cooldown on new exceptions, entropy- checked justification (>= 5 words), append-only audit log, chattr +i immutability on enforcement-critical config files - Add is_protected_app() in game_install.py; used everywhere instead of direct PROTECTED_APP_IDS membership checks - Add 'add-exception' CLI command (cmd_add_exception in main.py) - Call promote_pending_exceptions() and lock_enforcement_files() in each _enforce_loop_iteration - 590 tests, 100% branch coverage on all steam_backlog_enforcer modules - Add .worktrees to .gitignore
796 lines
30 KiB
Python
796 lines
30 KiB
Python
"""Tests for scanning module."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from python_pkg.steam_backlog_enforcer.config import Config, State
|
|
from python_pkg.steam_backlog_enforcer.protondb import ProtonDBRating
|
|
from python_pkg.steam_backlog_enforcer.scanning import (
|
|
_filter_hltb_confident_candidates,
|
|
_force_refresh_candidate_confidence,
|
|
_pick_next_shortest_candidate,
|
|
_pick_playable_candidate,
|
|
_refresh_candidate_confidence_batch,
|
|
do_check,
|
|
do_scan,
|
|
pick_next_game,
|
|
)
|
|
from python_pkg.steam_backlog_enforcer.steam_api import GameInfo
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Callable
|
|
|
|
|
|
def _game(
|
|
app_id: int = 1,
|
|
name: str = "G",
|
|
total: int = 10,
|
|
unlocked: int = 0,
|
|
hours: float = -1,
|
|
) -> GameInfo:
|
|
return GameInfo(
|
|
app_id=app_id,
|
|
name=name,
|
|
total_achievements=total,
|
|
unlocked_achievements=unlocked,
|
|
playtime_minutes=60,
|
|
completionist_hours=hours,
|
|
comp_100_count=3,
|
|
count_comp=15,
|
|
)
|
|
|
|
|
|
class TestDoScan:
|
|
"""Tests for do_scan."""
|
|
|
|
def test_scans_and_picks(self) -> None:
|
|
game = _game(app_id=440, name="TF2", total=10, unlocked=5)
|
|
mock_client = MagicMock()
|
|
|
|
def build_game_list(
|
|
progress_callback: Callable[..., object] | None = None,
|
|
) -> list[GameInfo]:
|
|
# Trigger progress callback to cover those lines.
|
|
if progress_callback:
|
|
progress_callback(50, 100)
|
|
progress_callback(100, 100)
|
|
return [game]
|
|
|
|
mock_client.build_game_list.side_effect = build_game_list
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.SteamAPIClient",
|
|
return_value=mock_client,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.fetch_hltb_times_cached",
|
|
side_effect=lambda _games, progress_cb=None: (
|
|
progress_cb(1, 1, 1, "TF2") if progress_cb else None,
|
|
{440: 20.0},
|
|
)[1],
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.save_snapshot",
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.pick_next_game",
|
|
) as mock_pick,
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._echo",
|
|
),
|
|
):
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
result = do_scan(config, state)
|
|
assert len(result) == 1
|
|
mock_pick.assert_called_once()
|
|
|
|
def test_scan_all_complete(self) -> None:
|
|
game = _game(app_id=440, name="TF2", total=10, unlocked=10)
|
|
mock_client = MagicMock()
|
|
|
|
def build_game_list(
|
|
progress_callback: Callable[..., object] | None = None,
|
|
) -> list[GameInfo]:
|
|
if progress_callback:
|
|
# current=1, total=2 → not %50 and not ==total → covers False branch
|
|
progress_callback(1, 2)
|
|
return [game]
|
|
|
|
mock_client.build_game_list.side_effect = build_game_list
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.SteamAPIClient",
|
|
return_value=mock_client,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.save_snapshot",
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.pick_next_game",
|
|
) as mock_pick,
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
):
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
result = do_scan(config, state)
|
|
assert len(result) == 1
|
|
mock_pick.assert_called_once()
|
|
|
|
def test_scan_already_assigned(self) -> None:
|
|
game = _game(app_id=440, total=10, unlocked=5)
|
|
mock_client = MagicMock()
|
|
mock_client.build_game_list.return_value = [game]
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.SteamAPIClient",
|
|
return_value=mock_client,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.fetch_hltb_times_cached",
|
|
return_value={440: 20.0},
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.save_snapshot",
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.pick_next_game",
|
|
) as mock_pick,
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
):
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State(current_app_id=440)
|
|
result = do_scan(config, state)
|
|
assert len(result) == 1
|
|
mock_pick.assert_not_called()
|
|
|
|
|
|
class TestPickPlayableCandidate:
|
|
"""Tests for _pick_playable_candidate."""
|
|
|
|
def test_finds_playable(self) -> None:
|
|
game = _game(app_id=440, name="TF2")
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.fetch_protondb_ratings",
|
|
return_value={
|
|
440: ProtonDBRating(app_id=440, tier="gold"),
|
|
},
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
):
|
|
result = _pick_playable_candidate([game])
|
|
assert result is not None
|
|
assert result.app_id == 440
|
|
|
|
def test_skips_bad_rating(self) -> None:
|
|
bad = _game(app_id=1, name="Bad")
|
|
good = _game(app_id=2, name="Good")
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.fetch_protondb_ratings",
|
|
return_value={
|
|
1: ProtonDBRating(app_id=1, tier="borked"),
|
|
2: ProtonDBRating(app_id=2, tier="platinum"),
|
|
},
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
):
|
|
result = _pick_playable_candidate([bad, good])
|
|
assert result is not None
|
|
assert result.app_id == 2
|
|
|
|
def test_all_unplayable(self) -> None:
|
|
game = _game(app_id=1, name="Bad")
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.fetch_protondb_ratings",
|
|
return_value={
|
|
1: ProtonDBRating(app_id=1, tier="borked"),
|
|
},
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
):
|
|
assert _pick_playable_candidate([game]) is None
|
|
|
|
def test_empty_list(self) -> None:
|
|
assert _pick_playable_candidate([]) is None
|
|
|
|
def test_first_in_batch_playable(self) -> None:
|
|
"""First game in first batch is playable — no skip message."""
|
|
game = _game(app_id=440, name="TF2")
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.fetch_protondb_ratings",
|
|
return_value={
|
|
440: ProtonDBRating(app_id=440, tier="platinum"),
|
|
},
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
):
|
|
result = _pick_playable_candidate([game])
|
|
assert result is not None
|
|
|
|
|
|
class TestPickNextGame:
|
|
"""Tests for pick_next_game."""
|
|
|
|
def test_picks_shortest(self) -> None:
|
|
g1 = _game(app_id=1, name="Long", hours=100.0)
|
|
g2 = _game(app_id=2, name="Short", hours=10.0)
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._force_refresh_candidate_confidence"
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=0,
|
|
),
|
|
):
|
|
pick_next_game([g1, g2], state, config)
|
|
assert state.current_app_id == 2
|
|
|
|
def test_no_candidates(self) -> None:
|
|
g1 = _game(app_id=1, total=5, unlocked=5)
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
with patch("python_pkg.steam_backlog_enforcer.scanning._echo"):
|
|
pick_next_game([g1], state, config)
|
|
assert state.current_app_id is None
|
|
|
|
def test_skips_finished(self) -> None:
|
|
g1 = _game(app_id=1, name="G1", hours=10.0)
|
|
g2 = _game(app_id=2, name="G2", hours=20.0)
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State(finished_app_ids=[1])
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=0,
|
|
),
|
|
):
|
|
pick_next_game([g1, g2], state, config)
|
|
assert state.current_app_id == 2
|
|
|
|
def test_no_playable(self) -> None:
|
|
g1 = _game(app_id=1, name="G1")
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
return_value=None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
):
|
|
pick_next_game([g1], state, config)
|
|
assert state.current_app_id is None
|
|
|
|
def test_uninstalls_others(self) -> None:
|
|
g1 = _game(app_id=1, name="G1", hours=10.0)
|
|
config = Config(steam_api_key="k", steam_id="i", uninstall_other_games=True)
|
|
state = State()
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._force_refresh_candidate_confidence"
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=2,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
):
|
|
pick_next_game([g1], state, config)
|
|
assert state.current_app_id == 1
|
|
|
|
def test_auto_installs(self) -> None:
|
|
g1 = _game(app_id=1, name="G1", hours=10.0)
|
|
config = Config(steam_api_key="k", steam_id="i", uninstall_other_games=False)
|
|
state = State()
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._force_refresh_candidate_confidence"
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=False,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.install_game"
|
|
) as mock_install,
|
|
):
|
|
pick_next_game([g1], state, config)
|
|
mock_install.assert_called_once()
|
|
|
|
def test_unknown_hours(self) -> None:
|
|
g1 = _game(app_id=1, name="G1", hours=-1)
|
|
g2 = _game(app_id=2, name="G2", hours=10.0)
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=0,
|
|
),
|
|
):
|
|
pick_next_game([g1, g2], state, config)
|
|
assert state.current_app_id == 2
|
|
|
|
def test_picks_game_no_hours(self) -> None:
|
|
"""Chosen game has no HLTB hours — covers no-hours output branch."""
|
|
g1 = _game(app_id=1, name="G1", hours=-1)
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=0,
|
|
),
|
|
):
|
|
pick_next_game([g1], state, config)
|
|
assert state.current_app_id == 1
|
|
|
|
def test_skips_low_confidence_and_picks_next(self) -> None:
|
|
low = _game(app_id=1, name="LowConfidence", hours=1.0)
|
|
low.comp_100_count = 1
|
|
low.count_comp = 5
|
|
valid = _game(app_id=2, name="ValidConfidence", hours=2.0)
|
|
valid.comp_100_count = 3
|
|
valid.count_comp = 15
|
|
echoed: list[str] = []
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._force_refresh_candidate_confidence"
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._echo",
|
|
side_effect=lambda *a, **_: echoed.append(a[0]),
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=0,
|
|
),
|
|
):
|
|
pick_next_game([low, valid], state, config)
|
|
assert state.current_app_id == 2
|
|
assert any("Skipping LowConfidence" in line for line in echoed)
|
|
assert any("comp_100 polls 1 < 3" in line for line in echoed)
|
|
|
|
def test_all_candidates_filtered_by_confidence(self) -> None:
|
|
low_a = _game(app_id=1, name="LowA", hours=1.0)
|
|
low_a.comp_100_count = 2
|
|
low_a.count_comp = 15
|
|
low_b = _game(app_id=2, name="LowB", hours=2.0)
|
|
low_b.comp_100_count = 3
|
|
low_b.count_comp = 14
|
|
echoed: list[str] = []
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._echo",
|
|
side_effect=lambda *a, **_: echoed.append(a[0]),
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._force_refresh_candidate_confidence"
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
return_value=None,
|
|
) as mock_pick,
|
|
):
|
|
pick_next_game([low_a, low_b], state, config)
|
|
assert state.current_app_id is None
|
|
mock_pick.assert_not_called()
|
|
assert any("No assignable games found" in line for line in echoed)
|
|
|
|
def test_zero_confidence_is_refreshed_before_skipping(self) -> None:
|
|
"""Missing confidence fields are refreshed once before final skip decision."""
|
|
stale = _game(app_id=1, name="Celeste", hours=1.0)
|
|
stale.comp_100_count = 0
|
|
stale.count_comp = 0
|
|
fallback = _game(app_id=2, name="Fallback", hours=2.0)
|
|
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
echoed: list[str] = []
|
|
|
|
def refresh_side_effect(game: GameInfo) -> None:
|
|
if game.app_id == 1:
|
|
game.comp_100_count = 899
|
|
game.count_comp = 14055
|
|
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._refresh_candidate_confidence",
|
|
side_effect=refresh_side_effect,
|
|
) as mock_refresh,
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._echo",
|
|
side_effect=lambda *a, **_: echoed.append(a[0]),
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=0,
|
|
),
|
|
):
|
|
pick_next_game([stale, fallback], state, config)
|
|
|
|
assert state.current_app_id == 1
|
|
mock_refresh.assert_called_once_with(stale)
|
|
assert not any("Skipping Celeste" in line for line in echoed)
|
|
|
|
def test_nonzero_low_confidence_does_not_force_refetch(self) -> None:
|
|
"""Non-zero low-confidence entries are skipped using cached values."""
|
|
low = _game(app_id=1, name="Low", hours=1.0)
|
|
low.comp_100_count = 1
|
|
low.count_comp = 8
|
|
fallback = _game(app_id=2, name="Fallback", hours=2.0)
|
|
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._refresh_candidate_confidence_batch"
|
|
) as mock_refresh_batch,
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=0,
|
|
),
|
|
):
|
|
pick_next_game([low, fallback], state, config)
|
|
|
|
assert state.current_app_id == 2
|
|
mock_refresh_batch.assert_not_called()
|
|
|
|
def test_cached_confidence_overlay_avoids_refetch_for_zero_snapshot_fields(
|
|
self,
|
|
) -> None:
|
|
"""Use cached confidence before deciding whether refresh is needed."""
|
|
low = _game(app_id=1, name="Low", hours=1.0)
|
|
low.comp_100_count = 0
|
|
low.count_comp = 0
|
|
fallback = _game(app_id=2, name="Fallback", hours=2.0)
|
|
fallback.comp_100_count = 3
|
|
fallback.count_comp = 20
|
|
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.load_hltb_polls_cache",
|
|
return_value={1: 1, 2: 3},
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.load_hltb_count_comp_cache",
|
|
return_value={1: 8, 2: 20},
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._refresh_candidate_confidence_batch"
|
|
) as mock_refresh_batch,
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=0,
|
|
),
|
|
):
|
|
pick_next_game([low, fallback], state, config)
|
|
|
|
assert state.current_app_id == 2
|
|
mock_refresh_batch.assert_not_called()
|
|
|
|
def test_stops_after_first_confident_assignment(self) -> None:
|
|
"""Only candidates up to the winning one are checked/skipped."""
|
|
low = _game(app_id=1, name="Low", hours=1.0)
|
|
low.comp_100_count = 1
|
|
low.count_comp = 2
|
|
good = _game(app_id=2, name="Good", hours=2.0)
|
|
good.comp_100_count = 10
|
|
good.count_comp = 50
|
|
never_checked = _game(app_id=3, name="NeverChecked", hours=3.0)
|
|
never_checked.comp_100_count = 0
|
|
never_checked.count_comp = 0
|
|
|
|
config = Config(steam_api_key="k", steam_id="i")
|
|
state = State()
|
|
echoed: list[str] = []
|
|
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._refresh_candidate_confidence"
|
|
) as mock_refresh,
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=lambda c: c[0] if c else None,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._echo",
|
|
side_effect=lambda *a, **_: echoed.append(a[0]),
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.is_game_installed",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.uninstall_other_games",
|
|
return_value=0,
|
|
),
|
|
):
|
|
pick_next_game([low, good, never_checked], state, config)
|
|
|
|
assert state.current_app_id == 2
|
|
mock_refresh.assert_called_once_with(low)
|
|
assert any("Skipping Low" in line for line in echoed)
|
|
assert not any("Skipping NeverChecked" in line for line in echoed)
|
|
|
|
|
|
class TestDoCheck:
|
|
"""Tests for do_check."""
|
|
|
|
def test_no_assignment(self) -> None:
|
|
with patch("python_pkg.steam_backlog_enforcer.scanning._echo") as mock_echo:
|
|
do_check(Config(), State())
|
|
mock_echo.assert_called()
|
|
|
|
def test_fetch_fails(self) -> None:
|
|
mock_client = MagicMock()
|
|
mock_client.refresh_single_game.return_value = None
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.SteamAPIClient",
|
|
return_value=mock_client,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning.detect_tampering"),
|
|
):
|
|
state = State(current_app_id=440, current_game_name="TF2")
|
|
do_check(Config(steam_api_key="k", steam_id="i"), state)
|
|
|
|
|
|
class TestConfidenceHelpers:
|
|
"""Coverage-focused tests for scanning confidence helper branches."""
|
|
|
|
def test_force_refresh_candidate_confidence_delegates(self) -> None:
|
|
game = _game(app_id=10, name="A")
|
|
with patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._refresh_candidate_confidence_batch",
|
|
) as mock_batch:
|
|
_force_refresh_candidate_confidence(game)
|
|
mock_batch.assert_called_once_with([game], force=True)
|
|
|
|
def test_refresh_candidate_confidence_batch_no_missing_skips_fetch(self) -> None:
|
|
game = _game(app_id=20, name="B", hours=12.0)
|
|
game.comp_100_count = 3
|
|
game.count_comp = 15
|
|
with patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.fetch_hltb_confidence_cached",
|
|
) as mock_fetch:
|
|
_refresh_candidate_confidence_batch([game], force=False)
|
|
mock_fetch.assert_not_called()
|
|
|
|
def test_refresh_candidate_confidence_batch_preserves_existing_hours(self) -> None:
|
|
game = _game(app_id=30, name="C", hours=9.5)
|
|
game.comp_100_count = 0
|
|
game.count_comp = 0
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.load_hltb_cache",
|
|
side_effect=[{30: 9.5}, {30: -1.0}],
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.load_hltb_polls_cache",
|
|
return_value={30: 0},
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.load_hltb_count_comp_cache",
|
|
return_value={30: 0},
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.fetch_hltb_confidence_cached",
|
|
return_value={30: -1.0},
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.save_hltb_cache",
|
|
) as mock_save,
|
|
):
|
|
_refresh_candidate_confidence_batch([game], force=True)
|
|
|
|
assert game.completionist_hours == 9.5
|
|
saved_cache = mock_save.call_args.args[0]
|
|
assert saved_cache[30] == 9.5
|
|
|
|
def test_filter_hltb_confident_candidates_skips_low_confidence(self) -> None:
|
|
low = _game(app_id=40, name="Low", hours=2.0)
|
|
low.comp_100_count = 1
|
|
low.count_comp = 2
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._refresh_candidate_confidence_batch",
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo") as mock_echo,
|
|
):
|
|
result = _filter_hltb_confident_candidates([low])
|
|
assert result == []
|
|
assert mock_echo.called
|
|
|
|
def test_pick_next_shortest_candidate_logs_skipped_unplayable_batches(self) -> None:
|
|
bad = _game(app_id=50, name="Bad", hours=1.0)
|
|
good = _game(app_id=51, name="Good", hours=2.0)
|
|
bad.comp_100_count = 3
|
|
bad.count_comp = 15
|
|
good.comp_100_count = 3
|
|
good.count_comp = 15
|
|
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning._pick_playable_candidate",
|
|
side_effect=[None, good],
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo") as mock_echo,
|
|
):
|
|
picked, skipped_low_conf, skipped_linux = _pick_next_shortest_candidate(
|
|
[bad, good],
|
|
)
|
|
|
|
assert picked is good
|
|
assert skipped_low_conf == 0
|
|
assert skipped_linux == 1
|
|
assert any(
|
|
"Skipped 1 game(s) with poor Linux compatibility" in str(call)
|
|
for call in mock_echo.call_args_list
|
|
)
|
|
|
|
def test_complete(self) -> None:
|
|
game = _game(app_id=440, name="TF2", total=5, unlocked=5)
|
|
mock_client = MagicMock()
|
|
mock_client.refresh_single_game.return_value = game
|
|
snap = [game.to_snapshot()]
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.SteamAPIClient",
|
|
return_value=mock_client,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.send_notification",
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.load_snapshot",
|
|
return_value=snap,
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.pick_next_game",
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning.detect_tampering"),
|
|
):
|
|
state = State(current_app_id=440, current_game_name="TF2")
|
|
do_check(Config(steam_api_key="k", steam_id="i"), state)
|
|
assert 440 in state.finished_app_ids
|
|
|
|
def test_complete_no_snapshot(self) -> None:
|
|
game = _game(app_id=440, name="TF2", total=5, unlocked=5)
|
|
mock_client = MagicMock()
|
|
mock_client.refresh_single_game.return_value = game
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.SteamAPIClient",
|
|
return_value=mock_client,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.send_notification",
|
|
),
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.load_snapshot",
|
|
return_value=None,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning.detect_tampering"),
|
|
):
|
|
state = State(current_app_id=440, current_game_name="TF2")
|
|
do_check(Config(steam_api_key="k", steam_id="i"), state)
|
|
|
|
def test_not_complete(self) -> None:
|
|
game = _game(app_id=440, name="TF2", total=10, unlocked=5)
|
|
mock_client = MagicMock()
|
|
mock_client.refresh_single_game.return_value = game
|
|
with (
|
|
patch(
|
|
"python_pkg.steam_backlog_enforcer.scanning.SteamAPIClient",
|
|
return_value=mock_client,
|
|
),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning._echo"),
|
|
patch("python_pkg.steam_backlog_enforcer.scanning.detect_tampering"),
|
|
):
|
|
state = State(current_app_id=440, current_game_name="TF2")
|
|
do_check(Config(steam_api_key="k", steam_id="i"), state)
|