mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 20:36:04 +00:00
* feat(xbox): stage the PlayFab Game Saves save-folder proxy from the Nexus runtime Xbox titles that use PlayFab Game Saves, such as Forza Horizon 6, stop with "Initialization Failed" E:0-17 right after sign-in. The SDK's default provider needs Gaming Runtime save APIs that xgameruntime does not have, and its in-process provider needs a save folder the title never passes on Windows. xodus-nexus already builds a proxy for this into the runtime archive we pin (scripts/runtime-compat, MIT): it keeps the title's SDK as nexus_pgs_native.dll, sets ForceUseInprocGameSaves and passes the PersistentLocalStorage PlayFabGameSaves folder. runtime.py now takes it and its license from the archive, checked against runtime.lock.json, and droiddeck-xbox stages it before each launch when the game's PlayFabGameSave.dll has exactly the SDK's 40 exports. A game update that brings a new SDK replaces the kept copy; anything unknown is left alone. Unlike Nexus, no DLL override is set for the two DLLs: Wine has no builtin of either, and forcing them native-only made Forza Horizon 6 fail with E:0-0-4. * fix(xbox): check the whole PlayFab export table and never overwrite an unknown kept SDK The SDK and proxy checks now also require the export address table to hold exactly 40 functions, so a DLL with the same names plus an ordinal-only export is no longer taken for the SDK. Before copying a new SDK to nexus_pgs_native.dll, an existing file there must itself be a regular file holding the SDK; an unknown file or a link is left as it is.
395 lines
23 KiB
Python
395 lines
23 KiB
Python
import io
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import runpy
|
|
import socket
|
|
import subprocess
|
|
import tempfile
|
|
import threading
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
|
|
xbox = runpy.run_path(str(BIN / 'droiddeck-xbox'))
|
|
|
|
|
|
class XboxLaunchTest(unittest.TestCase):
|
|
def test_other_stores_keep_their_existing_launch(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = Path(root)
|
|
(folder / '.droiddeck-store.json').write_text(json.dumps({'store': 'gog', 'id': '1'}))
|
|
self.assertIsNone(xbox['launch'](['/proton', 'waitforexitandrun', str(folder / 'Game.exe')], {}))
|
|
|
|
def test_renewal_retries_a_timeout_and_stops_after_rejection(self):
|
|
stopped = unittest.mock.Mock()
|
|
stopped.wait.side_effect = [False, False, False, AssertionError('renewed a rejected lease')]
|
|
ask = unittest.mock.Mock(side_effect=[None, {'ok': True}, {'ok': False}])
|
|
xbox['renew_lease'](ask, Path('/channel'), 'GAME', 'lease-1', stopped)
|
|
self.assertEqual(ask.call_count, 3)
|
|
|
|
def test_stopping_a_launch_stops_renewal_without_another_request(self):
|
|
stopped = threading.Event()
|
|
stopped.set()
|
|
ask = unittest.mock.Mock()
|
|
xbox['renew_lease'](ask, Path('/channel'), 'GAME', 'lease-1', stopped)
|
|
ask.assert_not_called()
|
|
|
|
def test_missing_store_detector_keeps_stock_launch(self):
|
|
for error in (FileNotFoundError('missing'), RuntimeError('module initialization failed')):
|
|
with self.subTest(error=error), patch('runpy.run_path', side_effect=error):
|
|
self.assertIsNone(xbox['launch'](['/proton', 'waitforexitandrun', '/Game.exe'], {}))
|
|
|
|
def test_launch_uses_prepared_image_and_never_receives_account_credentials(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
root = Path(root)
|
|
runtime = root / 'runtime/windows'
|
|
runtime.mkdir(parents=True)
|
|
for name in xbox['DLLS']:
|
|
(runtime / name).write_bytes(b'MZ')
|
|
store = {'find_store_game': lambda argv: (root, {'store': 'xbox', 'id': 'GAME'}),
|
|
'ask': unittest.mock.Mock(return_value={'ok': True, 'socket': '/service', 'lease': 'lease-1',
|
|
'exe': '/private/Game.exe', 'playfab': 'game-token'})}
|
|
close = unittest.mock.Mock()
|
|
with patch('runpy.run_path', return_value=store), patch.dict(xbox['launch'].__globals__, RUNTIME=runtime.parent), \
|
|
patch.dict(xbox['launch'].__globals__, bridge=lambda path: (1234, 'key', close)), \
|
|
patch.dict(xbox['launch'].__globals__, wine=unittest.mock.Mock(return_value=7)):
|
|
launch = xbox['launch']
|
|
self.assertEqual(launch(['/proton', 'waitforexitandrun', '/encrypted/Game.exe'],
|
|
{'BL_LAUNCH_DIR': '/launch', 'DROIDDECK_XBOX_CREDENTIAL_SOCKET': 'stale',
|
|
'DROIDDECK_XBOX_CREDENTIAL_PORT': '4100', 'DROIDDECK_XBOX_CREDENTIAL_KEY': 'stale-key'}), 7)
|
|
wine = launch.__globals__['wine']
|
|
self.assertEqual(wine.call_args.args[0], ['/private/Game.exe'])
|
|
env = wine.call_args.args[1]
|
|
for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
|
|
self.assertNotIn(name, env)
|
|
self.assertEqual(env['XODUS_XSTS_PLAYFAB'], 'game-token')
|
|
close.assert_called_once()
|
|
self.assertEqual(store['ask'].call_args.args[1], {'op': 'xbox-released', 'lease': 'lease-1'})
|
|
|
|
def test_bridge_start_failure_still_releases_the_lease(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
root = Path(root)
|
|
runtime = root / 'windows'
|
|
runtime.mkdir()
|
|
for name in xbox['DLLS']:
|
|
(runtime / name).touch()
|
|
ask = unittest.mock.Mock(return_value={'ok': True, 'socket': '/service', 'lease': 'lease-1'})
|
|
with patch('runpy.run_path', return_value={'find_store_game': lambda argv: (root, {'store': 'xbox', 'id': 'GAME'}), 'ask': ask}), \
|
|
patch.dict(xbox['launch'].__globals__, RUNTIME=root, bridge=unittest.mock.Mock(side_effect=OSError('bind failed'))):
|
|
with self.assertRaises(OSError):
|
|
xbox['launch'](['/proton', 'waitforexitandrun', '/Game.exe'], {'BL_LAUNCH_DIR': '/launch'})
|
|
self.assertEqual(ask.call_args.args[1], {'op': 'xbox-released', 'lease': 'lease-1'})
|
|
|
|
def test_bridge_authenticates_before_forwarding(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
path = str(Path(root) / 'service.sock')
|
|
upstream = socket.socket(socket.AF_UNIX)
|
|
upstream.bind(path); upstream.listen(1); upstream.settimeout(3)
|
|
received = []
|
|
def serve():
|
|
connection, _ = upstream.accept()
|
|
with connection:
|
|
received.append(connection.recv(8))
|
|
connection.sendall(b'reply')
|
|
worker = threading.Thread(target=serve); worker.start()
|
|
port, key, close = xbox['bridge'](path)
|
|
try:
|
|
with socket.create_connection(('127.0.0.1', port), timeout=2) as denied:
|
|
denied.sendall(b'x' * 64)
|
|
self.assertEqual(denied.recv(1), b'')
|
|
with socket.create_connection(('127.0.0.1', port), timeout=2) as client:
|
|
client.sendall(key[:20].encode())
|
|
client.sendall(key[20:].encode() + b'request')
|
|
self.assertEqual(client.recv(5), b'reply')
|
|
worker.join(3)
|
|
self.assertFalse(worker.is_alive())
|
|
self.assertEqual(received, [b'request'])
|
|
finally:
|
|
close(); upstream.close()
|
|
|
|
def test_wine_wrapper_preserves_selected_proton_args_and_prefix_isolation(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
root = Path(root)
|
|
prefix = root / 'compat/pfx'
|
|
prefix.mkdir(parents=True)
|
|
runtime = root / 'runtime/windows'; runtime.mkdir(parents=True)
|
|
for name in xbox['DLLS']:
|
|
(runtime / name).write_bytes(b'MZ-synthetic')
|
|
command = root / 'command.json'
|
|
command.write_text(json.dumps(['/selected/proton', 'waitforexitandrun', '/encrypted/Game.exe', '--custom', 'two words']))
|
|
env = {'STEAM_COMPAT_DATA_PATH': str(prefix.parent), 'DROIDDECK_XBOX_COMMAND_FILE': str(command),
|
|
'DROIDDECK_XBOX_CREDENTIAL_SOCKET': 'private-account-channel', 'DROIDDECK_XBOX_CREDENTIAL_PORT': '4100',
|
|
'DROIDDECK_XBOX_CREDENTIAL_KEY': 'private-key', 'XODUS_BRIDGE_KEY': 'runtime-key'}
|
|
with patch.dict(os.environ, env), patch.dict(xbox['wine'].__globals__, RUNTIME=runtime.parent), patch('subprocess.run') as initialize, patch('subprocess.call', return_value=7) as call:
|
|
initialize.return_value.returncode = 0
|
|
self.assertEqual(xbox['wine'](['/private-view/Game.exe']), 7)
|
|
argv = call.call_args.args[0]
|
|
self.assertEqual(argv, ['/selected/proton', 'waitforexitandrun', '/private-view/Game.exe', '--custom', 'two words'])
|
|
self.assertIn('xgameruntime=n', call.call_args.kwargs['env']['WINEDLLOVERRIDES'])
|
|
self.assertEqual((prefix / 'drive_c/windows/system32/xgameruntime.dll').read_bytes(), b'MZ-synthetic')
|
|
initialize.assert_called_once()
|
|
for child in (initialize, call):
|
|
child_env = child.call_args.kwargs['env']
|
|
for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
|
|
self.assertNotIn(name, child_env)
|
|
self.assertNotIn('DROIDDECK_XBOX_COMMAND_FILE', child_env)
|
|
self.assertEqual(child_env['XODUS_BRIDGE_KEY'], 'runtime-key')
|
|
|
|
def test_launch_view_runs_from_its_own_folder_on_a_short_drive_letter(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
root = Path(root)
|
|
prefix = root / 'compat/pfx'
|
|
prefix.mkdir(parents=True)
|
|
runtime = root / 'runtime/windows'; runtime.mkdir(parents=True)
|
|
for name in xbox['DLLS']:
|
|
(runtime / name).write_bytes(b'MZ-synthetic')
|
|
view = root / 'files/xbox-runtime/views/launch-4093691424/droiddeck-xbox-1ZpM3D'
|
|
(view / 'Bin').mkdir(parents=True)
|
|
command = root / 'command.json'
|
|
command.write_text(json.dumps(['/selected/proton', 'waitforexitandrun', '/encrypted/Game.exe']))
|
|
env = {'STEAM_COMPAT_DATA_PATH': str(prefix.parent), 'DROIDDECK_XBOX_COMMAND_FILE': str(command)}
|
|
seen = []
|
|
def call(argv, **kwargs):
|
|
seen.append((argv, os.readlink(prefix / 'dosdevices/x:')))
|
|
return 0
|
|
with patch.dict(os.environ, env), patch.dict(xbox['wine'].__globals__, RUNTIME=runtime.parent), patch('subprocess.run') as initialize, patch('subprocess.call', side_effect=call):
|
|
initialize.return_value.returncode = 0
|
|
self.assertEqual(xbox['wine']([str(view / 'Bin/Game.exe')]), 0)
|
|
self.assertEqual(seen, [(['/selected/proton', 'waitforexitandrun', 'X:\\droiddeck-xbox-1ZpM3D\\Bin\\Game.exe'], str(view.parent))])
|
|
self.assertFalse(os.path.lexists(prefix / 'dosdevices/x:'))
|
|
|
|
def test_view_drive_keeps_drives_in_use_and_reuses_a_stale_view(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
root = Path(root)
|
|
devices = root / 'pfx/dosdevices'; devices.mkdir(parents=True)
|
|
views = root / 'views'
|
|
live = views / 'launch-1/droiddeck-xbox-live'; live.mkdir(parents=True)
|
|
view = views / 'launch-2/droiddeck-xbox-new'; view.mkdir(parents=True)
|
|
(devices / 'x:').symlink_to(live)
|
|
(devices / 'w:').symlink_to(root / 'games')
|
|
(devices / 'v:').symlink_to(views / 'launch-0/droiddeck-xbox-gone')
|
|
exe, link = xbox['view_drive'](root / 'pfx', str(view / 'Game.exe'))
|
|
self.assertEqual((exe, link), ('V:\\droiddeck-xbox-new\\Game.exe', devices / 'v:'))
|
|
self.assertEqual(os.readlink(devices / 'v:'), str(view.parent))
|
|
self.assertEqual(os.readlink(devices / 'x:'), str(live))
|
|
self.assertEqual(sorted(p.name for p in devices.iterdir()), ['v:', 'w:', 'x:'])
|
|
self.assertEqual(xbox['view_drive'](root / 'pfx', '/games/Game.exe'), ('/games/Game.exe', None))
|
|
|
|
def test_missing_runtime_classes_are_registered_once(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
prefix = Path(root)
|
|
key = xbox['CLASS_KEY'].replace('\\', '\\\\')
|
|
present = [name for names in xbox['CLASSES'].values() for name in names
|
|
if name != 'Windows.ApplicationModel.DataTransfer.DataTransferManager']
|
|
(prefix / 'system.reg').write_text(''.join('[%s%s] 1\n"DllPath"="x"\n\n' % (key, name) for name in present))
|
|
imported = []
|
|
def run(argv, **kwargs):
|
|
imported.append(Path(argv[4][2:].replace('\\', '/')).read_bytes()[2:].decode('utf-16-le'))
|
|
return subprocess.CompletedProcess(argv, 0)
|
|
with patch('subprocess.run', side_effect=run) as child:
|
|
xbox['register_classes']('/selected/proton', prefix, {'A': '1'})
|
|
self.assertEqual(child.call_args.args[0][:4], ['/selected/proton', 'run', 'reg.exe', 'import'])
|
|
self.assertEqual(child.call_args.kwargs['env'], {'A': '1'})
|
|
self.assertEqual(imported, ['Windows Registry Editor Version 5.00\r\n\r\n[HKEY_LOCAL_MACHINE\\Software\\Microsoft\\WindowsRuntime'
|
|
'\\ActivatableClassId\\Windows.ApplicationModel.DataTransfer.DataTransferManager]\r\n'
|
|
'"DllPath"="C:\\\\windows\\\\system32\\\\twinapi.appcore.dll"\r\n\r\n'])
|
|
with (prefix / 'system.reg').open('a') as file:
|
|
file.write('[%sWindows.ApplicationModel.DataTransfer.DataTransferManager] 1\n' % key)
|
|
with patch('subprocess.run') as child:
|
|
xbox['register_classes']('/selected/proton', prefix, {})
|
|
(prefix / 'system.reg').unlink()
|
|
xbox['register_classes']('/selected/proton', prefix, {})
|
|
child.assert_not_called()
|
|
|
|
def test_failed_class_registration_is_reported_and_launch_continues(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
prefix = Path(root)
|
|
(prefix / 'system.reg').write_text('')
|
|
for outcome in ({'return_value': subprocess.CompletedProcess([], 1)},
|
|
{'side_effect': subprocess.TimeoutExpired('reg.exe', 90)}):
|
|
with patch('subprocess.run', **outcome), patch('sys.stderr', new_callable=io.StringIO) as err:
|
|
self.assertIsNone(xbox['register_classes']('/selected/proton', prefix, {}))
|
|
self.assertIn('registration failed', err.getvalue())
|
|
|
|
|
|
def pe_with_exports(names, forward=None, machine=0x8664, unnamed=0):
|
|
"""A minimal x64 PE image whose export table names `names`; with `forward`, every export is forwarded there.
|
|
`unnamed` adds that many ordinal-only exports after the named ones."""
|
|
rva, raw = 0x1000, 0x200
|
|
functions = rva + 40
|
|
name_pointers = functions + 4 * (len(names) + unnamed)
|
|
ordinals = name_pointers + 4 * len(names)
|
|
strings = ordinals + 2 * len(names)
|
|
blob = bytearray()
|
|
name_rvas, forward_rvas = [], []
|
|
for name in names:
|
|
name_rvas.append(strings + len(blob))
|
|
blob += name.encode() + b'\0'
|
|
for name in names:
|
|
forward_rvas.append(strings + len(blob))
|
|
if forward:
|
|
blob += ('%s.%s' % (forward, name)).encode() + b'\0'
|
|
size = strings + len(blob) - rva
|
|
directory = bytearray(40)
|
|
directory[16:20] = (1).to_bytes(4, 'little')
|
|
directory[20:24] = (len(names) + unnamed).to_bytes(4, 'little')
|
|
directory[24:28] = len(names).to_bytes(4, 'little')
|
|
directory[28:32] = functions.to_bytes(4, 'little')
|
|
directory[32:36] = name_pointers.to_bytes(4, 'little')
|
|
directory[36:40] = ordinals.to_bytes(4, 'little')
|
|
section = bytearray(directory)
|
|
for index in range(len(names)):
|
|
section += (forward_rvas[index] if forward else 0x3000 + index).to_bytes(4, 'little')
|
|
for index in range(unnamed):
|
|
section += (0x4000 + index).to_bytes(4, 'little')
|
|
for value in name_rvas:
|
|
section += value.to_bytes(4, 'little')
|
|
for index in range(len(names)):
|
|
section += index.to_bytes(2, 'little')
|
|
section += blob
|
|
image = bytearray(raw)
|
|
image[:2] = b'MZ'
|
|
image[60:64] = (0x40).to_bytes(4, 'little')
|
|
image[0x40:0x44] = b'PE\0\0'
|
|
image[0x44:0x46] = machine.to_bytes(2, 'little')
|
|
image[0x46:0x48] = (1).to_bytes(2, 'little')
|
|
image[0x54:0x56] = (240).to_bytes(2, 'little')
|
|
optional = 0x58
|
|
image[optional:optional + 2] = (0x20B).to_bytes(2, 'little')
|
|
image[optional + 108:optional + 112] = (16).to_bytes(4, 'little')
|
|
image[optional + 112:optional + 116] = rva.to_bytes(4, 'little')
|
|
image[optional + 116:optional + 120] = size.to_bytes(4, 'little')
|
|
header = optional + 240
|
|
image[header + 8:header + 12] = len(section).to_bytes(4, 'little')
|
|
image[header + 12:header + 16] = rva.to_bytes(4, 'little')
|
|
image[header + 16:header + 20] = len(section).to_bytes(4, 'little')
|
|
image[header + 20:header + 24] = raw.to_bytes(4, 'little')
|
|
return bytes(image + section)
|
|
|
|
|
|
class PlayFabProxyTest(unittest.TestCase):
|
|
SDK = pe_with_exports(xbox['PGS_EXPORTS'])
|
|
NEWER_SDK = SDK + b'\0update'
|
|
PROXY = pe_with_exports(xbox['PGS_EXPORTS'], forward='nexus_pgs_native')
|
|
|
|
def stage(self, root, proxy=PROXY):
|
|
runtime = Path(root) / 'runtime'
|
|
if proxy is not None:
|
|
(runtime / 'compat').mkdir(parents=True, exist_ok=True)
|
|
(runtime / 'compat/PlayFabGameSave.dll').write_bytes(proxy)
|
|
with patch.dict(xbox['stage_playfab_proxy'].__globals__, PGS_PROXY=runtime / 'compat/PlayFabGameSave.dll'), \
|
|
patch('sys.stderr', new_callable=io.StringIO):
|
|
return xbox['stage_playfab_proxy'](Path(root) / 'game')
|
|
|
|
def game(self, root, data, sub='Bin'):
|
|
folder = Path(root) / 'game' / sub
|
|
folder.mkdir(parents=True)
|
|
(folder / 'PlayFabGameSave.dll').write_bytes(data)
|
|
return folder
|
|
|
|
def test_sdk_and_proxy_are_told_apart_by_their_exports(self):
|
|
self.assertTrue(xbox['playfab_sdk'](self.SDK))
|
|
self.assertFalse(xbox['playfab_proxy'](self.SDK))
|
|
self.assertTrue(xbox['playfab_proxy'](self.PROXY))
|
|
self.assertFalse(xbox['playfab_sdk'](self.PROXY))
|
|
other = pe_with_exports(list(xbox['PGS_EXPORTS'][:-1]) + ['PFGameSaveFilesSomethingNew'])
|
|
self.assertFalse(xbox['playfab_sdk'](other))
|
|
self.assertFalse(xbox['playfab_sdk'](pe_with_exports(xbox['PGS_EXPORTS'], machine=0xAA64)))
|
|
self.assertIsNone(xbox['pe_exports'](b'not a pe image'))
|
|
self.assertEqual(xbox['pe_exports'](pe_with_exports(['A', 'B'], unnamed=1))[0], 3)
|
|
self.assertFalse(xbox['playfab_sdk'](pe_with_exports(xbox['PGS_EXPORTS'], unnamed=1)))
|
|
self.assertFalse(xbox['playfab_proxy'](pe_with_exports(xbox['PGS_EXPORTS'], forward='nexus_pgs_native', unnamed=1)))
|
|
|
|
def test_first_launch_keeps_the_sdk_and_puts_the_proxy_in_front(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = self.game(root, self.SDK)
|
|
self.assertEqual(self.stage(root), 1)
|
|
self.assertEqual((folder / 'nexus_pgs_native.dll').read_bytes(), self.SDK)
|
|
self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.PROXY)
|
|
self.assertEqual(self.stage(root), 1)
|
|
self.assertEqual((folder / 'nexus_pgs_native.dll').read_bytes(), self.SDK)
|
|
self.assertEqual(sorted(path.name for path in folder.iterdir()), ['PlayFabGameSave.dll', 'nexus_pgs_native.dll'])
|
|
|
|
def test_a_game_update_replaces_the_kept_sdk(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = self.game(root, self.SDK)
|
|
self.stage(root)
|
|
(folder / 'PlayFabGameSave.dll').write_bytes(self.NEWER_SDK)
|
|
self.assertEqual(self.stage(root), 1)
|
|
self.assertEqual((folder / 'nexus_pgs_native.dll').read_bytes(), self.NEWER_SDK)
|
|
self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.PROXY)
|
|
|
|
def test_an_older_proxy_is_refreshed_only_while_its_sdk_is_there(self):
|
|
older = self.PROXY + b'\0older'
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = self.game(root, older)
|
|
(folder / 'nexus_pgs_native.dll').write_bytes(self.SDK)
|
|
self.assertEqual(self.stage(root), 1)
|
|
self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.PROXY)
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = self.game(root, older)
|
|
self.assertEqual(self.stage(root), 0)
|
|
self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), older)
|
|
|
|
def test_an_unknown_file_or_link_in_place_of_the_kept_sdk_is_never_overwritten(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = self.game(root, self.SDK)
|
|
(folder / 'nexus_pgs_native.dll').write_bytes(b'MZ someone else')
|
|
self.assertEqual(self.stage(root), 0)
|
|
self.assertEqual((folder / 'nexus_pgs_native.dll').read_bytes(), b'MZ someone else')
|
|
self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.SDK)
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = self.game(root, self.SDK)
|
|
target = Path(root) / 'elsewhere.dll'
|
|
target.write_bytes(self.SDK)
|
|
(folder / 'nexus_pgs_native.dll').symlink_to(target)
|
|
self.assertEqual(self.stage(root), 0)
|
|
self.assertTrue((folder / 'nexus_pgs_native.dll').is_symlink())
|
|
self.assertEqual(target.read_bytes(), self.SDK)
|
|
self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.SDK)
|
|
|
|
def test_unknown_sdk_symlinks_and_a_runtime_without_the_proxy_are_left_alone(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
unknown = pe_with_exports(['PFGameSaveFilesInitialize'])
|
|
folder = self.game(root, unknown)
|
|
self.assertEqual(self.stage(root), 0)
|
|
self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), unknown)
|
|
self.assertFalse((folder / 'nexus_pgs_native.dll').exists())
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = self.game(root, self.SDK)
|
|
self.assertEqual(self.stage(root, proxy=None), 0)
|
|
self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.SDK)
|
|
with tempfile.TemporaryDirectory() as root:
|
|
target = Path(root) / 'elsewhere.dll'
|
|
target.write_bytes(self.SDK)
|
|
folder = Path(root) / 'game'
|
|
folder.mkdir()
|
|
(folder / 'PlayFabGameSave.dll').symlink_to(target)
|
|
self.assertEqual(self.stage(root), 0)
|
|
self.assertEqual(target.read_bytes(), self.SDK)
|
|
|
|
def test_launch_stages_the_proxy_without_dll_overrides_and_survives_a_failure(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
root = Path(root)
|
|
runtime = root / 'windows'
|
|
runtime.mkdir()
|
|
for name in xbox['DLLS']:
|
|
(runtime / name).touch()
|
|
store = {'find_store_game': lambda argv: (root, {'store': 'xbox', 'id': 'GAME'}),
|
|
'ask': unittest.mock.Mock(return_value={'ok': True, 'socket': '/service', 'lease': 'lease-1',
|
|
'exe': '/Game.exe'})}
|
|
wine = unittest.mock.Mock(return_value=0)
|
|
staged = []
|
|
def failing(folder):
|
|
raise RuntimeError('unreadable game folder')
|
|
for stage in (lambda folder: staged.append(folder) or 1, failing):
|
|
wine.reset_mock()
|
|
with patch('runpy.run_path', return_value=store), patch('sys.stderr', new_callable=io.StringIO), \
|
|
patch.dict(xbox['launch'].__globals__, RUNTIME=root, bridge=lambda path: (1, 'key', lambda: None),
|
|
wine=wine, stage_playfab_proxy=stage):
|
|
self.assertEqual(xbox['launch'](['/proton', 'waitforexitandrun', '/Game.exe'],
|
|
{'BL_LAUNCH_DIR': '/launch', 'WINEDLLOVERRIDES': 'd3d11=n'}), 0)
|
|
self.assertEqual(wine.call_args.args[1]['WINEDLLOVERRIDES'], 'd3d11=n')
|
|
self.assertEqual(staged, [root])
|