merge main into feat/native-userland-no-proot

This commit is contained in:
Kurt Himebauch committed 2026-11-09 12:39:42 -05:00
commit 507ccc6655
36 files changed
+1295 -67

No files matched your search

+24
View File
@@ -398,6 +398,30 @@ class DroiddeckctlTest(FakeAdbTest):
self.assertEqual(4, code)
self.assertEqual("NO_FRAMES", out["error"]["code"])
def test_provider_call_falls_back_to_a_broadcast_without_content(self):
calls = []
answers = iter([b"", b'{"ok": true, "command": "state"}'])
def adb(_adb, _serial, *args, timeout=30):
calls.append(args)
if args[:2] == ("shell", "content"):
return ctl.subprocess.CompletedProcess(args, 127, b"", b"/system/bin/sh: content: inaccessible or not found")
if args[:2] == ("shell", "am"):
return ctl.subprocess.CompletedProcess(args, 0, b"Broadcast completed: result=0", b"")
if args[:2] == ("shell", "pidof " + ctl.PACKAGE):
return ctl.subprocess.CompletedProcess(args, 0, b"4940\n", b"")
return ctl.subprocess.CompletedProcess(args, 0, next(answers), b"")
with unittest.mock.patch.object(ctl, "run_adb", adb), unittest.mock.patch.object(ctl.time, "sleep"):
answer = ctl.provider_call("adb", "fake-1", "state", arg="a b", request={"x": 1})
self.assertEqual({"ok": True, "command": "state"}, answer)
broadcast = next(c for c in calls if c[:2] == ("shell", "am"))
self.assertEqual(("shell", "am", "broadcast", "-a", ctl.PACKAGE + ".AGENT_CALL", "-p", ctl.PACKAGE), broadcast[:7])
self.assertIn("'a b'", broadcast)
self.assertEqual(ctl.encode_request({"x": 1}), broadcast[broadcast.index("request") + 1])
call_id = broadcast[broadcast.index("id") + 1]
self.assertIn("agent-calls/%s.json" % call_id, calls[-1][1])
def test_pacing_turns_timestats_off_when_the_dump_fails(self):
calls = []
+40
View File
@@ -902,6 +902,46 @@ class GameEnvironmentTest(unittest.TestCase):
self.assertEqual(MODULE["apply_config"](env, config, "42")["TU_DEBUG"], "sysmem")
self.assertNotIn("TU_DEBUG", MODULE["apply_config"](env, config, "43"))
def test_a_chromium_app_keeps_the_sessions_turnip_debug(self):
gpu = MODULE["game_gpu"]
self.assertEqual(gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "", "KEEP": "1"}, True),
{"TU_DEBUG": "sysmem", "KEEP": "1"})
self.assertEqual(gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "nolrz"}, True), {"TU_DEBUG": "sysmem"})
self.assertEqual(gpu({"TU_DEBUG": "sysmem"}, True), {"TU_DEBUG": "sysmem"})
def test_chromium_files_are_found_four_levels_deep_and_no_further(self):
chromium = MODULE["chromium_app"]
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp) / "app"
(root / "usr/lib/tool").mkdir(parents=True)
(root / "usr/lib/tool/libtool.so").write_bytes(b"")
self.assertFalse(chromium(str(root)))
for name in ("chrome-sandbox", "chrome_100_percent.pak", "v8_context_snapshot.bin"):
found = root / "a/b/c" / name
found.parent.mkdir(parents=True, exist_ok=True)
found.write_bytes(b"")
self.assertTrue(chromium(str(root)), name)
found.unlink()
deep = root / "a/b/c/d/chrome-sandbox"
deep.parent.mkdir(parents=True)
deep.write_bytes(b"")
self.assertFalse(chromium(str(root)))
self.assertFalse(chromium(str(Path(tmp) / "missing")))
def test_chromium_detection_does_not_follow_links_inside_the_app(self):
chromium = MODULE["chromium_app"]
with tempfile.TemporaryDirectory() as tmp:
other = Path(tmp) / "other"
other.mkdir()
(other / "chrome-sandbox").write_bytes(b"")
root = Path(tmp) / "app"
root.mkdir()
(root / "linked").symlink_to(other, target_is_directory=True)
self.assertFalse(chromium(str(root)))
link = Path(tmp) / "app-link"
link.symlink_to(other, target_is_directory=True)
self.assertTrue(chromium(str(link)))
def test_the_vram_cap_comes_before_the_games_own_dxvk_settings(self):
cap = MODULE["vram_cap"]
self.assertEqual(cap({"BL_VRAM_MB": "4096"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4096")
+98
View File
@@ -0,0 +1,98 @@
import os
import runpy
import shutil
import subprocess
import sys
import tempfile
import unittest
from pathlib import Path
BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin"
KEYS = ("TU_DEBUG", "DROIDDECK_GAME_TU_DEBUG")
SESSION = {"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": ""}
class GameGpuLaunchersTest(unittest.TestCase):
def setUp(self):
self.tmp = Path(tempfile.mkdtemp())
self.addCleanup(shutil.rmtree, self.tmp, True)
self.out = self.tmp / "env"
self.tools = self.tmp / "tools"
self.tools.mkdir()
self.app = self.tmp / "deploy"
(self.app / "files/bin").mkdir(parents=True)
self.report = self.tools / "report"
self.report.write_text("#!/bin/sh\nfor k in %s; do eval \"echo $k=\\${$k-unset}\"; done > %s\n"
% (" ".join(KEYS), self.out))
self.report.chmod(0o755)
flatpak = self.tools / "flatpak"
flatpak.write_text("#!/bin/sh\n"
"if [ \"$1\" = info ]; then [ \"$3\" = org.example.App ] && echo %s; exit 0; fi\n"
"exec %s\n" % (self.app, self.report))
flatpak.chmod(0o755)
def chromium(self):
(self.app / "files/lib/browser").mkdir(parents=True)
(self.app / "files/lib/browser/chrome_100_percent.pak").write_bytes(b"")
def run_env(self, command, session):
env = {k: v for k, v in os.environ.items() if k not in KEYS + ("DBUS_SESSION_BUS_ADDRESS", "GAMESCOPE_WAYLAND_DISPLAY")}
env.update(session, PATH="%s:%s" % (self.tools, env.get("PATH", "/usr/bin:/bin")),
DBUS_SESSION_BUS_ADDRESS="unix:path=/dev/null")
result = subprocess.run(command, env=env, capture_output=True, text=True, timeout=30)
self.assertEqual(0, result.returncode, result.stderr)
return dict(line.split("=", 1) for line in self.out.read_text().splitlines())
def wrapper(self, *args, session=SESSION):
return self.run_env([sys.executable, str(BIN / "droiddeck-game-gpu"), *args, "--", str(self.report)], session)
def flatpak(self, session=SESSION):
return self.run_env(["bash", str(BIN / "droiddeck-flatpak-run"), "--command=app", "org.example.App"], session)
def test_the_wrapper_gives_a_program_the_game_setting(self):
self.assertEqual({"TU_DEBUG": "unset", "DROIDDECK_GAME_TU_DEBUG": "unset"}, self.wrapper())
self.assertEqual("gmem", self.wrapper(session={"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "gmem"})["TU_DEBUG"])
def test_the_wrapper_keeps_the_session_setting_for_chromium(self):
self.assertEqual({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "unset"}, self.wrapper("--chromium"))
self.assertEqual("unset", self.wrapper("--for", str(self.app / "files"))["TU_DEBUG"])
self.chromium()
self.assertEqual("sysmem", self.wrapper("--for", str(self.app / "files"))["TU_DEBUG"])
def test_without_the_game_setting_the_wrapper_changes_nothing(self):
self.assertEqual("sysmem", self.wrapper(session={"TU_DEBUG": "sysmem"})["TU_DEBUG"])
self.assertEqual("unset", self.wrapper(session={})["TU_DEBUG"])
def test_the_wrapper_reports_a_missing_program(self):
result = subprocess.run([sys.executable, str(BIN / "droiddeck-game-gpu"), "--", str(self.tmp / "missing")],
capture_output=True, text=True, timeout=30)
self.assertEqual(127, result.returncode)
self.assertEqual(2, subprocess.run([sys.executable, str(BIN / "droiddeck-game-gpu")], capture_output=True,
timeout=30).returncode)
def test_a_flatpak_app_gets_the_game_setting(self):
self.assertEqual({"TU_DEBUG": "unset", "DROIDDECK_GAME_TU_DEBUG": "unset"}, self.flatpak())
self.assertEqual("nolrz", self.flatpak({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "nolrz"})["TU_DEBUG"])
def test_a_chromium_flatpak_keeps_the_session_setting(self):
self.chromium()
self.assertEqual({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "unset"}, self.flatpak())
def test_a_flatpak_without_the_game_setting_is_unchanged(self):
self.assertEqual("sysmem", self.flatpak({"TU_DEBUG": "sysmem"})["TU_DEBUG"])
def test_a_snap_gets_the_game_setting_unless_it_is_chromium(self):
try:
snap_run = runpy.run_path(str(BIN / "droiddeck-snap-run"))
except ImportError:
self.skipTest("PyYAML is not installed")
gpu = snap_run["game_gpu"]
snap = self.app / "files"
self.assertEqual({"KEEP": "1"}, gpu(dict(SESSION, KEEP="1"), str(snap)))
self.assertEqual({"TU_DEBUG": "nolrz"}, gpu({"TU_DEBUG": "sysmem", "DROIDDECK_GAME_TU_DEBUG": "nolrz"}, str(snap)))
self.chromium()
self.assertEqual({"TU_DEBUG": "sysmem"}, gpu(dict(SESSION), str(snap)))
if __name__ == "__main__":
unittest.main()
+26 -1
View File
@@ -229,9 +229,34 @@ echo "backoff:$_bl_tier_backoff"
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
_bl_tier_backoff=300
SECONDS=0; bl_session_pressure
swap=0
SECONDS=20; bl_session_pressure
SECONDS=30; bl_session_pressure
'''))
def test_nearly_out_of_memory_still_backs_off_when_the_game_reads_its_pageout_back(self):
self.memory(available=512)
self.assertEqual(['send:1:game', 'backoff:60', 'send:1:game'], self.run_policy('''
SECONDS=0; bl_session_pressure
swap=0
SECONDS=30; bl_session_pressure
echo "backoff:$_bl_tier_backoff"
SECONDS=59; bl_session_pressure
SECONDS=60; bl_session_pressure
SECONDS=90; bl_session_pressure
'''))
def test_nearly_out_of_memory_retries_a_skipped_pageout_after_30_seconds(self):
self.memory(available=512)
self.assertEqual(['send:1:game', 'send:1:game'], self.run_policy('''
SECONDS=0; bl_session_pressure
swap=0
SECONDS=30; bl_session_pressure
_bl_tier_backoff=300
saved=$rss; rss=$((128 * 1024))
SECONDS=330; bl_session_pressure
rss=$saved
SECONDS=359; bl_session_pressure
SECONDS=360; bl_session_pressure
'''))
def test_small_swap_headroom_skips_the_pageout(self):
+64
View File
@@ -118,6 +118,7 @@ PROGRAM = r"""
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/uio.h>
#include <sys/wait.h>
#include <unistd.h>
@@ -317,6 +318,8 @@ static void *ordinary_traffic(void *argument) {
probe_end(counts);
require(counts[0] == 0, "ordinary setup avoids netlink lock");
int pipes[2];
require(pipe(pipes) == 0, "ordinary pipe setup");
probe_begin(0);
const int rounds = 32;
for (int round = 0; round < rounds; round++) {
@@ -338,6 +341,15 @@ static void *ordinary_traffic(void *argument) {
message.msg_name = &source;
message.msg_namelen = sizeof(source);
require(recvmsg(server, &message, 0) == 1 && buffer == 'z', "ordinary recvmsg");
require(write(client, "w", 1) == 1, "ordinary write");
require(read(server, &buffer, 1) == 1 && buffer == 'w', "ordinary read");
char pair[2];
struct iovec pieces[2] = {{.iov_base = "v", .iov_len = 1}, {.iov_base = "u", .iov_len = 1}};
require(writev(client, pieces, 2) == 2, "ordinary writev");
require(recv(server, pair, 2, MSG_WAITALL) == 2 && pair[0] == 'v' && pair[1] == 'u',
"ordinary writev data");
require(write(pipes[1], "p", 1) == 1 && read(pipes[0], &buffer, 1) == 1 && buffer == 'p',
"ordinary pipe");
length = sizeof(source);
require(getpeername(client, (struct sockaddr *)&source, &length) == 0, "ordinary peer");
const int options[] = {SO_TYPE, SO_DOMAIN, SO_PROTOCOL};
@@ -368,6 +380,8 @@ static void *ordinary_traffic(void *argument) {
require(counts[2] == (unsigned)rounds, "ordinary traffic has only requested getpeername");
require(counts[3] == 0, "ordinary traffic avoids restoration fstat");
require(counts[4] == (unsigned)rounds * 3, "ordinary socket options use one syscall each");
close(pipes[0]);
close(pipes[1]);
close(client);
close(server);
if (server != listener) close(listener);
@@ -798,6 +812,52 @@ static void connect_test(void) {
close(descriptor);
}
static ssize_t link_reply(int descriptor, const char *path, unsigned char *buffer, size_t capacity) {
struct {
struct nlmsghdr header;
struct ifinfomsg info;
} query = {
.header = {.nlmsg_len = sizeof(query), .nlmsg_type = RTM_GETLINK,
.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK, .nlmsg_seq = 42},
.info = {.ifi_index = 1}
};
struct iovec parts[2] = {{.iov_base = &query.header, .iov_len = sizeof(query.header)},
{.iov_base = &query.info, .iov_len = sizeof(query.info)}};
struct msghdr message = {.msg_iov = parts, .msg_iovlen = 2};
ssize_t sent;
if (!strcmp(path, "send")) sent = send(descriptor, &query, sizeof(query), 0);
else if (!strcmp(path, "sendmsg")) sent = sendmsg(descriptor, &message, 0);
else if (!strcmp(path, "write")) sent = write(descriptor, &query, sizeof(query));
else sent = writev(descriptor, parts, 2);
require(sent == sizeof(query), path);
ssize_t received = read(descriptor, buffer, capacity);
require(received > 0, "read reply");
return received;
}
static void write_test(void) {
const char *paths[] = {"send", "sendmsg", "write", "writev"};
unsigned char expected[4096];
int descriptor = route_socket();
ssize_t expected_length = link_reply(descriptor, paths[0], expected, sizeof(expected));
struct nlmsghdr *header = (struct nlmsghdr *)expected;
require(header->nlmsg_type == RTM_NEWLINK && header->nlmsg_seq == 42
&& header->nlmsg_pid == port_of(descriptor), "send reply");
require(expected_length > (ssize_t)NLMSG_ALIGN(header->nlmsg_len), "acknowledged reply");
struct nlmsghdr *acknowledgement = (struct nlmsghdr *)(expected + NLMSG_ALIGN(header->nlmsg_len));
require(acknowledgement->nlmsg_type == NLMSG_ERROR
&& ((struct nlmsgerr *)NLMSG_DATA(acknowledgement))->error == 0, "send acknowledgement");
for (size_t index = 1; index < sizeof(paths) / sizeof(paths[0]); index++) {
unsigned char buffer[4096];
ssize_t length = link_reply(descriptor, paths[index], buffer, sizeof(buffer));
require(length == expected_length, "reply length");
require(!memcmp(buffer, expected, length), "reply bytes");
}
require(recv(descriptor, expected, sizeof(expected), MSG_DONTWAIT) == -1 && errno == EAGAIN,
"no extra replies");
close(descriptor);
}
static void receive_test(void) {
int descriptor = route_socket();
send_link(descriptor, 1, 0);
@@ -985,6 +1045,7 @@ int main(int argc, char **argv) {
else if (!strcmp(argv[1], "nonblocking")) send_timeout_test(1);
else if (!strcmp(argv[1], "connect")) connect_test();
else if (!strcmp(argv[1], "receive")) receive_test();
else if (!strcmp(argv[1], "write")) write_test();
else if (!strcmp(argv[1], "replace")) replacement_test(0);
else if (!strcmp(argv[1], "raw_replace")) replacement_test(1);
else if (!strcmp(argv[1], "shared")) shared_test(0);
@@ -1160,6 +1221,9 @@ class NetlinkPreloadTest(unittest.TestCase):
def test_kernel_connect_and_disconnect(self):
self.run_program("connect")
def test_write_and_writev_requests_get_the_same_replies_as_send(self):
self.run_program("write")
def test_receive_sources_and_truncation(self):
self.run_program("receive")
+109 -5
View File
@@ -14,17 +14,30 @@ class PrDiscordTest(unittest.TestCase):
self.discord.request.return_value = {"id": "1557547293375332465"}
self.github = patch.object(module, "github").start()
self.addCleanup(patch.stopall)
self.github.side_effect = lambda path, method="GET", body=None: self.pull if "/pulls/" in path else self.comment
def github_request(path, method="GET", body=None):
if "/pulls/" in path:
return self.pull
if "/commits/" in path:
return {"commit": {"message": "Fix reconnect behavior\n\nMore details"}}
if path.endswith("/issues/comments/10"):
if method == "PATCH":
self.comment["body"] = body["body"]
return self.comment
return self.comment
self.github.side_effect = github_request
patch.object(module, "report_comment", return_value=self.comment).start()
def publish(self):
module.sync("publish", "Droid-Deck/DroidDeck", "410", self.discord, "a" * 40,
def publish(self, sha=None):
if sha is not None:
self.pull["head"]["sha"] = sha
sha = sha or "a" * 40
module.sync("publish", "Droid-Deck/DroidDeck", "410", self.discord, sha,
"https://github.com/Droid-Deck/DroidDeck-CI/releases/download/pr-410/build.apk",
"https://github.com/Droid-Deck/DroidDeck-CI/releases/tag/pr-410")
def save_state(self):
self.comment["body"] += '\n<!-- droiddeck-discord: ' + json.dumps({
"webhook_id": self.discord.id, "message_id": "1557547293375332465"}) + ' -->'
"webhook_id": self.discord.id, "message_id": "1557547293375332465", "sha": "a" * 40}) + ' -->'
def test_create_confirmed_message_and_persist_reference(self):
self.publish()
@@ -36,12 +49,76 @@ class PrDiscordTest(unittest.TestCase):
self.assertEqual("1557547293375332465", module.saved_message(saved, self.discord.id))
self.assertIn("Build download", saved)
def test_new_build_updates_existing_message(self):
def test_same_build_updates_existing_message_without_duplicate(self):
self.save_state()
self.publish()
self.assertEqual("PATCH", self.discord.request.call_args.args[0])
saved = self.github.call_args.args[2]["body"]
self.assertEqual(1, len(module.STATE.findall(saved)))
self.assertIn('"sha": "' + "a" * 40 + '"', saved)
def test_new_commit_retires_old_message_and_posts_replacement(self):
self.save_state()
old_content = module.build_content("Droid-Deck/DroidDeck", "410", self.pull["title"], "a" * 40,
"apk", "release")
self.discord.request.side_effect = [
{"content": old_content}, {"id": "1557547293375332465"}, {"id": "1557547293375332466"}]
self.publish("b" * 40)
calls = self.discord.request.call_args_list
self.assertEqual(["GET", "PATCH", "POST"], [call.args[0] for call in calls])
self.assertIn("**Superseded by `bbbbbbb`**", calls[1].args[2]["content"])
self.assertIn("~~Download:", calls[1].args[2]["content"])
self.assertIn("Latest commit: Fix reconnect behavior", calls[2].args[2]["content"])
saved = self.github.call_args.args[2]["body"]
self.assertEqual("1557547293375332466", module.saved_message(saved, self.discord.id))
self.assertIn('"sha": "' + "b" * 40 + '"', saved)
def test_publish_supersede_rerun_and_close_lifecycle(self):
messages = {}
created = []
next_id = 1
def discord_request(method, suffix="", body=None):
nonlocal next_id
if method == "POST":
message_id = str(1557547293375332465 + next_id)
next_id += 1
messages[message_id] = {"id": message_id, "content": body["content"]}
created.append(message_id)
return messages[message_id]
message_id = suffix.split("/")[-1]
if method == "GET":
return messages.get(message_id)
if method == "PATCH":
if message_id not in messages:
return None
messages[message_id].update(body)
return messages[message_id]
self.fail(f"Unexpected Discord method: {method}")
self.discord.request.side_effect = discord_request
self.publish("a" * 40)
first_id = created[-1]
self.publish("b" * 40)
second_id = created[-1]
self.publish("b" * 40)
self.assertEqual(2, len(created))
self.assertIn("**Superseded by `bbbbbbb`**", messages[first_id]["content"])
self.assertIn("`bbbbbbb`", messages[second_id]["content"])
self.pull.update(state="closed", merged=True)
module.sync("retire", "Droid-Deck/DroidDeck", "410", self.discord)
self.assertTrue(messages[second_id]["content"].startswith("**Merged**"))
self.assertIn("~~Latest commit:", messages[second_id]["content"])
def test_legacy_state_uses_embedded_short_sha_to_supersede(self):
self.save_state()
self.comment["body"] = self.comment["body"].replace(', "sha": "' + "a" * 40 + '"', '')
old_content = "**Signed test build** `pr-410` · `aaaaaaa`\nold build"
self.discord.request.side_effect = [
{"content": old_content}, {"id": "1557547293375332465"}, {"id": "1557547293375332466"}]
self.publish("b" * 40)
self.assertEqual(["GET", "PATCH", "POST"], [call.args[0] for call in self.discord.request.call_args_list])
def test_deleted_message_is_recreated(self):
self.save_state()
@@ -78,6 +155,10 @@ class PrDiscordTest(unittest.TestCase):
module.sync("retire", "Droid-Deck/DroidDeck", "410", self.discord)
self.discord.request.assert_not_called()
def test_superseded_content_is_idempotent(self):
once = module.retired_content("first\n\nlast", superseded_by="a" * 40)
self.assertEqual(once, module.retired_content(once, superseded_by="a" * 40))
def test_old_build_without_saved_id_is_not_guessed(self):
self.pull["state"] = "closed"
module.sync("retire", "Droid-Deck/DroidDeck", "410", self.discord)
@@ -153,6 +234,29 @@ class PrDiscordTest(unittest.TestCase):
self.assertLessEqual(len(content), 1800)
self.assertLessEqual(len(module.retired_content(content, True)), 2000)
def test_commit_subject_is_sanitized_and_uses_only_first_line(self):
content = module.build_content("Droid-Deck/DroidDeck", "410", "title", "a" * 40,
"apk", "release", commit_message="Fix *input* @everyone\nDetails")
self.assertIn(r"Latest commit: Fix \*input\* @everyone", content)
self.assertNotIn("Details", content)
def test_commit_lookup_failure_does_not_block_announcement(self):
def unavailable_commit(path, method="GET", body=None):
if "/commits/" in path:
raise RuntimeError("GitHub request failed")
return self.pull if "/pulls/" in path else self.comment
self.github.side_effect = unavailable_commit
self.publish()
self.assertEqual("POST", self.discord.request.call_args.args[0])
self.assertNotIn("Latest commit:", self.discord.request.call_args.args[2]["content"])
def test_empty_commit_response_does_not_block_announcement(self):
self.github.side_effect = lambda path, method="GET", body=None: (
self.pull if "/pulls/" in path else None if "/commits/" in path else self.comment)
self.publish()
self.assertEqual("POST", self.discord.request.call_args.args[0])
self.assertNotIn("Latest commit:", self.discord.request.call_args.args[2]["content"])
original_report = module.report_comment
+55
View File
@@ -0,0 +1,55 @@
import re
import shutil
import subprocess
import tempfile
import unittest
from pathlib import Path
SESSION = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-session"
FAKE_DAEMON = """#!/usr/bin/env python3
import socket, sys, time
address = next(a for a in sys.argv if a.startswith("--address="))
path = address.split("unix:path=", 1)[1]
open(sys.argv[0] + ".args", "w").write(" ".join(sys.argv[1:]))
s = socket.socket(socket.AF_UNIX)
s.bind(path)
time.sleep(5)
"""
class SessionBusTest(unittest.TestCase):
def setUp(self):
self.root = Path(tempfile.mkdtemp())
self.addCleanup(shutil.rmtree, self.root, True)
self.bin = self.root / "bin"
self.bin.mkdir()
self.runtime = self.root / "run"
self.runtime.mkdir()
daemon = self.bin / "dbus-daemon"
daemon.write_text(FAKE_DAEMON)
daemon.chmod(0o755)
def run_block(self, env_address=""):
match = re.search(r'^ *if \[ -z "\$\{DBUS_SESSION_BUS_ADDRESS:-\}" \]; then\n.*?^ *fi\n *fi\n',
SESSION.read_text(), re.M | re.S)
self.assertIsNotNone(match)
script = "nap() { sleep \"$1\"; }\n" + match.group(0) + 'echo "ADDRESS=$DBUS_SESSION_BUS_ADDRESS"\nkill %1 2>/dev/null\n'
env = {"PATH": "%s:/usr/bin:/bin" % self.bin, "XDG_RUNTIME_DIR": str(self.runtime)}
if env_address:
env["DBUS_SESSION_BUS_ADDRESS"] = env_address
return subprocess.run(["bash", "-c", script], env=env, capture_output=True, text=True, timeout=30).stdout
def test_steam_mode_exports_its_own_session_bus(self):
out = self.run_block()
self.assertIn("ADDRESS=unix:path=%s/bus" % self.runtime, out)
self.assertIn("--session", (self.bin / "dbus-daemon.args").read_text())
def test_an_existing_session_bus_is_kept(self):
out = self.run_block("unix:path=/somewhere/else")
self.assertIn("ADDRESS=unix:path=/somewhere/else", out)
self.assertFalse((self.bin / "dbus-daemon.args").exists())
if __name__ == "__main__":
unittest.main()
+215
View File
@@ -0,0 +1,215 @@
import json
import os
from pathlib import Path
import select
import tempfile
import unittest
from unittest import mock
from tools.tests import test_droiddeck_fex as fixtures
from tools.tests import test_steam_compat_live as live
from tools.tests.test_steam_compat_mapping import config_text
COMPAT = live.COMPAT
TOOL = COMPAT["TOOL"]
class ToolPlatformsTest(unittest.TestCase):
def setUp(self):
temporary = tempfile.TemporaryDirectory()
self.addCleanup(temporary.cleanup)
self.root = Path(temporary.name)
self.steam = self.root / "Steam"
self.state = self.root / "state"
self.config = self.steam / "config/config.vdf"
self.config.parent.mkdir(parents=True)
self.state.mkdir()
(self.steam / "appcache").mkdir()
(self.steam / "steamapps").mkdir()
self.entries = {
976730: ("windows", "64", "game"),
1826330: ("linux", "", "tool"),
1161040: ("linux", "", "tool"),
900001: ("windows", "64", "tool"),
900002: ("linux", "arm64", "tool"),
900003: ("osx", "64", "tool"),
900004: ("", "", "tool"),
900005: ("linux,windows", "64", "tool"),
}
self.write_appinfo()
self.catalog = [{"name": TOOL, "display": "Proton", "dir": "Proton", "valve": True}]
self.config.write_text(config_text('"0" { "name" "%s" }' % TOOL))
patcher = mock.patch.dict(COMPAT["register_default"].__globals__, COMPAT_DIR=str(self.state))
patcher.start()
self.addCleanup(patcher.stop)
def write_appinfo(self, magic=0x07564429):
(self.steam / "appcache/appinfo.vdf").write_bytes(fixtures.AppInfoTest.appinfo(self.entries, magic))
def platforms(self):
return COMPAT["tool_platforms"](str(self.steam))
def plan(self, current, auto=None, **kwargs):
return COMPAT["plan_mapping"](current, ["976730"], [TOOL], TOOL, auto or {},
tools=self.platforms(), **kwargs)
def test_metadata_selects_tools_across_cache_formats(self):
for magic in (0x07564427, 0x07564428, 0x07564429):
with self.subTest(magic=magic):
self.write_appinfo(magic)
self.assertEqual(set(self.platforms()), {"1826330", "1161040", "900001", "900002", "900005"})
def test_tools_are_not_installed_games(self):
for app in self.entries:
(self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text("")
self.assertEqual(COMPAT["installed_apps"](str(self.steam)), ["976730"])
def test_linux_tools_clear_proton_and_windows_tools_get_default_before_install(self):
current = {"0": TOOL, "976730": TOOL, "1826330": TOOL, "1161040": "proton_experimental"}
changes, auto = self.plan(current, {"1826330": TOOL, "976730": TOOL})
self.assertEqual(changes, {"1826330": None, "1161040": None, "900001": TOOL})
self.assertNotIn("1826330", auto)
self.assertEqual(auto["900001"], TOOL)
self.assertEqual(auto["976730"], TOOL)
def test_removed_ge_proton_is_cleared_with_or_without_saved_ownership(self):
for saved in ({}, {"1826330": "GE-Proton11-7"}):
with self.subTest(saved=saved):
changes, auto = self.plan({"0": TOOL, "1826330": "GE-Proton11-7"}, saved)
self.assertIsNone(changes["1826330"])
self.assertNotIn("1826330", auto)
def test_removed_ge_proton_game_selection_survives(self):
changes, auto = self.plan({"0": TOOL, "976730": "GE-Proton11-7"})
self.assertNotIn("976730", changes)
self.assertNotIn("976730", auto)
def test_saved_native_selections_survive(self):
for name in (COMPAT["FEX_TOOL"], "custom-native"):
with self.subTest(name=name):
changes, auto = self.plan({"0": TOOL, "1826330": name}, {"1826330": name})
self.assertNotIn("1826330", changes)
self.assertNotIn("1826330", auto)
def test_main_watches_cache_updates_and_replacements(self):
class StopWatching(BaseException):
pass
watchers = []
def capture(files):
watcher = live.LIVE["Watcher"](files)
watchers.append(watcher)
raise StopWatching()
namespace = live.LIVE["main"].__globals__
with mock.patch.dict(namespace, Watcher=capture), mock.patch.dict(os.environ, BL_CDP_PORT="1"), \
mock.patch.object(live.LIVE["sys"], "argv", ["compat", str(self.steam)]):
with self.assertRaises(StopWatching):
live.LIVE["main"]()
watcher = watchers[0]
if watcher.fd >= 0:
self.addCleanup(os.close, watcher.fd)
self.assertFalse(watcher.changed())
self.entries[900006] = ("linux", "", "tool")
self.write_appinfo()
self.assertTrue(watcher.changed())
self.assertIn("900006", self.platforms())
cache = self.steam / "appcache/appinfo.vdf"
replacement = cache.with_suffix(".tmp")
replacement.write_bytes(cache.read_bytes())
replacement.replace(cache)
self.assertTrue(watcher.changed())
def test_watcher_follows_an_appcache_created_after_startup(self):
root = self.root / "late"
(root / "state").mkdir(parents=True)
watcher = live.LIVE["Watcher"]([str(root / "state/request.json"), str(root / "appcache/appinfo.vdf")])
self.assertGreaterEqual(watcher.fd, 0)
self.addCleanup(os.close, watcher.fd)
self.assertFalse(watcher.changed())
(root / "appcache").mkdir()
self.assertTrue(watcher.changed())
(root / "appcache/appinfo.vdf").write_bytes(b"x")
self.assertTrue(watcher.changed())
def test_watcher_follows_each_missing_directory_level(self):
root = self.root / "levels"
root.mkdir()
target = root / "sd/steamapps/appmanifest_1.acf"
watcher = live.LIVE["Watcher"]([str(target)])
self.assertGreaterEqual(watcher.fd, 0)
self.addCleanup(os.close, watcher.fd)
(root / "sd").mkdir()
self.assertTrue(select.select([watcher.fd], [], [], 1)[0])
self.assertFalse(watcher.changed())
(root / "sd/steamapps").mkdir()
self.assertTrue(select.select([watcher.fd], [], [], 1)[0])
self.assertTrue(watcher.changed())
target.write_bytes(b"x")
self.assertTrue(watcher.changed())
def test_linux_tool_requests_cannot_restore_windows_platform(self):
changes, auto = self.plan({"0": TOOL, "1826330": TOOL}, overrides={"1826330": TOOL})
self.assertIsNone(changes["1826330"])
self.assertNotIn("1826330", auto)
def test_linux_execution_tools_and_custom_selections_survive(self):
current = {"0": TOOL, "1826330": COMPAT["FEX_TOOL"], "900002": "custom-native",
"900001": "custom-windows", "900005": TOOL}
changes, auto = self.plan(current)
self.assertEqual(changes, {"976730": TOOL})
self.assertNotIn("1826330", auto)
def test_missing_or_malformed_cache_does_not_invent_platforms(self):
cache = self.steam / "appcache/appinfo.vdf"
cache.unlink()
self.assertEqual(self.platforms(), {})
cache.write_bytes(b"invalid")
self.assertEqual(self.platforms(), {})
def test_offline_repair_is_idempotent_and_preserves_game_and_neighbor_fields(self):
self.config.write_text(config_text(
'"0" { "name" "%s" } "976730" { "name" "custom-game" } '
'"1826330" { "name" "%s" }' % (TOOL, TOOL)))
for _ in range(2):
COMPAT["register_default"](str(self.config), ["976730"], catalog=self.catalog,
directory=str(self.state), default=TOOL)
self.assertEqual(COMPAT["read_config_mapping"](str(self.config)),
{"0": TOOL, "976730": "custom-game", "900001": TOOL})
self.assertIn('"outside"', self.config.read_text())
state = json.loads((self.state / "state.json").read_text())
self.assertNotIn("1826330", state["auto"])
def reconcile(self, page):
helper = live.LIVE["Helper"](str(self.steam), 1)
helper.page = page
with mock.patch.dict(COMPAT, tool_catalog=lambda root: self.catalog):
helper.reconcile()
return json.loads((self.state / "state.json").read_text())
def test_live_repair_covers_uninstalled_dependencies_and_stays_idempotent(self):
page = live.FakePage({"0": TOOL, "1826330": TOOL, "976730": "custom-game"}, [TOOL])
state = self.reconcile(page)
self.assertEqual(page.sets, [("900001", TOOL), ("1826330", "")])
self.assertNotIn("1826330", state["auto"])
page.sets.clear()
self.reconcile(page)
self.assertEqual(page.sets, [])
self.assertEqual(page.mapping["976730"], "custom-game")
def test_live_removed_ge_proton_is_cleared_and_stays_cleared(self):
page = live.FakePage({"0": TOOL, "1826330": "GE-Proton11-7"}, [TOOL])
(self.state / "state.json").write_text(json.dumps({"auto": {"1826330": "GE-Proton11-7"}}))
state = self.reconcile(page)
self.assertIn(("1826330", ""), page.sets)
self.assertNotIn("1826330", state["auto"])
page.sets.clear()
self.reconcile(page)
self.assertEqual(page.sets, [])
def test_live_refused_tools_are_not_written(self):
page = live.FakePage({"0": TOOL, "1826330": TOOL}, [TOOL], refused={"1826330", "900001"})
self.reconcile(page)
self.assertEqual(page.sets, [])
+190 -1
View File
@@ -387,6 +387,193 @@ 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:
@@ -605,6 +792,8 @@ class GogRegistry(unittest.TestCase):
folder = game(root, store_id='gog')
with patch.dict(os.environ, {'BL_LAUNCH_DIR': root, 'STEAM_COMPAT_DATA_PATH': root + '/compat/', 'BL_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, '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')