mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 04:46:08 +00:00
* feat(ubisoft): keep Denuvo game tokens per account and product until the game invalidates them * feat(ubisoft): sync cloud saves through Ubisoft's cloud save service * fix(xbox): turning cloud saves off passes the offline mode the game save runtime reads * fix(ubisoft): Ubisoft games list their shared prefix, so they get a saves and cloud tab * feat(ea): sync cloud saves through EA's cloud sync service * fix(ea): sync at EA launch and exit, keep one rule snapshot, and check the cloud copy under the write lock * fix(ubisoft): exact slot versions, scoped save export, and a Denuvo cache bound to its account * fix(ea): fresh rules per sync, checksums required, backup before restore, and sign-in shown on the saves tab * fix(ubisoft): launch-time sync on the shared prefix, saves scoped to the game, and Denuvo bound to each launch's account * fix(ea): back up only the saves a restore replaces, refuse truncated manifests, and need a master title id * fix(ubisoft): treat a slot whose bytes changed since the last sync as a conflict before uploading over it * fix(ea): one resolved save folder per sync, refuse case collisions, and walk each folder once * fix(ubisoft): sync only identified slots, keep live saves and backups safe, and tie a pending eviction to its account * fix(cloud): a forced download fetches every saved conflict and keeps the ones it could not write * test(ea): keep the cloud save cases in EaTest * fix(ubisoft): report only written slots, keep drift conflicts, read whole headers, and never rename a named eviction * fix(ea): keep real save folders in the inventory, back up any restored file, refuse duplicate or malformed cloud listings * fix(cloud): commit Ubisoft slots one at a time and stop on a newer cloud write, name skipped and blocked slots, keep unsent conflicts * fix(ubisoft): acknowledge an invalidation only once its marker is published and never serve a kept token after it * fix(cloud): a cloud request the launcher cannot write still starts the game and keeps the exit upload * fix(cloud): scope Ubisoft sync state to the account and product, compare alike slots, keep committed progress, and name partial slots * fix(ea): ask for sign-in after a rejected refresh, upload saves reached through folder aliases * fix(cloud): a launch that stops waiting for the cloud download claims it back, so no save is written once the game starts * fix(ubisoft): name the account in an invalidation marker and never hold the token lock across a pipe write * fix(ea): only invalid_grant asks for sign-in again, and case collisions count only among synced saves * test(epic): let the launcher's ask doubles take the claim flag * fix(ea): apply save rules in their order, match bare patterns inside the save folder, and resolve LocalLow and install folders * fix(ubisoft): stamp a fresh identifier into a new save that has none, so it can sync * fix(ubisoft): answer a burn ticket request as unavailable instead of leaving the game waiting * fix(cloud): read EA manifests with the XML parser, clear conflicts whose sides match, and bound the claim and stall tests
1033 lines
60 KiB
Python
1033 lines
60 KiB
Python
import importlib.machinery
|
|
import importlib.util
|
|
import json
|
|
import shlex
|
|
import subprocess
|
|
import os
|
|
from pathlib import Path
|
|
import tempfile
|
|
import threading
|
|
import time
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
|
|
|
|
|
|
def load(name):
|
|
loader = importlib.machinery.SourceFileLoader(name.replace('-', '_'), str(BIN / name))
|
|
spec = importlib.util.spec_from_loader(loader.name, loader)
|
|
module = importlib.util.module_from_spec(spec)
|
|
loader.exec_module(module)
|
|
return module
|
|
|
|
|
|
store = load('droiddeck-store-launch')
|
|
|
|
|
|
def load_path(path, name):
|
|
loader = importlib.machinery.SourceFileLoader(name, str(path))
|
|
spec = importlib.util.spec_from_loader(name, loader)
|
|
module = importlib.util.module_from_spec(spec)
|
|
loader.exec_module(module)
|
|
return module
|
|
compat = load('steam-compatibility')
|
|
|
|
|
|
def game(root, store_id='epic', ident='8b6a0e14'):
|
|
folder = Path(root) / 'Games/Stores/Epic/Metalstorm'
|
|
folder.mkdir(parents=True)
|
|
(folder / '.droiddeck-store.json').write_text(json.dumps({'store': store_id, 'id': ident, 'title': 'Metalstorm', 'exe': 'Metalstorm.exe'}))
|
|
(folder / '.droiddeck-launch.bat').write_text('@echo off\r\n')
|
|
return folder
|
|
|
|
|
|
class Detection(unittest.TestCase):
|
|
def test_the_launcher_among_steams_arguments_names_the_game(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root)
|
|
found = store.find_store_game(['/usr/bin/steam-runtime', '"%s/.droiddeck-launch.bat"' % folder, '-flag'])
|
|
self.assertIsNotNone(found)
|
|
self.assertEqual(folder, found[0])
|
|
self.assertEqual('epic', found[1]['store'])
|
|
self.assertEqual('8b6a0e14', found[1]['id'])
|
|
|
|
def test_anything_else_is_left_alone(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root)
|
|
self.assertEqual(folder, store.find_store_game([str(folder / 'Metalstorm.exe')])[0])
|
|
self.assertIsNone(store.find_store_game([str(Path(root) / 'elsewhere/readme.txt')]))
|
|
(folder / '.droiddeck-store.json').unlink()
|
|
self.assertIsNone(store.find_store_game([str(folder / '.droiddeck-launch.bat')]))
|
|
|
|
def test_only_epic_asks_for_a_code(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog')
|
|
sc = json.loads((folder / '.droiddeck-store.json').read_text()); sc['cloud'] = False
|
|
(folder / '.droiddeck-store.json').write_text(json.dumps(sc))
|
|
os.environ['DD_LAUNCH_DIR'] = str(Path(root) / 'session')
|
|
try:
|
|
with patch.object(store, 'ask', return_value={'ready': False, 'reason': 'off'}) as ask:
|
|
self.assertEqual(0, store.main([str(folder / '.droiddeck-launch.bat')]))
|
|
self.assertEqual('gog-achievements', ask.call_args.args[1]['op'])
|
|
finally:
|
|
del os.environ['DD_LAUNCH_DIR']
|
|
|
|
|
|
|
|
class Asking(unittest.TestCase):
|
|
def test_a_request_is_answered_through_the_resp_folder(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
channel = Path(root) / 'stores'
|
|
|
|
def app():
|
|
req = channel / 'req'
|
|
for _ in range(100):
|
|
names = [p for p in req.glob('*.json')] if req.exists() else []
|
|
if names:
|
|
request = json.loads(names[0].read_text())
|
|
self.assertEqual({'op': 'epic-code', 'store': 'epic', 'id': 'x'}, request)
|
|
names[0].unlink()
|
|
tmp = channel / 'resp' / (names[0].name + '.tmp')
|
|
tmp.write_text(json.dumps({'ok': True, 'code': True, 'reason': 'ok'}))
|
|
os.rename(tmp, channel / 'resp' / names[0].name)
|
|
return
|
|
time.sleep(0.02)
|
|
|
|
t = threading.Thread(target=app)
|
|
t.start()
|
|
answer = store.ask(channel, {'op': 'epic-code', 'store': 'epic', 'id': 'x'}, timeout=3)
|
|
t.join()
|
|
self.assertEqual({'ok': True, 'code': True, 'reason': 'ok'}, answer)
|
|
|
|
def test_no_answer_withdraws_the_request(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
channel = Path(root) / 'stores'
|
|
self.assertIsNone(store.ask(channel, {'op': 'epic-code'}, timeout=0.2))
|
|
self.assertEqual([], list((channel / 'req').iterdir()))
|
|
|
|
def test_a_cloud_download_the_launcher_stops_waiting_for_loses_its_claim(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
channel = Path(root) / 'stores'
|
|
taken = []
|
|
handed = threading.Event()
|
|
|
|
def app():
|
|
deadline = time.monotonic() + 5
|
|
while not taken and time.monotonic() < deadline:
|
|
for request in (channel / 'req').glob('*.json') if (channel / 'req').is_dir() else []:
|
|
target = channel / 'resp' / (request.stem + '.taken')
|
|
os.rename(request, target)
|
|
taken.append(target)
|
|
handed.set()
|
|
time.sleep(0.02)
|
|
|
|
t = threading.Thread(target=app, daemon=True)
|
|
t.start()
|
|
try:
|
|
self.assertIsNone(store.ask(channel, {'op': 'cloud-down'}, timeout=2.0, claim=True))
|
|
finally:
|
|
t.join(5)
|
|
self.assertTrue(handed.is_set(), 'the app never took the request')
|
|
with self.assertRaises(OSError):
|
|
os.rename(taken[0], taken[0].with_suffix('.writing'))
|
|
|
|
def test_a_claimed_cloud_download_is_waited_for(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
channel = Path(root) / 'stores'
|
|
handed = threading.Event()
|
|
|
|
def app():
|
|
deadline = time.monotonic() + 5
|
|
while time.monotonic() < deadline:
|
|
names = list((channel / 'req').glob('*.json')) if (channel / 'req').is_dir() else []
|
|
if names:
|
|
handed.set()
|
|
writing = channel / 'resp' / (names[0].stem + '.writing')
|
|
os.rename(names[0], writing)
|
|
time.sleep(0.6)
|
|
tmp = channel / 'resp' / (names[0].name + '.tmp')
|
|
tmp.write_text(json.dumps({'ok': True, 'result': 'ok'}))
|
|
os.rename(tmp, channel / 'resp' / names[0].name)
|
|
writing.unlink()
|
|
return
|
|
time.sleep(0.02)
|
|
|
|
t = threading.Thread(target=app, daemon=True)
|
|
t.start()
|
|
try:
|
|
answer = store.ask(channel, {'op': 'cloud-down'}, timeout=0.2, claim=True)
|
|
finally:
|
|
t.join(5)
|
|
self.assertTrue(handed.is_set(), 'the app never took the request')
|
|
self.assertEqual({'ok': True, 'result': 'ok'}, answer)
|
|
|
|
def test_a_stale_code_is_dropped_before_asking(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root)
|
|
code = folder / '.droiddeck-epic-code'
|
|
code.write_text('old')
|
|
self.assertFalse(store.drop_stale(folder, now=code.stat().st_mtime + 60))
|
|
self.assertTrue(store.drop_stale(folder, now=code.stat().st_mtime + store.STALE_SECONDS + 1))
|
|
self.assertFalse(code.exists())
|
|
|
|
|
|
class Prefix(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
root = Path(self.tmp.name)
|
|
self.compat = root / 'compatdata/3785150007'
|
|
(self.compat / 'pfx').mkdir(parents=True)
|
|
self.reg = self.compat / 'pfx/user.reg'
|
|
self.reg.write_text('WINE REGISTRY Version 2\n\n[Software\\\\Wine] 1\n"Version"="win10"\n')
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def test_wines_browser_is_the_hand_off_by_its_path(self):
|
|
self.assertEqual('browser-set', store.provision_prefix(str(self.compat)))
|
|
text = self.reg.read_text()
|
|
self.assertIn('[Software\\\\Wine\\\\WineBrowser] ', text)
|
|
self.assertIn('"Browsers"="/usr/local/bin/droiddeck-open-url,xdg-open"', text)
|
|
store.provision_prefix(str(self.compat))
|
|
self.assertEqual(text, self.reg.read_text())
|
|
|
|
def test_an_earlier_builds_overlay_pointer_is_removed(self):
|
|
self.reg.write_text(self.reg.read_text() + '\n[Software\\\\Epic Games\\\\EOS] 2\n"OverlayPath"="Z:\\\\x"\n"Other"="kept"\n')
|
|
self.assertEqual('browser-set old-overlay-removed', store.provision_prefix(str(self.compat)))
|
|
text = self.reg.read_text()
|
|
self.assertNotIn('OverlayPath', text)
|
|
self.assertIn('"Other"="kept"', text)
|
|
|
|
def test_no_prefix_yet(self):
|
|
self.assertEqual('prefix-not-created', store.provision_prefix(self.tmp.name + '/compatdata/1'))
|
|
self.assertEqual('no-prefix', store.provision_prefix(''))
|
|
|
|
|
|
class Choices(unittest.TestCase):
|
|
def test_the_sidecars_epic_choices_are_honoured(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root)
|
|
sidecar = json.loads((folder / '.droiddeck-store.json').read_text())
|
|
self.assertEqual({'eos': True, 'offline': False}, store.options(sidecar))
|
|
self.assertEqual({'eos': True, 'offline': False}, store.options({'epic': {'v': 2, 'overlay': True}}))
|
|
sidecar['epic'] = {'eos': True, 'offline': True}
|
|
sidecar['cloud'] = False
|
|
(folder / '.droiddeck-store.json').write_text(json.dumps(sidecar))
|
|
(folder / '.droiddeck-epic-code').write_text('left over')
|
|
compat = Path(root) / 'compatdata/1'
|
|
(compat / 'pfx').mkdir(parents=True)
|
|
reg = compat / 'pfx/user.reg'
|
|
reg.write_text('WINE REGISTRY Version 2\n\n[Software\\\\Epic Games\\\\EOS] 1\n"OverlayPath"="Z:\\\\x"\n"Other"="kept"\n')
|
|
os.environ['DD_LAUNCH_DIR'] = str(Path(root) / 'session')
|
|
os.environ['STEAM_COMPAT_DATA_PATH'] = str(compat)
|
|
try:
|
|
self.assertEqual(0, store.main([str(folder / '.droiddeck-launch.bat')]))
|
|
finally:
|
|
del os.environ['DD_LAUNCH_DIR']
|
|
del os.environ['STEAM_COMPAT_DATA_PATH']
|
|
self.assertFalse((Path(root) / 'session/stores/req').exists())
|
|
self.assertFalse((folder / '.droiddeck-epic-code').exists())
|
|
text = reg.read_text()
|
|
self.assertNotIn('OverlayPath', text)
|
|
self.assertIn('"Other"="kept"', text)
|
|
|
|
|
|
class Browser(unittest.TestCase):
|
|
def test_a_web_address_is_handed_to_the_app(self):
|
|
xdg = load_path(BIN / 'droiddeck-open-url', 'open_url')
|
|
with tempfile.TemporaryDirectory() as root:
|
|
os.environ['DD_LAUNCH_DIR'] = root
|
|
try:
|
|
self.assertEqual(0, xdg.main(['https://www.epicgames.com/activate']))
|
|
finally:
|
|
del os.environ['DD_LAUNCH_DIR']
|
|
reqs = list((Path(root) / 'stores/req').glob('*.json'))
|
|
self.assertEqual(1, len(reqs))
|
|
self.assertEqual({'op': 'open-url', 'url': 'https://www.epicgames.com/activate'}, json.loads(reqs[0].read_text()))
|
|
self.assertEqual('https://www.epicgames.com', xdg.where('https://www.epicgames.com/activate?code=SECRET'))
|
|
|
|
|
|
class ExeTarget(unittest.TestCase):
|
|
def test_a_game_started_by_its_exe_is_found_from_a_subfolder(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1207664643')
|
|
(folder / 'bin/x64').mkdir(parents=True)
|
|
exe = folder / 'bin/x64/ELDERBORN.exe'
|
|
exe.write_text('MZ')
|
|
found = store.find_store_game(['"%s"' % exe])
|
|
self.assertEqual(folder, found[0])
|
|
self.assertEqual('gog', found[1]['store'])
|
|
self.assertIsNone(store.find_store_game(['/root/Games/Other/x.exe']))
|
|
|
|
|
|
class CloudHooks(unittest.TestCase):
|
|
def test_a_store_game_with_cloud_saves_asks_before_and_after(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1207664643')
|
|
bat = str(folder / '.droiddeck-launch.bat')
|
|
os.environ['DD_LAUNCH_DIR'] = str(Path(root) / 'session')
|
|
try:
|
|
original = store.ask
|
|
asked = []
|
|
store.ask = lambda channel, request, timeout=5.0, claim=False: asked.append((request, timeout)) or {'ok': True, 'files': 2, 'reason': 'ok'}
|
|
self.assertEqual(store.STORE_GAME, store.main([bat]))
|
|
self.assertEqual(0, store.main(['--exited', bat]))
|
|
finally:
|
|
store.ask = original
|
|
del os.environ['DD_LAUNCH_DIR']
|
|
self.assertEqual('gog-achievements', asked[0][0]['op'])
|
|
self.assertEqual({'op': 'cloud-down', 'store': 'gog', 'id': '1207664643'}, asked[1][0])
|
|
self.assertEqual(store.CLOUD_TIMEOUT, asked[1][1])
|
|
self.assertEqual('cloud-up', asked[2][0]['op'])
|
|
|
|
def test_a_cloud_request_that_cannot_be_written_still_starts_the_game_and_uploads_on_exit(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='ubisoft', ident='space-1')
|
|
sc = json.loads((folder / '.droiddeck-store.json').read_text()); sc['extra'] = {'productId': '109'}
|
|
(folder / '.droiddeck-store.json').write_text(json.dumps(sc))
|
|
bat = str(folder / '.droiddeck-launch.bat')
|
|
asked = []
|
|
|
|
def ask(channel, request, timeout=5.0, claim=False):
|
|
asked.append(request['op'])
|
|
if request['op'] in ('cloud-down', 'cloud-up'):
|
|
raise PermissionError(13, 'read-only')
|
|
return {'ok': True}
|
|
|
|
lines = []
|
|
with patch.dict(os.environ, {'DD_LAUNCH_DIR': str(Path(root) / 'session')}), patch.object(store, 'ask', side_effect=ask), patch.object(store, 'prepare_ubisoft', return_value='ready'), patch.object(store, 'create_prefix', return_value='present'), patch.object(store, 'log', side_effect=lines.append):
|
|
self.assertEqual(store.STORE_GAME, store.main([bat]))
|
|
self.assertEqual(0, store.main(['--exited', bat]))
|
|
self.assertEqual(['cloud-down', 'cloud-up'], [op for op in asked if op.startswith('cloud-')])
|
|
self.assertIn('cloud ubisoft space-1 down result=failed reason=PermissionError', lines)
|
|
self.assertIn('cloud ubisoft space-1 up not requested (PermissionError)', lines)
|
|
def test_an_ea_game_with_cloud_saves_asks_after_its_preparation_and_exit(self):
|
|
ident = 'Origin.OFR.50.0002694'
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='ea', ident=ident)
|
|
bat = str(folder / '.droiddeck-launch.bat')
|
|
asked = []
|
|
env = {'DD_LAUNCH_DIR': str(Path(root) / 'session')}
|
|
record = lambda channel, request, timeout=5.0, claim=False: asked.append(request) or {'result': 'ok'}
|
|
with patch.dict(os.environ, env), \
|
|
patch.object(store, 'prepare_ea', side_effect=lambda *a: asked.append({'op': 'prepared'})), \
|
|
patch.object(store, 'create_prefix', side_effect=AssertionError('EA prepares its own prefix')), \
|
|
patch.object(store, 'ask', side_effect=record):
|
|
self.assertEqual(store.STORE_GAME, store.main([bat]))
|
|
self.assertEqual(['prepared', 'cloud-down'], [r['op'] for r in asked])
|
|
self.assertEqual({'op': 'cloud-down', 'store': 'ea', 'id': ident}, asked[1])
|
|
self.assertEqual(0, store.main(['--exited', bat]))
|
|
self.assertEqual(['ea-exited', 'cloud-up'], [r['op'] for r in asked[2:]])
|
|
self.assertEqual({'op': 'cloud-up', 'store': 'ea', 'id': ident}, asked[3])
|
|
sidecar = json.loads((folder / store.SIDECAR).read_text())
|
|
sidecar['cloud'] = False
|
|
(folder / store.SIDECAR).write_text(json.dumps(sidecar))
|
|
asked.clear()
|
|
with patch.dict(os.environ, env), patch.object(store, 'prepare_ea'), patch.object(store, 'ask', side_effect=record):
|
|
self.assertEqual(store.STORE_GAME, store.main([bat]))
|
|
self.assertEqual([], asked)
|
|
self.assertEqual(0, store.main(['--exited', bat]))
|
|
self.assertEqual(['ea-exited'], [r['op'] for r in asked])
|
|
|
|
def test_a_first_launch_creates_the_prefix_before_the_cloud_download(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='epic', ident='fa4240e5')
|
|
sidecar = json.loads((folder / store.SIDECAR).read_text())
|
|
sidecar['epic'] = {'eos': False, 'offline': True}
|
|
(folder / store.SIDECAR).write_text(json.dumps(sidecar))
|
|
proton = Path(root) / 'proton'
|
|
proton.write_text('selected Proton')
|
|
compat = Path(root) / 'compatdata/1'
|
|
order = []
|
|
|
|
def run(argv, **kwargs):
|
|
order.append(argv)
|
|
(compat / 'pfx').mkdir(parents=True)
|
|
(compat / 'pfx/user.reg').write_text('WINE REGISTRY Version 2\n')
|
|
return __import__('subprocess').CompletedProcess(argv, 0)
|
|
|
|
env = {'DD_LAUNCH_DIR': root, 'STEAM_COMPAT_DATA_PATH': str(compat), 'DD_STORE_PROTON': str(proton)}
|
|
with patch.dict(os.environ, env), patch.object(store.subprocess, 'run', side_effect=run), \
|
|
patch.object(store, 'ask', side_effect=lambda channel, request, timeout=5.0, claim=False: order.append(request) or {'result': 'ok'}):
|
|
self.assertEqual(store.STORE_GAME, store.main([str(folder / store.LAUNCHER)]))
|
|
self.assertEqual([str(proton), 'run', 'cmd.exe', '/d', '/c', 'exit'], order[0])
|
|
self.assertEqual({'op': 'cloud-down', 'store': 'epic', 'id': 'fa4240e5'}, order[-1])
|
|
self.assertEqual('present', store.create_prefix(str(compat), str(proton)))
|
|
self.assertEqual(2, len(order))
|
|
|
|
def test_a_prefix_that_is_not_made_leaves_the_deferred_download(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
proton = Path(root) / 'proton'
|
|
proton.write_text('selected Proton')
|
|
with patch.object(store.subprocess, 'run', return_value=__import__('subprocess').CompletedProcess([], 1)):
|
|
self.assertEqual('failed', store.create_prefix(root + '/compatdata/1', str(proton)))
|
|
with patch.object(store.subprocess, 'run', side_effect=__import__('subprocess').TimeoutExpired('proton', 1)):
|
|
self.assertEqual('timeout', store.create_prefix(root + '/compatdata/1', str(proton)))
|
|
self.assertEqual('no-proton', store.create_prefix(root + '/compatdata/1', root + '/missing'))
|
|
self.assertEqual('no-proton', store.create_prefix('', str(proton)))
|
|
|
|
def test_cloud_off_or_amazon_runs_proton_as_before(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1')
|
|
sidecar = json.loads((folder / '.droiddeck-store.json').read_text())
|
|
sidecar['cloud'] = False
|
|
(folder / '.droiddeck-store.json').write_text(json.dumps(sidecar))
|
|
self.assertEqual(0, store.main([str(folder / '.droiddeck-launch.bat')]))
|
|
self.assertFalse(store.cloud_on({'store': 'amazon', 'id': 'x'}))
|
|
self.assertTrue(store.cloud_on({'store': 'epic', 'id': 'x'}))
|
|
|
|
def test_both_launchers_wait_for_proton_only_for_a_store_game(self):
|
|
for sh in (compat.LAUNCHER_SH, compat.EXTRA_WRAPPER_SH):
|
|
self.assertIn('dd_run ${DD_TASKSET:-} /usr/local/bin/droiddeck-game-env', sh)
|
|
self.assertNotIn('exec ${DD_TASKSET:-} /usr/local/bin/droiddeck-game-env', sh)
|
|
self.assertIn('[ $rc -eq 10 ] && DD_STORE_EXIT=1', compat.DD_STORE_SETUP)
|
|
self.assertIn('droiddeck-store-launch --exited --code "$rc" "${DD_STORE_ARGS[@]}"', compat.DD_STORE_SETUP)
|
|
self.assertIn('exec "$@"', compat.DD_STORE_SETUP)
|
|
|
|
|
|
BNET_EXE = '/root/.local/share/Steam/steamapps/compatdata/2596113170/pfx/drive_c/Program Files (x86)/Battle.net/Battle.net.exe'
|
|
|
|
|
|
class BattleNet(unittest.TestCase):
|
|
def test_a_games_shortcut_is_handed_to_droiddeck_battlenet(self):
|
|
self.assertEqual([store.BATTLENET, 'launch', 'Fen'], store.battlenet(['waitforexitandrun', BNET_EXE, '--exec=launch Fen'], env={}))
|
|
self.assertEqual([store.BATTLENET, 'launch', 'OSI'], store.battlenet(['"%s"' % BNET_EXE, '--exec="launch OSI"'], env={}))
|
|
self.assertEqual([store.BATTLENET, 'open'], store.battlenet([BNET_EXE], env={}))
|
|
|
|
def test_anything_else_and_its_own_starts_are_left_alone(self):
|
|
other = BNET_EXE.replace('2596113170', '123')
|
|
self.assertIsNone(store.battlenet([other, '--exec=launch Fen'], env={}))
|
|
self.assertIsNone(store.battlenet(['/x/Diablo IV/Diablo IV.exe'], env={}))
|
|
self.assertIsNone(store.battlenet([BNET_EXE, '--exec=launch Fen'], env={'DD_BATTLENET': '1'}))
|
|
self.assertEqual([store.BATTLENET, 'open'], store.battlenet([BNET_EXE, '--exec=launch Fen;rm'], env={}))
|
|
|
|
def test_the_launch_runs_there_and_the_wrapper_ends_with_it(self):
|
|
with patch.dict(os.environ, {}, clear=False), patch.object(store.subprocess, 'call', return_value=0) as call:
|
|
os.environ.pop('DD_BATTLENET', None)
|
|
self.assertEqual(store.RAN, store.main([BNET_EXE, '--exec=launch Pro']))
|
|
call.assert_called_once_with([store.BATTLENET, 'launch', 'Pro'])
|
|
with patch.dict(os.environ, {}, clear=False), patch.object(store.subprocess, 'call', return_value=1):
|
|
os.environ.pop('DD_BATTLENET', None)
|
|
self.assertEqual(store.RAN_FAILED, store.main([BNET_EXE, '--exec=launch Pro']))
|
|
self.assertIn('[ $rc -eq 11 ] && exit 0', compat.DD_STORE_SETUP)
|
|
self.assertIn('[ $rc -eq 12 ] && exit 1', compat.DD_STORE_SETUP)
|
|
self.assertLess(compat.DD_STORE_SETUP.index('droiddeck-store-launch "$@"'), compat.DD_STORE_SETUP.index('[ $rc -eq 11 ] && exit 0'))
|
|
|
|
|
|
class Launchers(unittest.TestCase):
|
|
def test_both_proton_launchers_ask_before_proton_starts(self):
|
|
sh = compat.LAUNCHER_SH
|
|
self.assertIn('dd_store_launch() {', sh)
|
|
self.assertLess(sh.index('dd_store_launch "$@"'), sh.index('droiddeck-game-env "$depot/proton"'))
|
|
self.assertIn('dd_store_launch "$@"', compat.EXTRA_WRAPPER_SH)
|
|
self.assertIn('dd_store_launch() {', compat.DD_STORE_SETUP)
|
|
self.assertIn('waitforexitandrun', compat.DD_STORE_SETUP)
|
|
|
|
def run_store_game(self, game, store_exit=True):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
hook = Path(root) / 'hook'
|
|
record = Path(root) / 'exited'
|
|
hook.write_text('#!/bin/sh\necho "$@" > "%s"\n' % record)
|
|
hook.chmod(0o755)
|
|
setup = compat.DD_STORE_SETUP.replace('/usr/local/bin/droiddeck-store-launch --exited', str(hook) + ' --exited')
|
|
script = setup + '\nDD_STORE_ARGS=(game.bat)\n%sdd_run sh -c %s\nexit 99\n' % (
|
|
'DD_STORE_EXIT=1\n' if store_exit else '', shlex.quote(game))
|
|
done = subprocess.run(['bash', '-c', script], start_new_session=True, timeout=20)
|
|
return done.returncode, record.read_text().split() if record.exists() else None
|
|
|
|
def test_a_store_game_ended_by_a_group_signal_still_reports_its_exit(self):
|
|
for signal_name, code in (('INT', '130'), ('TERM', '143'), ('HUP', '129')):
|
|
rc, hook = self.run_store_game('kill -%s 0; sleep 5' % signal_name)
|
|
self.assertEqual(['--exited', '--code', code, 'game.bat'], hook, signal_name)
|
|
self.assertEqual(int(code), rc, signal_name)
|
|
|
|
def test_a_store_game_that_exits_by_itself_reports_its_code_once(self):
|
|
self.assertEqual((3, ['--exited', '--code', '3', 'game.bat']), self.run_store_game('exit 3'))
|
|
|
|
def test_other_games_still_replace_the_wrapper_without_the_exit_hook(self):
|
|
self.assertEqual((4, None), self.run_store_game('exit 4', store_exit=False))
|
|
rc, hook = self.run_store_game('kill -INT 0; sleep 5', store_exit=False)
|
|
self.assertIsNone(hook)
|
|
self.assertEqual(-2, rc)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|
|
|
|
|
|
class GogAchievements(unittest.TestCase):
|
|
def test_cloud_off_still_prepares_the_gog_companion(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog')
|
|
sidecar = json.loads((folder / store.SIDECAR).read_text())
|
|
sidecar['cloud'] = False
|
|
(folder / store.SIDECAR).write_text(json.dumps(sidecar))
|
|
with patch.dict(os.environ, {'DD_LAUNCH_DIR': root, 'STEAM_COMPAT_DATA_PATH': root + '/compat', 'DD_STORE_PROTON': '/chosen/proton'}), patch.object(store, 'ask', return_value={'ready': True}) as ask, patch.object(store, 'provision_galaxy', return_value='ready') as provision:
|
|
self.assertEqual(0, store.main([str(folder / store.LAUNCHER)]))
|
|
ask.assert_called_once()
|
|
provision.assert_called_once_with(root + '/compat', '/chosen/proton')
|
|
|
|
def test_unavailable_companion_does_not_provision_or_block_the_game(self):
|
|
with patch.object(store, 'ask', return_value=None), patch.object(store, 'provision_galaxy') as provision:
|
|
self.assertFalse(store.prepare_gog({'id': '1', 'achievements': False}, '/pfx', '/session'))
|
|
provision.assert_not_called()
|
|
|
|
def test_a_fresh_prefix_is_bootstrapped_before_marking_success(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
base = Path(root)
|
|
tools = base / 'tools'; tools.mkdir()
|
|
for name in ('GalaxyCommunication.exe', 'update-permissions.exe', 'version'):
|
|
(tools / name).write_text(name)
|
|
proton = base / 'proton'; proton.write_text('selected Proton')
|
|
data = base / 'compat'
|
|
seen = []
|
|
def run(argv, **kwargs):
|
|
self.assertEqual([str(proton), 'run', 'cmd.exe', '/d', '/c'], argv[:5])
|
|
bat = Path(argv[5][2:].replace('\\', '/'))
|
|
text = bat.read_text()
|
|
seen.append(text)
|
|
self.assertIn('goto existing', text)
|
|
self.assertIn('update-permissions.exe', text)
|
|
result = text.split('echo ready>"')[1].split('"')[0]
|
|
Path(result[2:].replace('\\', '/')).write_text('ready')
|
|
(data / 'pfx').mkdir(parents=True)
|
|
(data / 'pfx/system.reg').write_text('Wine registry')
|
|
return __import__('subprocess').CompletedProcess(argv, 0)
|
|
with patch.object(store, 'COMET_DIR', tools), patch.object(store.subprocess, 'run', side_effect=run):
|
|
self.assertEqual('ready', store.provision_galaxy(str(data), str(proton)))
|
|
self.assertTrue((data / 'pfx/.droiddeck-comet-service').is_file())
|
|
self.assertEqual('ready', store.provision_galaxy(str(data), str(proton)))
|
|
self.assertEqual(1, len(seen))
|
|
__import__('shutil').rmtree(data / 'pfx')
|
|
self.assertEqual('ready', store.provision_galaxy(str(data), str(proton)))
|
|
self.assertEqual(2, len(seen))
|
|
|
|
def test_failed_service_install_is_not_marked_done(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
base = Path(root)
|
|
for name in ('GalaxyCommunication.exe', 'update-permissions.exe', 'version', 'proton'):
|
|
(base / name).write_text(name)
|
|
with patch.object(store, 'COMET_DIR', base), patch.object(store.subprocess, 'run', return_value=__import__('subprocess').CompletedProcess([], 1)):
|
|
self.assertEqual('service-unavailable', store.provision_galaxy(str(base / 'compat'), str(base / 'proton')))
|
|
self.assertFalse((base / 'compat/pfx/.droiddeck-comet-service').exists())
|
|
|
|
|
|
def gog_script(folder, product, actions):
|
|
(folder / ('goggame-%s.script' % product)).write_text(json.dumps({'actions': actions, 'baseProductId': product, 'version': 1}))
|
|
|
|
|
|
def set_registry(**arguments):
|
|
return {'install': {'action': 'setRegistry', 'arguments': arguments}, 'name': 'setRegistry'}
|
|
|
|
|
|
def support_data(**arguments):
|
|
return {'install': {'action': 'supportData', 'arguments': arguments}, 'name': 'supportData'}
|
|
|
|
|
|
class GogSupportData(unittest.TestCase):
|
|
def prefix(self, root):
|
|
user = Path(root) / 'compat/pfx/drive_c/users/steamuser'
|
|
user.mkdir(parents=True)
|
|
return user
|
|
|
|
def test_support_files_reach_the_prefix_once(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
user = self.prefix(root)
|
|
support = folder / 'support/9'
|
|
(support / 'Docs').mkdir(parents=True)
|
|
(support / 'Docs/Fallout4.ini').write_text('[Archive]\n')
|
|
(support / 'Plugins.txt').write_text('*LondonWorldSpace.esm\n')
|
|
(folder / '__AppData/Saves').mkdir(parents=True)
|
|
(folder / '__AppData/Saves/a.txt').write_text('a')
|
|
gog_script(folder, '9', [
|
|
set_registry(root='HKLM', subkey='Software\\Game', valueName='a', valueData='b', valueType='string'),
|
|
support_data(type='folder', target='{userdocs}/My Games/Fallout4'),
|
|
support_data(type='file', overwrite=True, source='{supportDir}/docs/Fallout4.ini',
|
|
target='{userdocs}/My Games/Fallout4/Fallout4.ini'),
|
|
support_data(type='file', overwrite=True, source='{supportDir}/Plugins.txt',
|
|
target='{localappdata}/Fallout4/Plugins.txt'),
|
|
support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/Fallout4'),
|
|
])
|
|
with patch.object(store, 'create_prefix') as create:
|
|
self.assertEqual('copied=3', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
create.assert_not_called()
|
|
self.assertTrue((user / 'Documents/My Games/Fallout4').is_dir())
|
|
self.assertEqual('[Archive]\n', (user / 'Documents/My Games/Fallout4/Fallout4.ini').read_text())
|
|
self.assertEqual('*LondonWorldSpace.esm\n', (user / 'AppData/Local/Fallout4/Plugins.txt').read_text())
|
|
self.assertEqual('a', (user / 'AppData/Local/Fallout4/Saves/a.txt').read_text())
|
|
(user / 'AppData/Local/Fallout4/Plugins.txt').write_text('player order')
|
|
self.assertEqual('ready', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
self.assertEqual('player order', (user / 'AppData/Local/Fallout4/Plugins.txt').read_text())
|
|
|
|
def test_a_source_the_build_lacks_does_not_recopy_the_rest_every_launch(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
user = self.prefix(root)
|
|
(folder / 'support/9').mkdir(parents=True)
|
|
(folder / 'support/9/Plugins.txt').write_text('x')
|
|
gog_script(folder, '9', [
|
|
support_data(type='file', overwrite=True, source='{supportDir}/Plugins.txt', target='{localappdata}/G/Plugins.txt'),
|
|
support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/G'),
|
|
])
|
|
self.assertEqual('copied=1 missing=1', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
(user / 'AppData/Local/G/Plugins.txt').write_text('player order')
|
|
self.assertEqual('ready', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
self.assertEqual('player order', (user / 'AppData/Local/G/Plugins.txt').read_text())
|
|
|
|
def test_a_link_never_carries_a_copy_outside(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
user = self.prefix(root)
|
|
outside = Path(root) / 'outside'
|
|
outside.mkdir()
|
|
(outside / 'secret.ini').write_text('s')
|
|
(folder / '__AppData').mkdir()
|
|
(folder / '__AppData/linked').symlink_to(outside)
|
|
(folder / 'support/9').mkdir(parents=True)
|
|
(folder / 'support/9/a.ini').write_text('a')
|
|
gog_script(folder, '9', [
|
|
support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/G'),
|
|
support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='{localappdata}/G/linked/a.ini'),
|
|
support_data(type='file', overwrite=True, source='{app}/__AppData/linked/secret.ini', target='{userdocs}/secret.ini'),
|
|
])
|
|
self.assertEqual('copied=1 skipped=2', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
self.assertTrue((user / 'AppData/Local/G/linked').is_symlink())
|
|
self.assertEqual(['secret.ini'], sorted(p.name for p in outside.iterdir()))
|
|
self.assertFalse((user / 'Documents/secret.ini').exists())
|
|
|
|
def test_a_linked_source_folder_is_copied_as_a_link(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
user = self.prefix(root)
|
|
outside = Path(root) / 'outside'
|
|
outside.mkdir()
|
|
(outside / 'secret.ini').write_text('s')
|
|
(folder / 'linked').symlink_to(outside)
|
|
gog_script(folder, '9', [support_data(type='folder', overwrite=True, source='{app}/linked', target='{userdocs}/G')])
|
|
store.gog_support_data(folder, root + '/compat', '/proton')
|
|
self.assertTrue((user / 'Documents/G').is_symlink())
|
|
self.assertEqual(outside, Path(os.readlink(user / 'Documents/G')))
|
|
|
|
def test_a_players_own_links_stay_without_overwrite(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
user = self.prefix(root)
|
|
(folder / 'support/9/Saves').mkdir(parents=True)
|
|
(folder / 'support/9/a.ini').write_text('a')
|
|
(folder / 'support/9/Saves/b.ini').write_text('b')
|
|
(user / 'Documents/G').mkdir(parents=True)
|
|
(user / 'Documents/a.ini').symlink_to(user / 'mine.ini')
|
|
(user / 'Documents/G/b.ini').symlink_to(user / 'gone.ini')
|
|
gog_script(folder, '9', [
|
|
support_data(type='file', source='{supportDir}/a.ini', target='{userdocs}/a.ini'),
|
|
support_data(type='folder', source='{supportDir}/Saves', target='{userdocs}/G'),
|
|
])
|
|
self.assertEqual('copied=0', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
self.assertEqual(user / 'mine.ini', Path(os.readlink(user / 'Documents/a.ini')))
|
|
self.assertEqual(user / 'gone.ini', Path(os.readlink(user / 'Documents/G/b.ini')))
|
|
|
|
def test_a_changed_script_applies_again(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
user = self.prefix(root)
|
|
(folder / 'support/9').mkdir(parents=True)
|
|
(folder / 'support/9/a.ini').write_text('1')
|
|
action = support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='{userdocs}/a.ini')
|
|
gog_script(folder, '9', [action])
|
|
self.assertEqual('copied=1', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
(folder / 'support/9/b.ini').write_text('2')
|
|
gog_script(folder, '9', [action, support_data(type='file', overwrite=True, source='{supportDir}/b.ini',
|
|
target='{userdocs}/b.ini')])
|
|
self.assertEqual('copied=2', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
self.assertEqual('2', (user / 'Documents/b.ini').read_text())
|
|
|
|
def test_a_players_file_is_kept_unless_the_script_overwrites_it(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
user = self.prefix(root)
|
|
(folder / 'support/9').mkdir(parents=True)
|
|
(folder / 'support/9/a.ini').write_text('default')
|
|
(user / 'Documents').mkdir()
|
|
(user / 'Documents/a.ini').write_text('mine')
|
|
gog_script(folder, '9', [support_data(type='file', source='{supportDir}/a.ini', target='{userdocs}/a.ini')])
|
|
self.assertEqual('copied=0', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
self.assertEqual('mine', (user / 'Documents/a.ini').read_text())
|
|
|
|
def test_paths_outside_the_known_folders_are_refused(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
self.prefix(root)
|
|
(folder / 'support/9').mkdir(parents=True)
|
|
(folder / 'support/9/a.ini').write_text('x')
|
|
gog_script(folder, '9', [
|
|
support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='{userdocs}/../../../../escape.ini'),
|
|
support_data(type='file', overwrite=True, source='{supportDir}/a.ini', target='C:/escape.ini'),
|
|
support_data(type='folder', target='{windir}/x'),
|
|
])
|
|
self.assertEqual('copied=0 skipped=3', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
self.assertEqual([], list(Path(root).rglob('escape.ini')))
|
|
self.assertFalse((Path(root) / 'compat/pfx' / store.GOG_SUPPORT_MARK).exists())
|
|
|
|
def test_links_in_a_support_folder_are_copied_as_links(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
user = self.prefix(root)
|
|
outside = Path(root) / 'outside'
|
|
outside.mkdir()
|
|
(outside / 'secret.txt').write_text('s')
|
|
(folder / '__AppData').mkdir()
|
|
(folder / '__AppData/linked').symlink_to(outside, target_is_directory=True)
|
|
gog_script(folder, '9', [support_data(type='folder', overwrite=True, source='{app}/__AppData', target='{localappdata}/G')])
|
|
self.assertEqual('copied=1', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
self.assertTrue((user / 'AppData/Local/G/linked').is_symlink())
|
|
self.assertEqual('s', (outside / 'secret.txt').read_text())
|
|
|
|
def test_without_support_data_no_prefix_is_made(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
gog_script(folder, '9', [set_registry(root='HKLM', subkey='Software\\Game', valueName='a', valueData='b', valueType='string')])
|
|
with patch.object(store, 'create_prefix') as create:
|
|
self.assertEqual('none', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
create.assert_not_called()
|
|
|
|
def test_a_missing_prefix_is_made_first(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='9')
|
|
gog_script(folder, '9', [support_data(type='folder', target='{userdocs}/My Games/G')])
|
|
with patch.object(store, 'create_prefix', return_value='failed') as create:
|
|
self.assertEqual('no-prefix', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
create.assert_called_once_with(root + '/compat', '/proton')
|
|
|
|
def made(compat_data, proton):
|
|
self.prefix(root)
|
|
return 'created'
|
|
with patch.object(store, 'create_prefix', side_effect=made):
|
|
self.assertEqual('copied=0', store.gog_support_data(folder, root + '/compat', '/proton'))
|
|
self.assertTrue((Path(root) / 'compat/pfx/drive_c/users/steamuser/Documents/My Games/G').is_dir())
|
|
|
|
|
|
class GogRegistry(unittest.TestCase):
|
|
def test_patch_registration_uses_authentic_build_and_the_prefix_registry_executable(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='7')
|
|
(folder / 'goggame-7.id').write_text(json.dumps({'buildId': 'opaque-0001'}))
|
|
proton = Path(root) / 'proton'; proton.write_text('selected Proton')
|
|
data = Path(root) / 'compat'
|
|
executable = data / 'pfx/drive_c/windows/system32/reg.exe'
|
|
executable.parent.mkdir(parents=True); executable.write_bytes(b'MZreg')
|
|
(data / 'pfx/system.reg').write_text('registry')
|
|
imported = []
|
|
def run(argv, **kwargs):
|
|
self.assertEqual([str(proton), 'run', str(executable), 'import'], argv[:4])
|
|
text = Path(argv[4][2:].replace('\\', '/')).read_bytes()[2:].decode('utf-16-le')
|
|
imported.append(text)
|
|
return __import__('subprocess').CompletedProcess(argv, 0)
|
|
record = {'id': '7', 'build': 'opaque-0001', 'version': 'RC-final'}
|
|
with patch.object(store.subprocess, 'run', side_effect=run):
|
|
self.assertTrue(store.apply_gog_registry(folder, str(data), str(proton), installation=record).startswith('written='))
|
|
self.assertIn('[HKEY_LOCAL_MACHINE\\Software\\GOG.com\\Games\\7]', imported[0])
|
|
self.assertIn('"BUILDID"="opaque-0001"', imported[0])
|
|
self.assertIn('"VER"="RC-final"', imported[0])
|
|
with self.assertRaises(ValueError):
|
|
store.apply_gog_registry(folder, str(data), str(proton), installation=dict(record, build='invented'))
|
|
|
|
def test_the_scripts_registry_values_are_read_with_the_games_paths(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1454587428')
|
|
gog_script(folder, '1454587428', [
|
|
set_registry(root='HKEY_LOCAL_MACHINE', subkey='Software\\Bethesda Softworks\\FalloutNV',
|
|
valueName='Installed Path', valueData='{app}\\', valueType='string'),
|
|
set_registry(root='HKEY_LOCAL_MACHINE', subkey='Software\\GOG.com\\Games\\{productId}',
|
|
valueName='buildId', valueData='42', valueType='dword'),
|
|
set_registry(root='HKEY_CURRENT_USER', subkey='Software\\Game', valueName='', valueData='AAH/', valueType='binary'),
|
|
set_registry(root='HKEY_LOCAL_MACHINE', subkey='Software\\Empty'),
|
|
set_registry(root='HKEY_LOCAL_MACHINE', subkey='Software\\Game', valueName='x', valueData='1', valueType='qword'),
|
|
set_registry(root='HKEY_LOCAL_MACHINE', subkey='Software\\Game', valueName='x', valueData='{nowhere}', valueType='string'),
|
|
set_registry(root='HKEY_USERS', subkey='S-1-5', valueName='x', valueData='1', valueType='string'),
|
|
{'install': {'action': 'Execute', 'arguments': {'executable': 'setup.exe'}}},
|
|
'nonsense',
|
|
])
|
|
entries, skipped = store.gog_registry(folder)
|
|
app = store.windows_path(str(folder)).replace('\\', '\\\\')
|
|
self.assertEqual([
|
|
'[HKEY_LOCAL_MACHINE\\Software\\Bethesda Softworks\\FalloutNV]\r\n"Installed Path"="%s\\\\"' % app,
|
|
'[HKEY_LOCAL_MACHINE\\Software\\GOG.com\\Games\\1454587428]\r\n"buildId"=dword:0000002a',
|
|
'[HKEY_CURRENT_USER\\Software\\Game]\r\n@=hex:00,01,ff',
|
|
'[HKEY_LOCAL_MACHINE\\Software\\Empty]',
|
|
], entries)
|
|
self.assertEqual(3, skipped)
|
|
|
|
def test_a_game_whose_support_installer_cannot_run_gets_the_install_registry(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1207658924')
|
|
(folder / 'goggame-1207658924.info').write_text(json.dumps({'language': 'English', 'languages': ['en-US']}))
|
|
gog_script(folder, '1207658924', [
|
|
{'install': {'action': 'Execute', 'arguments': {'executable': 'galaxy_the_witcher_enhanced_edition_2.1.0.15.exe'}}},
|
|
])
|
|
entries, skipped = store.gog_registry(folder)
|
|
app = store.windows_path(str(folder)).replace('\\', '\\\\')
|
|
self.assertEqual([
|
|
'[HKEY_LOCAL_MACHINE\\Software\\CD Projekt Red\\The Witcher]\r\n"InstallFolder"="%s\\\\"' % app,
|
|
'[HKEY_LOCAL_MACHINE\\Software\\CD Projekt Red\\The Witcher]\r\n"RegionVersion"="US"',
|
|
'[HKEY_LOCAL_MACHINE\\Software\\CD Projekt Red\\The Witcher]\r\n"IsDjinniInstalled"=dword:00000001',
|
|
'[HKEY_LOCAL_MACHINE\\Software\\CD Projekt Red\\The Witcher]\r\n"Language"="3"',
|
|
'[HKEY_CURRENT_USER\\Software\\CD Projekt RED\\Witcher\\Settings]\r\n"TextLanguage"="3"',
|
|
'[HKEY_CURRENT_USER\\Software\\CD Projekt RED\\Witcher\\Settings]\r\n"VoiceLanguage"="3"',
|
|
], entries)
|
|
self.assertEqual(0, skipped)
|
|
|
|
def test_a_players_language_choice_is_not_overwritten(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1207658924')
|
|
(folder / 'goggame-1207658924.info').write_text(json.dumps({'languages': ['en-US']}))
|
|
proton = Path(root) / 'proton'
|
|
proton.write_text('selected Proton')
|
|
data = Path(root) / 'compat'
|
|
(data / 'pfx').mkdir(parents=True)
|
|
(data / 'pfx/user.reg').write_text(
|
|
'[Software\\\\OtherApp] 1\n"InstallFolder"="C:\\\\Other"\n\n'
|
|
'[Software\\\\CD Projekt RED\\\\Witcher\\\\Settings] 1\n"TextLanguage"="5"\n')
|
|
imported = []
|
|
def run(argv, **kwargs):
|
|
imported.append(Path(argv[4][2:].replace('\\', '/')).read_bytes()[2:].decode('utf-16-le'))
|
|
(data / 'pfx/system.reg').write_text('Wine registry')
|
|
return __import__('subprocess').CompletedProcess(argv, 0)
|
|
with patch.object(store.subprocess, 'run', side_effect=run):
|
|
store.apply_gog_registry(folder, str(data), str(proton))
|
|
text = imported[0]
|
|
self.assertNotIn('"TextLanguage"', text)
|
|
self.assertIn('"VoiceLanguage"', text)
|
|
self.assertIn('"InstallFolder"', text)
|
|
|
|
def test_malformed_language_metadata_falls_back_to_english(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1207658924')
|
|
(folder / 'goggame-1207658924.info').write_text(json.dumps({'languages': 3}))
|
|
entries, _ = store.gog_registry(folder)
|
|
self.assertIn('"Language"="3"', entries[3])
|
|
|
|
def test_a_native_hklm_value_does_not_replace_the_32_bit_fallback(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1207658924')
|
|
(folder / 'goggame-1207658924.info').write_text(json.dumps({'languages': ['en-US']}))
|
|
pfx = Path(root) / 'pfx'
|
|
pfx.mkdir()
|
|
(pfx / 'system.reg').write_text(
|
|
'[Software\\\\CD Projekt Red\\\\The Witcher] 1\n"InstallFolder"="C:\\\\Native"\n')
|
|
entries, _ = store.gog_registry(folder, store.gog_registry_values(pfx))
|
|
self.assertTrue(any('"InstallFolder"' in entry for entry in entries))
|
|
(pfx / 'system.reg').write_text(
|
|
'[Software\\\\Wow6432Node\\\\CD Projekt Red\\\\The Witcher] 1\n"InstallFolder"="C:\\\\32bit"\n')
|
|
entries, _ = store.gog_registry(folder, store.gog_registry_values(pfx))
|
|
self.assertFalse(any('"InstallFolder"' in entry for entry in entries))
|
|
|
|
def test_a_deleted_fallback_value_is_imported_again(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1207658924')
|
|
(folder / 'goggame-1207658924.info').write_text(json.dumps({'languages': ['en-US']}))
|
|
proton = Path(root) / 'proton'
|
|
proton.write_text('selected Proton')
|
|
data = Path(root) / 'compat'
|
|
pfx = data / 'pfx'
|
|
pfx.mkdir(parents=True)
|
|
imported = []
|
|
def run(argv, **kwargs):
|
|
imported.append(argv)
|
|
(pfx / 'system.reg').write_text(
|
|
'[Software\\\\Wow6432Node\\\\CD Projekt Red\\\\The Witcher] 1\n'
|
|
'"InstallFolder"="C:\\\\Game"\n"RegionVersion"="US"\n'
|
|
'"IsDjinniInstalled"=dword:00000001\n"Language"="3"\n')
|
|
(pfx / 'user.reg').write_text(
|
|
'[Software\\\\CD Projekt RED\\\\Witcher\\\\Settings] 1\n'
|
|
'"TextLanguage"="3"\n"VoiceLanguage"="3"\n')
|
|
return __import__('subprocess').CompletedProcess(argv, 0)
|
|
with patch.object(store.subprocess, 'run', side_effect=run):
|
|
self.assertEqual('written=6', store.apply_gog_registry(folder, str(data), str(proton)))
|
|
self.assertEqual('none', store.apply_gog_registry(folder, str(data), str(proton)))
|
|
(pfx / 'system.reg').write_text(
|
|
'[Software\\\\Wow6432Node\\\\CD Projekt Red\\\\The Witcher] 1\n'
|
|
'"RegionVersion"="US"\n"IsDjinniInstalled"=dword:00000001\n"Language"="3"\n')
|
|
self.assertEqual('written=1', store.apply_gog_registry(folder, str(data), str(proton)))
|
|
self.assertEqual(2, len(imported))
|
|
|
|
def test_the_install_language_selects_the_titles_language_id(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1207658924')
|
|
(folder / 'goggame-1207658924.info').write_text(json.dumps({'languages': ['pl-PL']}))
|
|
entries, _ = store.gog_registry(folder)
|
|
self.assertIn('"Language"="5"', entries[3])
|
|
|
|
def test_a_script_that_sets_registry_keeps_its_own_values(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1207658924')
|
|
(folder / 'goggame-1207658924.info').write_text(json.dumps({'languages': ['en-US']}))
|
|
gog_script(folder, '1207658924', [
|
|
set_registry(root='HKLM', subkey='Software\\CD Projekt Red\\The Witcher',
|
|
valueName='InstallFolder', valueData='{app}\\', valueType='string'),
|
|
])
|
|
entries, _ = store.gog_registry(folder)
|
|
app = store.windows_path(str(folder)).replace('\\', '\\\\')
|
|
self.assertEqual([
|
|
'[HKEY_LOCAL_MACHINE\\Software\\CD Projekt Red\\The Witcher]\r\n"InstallFolder"="%s\\\\"' % app,
|
|
], entries)
|
|
|
|
def test_a_game_without_a_script_starts_without_proton(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog')
|
|
with patch.object(store.subprocess, 'run') as run:
|
|
self.assertEqual('none', store.apply_gog_registry(folder, root + '/compat', root + '/proton'))
|
|
run.assert_not_called()
|
|
|
|
def test_values_are_imported_into_the_32_bit_view_once_until_the_script_changes(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='1454587428')
|
|
proton = Path(root) / 'proton'
|
|
proton.write_text('selected Proton')
|
|
data = Path(root) / 'compat'
|
|
action = set_registry(root='HKLM', subkey='Software\\Bethesda Softworks\\FalloutNV',
|
|
valueName='Installed Path', valueData='{app}', valueType='string')
|
|
gog_script(folder, '1454587428', [action])
|
|
imported = []
|
|
def run(argv, **kwargs):
|
|
self.assertEqual([str(proton), 'run', 'reg.exe', 'import'], argv[:4])
|
|
self.assertEqual('/reg:32', argv[5])
|
|
raw = Path(argv[4][2:].replace('\\', '/')).read_bytes()
|
|
self.assertTrue(raw.startswith(b'\xff\xfe'))
|
|
imported.append(raw[2:].decode('utf-16-le'))
|
|
(data / 'pfx').mkdir(parents=True, exist_ok=True)
|
|
(data / 'pfx/system.reg').write_text('Wine registry')
|
|
return __import__('subprocess').CompletedProcess(argv, 0)
|
|
with patch.object(store.subprocess, 'run', side_effect=run):
|
|
self.assertEqual('written=1', store.apply_gog_registry(folder, str(data), str(proton)))
|
|
self.assertTrue(imported[0].startswith('Windows Registry Editor Version 5.00\r\n'))
|
|
self.assertIn('[HKEY_LOCAL_MACHINE\\Software\\Bethesda Softworks\\FalloutNV]', imported[0])
|
|
self.assertEqual('ready', store.apply_gog_registry(folder, str(data), str(proton)))
|
|
self.assertEqual(1, len(imported))
|
|
action['install']['arguments']['valueData'] = '{app}\\'
|
|
gog_script(folder, '1454587428', [action])
|
|
self.assertEqual('written=1', store.apply_gog_registry(folder, str(data), str(proton)))
|
|
self.assertEqual(2, len(imported))
|
|
|
|
def test_a_failed_import_is_tried_again_next_launch(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog', ident='7')
|
|
proton = Path(root) / 'proton'
|
|
proton.write_text('selected Proton')
|
|
gog_script(folder, '7', [set_registry(root='HKLM', subkey='Software\\Game', valueName='a', valueData='b', valueType='string')])
|
|
with patch.object(store.subprocess, 'run', return_value=__import__('subprocess').CompletedProcess([], 1)):
|
|
self.assertEqual('import-failed', store.apply_gog_registry(folder, root + '/compat', str(proton)))
|
|
self.assertFalse((Path(root) / 'compat/pfx' / store.GOG_REGISTRY_MARK).exists())
|
|
self.assertEqual('no-proton', store.apply_gog_registry(folder, root + '/compat', root + '/missing'))
|
|
|
|
def test_every_gog_launch_brings_the_registry_in(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog')
|
|
with patch.dict(os.environ, {'DD_LAUNCH_DIR': root, 'STEAM_COMPAT_DATA_PATH': root + '/compat/', 'DD_STORE_PROTON': '/chosen/proton'}), \
|
|
patch.object(store, 'prepare_gog', return_value=False), patch.object(store, 'ask', return_value=None), \
|
|
patch.object(store, 'apply_gog_registry', return_value='ready') as apply, \
|
|
patch.object(store, 'gog_support_data', return_value='ready') as support:
|
|
store.main([str(folder / store.LAUNCHER)])
|
|
apply.assert_called_once_with(folder, root + '/compat', '/chosen/proton')
|
|
support.assert_called_once_with(folder, root + '/compat', '/chosen/proton')
|
|
|
|
|
|
class Ubisoft(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
self.root = Path(self.tmp.name)
|
|
self.compat_data = self.root / 'compatdata/2929927072'
|
|
(self.compat_data / 'pfx').mkdir(parents=True)
|
|
(self.compat_data / 'pfx/system.reg').write_text('WINE REGISTRY Version 2\n')
|
|
(self.compat_data / 'pfx/user.reg').write_text('WINE REGISTRY Version 2\n')
|
|
self.folder = self.root / 'Games/Stores/Ubisoft/Splinter Cell'
|
|
(self.folder / 'system').mkdir(parents=True)
|
|
self.sidecar = {'store': 'ubisoft', 'id': 'space-1', 'exe': 'system/SplinterCell.exe', 'extra': {'productId': '109'}}
|
|
service = self.root / 'droiddeck-upc.exe'
|
|
service.write_bytes(b'MZ')
|
|
for patcher in (patch.object(store, 'UBISOFT_SERVICE', service), patch.object(store, 'UBISOFT_CACHE', self.root / 'cache'),
|
|
patch.object(store, 'wait_for_server', return_value=True)):
|
|
patcher.start()
|
|
self.addCleanup(patcher.stop)
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def runtime(self):
|
|
folder = store.ubisoft_runtime_dir(self.compat_data)
|
|
folder.mkdir(parents=True, exist_ok=True)
|
|
for name in store.UBISOFT_RUNTIME:
|
|
(folder / name).write_bytes(b'MZ')
|
|
|
|
def answer(self, *_args, **_kwargs):
|
|
return {'ok': True, 'ticket': 'PC', 'owned': [82, 109], 'appId': 'app',
|
|
'account': {'userId': 'u1', 'username': 'name', 'nameOnPlatform': 'name', 'email': 'e@x', 'country': 'US'}}
|
|
|
|
def prepare(self, ask_app):
|
|
return store.prepare_ubisoft(self.folder, self.sidecar, str(self.compat_data), str(self.root / 'launch'), '/proton', ask_app=ask_app)
|
|
|
|
def test_an_extracted_runtime_is_not_extracted_again(self):
|
|
self.runtime()
|
|
with patch.object(store.subprocess, 'run') as run:
|
|
self.assertEqual('present', store.install_runtime(str(self.compat_data)))
|
|
run.assert_not_called()
|
|
|
|
def test_the_runtime_comes_from_the_installer_through_7z(self):
|
|
installer = self.root / 'UbisoftConnectInstaller.exe'
|
|
|
|
def run(command, **_kwargs):
|
|
self.assertEqual(['7z', 'e', '-y'], command[:3])
|
|
self.assertEqual(str(installer), command[4])
|
|
out = Path(command[3][2:])
|
|
for name in command[5:]:
|
|
(out / name).write_bytes(b'MZ')
|
|
|
|
(self.root / 'cache').mkdir()
|
|
with patch.object(store, 'fetch_installer', return_value=installer), patch.object(store.subprocess, 'run', side_effect=run):
|
|
self.assertEqual('installed', store.install_runtime(str(self.compat_data)))
|
|
self.assertTrue(store.ubisoft_runtime_ready(str(self.compat_data)))
|
|
|
|
def test_a_launch_registers_the_game_and_writes_the_session_for_the_service(self):
|
|
self.runtime()
|
|
result = self.prepare(self.answer)
|
|
self.assertEqual('runtime present, registered 109, 0 manifest value(s), session ready', result)
|
|
reg = (self.compat_data / 'pfx/system.reg').read_text()
|
|
for view in ('[Software\\\\Ubisoft\\\\Launcher]', '[Software\\\\Wow6432Node\\\\Ubisoft\\\\Launcher]'):
|
|
self.assertIn(view, reg)
|
|
self.assertIn('[Software\\\\Wow6432Node\\\\Ubisoft\\\\Launcher\\\\Installs\\\\109]', reg)
|
|
self.assertIn('"InstallDir"="C:\\\\Program Files (x86)\\\\Ubisoft\\\\Ubisoft Game Launcher\\\\"', reg)
|
|
launch = json.loads((self.folder / store.UBISOFT_LAUNCH).read_text())
|
|
self.assertEqual(109, launch['productId'])
|
|
self.assertEqual('PC', launch['ticket'])
|
|
self.assertEqual([82, 109], launch['owned'])
|
|
self.assertEqual(store.windows_path(str(self.folder / 'system/SplinterCell.exe')), launch['exe'])
|
|
self.assertEqual('C:/users/steamuser/Saved Games/Ubisoft/u1/109/', launch['saves'])
|
|
self.assertTrue((self.compat_data / 'pfx/drive_c/users/steamuser/Saved Games/Ubisoft/u1/109').is_dir())
|
|
|
|
def test_without_a_session_the_launch_file_is_removed_and_the_game_starts_as_is(self):
|
|
self.runtime()
|
|
(self.folder / store.UBISOFT_LAUNCH).write_text('{}')
|
|
result = self.prepare(lambda *_a, **_k: {'ok': False, 'reason': 'signed-out'})
|
|
self.assertEqual('runtime present, registered 109, session signed-out', result)
|
|
self.assertFalse((self.folder / store.UBISOFT_LAUNCH).exists())
|
|
|
|
def test_a_game_without_a_product_is_left_alone(self):
|
|
self.sidecar['extra'] = {}
|
|
self.assertEqual('no-product', self.prepare(self.answer))
|
|
|
|
def test_the_manifest_registry_lands_in_both_views_with_the_install_folder_and_language(self):
|
|
self.runtime()
|
|
registry = [{'key': r'HKEY_LOCAL_MACHINE\SOFTWARE\Ubisoft\Launcher\Installs\109\Language',
|
|
'values': [{'name': 'French', 'value': 'fr-FR'}, {'name': 'English', 'value': 'en-US'}]},
|
|
{'key': r'HKEY_LOCAL_MACHINE\SOFTWARE\Ubisoft\Splinter Cell\GamePath', 'values': [{'name': '$INSTALL_DIR', 'value': ''}]}]
|
|
answer = dict(self.answer(), registry=registry, language='en-US')
|
|
result = self.prepare(lambda *_a, **_k: answer)
|
|
self.assertEqual('runtime present, registered 109, 4 manifest value(s), session ready', result)
|
|
reg = (self.compat_data / 'pfx/system.reg').read_text()
|
|
self.assertIn(r'[SOFTWARE\\Wow6432Node\\Ubisoft\\Launcher\\Installs\\109]', reg)
|
|
self.assertIn(r'[SOFTWARE\\Ubisoft\\Launcher\\Installs\\109]', reg)
|
|
self.assertIn('"Language"="en-US"', reg)
|
|
folder = store.windows_path(str(self.folder)).replace('\\', '\\\\')
|
|
self.assertIn('"GamePath"="%s\\\\"' % folder, reg)
|