mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-11 19:11:08 +00:00
The412Banner
a2e596a200
Each game's Windows components now come from the list its own source trusts, and the ones that list names turn on by themselves. The user's own on/off switches always win; each automatic row says why it is on. - Steam games: the Steamworks Shared redistributables Steam installs with the game (appmanifest SharedDepots, else the client's appinfo.vdf). Steam keeps its install scripts marked as already run. - GOG: the build manifest's dependencies. Epic: the manifest's prerequisite (Unreal's maps to VC++ and DirectX). Amazon: fuel.json PostInstall. Older GOG/Epic installs get their list fetched once with the saved sign-in; game files are never downloaded again. - Custom games (the + button, Add all, migrated folders): one shared Steam match per game, also used for artwork. An appid from the game's files turns components on; a name-only match stays Recommended; no match falls back to the folder scan. - Steam app info for apps the client never saw comes from an anonymous Steam PICS lookup (CM websocket, anonymous logon, product info), cached per appid; the user's Steam sign-in is never used. - Missing components download in the background on one low-priority worker that pauses during sessions and waits on battery saver, heat or a metered network unless the user asked. A game Steam installs during a session is readied right away so it can be played without ending the session; the launch waits up to 10 s only for a component still on its way. - Page: "On for this game" with reasons, a quiet "Checking what this game needs..." only for games never worked out, rows that ease in, pieces that need a download greyed out while offline. The intro names no other app. - The folder scan skips Unity's *_Data/Managed (Mono, not .NET Framework).
224 lines
10 KiB
Python
224 lines
10 KiB
Python
import json
|
|
import os
|
|
import runpy
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest import mock
|
|
|
|
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
|
|
MODULE = runpy.run_path(str(BIN / "droiddeck-wincomponents"))
|
|
GAME_ENV = runpy.run_path(str(BIN / "droiddeck-game-env"))
|
|
|
|
|
|
class WinComponentsTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
root = Path(self.tmp.name)
|
|
self.store = root / "store"
|
|
self.compat = root / "compatdata/2571976725"
|
|
self.selection = root / "wincomponents.json"
|
|
self.pfx = self.compat / "pfx/drive_c/windows"
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def component(self, cid, overrides, files):
|
|
folder = self.store / cid
|
|
for rel, data in files.items():
|
|
path = folder / rel
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_bytes(data)
|
|
(folder / "component.json").write_text(json.dumps({"id": cid, "overrides": overrides}))
|
|
|
|
def pick(self, *ids):
|
|
self.selection.write_text(json.dumps({"version": 1, "games": {"2571976725": list(ids)}}))
|
|
|
|
def apply(self):
|
|
return MODULE["apply"](self.compat, "2571976725", self.selection, self.store)
|
|
|
|
def test_places_files_before_the_prefix_exists_and_returns_overrides(self):
|
|
self.component("openal", ["openal32"], {"syswow64/OpenAL32.dll": b"x86", "system32/OpenAL32.dll": b"x64"})
|
|
self.pick("openal")
|
|
names, notes = self.apply()
|
|
self.assertEqual(names, ["openal32"])
|
|
self.assertEqual((self.pfx / "syswow64/openal32.dll").read_bytes(), b"x86")
|
|
self.assertEqual((self.pfx / "system32/openal32.dll").read_bytes(), b"x64")
|
|
self.assertIn("2 file(s) placed", notes[-1])
|
|
self.assertEqual(MODULE["overrides_value"](names + names), "openal32=n,b")
|
|
|
|
def test_second_launch_copies_nothing(self):
|
|
self.component("openal", ["openal32"], {"syswow64/OpenAL32.dll": b"x86"})
|
|
self.pick("openal")
|
|
self.apply()
|
|
_, notes = self.apply()
|
|
self.assertEqual(notes, [])
|
|
|
|
def test_replaces_a_proton_builtin_symlink_and_keeps_the_prefix_spelling(self):
|
|
self.component("xaudio", ["xaudio2_7"], {"syswow64/xaudio2_7.dll": b"native"})
|
|
builtin = Path(self.tmp.name) / "proton/lib/wine/i386-windows/xaudio2_7.dll"
|
|
builtin.parent.mkdir(parents=True)
|
|
builtin.write_bytes(b"builtin")
|
|
(self.pfx / "syswow64").mkdir(parents=True)
|
|
(self.pfx / "syswow64/XAudio2_7.dll").symlink_to(builtin)
|
|
self.pick("xaudio")
|
|
self.apply()
|
|
placed = self.pfx / "syswow64/XAudio2_7.dll"
|
|
self.assertFalse(placed.is_symlink())
|
|
self.assertEqual(placed.read_bytes(), b"native")
|
|
self.assertEqual(builtin.read_bytes(), b"builtin")
|
|
self.assertEqual(os.listdir(self.pfx / "syswow64"), ["XAudio2_7.dll"])
|
|
|
|
def test_restores_a_file_an_older_proton_deleted(self):
|
|
self.component("openal", ["openal32"], {"syswow64/OpenAL32.dll": b"x86"})
|
|
self.pick("openal")
|
|
self.apply()
|
|
(self.pfx / "syswow64/openal32.dll").unlink()
|
|
_, notes = self.apply()
|
|
self.assertTrue((self.pfx / "syswow64/openal32.dll").is_file())
|
|
self.assertIn("1 file(s) placed", notes[-1])
|
|
|
|
def test_turning_a_component_off_removes_its_files_and_forgets_protons_config(self):
|
|
self.component("openal", ["openal32"], {"syswow64/OpenAL32.dll": b"x86"})
|
|
self.pick("openal")
|
|
self.apply()
|
|
(self.compat / "config_info").write_text("cached")
|
|
self.pick()
|
|
names, notes = self.apply()
|
|
self.assertEqual(names, [])
|
|
self.assertFalse((self.pfx / "syswow64/openal32.dll").exists())
|
|
self.assertFalse((self.compat / "config_info").exists())
|
|
self.assertIn("1 removed", notes[-1])
|
|
|
|
def test_a_file_of_someone_elses_is_kept_and_put_back_when_turned_off(self):
|
|
self.component("vc", ["msvcp100"], {"syswow64/msvcp100.dll": b"ours"})
|
|
installer = self.pfx / "syswow64/MSVCP100.dll"
|
|
installer.parent.mkdir(parents=True)
|
|
installer.write_bytes(b"from a real installer")
|
|
self.pick("vc")
|
|
self.apply()
|
|
self.assertEqual(installer.read_bytes(), b"ours")
|
|
self.apply() # a second launch keeps the first backup, not ours
|
|
self.pick()
|
|
names, notes = self.apply()
|
|
self.assertEqual(installer.read_bytes(), b"from a real installer")
|
|
self.assertIn("1 put back as they were", notes[-1])
|
|
self.assertFalse((self.compat / ".droiddeck-wincomponents-backup/drive_c/windows/syswow64/msvcp100.dll").exists())
|
|
|
|
def test_protons_own_dlls_and_our_earlier_copy_get_no_backup(self):
|
|
self.component("vc", ["msvcp100"], {"syswow64/msvcp100.dll": b"ours v1", "system32/msvcp100.dll": b"ours 64"})
|
|
builtin = self.pfx / "system32/msvcp100.dll"
|
|
builtin.parent.mkdir(parents=True)
|
|
builtin.write_bytes(b"MZ" + b"\0" * 62 + b"Wine builtin DLL")
|
|
self.pick("vc")
|
|
self.apply()
|
|
(self.store / "vc/syswow64/msvcp100.dll").write_bytes(b"ours v2")
|
|
os.utime(self.store / "vc/syswow64/msvcp100.dll", (1, 1))
|
|
self.apply()
|
|
self.assertFalse((self.compat / ".droiddeck-wincomponents-backup").exists())
|
|
|
|
def test_missing_component_is_skipped(self):
|
|
self.pick("physx")
|
|
names, notes = self.apply()
|
|
self.assertEqual(names, [])
|
|
self.assertEqual(notes, ["physx is not installed; skipped"])
|
|
|
|
def test_no_selection_touches_nothing(self):
|
|
self.assertEqual(self.apply(), ([], []))
|
|
self.assertFalse(self.compat.exists())
|
|
|
|
def test_bad_selection_is_refused(self):
|
|
self.selection.write_text(json.dumps({"version": 1, "games": {"2571976725": ["a/../etc"]}}))
|
|
with self.assertRaises(ValueError):
|
|
self.apply()
|
|
|
|
def test_game_env_puts_component_overrides_before_the_games_own(self):
|
|
self.component("openal", ["openal32"], {"syswow64/OpenAL32.dll": b"x86"})
|
|
self.pick("openal")
|
|
globals_ = GAME_ENV["win_components"].__globals__
|
|
real = runpy.run_path(str(BIN / "droiddeck-wincomponents"))
|
|
real["apply"].__defaults__ = (self.selection, self.store, self.selection.parent / "no-pending.json", None)
|
|
with mock.patch.dict(globals_, {"runpy": mock.Mock(run_path=lambda _path: real)}):
|
|
self.assertEqual(GAME_ENV["win_components"](str(self.compat) + "/", "2571976725"), "openal32=n,b")
|
|
self.assertEqual(GAME_ENV["win_components"]("", "2571976725"), "")
|
|
|
|
def test_bundle_brings_its_parts_and_catalog_names_with_dots_work(self):
|
|
self.component("dmband", ["dmband"], {"syswow64/dmband.dll": b"band"})
|
|
self.component("dsound", ["dsound=n"], {"syswow64/dsound.dll": b"ds"})
|
|
meta = self.store / "directmusic"
|
|
meta.mkdir(parents=True)
|
|
(meta / "component.json").write_text(json.dumps({"id": "directmusic", "overrides": [], "requires": ["dmband", "dsound"]}))
|
|
self.component("xaudio2.7", ["xaudio2_7"], {"system32/xaudio2_7.dll": b"xa"})
|
|
self.pick("directmusic", "xaudio2.7")
|
|
names, _ = self.apply()
|
|
self.assertEqual(MODULE["overrides_value"](names), "dmband=n,b;dsound=n;xaudio2_7=n,b")
|
|
self.assertEqual((self.pfx / "syswow64/dmband.dll").read_bytes(), b"band")
|
|
self.assertEqual(json.loads((self.compat / ".droiddeck-wincomponents.json").read_text())["components"],
|
|
["dmband", "dsound", "directmusic", "xaudio2.7"])
|
|
|
|
def test_files_one_level_down_are_placed(self):
|
|
self.component("gmdls", [], {"system32/drivers/GM.DLS": b"dls"})
|
|
self.pick("gmdls")
|
|
self.apply()
|
|
self.assertEqual((self.pfx / "system32/drivers/gm.dls").read_bytes(), b"dls")
|
|
|
|
def test_overrides_value_last_word_wins_and_refuses_junk(self):
|
|
self.assertEqual(MODULE["overrides_value"](["a", "b=n", "a=b", "bad;name", "c=x"]), "b=n;a=b")
|
|
|
|
|
|
class PendingWaitTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
root = Path(self.tmp.name)
|
|
self.store = root / "store"
|
|
self.pending = root / "pending.json"
|
|
self.slept = []
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def install(self, cid):
|
|
folder = self.store / cid
|
|
folder.mkdir(parents=True, exist_ok=True)
|
|
(folder / "component.json").write_text(json.dumps({"id": cid, "overrides": []}))
|
|
|
|
def clock(self):
|
|
return len(self.slept) * 0.5
|
|
|
|
def wait(self, timeout=10.0, on_sleep=None):
|
|
def sleep(seconds):
|
|
self.slept.append(seconds)
|
|
if on_sleep:
|
|
on_sleep(len(self.slept))
|
|
return MODULE["wait_for_pending"]("1262580", self.pending, self.store, timeout, sleep, self.clock)
|
|
|
|
def test_nothing_pending_means_no_wait(self):
|
|
self.assertIsNone(self.wait())
|
|
self.pending.write_text(json.dumps({"games": {"999": ["d3dx9"]}}))
|
|
self.assertIsNone(self.wait())
|
|
self.install("d3dx9")
|
|
self.pending.write_text(json.dumps({"games": {"1262580": ["d3dx9"]}}))
|
|
self.assertIsNone(self.wait())
|
|
self.assertEqual([], self.slept)
|
|
|
|
def test_waits_until_the_component_lands(self):
|
|
self.pending.write_text(json.dumps({"games": {"1262580": ["vcredist2019_dll"]}}))
|
|
note = self.wait(on_sleep=lambda n: self.install("vcredist2019_dll") if n == 3 else None)
|
|
self.assertEqual(3, len(self.slept))
|
|
self.assertEqual("wincomp: 1262580 waited 1500ms for vcredist2019_dll", note)
|
|
|
|
def test_gives_up_cleanly_after_the_timeout(self):
|
|
self.pending.write_text(json.dumps({"games": {"1262580": ["vcredist2019_dll", "d3dx9"]}}))
|
|
self.install("d3dx9")
|
|
note = self.wait(timeout=2.0)
|
|
self.assertEqual(4, len(self.slept))
|
|
self.assertEqual("wincomp: 1262580 launched without vcredist2019_dll (not ready)", note)
|
|
|
|
def test_a_damaged_pending_file_is_no_wait(self):
|
|
self.pending.write_text("{not json")
|
|
self.assertIsNone(self.wait())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|