mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 12:28:40 +00:00
fix(proton): a Valve Proton picked for a game in Steam stays on the ARM64 build made from it Steam lists Valve's own Proton Experimental and Proton 11.0 next to the DroidDeck tools. They are not runnable here, so a per-game pick of one was replaced with the default. That used to be Proton Experimental ARM64, so the pick looked kept; since an installed DroidDeck-Proton became the default, the game is moved to DroidDeck-Proton instead. When Steam records one of those tools for a title the sync already knows (a title it mapped or one with a recorded pick), the title now gets the DroidDeck tool built from the same Valve depot, stops following the default and the choice is mirrored into the app's per-game setting. The same applies to Steam's default. Titles nobody picked anything for still follow the default, and Valve tools with no ARM64 build still fall back to it.
1033 lines
51 KiB
Python
1033 lines
51 KiB
Python
import json
|
|
import os
|
|
from pathlib import Path
|
|
import runpy
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
from unittest import mock
|
|
|
|
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
|
|
LIVE = runpy.run_path(str(BIN / "droiddeck-steam-compat"))
|
|
COMPAT = LIVE["COMPAT"]
|
|
TOOL = COMPAT["TOOL"]
|
|
TOOL_11 = COMPAT["TOOL_11"]
|
|
|
|
FAKE_STEAM = r"""
|
|
const dec = new TextDecoder(), enc = new TextEncoder();
|
|
function readVarint(b, at) { let r = 0n, s = 0n, x; do { x = b[at.i++]; r |= BigInt(x & 0x7f) << s; s += 7n; } while (x & 0x80); return r; }
|
|
function fields(b) {
|
|
const f = {}, at = { i: 0 };
|
|
while (at.i < b.length) {
|
|
const k = Number(readVarint(b, at)), n = k >> 3, w = k & 7; let v;
|
|
if (w === 0) v = readVarint(b, at);
|
|
else if (w === 1) { v = 0n; for (let j = 0; j < 8; j++) v |= BigInt(b[at.i + j]) << BigInt(8 * j); at.i += 8; }
|
|
else if (w === 2) { const len = Number(readVarint(b, at)); v = b.slice(at.i, at.i + len); at.i += len; }
|
|
else throw new Error("wire " + w);
|
|
(f[n] = f[n] || []).push(v);
|
|
}
|
|
return f;
|
|
}
|
|
function vint(n, out) { n = BigInt(n); do { let x = Number(n & 0x7fn); n >>= 7n; if (n) x |= 0x80; out.push(x); } while (n); }
|
|
function lenField(n, bytes, out) { vint(n * 8 + 2, out); vint(bytes.length, out); for (const x of bytes) out.push(x); }
|
|
function reply(eresult, jobid, body, name) {
|
|
const h = [];
|
|
if (jobid !== null) { vint(11 * 8 + 1, h); let n = jobid; for (let i = 0; i < 8; i++) { h.push(Number(n & 0xffn)); n >>= 8n; } }
|
|
if (name) lenField(12, enc.encode(name), h);
|
|
vint(13 * 8, h); vint(eresult, h);
|
|
const out = new Uint8Array(8 + h.length + body.length), dv = new DataView(out.buffer);
|
|
dv.setUint32(0, (0x80000000 | 147) >>> 0, true); dv.setUint32(4, h.length, true);
|
|
out.set(h, 8); out.set(body, 8 + h.length);
|
|
return out.buffer;
|
|
}
|
|
const state = { mapping: JSON.parse(process.argv[2]), known: JSON.parse(process.argv[3]), log: [], authed: false, notify: [] };
|
|
class FakeSocket {
|
|
constructor(url) { this.url = url; this.readyState = 0; state.socket = this; setTimeout(() => { this.readyState = 1; this.onopen(); }, 0); }
|
|
send(buffer) {
|
|
const b = new Uint8Array(buffer), dv = new DataView(buffer.buffer || buffer);
|
|
if (dv.getUint32(0, true) !== ((0x80000000 | 146) >>> 0)) throw new Error("bad emsg");
|
|
const hl = dv.getUint32(4, true), h = fields(b.slice(8, 8 + hl)), body = fields(b.slice(8 + hl));
|
|
const method = dec.decode(h[12][0]), jobid = h[10][0];
|
|
let out = [], result = 1;
|
|
if (method === "TransportAuth.Authenticate#1") {
|
|
state.authed = dec.decode(h[40][0]) === "secret" && dec.decode(body[1][0]) === "secret";
|
|
result = state.authed ? 1 : 5;
|
|
} else if (!state.authed) result = 5;
|
|
else if (method === "CompatManager.GetCompatTools#1" && ["16", "128"].includes(String(body[1][0]))) result = Number(body[1][0]);
|
|
else if (method === "CompatManager.GetCompatTools#1") {
|
|
const app = String(body[1] ? body[1][0] : 0n);
|
|
for (const name of state.known) { const t = []; lenField(1, enc.encode(name), t); lenField(2, enc.encode(name + " shown"), t); lenField(1, t, out); }
|
|
lenField(3, enc.encode(state.mapping[app] || ""), out);
|
|
lenField(4, enc.encode("proton_experimental"), out);
|
|
} else if (method === "CompatManager.SpecifyCompatTool#1") {
|
|
const app = String(body[1] ? body[1][0] : 0n), name = body[2] ? dec.decode(body[2][0]) : "";
|
|
state.mapping[app] = name; state.log.push(app + "=" + name);
|
|
setTimeout(() => this.onmessage({ data: reply(1, null, new Uint8Array(0), "CompatManager.NotifyStateChanged#1") }), 0);
|
|
} else result = 2;
|
|
setTimeout(() => this.onmessage({ data: reply(result, jobid, Uint8Array.from(out)) }), 0);
|
|
}
|
|
close() {}
|
|
}
|
|
globalThis.window = globalThis;
|
|
globalThis.WebSocket = FakeSocket;
|
|
globalThis.SteamClient = { WebUITransport: { GetTransportInfo: async () => ({ portClientdll: 4242, authKeyClientdll: "secret" }) } };
|
|
window.droiddeckCompatChanged = (n) => state.notify.push(n);
|
|
const install = require("fs").readFileSync(process.argv[4], "utf8");
|
|
(async () => {
|
|
if (eval(install) !== "installed" || eval(install) !== "present") throw new Error("install is not idempotent");
|
|
const c = window.__droiddeckCompat;
|
|
const before = await c.get(0);
|
|
await c.set(0, "droiddeck-proton-11-arm64");
|
|
await c.set(42, "");
|
|
const after = await c.many(["0", "42", "43", "128"]);
|
|
const timedOut = await c.many(["0", "16"]).then(() => null, (e) => e.eresult);
|
|
await new Promise((r) => setTimeout(r, 10));
|
|
console.log(JSON.stringify({ before, after, timedOut, log: state.log, notify: state.notify, url: state.socket.url }));
|
|
})().catch((e) => { console.error(e.stack || String(e)); process.exit(1); });
|
|
"""
|
|
|
|
|
|
class FakePage:
|
|
def __init__(self, mapping, known, refused=()):
|
|
self.mapping = dict(mapping)
|
|
self.known = list(known)
|
|
self.refused = set(refused)
|
|
self.sets = []
|
|
|
|
def compat(self, call):
|
|
name, _, args = call.partition("(")
|
|
args = json.loads("[%s]" % args[:-1])
|
|
if name == "get":
|
|
return {"selected": self.mapping.get(str(args[0]), ""), "fallback": "proton_experimental", "tools": self.known}
|
|
if name == "many":
|
|
return {app: self.mapping.get(app, "") for app in args[0] if app not in self.refused}
|
|
if name == "set":
|
|
if str(args[0]) in self.refused:
|
|
raise RuntimeError("SpecifyCompatTool %s failed (128)" % args[0])
|
|
self.mapping[str(args[0])] = args[1]
|
|
self.sets.append((str(args[0]), args[1]))
|
|
return True
|
|
raise AssertionError(call)
|
|
|
|
|
|
@unittest.skipUnless(shutil.which("node"), "node is not installed")
|
|
class PageScriptTest(unittest.TestCase):
|
|
def test_vr_games_wait_for_steamvr_and_preserve_the_original_launch(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
script = Path(tmp) / "vr.js"
|
|
script.write_text(LIVE["VR_JS"])
|
|
harness = Path(__file__).with_name("steam_vr_launch_harness.js")
|
|
result = subprocess.run(["node", str(harness), str(script)],
|
|
capture_output=True, text=True, timeout=20)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
|
|
def test_tool_installs_skip_only_their_own_install_dialog(self):
|
|
harness_source = r"""
|
|
const assert = require('assert');
|
|
globalThis.window = globalThis;
|
|
const script = require('fs').readFileSync(process.argv[2], 'utf8');
|
|
globalThis.SteamClient = { Installs: {}, Downloads: {} };
|
|
assert.throws(() => eval(script), /install calls are not ready/);
|
|
const opened = [], queued = [];
|
|
let wizard = null, continued = 0;
|
|
globalThis.SteamClient = {
|
|
Installs: {
|
|
OpenInstallWizard(apps, client) { opened.push([apps, client]); },
|
|
RegisterForShowInstallWizard(callback) { assert.strictEqual(wizard, null); wizard = callback; return { unregister() {} }; },
|
|
ContinueInstall() { continued++; },
|
|
},
|
|
Downloads: { QueueAppUpdate(app, client) { queued.push([app, client]); } },
|
|
};
|
|
assert.strictEqual(eval(script), 'installed');
|
|
assert.strictEqual(eval(script), 'present');
|
|
const tools = window.__droiddeckTools;
|
|
wizard({ eInstallState: 7, currentAppID: 4183110 });
|
|
assert.strictEqual(continued, 0);
|
|
tools.install(4183110);
|
|
assert.deepStrictEqual(opened, [[[4183110], '0']]);
|
|
wizard({ eInstallState: 8, currentAppID: 4183110 });
|
|
wizard({ eInstallState: 7, currentAppID: 892970 });
|
|
assert.strictEqual(continued, 0);
|
|
wizard({ eInstallState: 7, currentAppID: 4183110 });
|
|
wizard({ eInstallState: 7, currentAppID: 4183110 });
|
|
assert.strictEqual(continued, 1);
|
|
tools.update(4427310);
|
|
assert.deepStrictEqual(queued, [[4427310, '0']]);
|
|
"""
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
script = Path(tmp) / "tools.js"
|
|
script.write_text(LIVE["TOOLS_JS"])
|
|
harness = Path(tmp) / "harness.js"
|
|
harness.write_text(harness_source)
|
|
result = subprocess.run(["node", str(harness), str(script)], capture_output=True, text=True, timeout=20)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
|
|
def test_steamvr_library_launch_uses_binding_and_other_games_pass_through(self):
|
|
harness_source = r"""
|
|
const assert = require('assert');
|
|
globalThis.window = globalThis;
|
|
const calls = [], requests = [];
|
|
const apps = { RunGame(...args) { assert.strictEqual(this, apps); calls.push(args); return 'native'; } };
|
|
globalThis.SteamClient = { Apps: apps };
|
|
window.droiddeckLaunchSteamVr = id => requests.push(id);
|
|
const script = require('fs').readFileSync(process.argv[2], 'utf8');
|
|
assert.strictEqual(eval(script), 'installed');
|
|
assert.strictEqual(eval(script), 'present');
|
|
assert.strictEqual(apps.RunGame('250820', '', -1, 100), undefined);
|
|
apps.RunGame(250820, '', -1, 100);
|
|
assert.deepStrictEqual(requests, ['250820', '250820']);
|
|
assert.deepStrictEqual(calls, []);
|
|
assert.strictEqual(apps.RunGame('611670', 'custom args', -1, 100), 'native');
|
|
assert.strictEqual(apps.RunGame('2508200', '', -1, 100), 'native');
|
|
delete window.droiddeckLaunchSteamVr;
|
|
assert.strictEqual(apps.RunGame('250820', '', -1, 100), 'native');
|
|
assert.deepStrictEqual(calls, [['611670', 'custom args', -1, 100], ['2508200', '', -1, 100], ['250820', '', -1, 100]]);
|
|
"""
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
script = Path(tmp) / "vr.js"
|
|
script.write_text(LIVE["VR_JS"])
|
|
harness = Path(tmp) / "test.js"
|
|
harness.write_text(harness_source)
|
|
result = subprocess.run(["node", str(harness), str(script)],
|
|
capture_output=True, text=True, timeout=20)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
|
|
def test_transport_framing_auth_and_notifications(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
script = Path(tmp) / "install.js"
|
|
script.write_text(LIVE["INSTALL_JS"])
|
|
harness = Path(tmp) / "harness.js"
|
|
harness.write_text(FAKE_STEAM)
|
|
result = subprocess.run(["node", str(harness), json.dumps({"0": TOOL, "42": "proton_experimental"}),
|
|
json.dumps([TOOL, TOOL_11, "proton_experimental"]), str(script)],
|
|
capture_output=True, text=True, timeout=60)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
out = json.loads(result.stdout)
|
|
self.assertEqual(out["url"], "ws://127.0.0.1:4242/transportsocket/")
|
|
self.assertEqual(out["before"], {"selected": TOOL, "fallback": "proton_experimental", "tools": [TOOL, TOOL_11, "proton_experimental"]})
|
|
self.assertEqual(out["after"], {"0": TOOL_11, "42": "", "43": ""})
|
|
self.assertEqual(out["timedOut"], 16)
|
|
self.assertEqual(out["log"], ["0=" + TOOL_11, "42="])
|
|
self.assertEqual(out["notify"], ["1", "2"])
|
|
|
|
|
|
class DevtoolsHttpTest(unittest.TestCase):
|
|
def test_a_kept_alive_answer_is_read_to_its_length(self):
|
|
import socket
|
|
import threading
|
|
server = socket.socket()
|
|
server.bind(("127.0.0.1", 0))
|
|
server.listen(1)
|
|
port = server.getsockname()[1]
|
|
body = json.dumps([{"title": "other"}, {"title": "SharedJSContext", "webSocketDebuggerUrl": "ws://127.0.0.1:%d/devtools/page/AB" % port}]).encode()
|
|
done = threading.Event()
|
|
|
|
def answer():
|
|
conn, _ = server.accept()
|
|
conn.recv(4096)
|
|
conn.sendall(b"HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n" % len(body) + body)
|
|
done.wait(10)
|
|
conn.close()
|
|
server.close()
|
|
|
|
thread = threading.Thread(target=answer)
|
|
thread.start()
|
|
try:
|
|
self.assertEqual(LIVE["shared_context"](port), "/devtools/page/AB")
|
|
finally:
|
|
done.set()
|
|
thread.join()
|
|
|
|
|
|
class ReconcileTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.tmp.cleanup)
|
|
base = Path(self.tmp.name)
|
|
self.steam = base / "Steam"
|
|
for name in COMPAT["SOURCES"]:
|
|
(self.steam / "steamapps/common" / name / "files/bin-arm64").mkdir(parents=True)
|
|
for app in ("10", "11"):
|
|
(self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text("")
|
|
self.state = base / "compat"
|
|
self.state.mkdir()
|
|
COMPAT["main"].__globals__["COMPAT_DIR"] = str(self.state)
|
|
COMPAT["main"].__globals__["LABEL_FILE"] = str(base / "no-label")
|
|
self.addCleanup(COMPAT["main"].__globals__.__setitem__, "COMPAT_DIR", COMPAT["COMPAT_DIR"])
|
|
self.helper = LIVE["Helper"](str(self.steam), 1)
|
|
|
|
def reconcile(self, page):
|
|
self.helper.page = page
|
|
self.helper.reconcile()
|
|
return json.loads((self.state / "state.json").read_text())
|
|
|
|
def test_new_install_gets_the_default_live(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": "proton_experimental"}, [TOOL, TOOL_11])
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [("11", TOOL)])
|
|
self.assertEqual(state["auto"], {"10": TOOL, "11": TOOL})
|
|
self.assertTrue(state["live"])
|
|
self.assertEqual(self.helper.installed, ["10", "11"])
|
|
|
|
def test_an_app_the_client_refuses_is_dropped_instead_of_failing_the_sync(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": "proton_experimental"}, [TOOL, TOOL_11], refused={"1628350"})
|
|
(self.state / "state.json").write_text(json.dumps({"default": TOOL, "auto": {"10": TOOL, "1628350": TOOL}}))
|
|
(self.state / "games.json").write_text(json.dumps({"version": 1, "games": {"1628350": {"valve": True, "dir": "Proton 11.0 (ARM64)"}}}))
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [("11", TOOL)])
|
|
self.assertEqual(state["auto"], {"10": TOOL, "11": TOOL})
|
|
|
|
def test_a_refused_apps_native_choice_is_kept(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL}, [TOOL, TOOL_11], refused={"20"})
|
|
(self.state / "state.json").write_text(json.dumps({"default": TOOL, "auto": {"10": TOOL, "11": TOOL}, "native_choices": ["20"]}))
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["native_choices"], ["20"])
|
|
|
|
def test_app_request_moves_the_default_and_followers(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": "GE-Proton11-7"}, [TOOL, TOOL_11])
|
|
(self.state / "state.json").write_text(json.dumps({"default": TOOL, "auto": {"10": TOOL}}))
|
|
(self.state / "request.json").write_text(json.dumps({"seq": 7, "valve": True, "dir": "Proton 11.0 (ARM64)"}))
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [("0", TOOL_11), ("10", TOOL_11)])
|
|
self.assertEqual((state["default"], state["source"], state["applied"]), (TOOL_11, "app", 7))
|
|
self.assertEqual(page.mapping["11"], "GE-Proton11-7")
|
|
|
|
def test_a_steam_menu_change_is_mirrored(self):
|
|
page = FakePage({"0": TOOL_11, "10": TOOL}, [TOOL, TOOL_11])
|
|
(self.state / "state.json").write_text(json.dumps({"default": TOOL, "auto": {"10": TOOL}}))
|
|
state = self.reconcile(page)
|
|
self.assertEqual((state["default"], state["source"]), (TOOL_11, "steam"))
|
|
self.assertEqual(page.sets, [("10", TOOL_11), ("11", TOOL_11)])
|
|
|
|
def test_a_tool_the_client_has_not_loaded_waits_for_a_restart(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL}, [TOOL])
|
|
(self.state / "request.json").write_text(json.dumps({"seq": 3, "valve": True, "dir": "Proton 11.0 (ARM64)"}))
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual((state["pending"], state.get("applied", 0)), (TOOL_11, 0))
|
|
self.assertTrue(self.helper.request_waiting())
|
|
|
|
def test_per_game_customize_and_inherit_apply_live(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL_11}, [TOOL, TOOL_11])
|
|
(self.state / "games.json").write_text(json.dumps({
|
|
"version": 1,
|
|
"games": {
|
|
"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"},
|
|
"11": None,
|
|
},
|
|
}))
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [("10", TOOL_11), ("11", TOOL)])
|
|
self.assertEqual(state["auto"], {"11": TOOL})
|
|
|
|
def test_native_arm64_title_drops_auto_proton_once_and_keeps_explicit_choices(self):
|
|
(self.steam / "steamapps/appmanifest_11.acf").unlink()
|
|
(self.state / "state.json").write_text(json.dumps({
|
|
"default": TOOL,
|
|
"auto": {"10": TOOL},
|
|
}))
|
|
page = FakePage({"0": TOOL, "10": TOOL}, [TOOL, TOOL_11])
|
|
original_native_targets = COMPAT["native_targets"]
|
|
COMPAT["native_targets"] = lambda _root, _apps: {"10": None}
|
|
try:
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [("10", "")])
|
|
self.assertEqual(page.mapping["10"], "")
|
|
self.assertEqual(state["auto"], {})
|
|
|
|
page.sets.clear()
|
|
self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
|
|
(self.state / "games.json").write_text(json.dumps({
|
|
"version": 1,
|
|
"games": {"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}},
|
|
}))
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [("10", TOOL_11)])
|
|
self.assertEqual(page.mapping["10"], TOOL_11)
|
|
self.assertEqual(state["auto"], {})
|
|
(self.state / "games.json").unlink()
|
|
|
|
page.sets.clear()
|
|
page.mapping["10"] = "steamlinuxruntime_arm64"
|
|
self.reconcile(page)
|
|
self.assertEqual(page.mapping["10"], "steamlinuxruntime_arm64")
|
|
self.assertEqual(page.sets, [])
|
|
|
|
page.mapping["10"] = TOOL_11
|
|
self.reconcile(page)
|
|
self.assertEqual(page.mapping["10"], TOOL_11)
|
|
self.assertEqual(page.sets, [])
|
|
|
|
page.mapping["10"] = COMPAT["FEX_TOOL"]
|
|
self.reconcile(page)
|
|
self.assertEqual(page.mapping["10"], COMPAT["FEX_TOOL"])
|
|
self.assertEqual(page.sets, [])
|
|
|
|
page.mapping["10"] = "GE-Proton11-7"
|
|
self.reconcile(page)
|
|
self.assertEqual(page.mapping["10"], "GE-Proton11-7")
|
|
self.assertEqual(page.sets, [])
|
|
finally:
|
|
COMPAT["native_targets"] = original_native_targets
|
|
|
|
def test_factorio_native_choice_survives_inherited_live_selection_and_restart(self):
|
|
app = "427520"
|
|
(self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text("")
|
|
config = self.steam / "config/config.vdf"
|
|
config.parent.mkdir(parents=True)
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } } } } } }' % TOOL)
|
|
(self.state / "state.json").write_text(json.dumps({
|
|
"default": TOOL,
|
|
"auto": {app: TOOL},
|
|
}))
|
|
|
|
original_native_targets = COMPAT["native_targets"]
|
|
COMPAT["native_targets"] = lambda _root, apps: {
|
|
app: COMPAT["NATIVE_CHOICE"]
|
|
} if app in apps else {}
|
|
try:
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL, app: "proton"}, [TOOL, TOOL_11])
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["auto"], {})
|
|
self.assertEqual(state["native_choices"], [app])
|
|
self.assertEqual(COMPAT["read_config_mapping"](str(config)), {"0": TOOL})
|
|
|
|
page.sets.clear()
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["native_choices"], [app])
|
|
restarted = LIVE["Helper"](str(self.steam), 1)
|
|
restarted.page = page
|
|
restarted.reconcile()
|
|
state = json.loads((self.state / "state.json").read_text())
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["native_choices"], [app])
|
|
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } '
|
|
'"%s" { "name" "GE-Proton11-7" } } } } } }' % (TOOL, app))
|
|
page.mapping[app] = "GE-Proton11-7"
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.mapping[app], "GE-Proton11-7")
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["native_choices"], [])
|
|
|
|
for choice in ("steamlinuxruntime", COMPAT["FEX_TOOL"], TOOL_11):
|
|
(self.state / "state.json").write_text(json.dumps({
|
|
"default": TOOL,
|
|
"auto": {},
|
|
"native_choices": [app],
|
|
}))
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } '
|
|
'"%s" { "name" "%s" } } } } } }' % (TOOL, app, choice))
|
|
page.mapping[app] = choice
|
|
page.sets.clear()
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.mapping[app], choice)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["native_choices"], [], choice)
|
|
finally:
|
|
COMPAT["native_targets"] = original_native_targets
|
|
|
|
def test_saved_native_choice_survives_live_restart_without_manifest_or_appinfo(self):
|
|
app = "452280"
|
|
config = self.steam / "config/config.vdf"
|
|
config.parent.mkdir(parents=True)
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } } } } } }' % TOOL)
|
|
(self.state / "state.json").write_text(json.dumps({
|
|
"default": TOOL,
|
|
"auto": {},
|
|
"native_choices": [app],
|
|
}))
|
|
|
|
original_native_targets = COMPAT["native_targets"]
|
|
COMPAT["native_targets"] = lambda _root, _apps: {}
|
|
try:
|
|
page = FakePage({"0": TOOL, app: "proton"}, [TOOL, TOOL_11])
|
|
state = self.reconcile(page)
|
|
self.assertNotIn(app, self.helper.installed)
|
|
self.assertEqual(state["native_choices"], [app])
|
|
self.assertNotIn(app, state["auto"])
|
|
self.assertNotIn((app, TOOL), page.sets)
|
|
self.assertEqual(COMPAT["read_config_mapping"](str(config)), {"0": TOOL})
|
|
|
|
config.write_text('"InstallConfigStore" { "Software" { "Other" {} } }')
|
|
state = self.reconcile(page)
|
|
self.assertEqual(state["native_choices"], [app])
|
|
self.assertNotIn((app, TOOL), page.sets)
|
|
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } '
|
|
'"%s" { "name" "GE-Proton11-7" } } } } } }' % (TOOL, app))
|
|
page.mapping[app] = "proton"
|
|
state = self.reconcile(page)
|
|
self.assertEqual(state["native_choices"], [])
|
|
self.assertNotIn((app, TOOL), page.sets)
|
|
self.assertEqual(COMPAT["read_config_mapping"](str(config))[app], "GE-Proton11-7")
|
|
finally:
|
|
COMPAT["native_targets"] = original_native_targets
|
|
|
|
def dual_platform_game(self, state):
|
|
app = "892970"
|
|
(self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text("")
|
|
config = self.steam / "config/config.vdf"
|
|
config.parent.mkdir(parents=True)
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } } } } } }' % TOOL)
|
|
(self.state / "state.json").write_text(json.dumps(state))
|
|
patcher = mock.patch.dict(COMPAT, {"native_targets": lambda _root, apps: {
|
|
app: COMPAT["NATIVE_CHOICE"]
|
|
} if app in apps else {}})
|
|
patcher.start()
|
|
self.addCleanup(patcher.stop)
|
|
return app, FakePage({"0": TOOL, "10": TOOL, "11": TOOL}, [TOOL, TOOL_11])
|
|
|
|
def test_unmapped_dual_platform_game_gets_the_default_live(self):
|
|
app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL}})
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [(app, TOOL)])
|
|
self.assertEqual(state["auto"][app], TOOL)
|
|
self.assertEqual(state["native_choices"], [])
|
|
|
|
page.mapping[app] = ""
|
|
page.sets.clear()
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["native_choices"], [app])
|
|
|
|
def test_clearing_a_tool_picked_in_steam_keeps_the_native_build(self):
|
|
app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL}})
|
|
page.known.append(COMPAT["FEX_TOOL"])
|
|
page.mapping[app] = COMPAT["FEX_TOOL"]
|
|
config = self.steam / "config/config.vdf"
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } "%s" { "name" "%s" } } } } } }' % (TOOL, app, COMPAT["FEX_TOOL"]))
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertNotIn(app, state["auto"])
|
|
|
|
page.mapping[app] = ""
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } } } } } }' % TOOL)
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["native_choices"], [app])
|
|
|
|
restarted = LIVE["Helper"](str(self.steam), 1)
|
|
restarted.page = page
|
|
restarted.reconcile()
|
|
self.assertEqual(page.sets, [])
|
|
|
|
def test_a_new_tool_for_a_picked_game_is_kept_before_the_client_writes_its_config(self):
|
|
app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL}, "picked": ["892970"]})
|
|
page.mapping[app] = TOOL_11
|
|
with mock.patch.dict(COMPAT, {"native_targets": lambda _root, apps: {app: COMPAT["FEX_TOOL"]} if app in apps else {}}):
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(page.mapping[app], TOOL_11)
|
|
self.assertIn(app, state["picked"])
|
|
|
|
def test_a_cleared_picked_game_showing_a_stale_inherited_tool_stays_native(self):
|
|
app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL}, "picked": ["892970"]})
|
|
page.mapping[app] = "proton"
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["native_choices"], [app])
|
|
|
|
def test_a_clear_saved_after_the_helper_stopped_is_kept_at_the_next_start(self):
|
|
app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL}})
|
|
page.known.append(COMPAT["FEX_TOOL"])
|
|
page.mapping[app] = COMPAT["FEX_TOOL"]
|
|
config = self.steam / "config/config.vdf"
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } "%s" { "name" "%s" } } } } } }' % (TOOL, app, COMPAT["FEX_TOOL"]))
|
|
state = self.reconcile(page)
|
|
self.assertIn(app, state["picked"])
|
|
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } } } } } }' % TOOL)
|
|
with mock.patch.dict(COMPAT["register_default"].__globals__, {"native_targets": COMPAT["native_targets"]}):
|
|
COMPAT["register_default"](str(config), ["10", "11", app], settle=True, directory=str(self.state))
|
|
self.assertNotIn(app, COMPAT["read_config_mapping"](str(config)))
|
|
state = json.loads((self.state / "state.json").read_text())
|
|
self.assertEqual(state["native_choices"], [app])
|
|
self.assertNotIn(app, state["picked"])
|
|
|
|
def test_unmapped_dual_platform_game_gets_the_default_without_a_readable_config(self):
|
|
app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL}, "native_choices": ["11"]})
|
|
(self.steam / "config/config.vdf").unlink()
|
|
page.mapping["11"] = ""
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [(app, TOOL)])
|
|
self.assertEqual(state["auto"][app], TOOL)
|
|
self.assertEqual(state["native_choices"], ["11"])
|
|
|
|
def test_a_tool_set_live_is_kept_before_the_client_writes_its_config(self):
|
|
app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL, "892970": TOOL}})
|
|
page.known.append(COMPAT["FEX_TOOL"])
|
|
page.mapping[app] = TOOL
|
|
config = self.steam / "config/config.vdf"
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } "%s" { "name" "%s" } } } } } }' % (TOOL, app, TOOL))
|
|
with mock.patch.dict(COMPAT, {"native_targets": lambda _root, apps: {app: COMPAT["FEX_TOOL"]} if app in apps else {}}):
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [(app, COMPAT["FEX_TOOL"])])
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [(app, COMPAT["FEX_TOOL"])])
|
|
self.assertEqual(state["auto"][app], COMPAT["FEX_TOOL"])
|
|
|
|
def test_native_list_from_earlier_builds_is_not_trusted(self):
|
|
app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL}, "native": ["892970"]})
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [(app, TOOL)])
|
|
self.assertNotIn("native", state)
|
|
self.assertEqual(state["native_choices"], [])
|
|
|
|
def test_factorio_without_prior_auto_state_uses_the_default_proton(self):
|
|
app = "427520"
|
|
(self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text("")
|
|
config = self.steam / "config/config.vdf"
|
|
config.parent.mkdir(parents=True)
|
|
config.write_text(
|
|
'"InstallConfigStore" { "Software" { "Valve" { "Steam" { '
|
|
'"CompatToolMapping" { "0" { "name" "%s" } } } } } }' % TOOL)
|
|
(self.state / "state.json").write_text(json.dumps({"default": TOOL, "auto": {}}))
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL, app: "proton"}, [TOOL, TOOL_11])
|
|
original_native_targets = COMPAT["native_targets"]
|
|
COMPAT["native_targets"] = lambda _root, apps: {
|
|
app: COMPAT["NATIVE_CHOICE"]
|
|
} if app in apps else {}
|
|
try:
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [(app, TOOL)])
|
|
self.assertEqual(state["auto"], {app: TOOL})
|
|
self.assertEqual(state["native_choices"], [])
|
|
self.assertEqual(COMPAT["read_config_mapping"](str(config)), {"0": TOOL})
|
|
finally:
|
|
COMPAT["native_targets"] = original_native_targets
|
|
|
|
def test_missing_per_game_proton_stays_deferred_live(self):
|
|
page = FakePage({"0": TOOL, "10": "GE-Proton9-1", "11": TOOL_11}, [TOOL, TOOL_11])
|
|
(self.state / "games.json").write_text(json.dumps({
|
|
"version": 1,
|
|
"games": {
|
|
"10": {"valve": False, "dir": "GE-Proton9-1"},
|
|
"11": None,
|
|
},
|
|
}))
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [("11", TOOL)])
|
|
self.assertEqual(page.mapping["10"], "GE-Proton9-1")
|
|
self.assertEqual(state["auto"], {"11": TOOL})
|
|
|
|
def games(self):
|
|
return json.loads((self.state / "games.json").read_text())["games"]
|
|
|
|
def write_games(self, games):
|
|
(self.state / "games.json").write_text(json.dumps({"version": 1, "games": games}))
|
|
|
|
def test_a_steam_pick_after_the_app_choice_is_kept_live(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL}, [TOOL, TOOL_11, COMPAT["FEX_TOOL"]])
|
|
self.write_games({"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [("10", TOOL_11)])
|
|
self.assertEqual(state["games_applied"], {"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
|
|
page.sets.clear()
|
|
page.mapping["10"] = COMPAT["FEX_TOOL"]
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(page.mapping["10"], COMPAT["FEX_TOOL"])
|
|
self.assertEqual(self.games(), {})
|
|
self.assertEqual(state["games_applied"], {})
|
|
|
|
self.write_games({"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
self.reconcile(page)
|
|
self.assertEqual(page.sets, [("10", TOOL_11)])
|
|
|
|
def test_a_steam_pick_of_our_proton_becomes_the_app_choice_live(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL}, [TOOL, TOOL_11])
|
|
self.write_games({"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
self.reconcile(page)
|
|
page.sets.clear()
|
|
page.mapping["10"] = TOOL
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(self.games(), {"10": {"valve": True, "dir": "Proton Experimental (ARM64)"}})
|
|
self.assertEqual(state["games_applied"], self.games())
|
|
|
|
def test_use_the_default_applies_once_then_steam_picks_stand_live(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL_11, "11": TOOL}, [TOOL, TOOL_11, COMPAT["FEX_TOOL"]])
|
|
self.write_games({"10": None})
|
|
self.reconcile(page)
|
|
self.assertEqual(page.sets, [("10", TOOL)])
|
|
|
|
page.sets.clear()
|
|
self.reconcile(page)
|
|
self.assertEqual(self.games(), {})
|
|
page.mapping["10"] = COMPAT["FEX_TOOL"]
|
|
self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(page.mapping["10"], COMPAT["FEX_TOOL"])
|
|
|
|
def test_choices_an_earlier_build_applied_give_way_to_steam_picks_live(self):
|
|
(self.state / "state.json").write_text(json.dumps({"default": TOOL, "auto": {"11": TOOL}, "tools": []}))
|
|
self.write_games({"10": None, "11": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
page = FakePage({"0": TOOL, "10": COMPAT["FEX_TOOL"], "11": "steamlinuxruntime_sniper"},
|
|
[TOOL, TOOL_11, COMPAT["FEX_TOOL"]])
|
|
self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(self.games(), {})
|
|
|
|
def test_an_app_choice_written_during_a_sync_is_not_overwritten(self):
|
|
self.write_games({"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
requests, text = COMPAT["read_game_requests"]()
|
|
self.write_games({"10": {"valve": True, "dir": "Proton Experimental (ARM64)"}})
|
|
self.assertFalse(COMPAT["write_game_requests"]({}, text))
|
|
self.assertEqual(self.games(), {"10": {"valve": True, "dir": "Proton Experimental (ARM64)"}})
|
|
|
|
def test_an_app_the_client_briefly_refuses_keeps_its_applied_choice_live(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL}, [TOOL, TOOL_11, COMPAT["FEX_TOOL"]])
|
|
self.write_games({"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
self.reconcile(page)
|
|
page.refused = {"10"}
|
|
state = self.reconcile(page)
|
|
self.assertEqual(state["games_applied"], {"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
page.refused = set()
|
|
page.sets.clear()
|
|
page.mapping["10"] = COMPAT["FEX_TOOL"]
|
|
self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(page.mapping["10"], COMPAT["FEX_TOOL"])
|
|
|
|
def test_an_app_rewriting_its_choices_during_both_tries_applies_none_of_them_live(self):
|
|
page = FakePage({"0": TOOL, "10": TOOL, "11": TOOL}, [TOOL, TOOL_11, COMPAT["FEX_TOOL"]])
|
|
self.write_games({"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
self.reconcile(page)
|
|
page.sets.clear()
|
|
page.mapping["10"] = COMPAT["FEX_TOOL"]
|
|
self.write_games({"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}, "11": None})
|
|
with mock.patch.dict(COMPAT["settled_game_requests"].__globals__, write_game_requests=lambda *_: False):
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [])
|
|
self.assertEqual(state["games_applied"], {"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
|
|
def test_a_steam_pick_is_kept_at_the_next_start(self):
|
|
config = self.steam / "config/config.vdf"
|
|
config.parent.mkdir(parents=True)
|
|
vdf = '"InstallConfigStore" { "Software" { "Valve" { "Steam" { "CompatToolMapping" { %s } } } } }'
|
|
entry = '"%s" { "name" "%s" "config" "" "priority" "250" }'
|
|
catalog = COMPAT["tool_catalog"](str(self.steam))
|
|
self.write_games({"10": {"valve": True, "dir": "Proton 11.0 (ARM64)"}})
|
|
config.write_text(vdf % (entry % ("0", TOOL) + entry % ("10", TOOL)))
|
|
with mock.patch.dict(COMPAT["register_default"].__globals__, steam_running=lambda: False):
|
|
COMPAT["register_default"](str(config), ["10"], catalog=catalog, directory=str(self.state), settle=True)
|
|
self.assertIn(entry % ("10", TOOL_11), " ".join(config.read_text().split()))
|
|
config.write_text(vdf % (entry % ("0", TOOL) + entry % ("10", COMPAT["FEX_TOOL"])))
|
|
COMPAT["register_default"](str(config), ["10"], catalog=catalog, directory=str(self.state), settle=True)
|
|
self.assertIn(entry % ("10", COMPAT["FEX_TOOL"]), " ".join(config.read_text().split()))
|
|
self.assertEqual(self.games(), {})
|
|
|
|
def test_our_default_the_client_does_not_list_survives_to_the_next_start(self):
|
|
build = "DroidDeck-Proton 11-11.4"
|
|
(self.steam / "compatibilitytools.d" / build).mkdir(parents=True)
|
|
(self.steam / "compatibilitytools.d" / build / COMPAT["EXTRA_WRAPPER"]).write_text("")
|
|
(self.state / "state.json").write_text(json.dumps({"default": build, "written": build, "source": "update", "auto": {"10": build}}))
|
|
page = FakePage({"0": TOOL, "10": build}, [TOOL, TOOL_11])
|
|
state = self.reconcile(page)
|
|
self.assertEqual((state["default"], state["source"], state["written"]), (build, "update", TOOL))
|
|
self.assertEqual(page.sets, [("10", TOOL), ("11", TOOL)])
|
|
config = self.steam / "config/config.vdf"
|
|
config.parent.mkdir(parents=True)
|
|
vdf = '"InstallConfigStore" { "Software" { "Valve" { "Steam" { "CompatToolMapping" { %s } } } } }'
|
|
entry = '"%s" { "name" "%s" "config" "" "priority" "250" }'
|
|
config.write_text(vdf % "".join(entry % (app, page.mapping[app]) for app in ("0", "10", "11")))
|
|
with mock.patch.dict(COMPAT["register_default"].__globals__, steam_running=lambda: False):
|
|
default = COMPAT["register_default"](str(config), ["10", "11"], catalog=COMPAT["tool_catalog"](str(self.steam)),
|
|
directory=str(self.state), settle=True)
|
|
self.assertEqual(default, build)
|
|
self.assertEqual(COMPAT["read_config_mapping"](str(config)), {"0": build, "10": build, "11": build})
|
|
|
|
def test_proton_experimental_picked_for_a_game_in_steam_is_kept_and_mirrored(self):
|
|
build = "DroidDeck-Proton 11-12.3"
|
|
(self.steam / "compatibilitytools.d" / build).mkdir(parents=True)
|
|
(self.steam / "compatibilitytools.d" / build / COMPAT["EXTRA_WRAPPER"]).write_text("")
|
|
(self.state / "state.json").write_text(json.dumps(
|
|
{"default": build, "written": build, "source": "update", "auto": {"11": build}, "picked": ["10", "11"], "tools": [],
|
|
"games_applied": {"10": {"valve": False, "dir": build}}}))
|
|
self.write_games({"10": {"valve": False, "dir": build}})
|
|
page = FakePage({"0": build, "10": "proton_experimental", "11": build}, [TOOL, TOOL_11, build, "proton_experimental"])
|
|
state = self.reconcile(page)
|
|
self.assertEqual(page.sets, [("10", TOOL)])
|
|
self.assertEqual(state["auto"], {"11": build})
|
|
self.assertEqual(self.games(), {"10": {"valve": True, "dir": COMPAT["SOURCES"][0]}})
|
|
config = self.steam / "config/config.vdf"
|
|
config.parent.mkdir(parents=True)
|
|
vdf = '"InstallConfigStore" { "Software" { "Valve" { "Steam" { "CompatToolMapping" { %s } } } } }'
|
|
entry = '"%s" { "name" "%s" "config" "" "priority" "250" }'
|
|
config.write_text(vdf % "".join(entry % (app, page.mapping[app]) for app in ("0", "10", "11")))
|
|
with mock.patch.dict(COMPAT["register_default"].__globals__, steam_running=lambda: False):
|
|
default = COMPAT["register_default"](str(config), ["10", "11"], catalog=COMPAT["tool_catalog"](str(self.steam)),
|
|
directory=str(self.state), settle=True)
|
|
self.assertEqual(default, build)
|
|
self.assertEqual(COMPAT["read_config_mapping"](str(config)), {"0": build, "10": TOOL, "11": build})
|
|
page.sets.clear()
|
|
self.write_games({"10": {"valve": True, "dir": COMPAT["SOURCES"][1]}})
|
|
self.reconcile(page)
|
|
self.assertEqual(page.sets, [("10", TOOL_11)])
|
|
|
|
def test_file_mode_defers_to_the_live_helper(self):
|
|
(self.state / "live.pid").write_text("%d\n" % os.getpid())
|
|
self.assertTrue(COMPAT["live_helper_running"]())
|
|
LIVE["detach"]()
|
|
self.assertFalse(COMPAT["live_helper_running"]())
|
|
|
|
|
|
SWITCH_HARNESS = r"""
|
|
const sent = [], asked = [];
|
|
class FakeSocket { send(data) { sent.push(data); } }
|
|
globalThis.window = globalThis;
|
|
globalThis.WebSocket = FakeSocket;
|
|
window.droiddeckSwitchToDesktop = (x) => asked.push(x);
|
|
const install = require("fs").readFileSync(process.argv[2], "utf8");
|
|
const frame = (method) => {
|
|
const name = new TextEncoder().encode(method), h = [0x51, 1, 0, 0, 0, 0, 0, 0, 0, 0x62, name.length, ...name];
|
|
const out = new Uint8Array(8 + h.length), dv = new DataView(out.buffer);
|
|
dv.setUint32(0, (0x80000000 | 146) >>> 0, true); dv.setUint32(4, h.length, true); out.set(h, 8);
|
|
return out;
|
|
};
|
|
if (eval(install) !== "installed" || eval(install) !== "present") throw new Error("install is not idempotent");
|
|
const ws = new FakeSocket();
|
|
ws.send(frame("CompatManager.GetCompatTools#1"));
|
|
ws.send(frame("SteamOSManager.SwitchToDesktop#1").buffer);
|
|
ws.send(frame("SteamOSManager.SwitchToDesktop#1"));
|
|
ws.send("SteamOSManager.SwitchToDesktop#1");
|
|
console.log(JSON.stringify({ sent: sent.length, asked: asked.length }));
|
|
"""
|
|
|
|
|
|
class ToolPage(FakePage):
|
|
def __init__(self, fail=False):
|
|
super().__init__({"0": TOOL}, [TOOL])
|
|
self.calls = []
|
|
self.fail = fail
|
|
|
|
def tools(self, call):
|
|
self.calls.append(call)
|
|
if self.fail:
|
|
raise RuntimeError("the client's install calls are not ready")
|
|
return True
|
|
|
|
|
|
class ToolDownloadTest(unittest.TestCase):
|
|
def setUp(self):
|
|
tmp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(tmp.cleanup)
|
|
self.steam = Path(tmp.name) / "Steam"
|
|
(self.steam / "steamapps").mkdir(parents=True)
|
|
self.helper = LIVE["Helper"](str(self.steam), 1)
|
|
self.now = [1000.0]
|
|
self.running = [False]
|
|
self.requested = []
|
|
patcher = mock.patch.dict(COMPAT, {
|
|
"game_running": lambda: self.running[0],
|
|
"request_fex": lambda root, asked: self.requested.append(root) or ["3127680"],
|
|
})
|
|
patcher.start()
|
|
self.addCleanup(patcher.stop)
|
|
clock = mock.patch.object(LIVE["time"], "monotonic", lambda: self.now[0])
|
|
clock.start()
|
|
self.addCleanup(clock.stop)
|
|
|
|
def manifest(self, app, flags):
|
|
(self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text('"AppState" { "StateFlags" "%s" }' % flags)
|
|
|
|
def test_missing_tools_are_installed_and_deferred_ones_queued(self):
|
|
self.manifest("4427310", "6")
|
|
self.manifest("3127680", "4")
|
|
self.manifest("1628350", "1026")
|
|
self.helper.page = page = ToolPage()
|
|
self.helper.ensure_tools()
|
|
self.assertEqual(page.calls, ["update(4427310)", "update(1628350)", "install(4183110)"])
|
|
self.now[0] += 30
|
|
self.helper.ensure_tools()
|
|
self.now[0] += 60
|
|
self.helper.ensure_tools()
|
|
self.assertEqual(len(page.calls), 3)
|
|
self.now[0] += 300
|
|
self.manifest("4427310", "4")
|
|
self.helper.ensure_tools()
|
|
self.assertEqual(page.calls[3:], ["update(1628350)", "install(4183110)"])
|
|
self.assertEqual(self.requested, [])
|
|
|
|
def test_nothing_is_queued_while_a_game_runs(self):
|
|
self.running[0] = True
|
|
self.helper.page = page = ToolPage()
|
|
self.helper.ensure_tools()
|
|
self.assertEqual(page.calls, [])
|
|
self.running[0] = False
|
|
self.now[0] += 60
|
|
self.helper.ensure_tools()
|
|
self.assertEqual(len(page.calls), 4)
|
|
|
|
def test_an_install_falls_back_to_the_steam_url(self):
|
|
for app in ("4427310", "1628350", "4183110"):
|
|
self.manifest(app, "4")
|
|
self.helper.page = page = ToolPage(fail=True)
|
|
self.helper.ensure_tools()
|
|
self.assertEqual(page.calls, ["install(3127680)"])
|
|
self.assertEqual(self.requested, [str(self.steam)])
|
|
|
|
|
|
@unittest.skipUnless(shutil.which("node"), "node is not installed")
|
|
class SwitchScriptTest(unittest.TestCase):
|
|
def test_the_request_is_reported_and_still_sent(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
script = Path(tmp) / "switch.js"
|
|
script.write_text(LIVE["SWITCH_JS"])
|
|
harness = Path(tmp) / "harness.js"
|
|
harness.write_text(SWITCH_HARNESS)
|
|
result = subprocess.run(["node", str(harness), str(script)], capture_output=True, text=True, timeout=60)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertEqual(json.loads(result.stdout), {"sent": 4, "asked": 2})
|
|
|
|
|
|
class AttachPage:
|
|
def __init__(self, port, path):
|
|
self.calls, self.scripts = [], []
|
|
self.ws = mock.Mock()
|
|
|
|
def evaluate(self, expression, timeout=30):
|
|
self.scripts.append(expression)
|
|
return True
|
|
|
|
def call(self, method, params=None, timeout=30):
|
|
self.calls.append((method, (params or {}).get("name")))
|
|
return {}
|
|
|
|
def compat(self, call):
|
|
return {"selected": "", "fallback": "", "tools": []}
|
|
|
|
|
|
class TourFailurePage(AttachPage):
|
|
def evaluate(self, expression, timeout=30):
|
|
self.scripts.append(expression)
|
|
if expression == LIVE["TOUR_JS"]:
|
|
raise RuntimeError("SteamClient.Settings.SetSetting is unavailable")
|
|
return True
|
|
|
|
|
|
class SwitchToDesktopTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.globals = LIVE["Helper"].attach.__globals__
|
|
patcher = mock.patch.dict(self.globals, {"shared_context": lambda port: "/devtools/page/1", "Page": AttachPage})
|
|
patcher.start()
|
|
self.addCleanup(patcher.stop)
|
|
|
|
def test_only_a_client_without_its_steamos_manager_is_watched(self):
|
|
helper = LIVE["Helper"]("/steam", 1, steamos=False)
|
|
helper.attach()
|
|
self.assertIn(("Runtime.addBinding", LIVE["SWITCH_BINDING"]), helper.page.calls)
|
|
self.assertIn(LIVE["SWITCH_JS"], helper.page.scripts)
|
|
helper = LIVE["Helper"]("/steam", 1, steamos=True)
|
|
helper.attach()
|
|
self.assertNotIn(("Runtime.addBinding", LIVE["SWITCH_BINDING"]), helper.page.calls)
|
|
self.assertNotIn(LIVE["SWITCH_JS"], helper.page.scripts)
|
|
|
|
def test_vr_bridge_is_installed_for_both_steam_ui_modes(self):
|
|
for steamos in (False, True):
|
|
helper = LIVE["Helper"]("/steam", 1, steamos=steamos)
|
|
helper.attach()
|
|
self.assertIn(("Runtime.addBinding", LIVE["VR_BINDING"]), helper.page.calls)
|
|
self.assertIn(LIVE["VR_JS"], helper.page.scripts)
|
|
|
|
def test_missing_optional_tour_setting_does_not_block_attach(self):
|
|
with mock.patch.dict(self.globals, {"shared_context": lambda port: "/devtools/page/1", "Page": TourFailurePage}):
|
|
helper = LIVE["Helper"]("/steam", 1)
|
|
self.assertTrue(helper.attach())
|
|
self.assertIn(LIVE["VR_JS"], helper.page.scripts)
|
|
self.assertIn(LIVE["TOUR_JS"], helper.page.scripts)
|
|
self.assertIsNotNone(helper.page)
|
|
|
|
def test_vr_bridge_accepts_only_steamvr_and_coalesces_requests(self):
|
|
helper = LIVE["Helper"]("/steam", 1)
|
|
helper.page = mock.Mock()
|
|
event = lambda payload: {"method": "Runtime.bindingCalled", "params": {
|
|
"name": LIVE["VR_BINDING"], "payload": payload}}
|
|
with mock.patch.dict(self.globals, {"launch_steamvr": mock.Mock()}) as patched:
|
|
launch = patched["launch_steamvr"]
|
|
helper.page.drain.return_value = [event("0"), event("250820; touch /tmp/wrong"),
|
|
event("-1"), event("01"), event("18446744073709551616"),
|
|
event("\u0661"), event(None), event({})]
|
|
helper.drain()
|
|
launch.assert_not_called()
|
|
helper.page.drain.return_value = [event("250820"), event("250820")]
|
|
helper.drain()
|
|
launch.assert_called_once_with()
|
|
|
|
def test_vr_game_requests_share_an_in_progress_helper_and_retry_after_it_exits(self):
|
|
helper = LIVE["Helper"]("/steam", 1)
|
|
helper.page = mock.Mock()
|
|
event = lambda app: {"method": "Runtime.bindingCalled", "params": {
|
|
"name": LIVE["VR_BINDING"], "payload": app}}
|
|
child = mock.Mock()
|
|
child.poll.return_value = None
|
|
with mock.patch.dict(self.globals, {"launch_steamvr": mock.Mock(return_value=child)}) as patched:
|
|
helper.page.drain.return_value = [event("611670"), event("620980")]
|
|
helper.drain()
|
|
helper.drain()
|
|
patched["launch_steamvr"].assert_called_once_with()
|
|
child.poll.return_value = 0
|
|
helper.drain()
|
|
self.assertEqual(patched["launch_steamvr"].call_count, 2)
|
|
|
|
def test_vr_launch_runs_helper_without_shell_in_background(self):
|
|
with tempfile.TemporaryDirectory() as tmp, mock.patch.dict(os.environ, {"XDG_RUNTIME_DIR": tmp}):
|
|
with mock.patch.object(self.globals["subprocess"], "Popen") as popen:
|
|
LIVE["launch_steamvr"]()
|
|
self.assertEqual(popen.call_args.args, ([LIVE["VR_HELPER"], "launch"],))
|
|
self.assertTrue(popen.call_args.kwargs["start_new_session"])
|
|
self.assertNotIn("shell", popen.call_args.kwargs)
|
|
self.assertTrue((Path(tmp) / "droiddeck-steamvr/library-launch.log").exists())
|
|
|
|
def test_the_request_goes_to_steamos_session_select(self):
|
|
helper = LIVE["Helper"]("/steam", 1)
|
|
helper.page = mock.Mock()
|
|
helper.page.drain.return_value = [
|
|
{"method": "Runtime.bindingCalled", "params": {"name": LIVE["BINDING"], "payload": "1"}},
|
|
{"method": "Runtime.bindingCalled", "params": {"name": LIVE["SWITCH_BINDING"], "payload": ""}},
|
|
]
|
|
with mock.patch.object(self.globals["subprocess"], "call", return_value=0) as call:
|
|
events = helper.drain()
|
|
call.assert_called_once_with(["/usr/bin/steamos-session-select", "plasma"])
|
|
self.assertTrue(any(LIVE["called"](e, LIVE["BINDING"]) for e in events))
|
|
helper.page.drain.return_value = [{"method": "Runtime.bindingCalled", "params": {"name": LIVE["BINDING"]}}]
|
|
with mock.patch.object(self.globals["subprocess"], "call") as call:
|
|
helper.drain()
|
|
call.assert_not_called()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|