Files
DroidDeck/tools/tests/test_recipe.py
T

333 lines
18 KiB
Python

import contextlib
import hashlib
import io
import json
import os
from pathlib import Path
import runpy
import shutil
import subprocess
import sys
import tempfile
import time
import unittest
from test_esync_packs import make_pack, make_tool
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
RECIPE = runpy.run_path(str(BIN / "droiddeck-recipe"))
SYNC = runpy.run_path(str(BIN / "droiddeck-esync"))
GAME_ENV = runpy.run_path(str(BIN / "droiddeck-game-env"))
COMPAT = runpy.run_path(str(BIN / "steam-compatibility"))
DXVK = "files/lib/wine/dxvk"
VKD3D = "files/lib/wine/vkd3d-proton"
PROTON = ("#!/usr/bin/python3\nimport json, os, sys\n"
"print(json.dumps([sys.argv[0], sys.argv[1:], {k: os.environ.get(k) for k in "
"('DXVK_HUD', 'CUSTOM', 'DROIDDECK_RECIPES', 'FEX_TSOENABLED')}]))\n")
def tree_hashes(path):
"""Every entry under `path`, with symlink targets and file contents, for before/after checks."""
result = {}
for folder, dirs, names in os.walk(path):
for name in dirs + names:
full = os.path.join(folder, name)
rel = os.path.relpath(full, path)
if os.path.islink(full):
result[rel] = "-> " + os.readlink(full)
elif os.path.isfile(full):
result[rel] = hashlib.sha256(Path(full).read_bytes()).hexdigest()
else:
result[rel] = "dir"
return result
class RecipeTestCase(unittest.TestCase):
def setUp(self):
self.tmp = Path(tempfile.mkdtemp())
self.addCleanup(shutil.rmtree, self.tmp, True)
self.home = self.tmp / "home"
self.root = self.home / ".local/share/droiddeck-recipes"
self.store = self.root / "store"
self.store.mkdir(parents=True)
self.recipes = self.home / ".config/droiddeck/recipes.json"
self.recipes.parent.mkdir(parents=True)
RECIPE["store_root"].__globals__["ROOT"] = str(self.root)
self.depot = self.make_depot(self.tmp / "steamapps/common/Proton Experimental (ARM64)")
def make_depot(self, depot, line="1789159687 experimental-11.0-20260910b-arm64"):
for arch in ("aarch64-windows", "i386-windows"):
for comp, names in ((DXVK, ("d3d9.dll", "d3d11.dll", "dxgi.dll", "openvr_api_dxvk.dll")),
(VKD3D, ("d3d12.dll", "d3d12core.dll"))):
(depot / comp / arch).mkdir(parents=True, exist_ok=True)
for name in names:
(depot / comp / arch / name).write_bytes(b"valve " + name.encode() + arch.encode())
windows = depot / "files/lib/wine/aarch64-windows"
unix = depot / "files/lib/wine/aarch64-unix"
windows.mkdir(parents=True, exist_ok=True)
unix.mkdir(parents=True, exist_ok=True)
for name in ("libarm64ecfex.dll", "libwow64fex.dll", "kernel32.dll"):
(windows / name).write_bytes(b"valve " + name.encode())
for name in ("libarm64ecfex.so", "libwow64fex.so", "ntdll.so"):
(unix / name).write_bytes(b"valve " + name.encode())
(depot / "files/bin-arm64").mkdir(parents=True, exist_ok=True)
(depot / "files/share/wine").mkdir(parents=True, exist_ok=True)
(depot / "files/share/wine/wine.inf").write_text("inf")
(depot / "version").write_text(line + "\n")
(depot / "proton").write_text(PROTON)
(depot / "proton").chmod(0o755)
return depot
def make_package(self, name, files, complete=True):
package = self.store / name
for rel, data in files.items():
(package / rel).parent.mkdir(parents=True, exist_ok=True)
(package / rel).write_bytes(data)
(package / "files").mkdir(parents=True, exist_ok=True)
if complete:
(package / ".complete").write_text("1\n")
return package
def dxvk_package(self, name="dxvk-2.4-linux", with_i386=True):
files = {DXVK + "/aarch64-windows/d3d11.dll": b"recipe d3d11", DXVK + "/aarch64-windows/dxgi.dll": b"recipe dxgi"}
if with_i386:
files[DXVK + "/i386-windows/d3d11.dll"] = b"recipe d3d11 i386"
return self.make_package(name, files)
def write(self, games, version=1):
self.recipes.write_text(json.dumps({"version": version, "games": games}))
def lookup(self, app="42", env=None):
with contextlib.redirect_stderr(io.StringIO()) as said:
found = RECIPE["lookup"](env if env is not None else {"DROIDDECK_RECIPES": "1"}, app, str(self.recipes))
return found, said.getvalue()
def assemble(self, recipe, app="42"):
command = [str(self.depot / "proton"), "waitforexitandrun", "game.exe"]
with contextlib.redirect_stderr(io.StringIO()) as said:
result = RECIPE["assemble"](command, recipe, app, str(self.root))
return result, said.getvalue()
class LookupTest(RecipeTestCase):
def test_only_the_auto_tool_and_a_listed_game_get_a_recipe(self):
package = self.dxvk_package()
self.write({"42": {"dxvk": str(package)}})
self.assertIsNone(self.lookup(env={})[0])
self.assertIsNone(self.lookup(env={"DROIDDECK_RECIPES": "0"})[0])
self.assertIsNone(self.lookup(app=None)[0])
self.assertIsNone(self.lookup(app="43")[0])
found, _ = self.lookup()
self.assertEqual(found["components"], {"dxvk": os.path.realpath(package)})
self.recipes.unlink()
self.assertEqual(self.lookup(), (None, ""))
def test_a_bad_file_is_no_recipe(self):
for text in ("{broken", json.dumps({"version": 2, "games": {}}), json.dumps([1]), json.dumps({"version": 1, "games": []})):
self.recipes.write_text(text)
found, said = self.lookup()
self.assertIsNone(found)
self.assertIn("stock Proton", said)
def test_packages_must_be_complete_and_in_the_store(self):
outside = self.tmp / "elsewhere"
(outside / "files").mkdir(parents=True)
(outside / ".complete").write_text("1")
partial = self.make_package("vkd3d-partial", {VKD3D + "/aarch64-windows/d3d12.dll": b"x"}, complete=False)
link = self.store / "escape"
os.symlink(outside, link)
self.write({"42": {"dxvk": str(outside), "vkd3d": str(partial), "fex": str(link)}})
found, _ = self.lookup()
self.assertEqual(found["components"], {})
self.assertEqual(found["skipped"], ["dxvk", "vkd3d", "fex"])
self.write({"42": {"dxvk": "relative/path", "fex": 7}})
self.assertEqual(self.lookup()[0]["skipped"], ["dxvk", "fex"])
def test_environment_is_limited_to_tuning_variables(self):
allowed = {"DXVK_HUD": "version", "VKD3D_FEATURE_LEVEL": "12_1", "FEX_TSOENABLED": "1", "MESA_SHADER_CACHE_MAX_SIZE": "1G",
"PROTON_USE_WINED3D": "1", "mesa_glthread": "true", "WINEDLLOVERRIDES": "xinput1_3=n,b;d3dx9_43=n;libsentry=d;dinput8="}
denied = {"LD_PRELOAD": "/x.so", "WINEDLLPATH": "/x", "PROTON_LOG_DIR": "/x", "DXVK_CONFIG_FILE": "/x",
"VKD3D_SHADER_CACHE_PATH": "/x", "MESA_SHADER_CACHE_DIR": "/x", "FEX_ROOTFS": "/x", "FEX_THUNKHOSTLIBS": "/x",
"PATH": "/x", "HOME": "/x", "CUSTOM": "x", "DXVK_HUD2": "a\0b", "BAD-NAME": "x"}
self.write({"42": {"env": {**allowed, **denied}}})
found, said = self.lookup()
self.assertEqual(found["env"], allowed)
for name in denied:
self.assertIn(name, said)
for value in ("../evil.dll=n", "a=n;b=x", "a=native", "a"):
self.assertFalse(RECIPE["env_allowed"]("WINEDLLOVERRIDES", value), value)
self.assertFalse(RECIPE["env_allowed"]("DXVK_HUD", "x" * 8193))
self.assertFalse(RECIPE["env_allowed"]("DXVK_HUD", 1))
class TreeTest(RecipeTestCase):
def test_the_tree_links_the_depot_and_replaces_only_the_component(self):
before = tree_hashes(self.depot)
package = self.dxvk_package()
self.write({"42": {"dxvk": str(package), "note": "test"}})
command, said = self.assemble(self.lookup()[0])
dist = Path(command[0]).parent
self.assertEqual(command[1:], ["waitforexitandrun", "game.exe"])
self.assertEqual(dist.parent, self.root / "dist")
self.assertEqual(os.readlink(dist / "proton"), str(self.depot / "proton"))
self.assertEqual(os.readlink(dist / "files/share"), str(self.depot / "files/share"))
self.assertTrue((dist / VKD3D).is_symlink())
arm = dist / DXVK / "aarch64-windows"
self.assertFalse(arm.is_symlink())
real = Path(os.path.realpath(package))
self.assertEqual({p.name: os.readlink(p) for p in arm.iterdir()}, {
"d3d11.dll": str(real / DXVK / "aarch64-windows/d3d11.dll"),
"dxgi.dll": str(real / DXVK / "aarch64-windows/dxgi.dll"),
"openvr_api_dxvk.dll": str(self.depot / DXVK / "aarch64-windows/openvr_api_dxvk.dll"),
})
self.assertNotIn("d3d9.dll", os.listdir(arm))
self.assertEqual((dist / DXVK / "i386-windows/d3d11.dll").read_bytes(), b"recipe d3d11 i386")
self.assertEqual((dist / "files/lib/wine/aarch64-unix/ntdll.so").read_bytes(), b"valve ntdll.so")
self.assertIn("app 42: DXVK dxvk-2.4-linux, VKD3D stock, FEX stock, env 0 (test)", said)
self.assertEqual(tree_hashes(self.depot), before)
log = (self.root / "launches.log").read_text().splitlines()
self.assertEqual(log[-1].split("\t")[1:], ["42", "DXVK dxvk-2.4-linux, VKD3D stock, FEX stock, env 0 (test)"])
def test_fex_replaces_its_four_files_even_when_the_package_has_no_unix_half(self):
package = self.make_package("fex-2607", {"files/lib/wine/aarch64-windows/libarm64ecfex.dll": b"fex ec",
"files/lib/wine/aarch64-windows/libwow64fex.dll": b"fex wow"})
self.write({"42": {"fex": str(package)}})
dist = Path(self.assemble(self.lookup()[0])[0][0]).parent
windows = dist / "files/lib/wine/aarch64-windows"
unix = dist / "files/lib/wine/aarch64-unix"
self.assertEqual((windows / "libarm64ecfex.dll").read_bytes(), b"fex ec")
self.assertEqual(os.readlink(windows / "kernel32.dll"), str(self.depot / "files/lib/wine/aarch64-windows/kernel32.dll"))
self.assertEqual(sorted(os.listdir(unix)), ["ntdll.so"])
self.assertTrue((dist / DXVK).is_symlink())
def test_the_same_inputs_reuse_the_tree_and_changes_make_a_new_one(self):
package = self.dxvk_package()
self.write({"42": {"dxvk": str(package)}})
recipe = self.lookup()[0]
first = self.assemble(recipe)[0][0]
marker = Path(first).parent / "marker"
marker.write_text("kept")
self.assertEqual(self.assemble(recipe)[0][0], first)
self.assertTrue(marker.exists())
(self.depot / "version").write_text("1789999999 experimental-11.0-20261001-arm64\n")
updated = self.assemble(recipe)[0][0]
self.assertNotEqual(updated, first)
os.utime(package / ".complete", (time.time() + 5, time.time() + 5))
self.assertNotEqual(self.assemble(recipe)[0][0], updated)
def test_a_recipe_without_packages_or_with_a_failure_is_the_stock_command(self):
stock = [str(self.depot / "proton"), "waitforexitandrun", "game.exe"]
self.write({"42": {"env": {"DXVK_HUD": "fps"}}})
command, said = self.assemble(self.lookup()[0])
self.assertEqual(command, stock)
self.assertIn("env 1", said)
self.assertFalse((self.root / "dist").exists())
package = self.dxvk_package()
self.write({"42": {"dxvk": str(package), "vkd3d": str(self.store / "missing")}})
recipe = self.lookup()[0]
self.assertIn("VKD3D stock (package missing)", self.assemble(recipe)[1])
shutil.rmtree(package)
command, said = self.assemble(recipe)
self.assertEqual(command, stock)
self.assertIn("tree not assembled", said)
def test_old_trees_are_collected(self):
package = self.dxvk_package()
self.write({"42": {"dxvk": str(package)}})
recipe = self.lookup()[0]
dist = Path(self.assemble(recipe)[0][0]).parent
folder = dist.parent
stale = folder / "0123456789abcdef"
stale.mkdir()
temp = folder / ".0123.tmp-1"
temp.mkdir()
fresh_temp = folder / ".4567.tmp-2"
fresh_temp.mkdir()
old = time.time() - RECIPE["DIST_AGE"] - 10
for path in (stale, dist, temp):
os.utime(path, (old, old))
RECIPE["collect"](str(folder), keep=dist.name)
self.assertFalse(stale.exists())
self.assertFalse(temp.exists())
self.assertTrue(fresh_temp.exists())
self.assertTrue(dist.exists())
class EsyncCompositionTest(RecipeTestCase):
def test_esync_builds_its_tree_on_top_of_the_recipes(self):
self.make_depot(self.tmp / "valve/Proton Experimental (ARM64)")
depot = make_tool(self.tmp / "valve", "Proton Experimental (ARM64)")
esync = self.home / ".local/share/droiddeck-esync"
esync.mkdir(parents=True)
pack = make_pack(esync, depot, "valve-experimental-r1")
package = self.dxvk_package()
self.write({"42": {"dxvk": str(package)}})
with contextlib.redirect_stderr(io.StringIO()):
command = RECIPE["assemble"]([str(depot / "proton"), "waitforexitandrun", "game.exe"], self.lookup()[0], "42", str(self.root))
chosen, env = SYNC["select"](command, {"HOME": str(self.home), "STEAM_COMPAT_DATA_PATH": "/compatdata/42",
"BL_SYNC_FALLBACK": "1", "BL_SYNC_MIN_NOFILE": "1"})
final = Path(chosen[0]).parent
self.assertEqual(final.parent, esync / "dist")
self.assertEqual(env["BL_SYNC_PACK"], pack["id"])
self.assertEqual((final / DXVK / "aarch64-windows/d3d11.dll").read_bytes(), b"recipe d3d11")
self.assertEqual((final / SYNC["NTDLL"]).read_bytes(), b"patched ntdll " + pack["id"].encode())
self.assertEqual((final / "files/lib/wine/aarch64-windows/libarm64ecfex.dll").read_bytes(), b"valve libarm64ecfex.dll")
self.assertIn("winevulkan.so", os.listdir(final / "files/lib/wine/aarch64-unix"))
self.assertIn("msidb", os.listdir(final / "files/bin-arm64"))
def test_esyncs_directories_are_real_in_the_recipe_tree(self):
# On the device a guest opendir() through a directory symlink fails (proot's fast path), so
# esync must find every directory it lists already real in this tree.
self.assertEqual(RECIPE["ESYNC_DIRS"], SYNC["REAL_DIRS"])
(self.depot / "files/bin-arm64/wineserver").write_bytes(b"server")
package = self.dxvk_package()
self.write({"42": {"dxvk": str(package)}})
dist = Path(self.assemble(self.lookup()[0])[0][0]).parent
for rel in SYNC["REAL_DIRS"]:
self.assertTrue((dist / rel).is_dir() and not (dist / rel).is_symlink(), rel)
self.assertEqual(os.readlink(dist / "files/bin-arm64/wineserver"), str(self.depot / "files/bin-arm64/wineserver"))
class LaunchTest(RecipeTestCase):
def test_the_auto_launcher_reaches_proton_through_the_recipe_tree(self):
steam = self.tmp / "Steam"
depot = self.make_depot(steam / "steamapps/common" / COMPAT["SOURCES"][0])
tools = steam / "compatibilitytools.d"
package = self.dxvk_package()
self.write({"42": {"dxvk": str(package), "env": {"DXVK_HUD": "version", "FEX_TSOENABLED": "0"}}})
config = self.home / ".config/droiddeck/game-environment.json"
config.write_text(json.dumps({"version": 1, "shared": {"CUSTOM": "shared", "DXVK_HUD": "fps"},
"games": {"42": {"FEX_TSOENABLED": "1"}}}))
outputs = {}
for name in (COMPAT["TOOL"], COMPAT["RECIPE_TOOL"]):
COMPAT["build_tool"](str(tools / name), str(depot), COMPAT["SOURCES"], name)
wrapper = tools / name / COMPAT["LAUNCHER"]
wrapper.write_text(wrapper.read_text().replace("/usr/local/bin/droiddeck-game-env", str(BIN / "droiddeck-game-env")))
for prefix in ("/compatdata/42", "/compatdata/0"):
result = subprocess.run([str(wrapper), "waitforexitandrun", "game.exe"], text=True, capture_output=True,
env={"PATH": os.defpath, "HOME": str(self.home), "STEAM_COMPAT_DATA_PATH": prefix,
"STEAM_COMPAT_CLIENT_INSTALL_PATH": str(steam)})
self.assertEqual(result.returncode, 0, result.stderr)
outputs[name, prefix] = (json.loads(result.stdout), result.stderr)
(argv0, args, env), said = outputs[COMPAT["RECIPE_TOOL"], "/compatdata/42"]
self.assertEqual(Path(argv0).parent.parent, self.root / "dist")
self.assertEqual(args, ["waitforexitandrun", "game.exe"])
self.assertEqual(env, {"DXVK_HUD": "version", "CUSTOM": "shared", "DROIDDECK_RECIPES": None, "FEX_TSOENABLED": "1"})
self.assertIn("droiddeck-recipe: app 42: DXVK dxvk-2.4-linux", said)
for key in ((COMPAT["TOOL"], "/compatdata/42"), (COMPAT["TOOL"], "/compatdata/0"), (COMPAT["RECIPE_TOOL"], "/compatdata/0")):
(argv0, _, env), said = outputs[key]
self.assertEqual(argv0, str(depot / "proton"), key)
self.assertIsNone(env["DROIDDECK_RECIPES"], key)
self.assertNotIn("droiddeck-recipe", said, key)
self.assertEqual(outputs[COMPAT["TOOL"], "/compatdata/42"][0][2]["DXVK_HUD"], "fps")
def test_recipe_variables_join_the_automatic_fixes(self):
fixes = {"WINEDLLOVERRIDES": "libsentry=d", "FEX_MULTIBLOCK": "0"}
merged = GAME_ENV["recipe_fixes"](fixes, {"WINEDLLOVERRIDES": "xinput1_3=n", "FEX_MULTIBLOCK": "1"})
self.assertEqual(merged, {"WINEDLLOVERRIDES": "libsentry=d;xinput1_3=n", "FEX_MULTIBLOCK": "1"})
self.assertEqual(fixes["FEX_MULTIBLOCK"], "0")
if __name__ == "__main__":
unittest.main()