mirror of
https://github.com/spoopyghosty0/frameport.git
synced 2026-10-21 04:01:54 +02:00
spoopyghosty0
f996e5e7d9
Each drive the agent reports (SD card, USB, other Steam library drives) is a Files location with its free space; read-only drives allow downloads only. Installed PC VR and Linux games get their install folder. Agent v97: drives report read_only explicitly (checked on the Frame).
606 lines
33 KiB
Python
606 lines
33 KiB
Python
"""Agent: games on another drive (microSD, GitHub #90) and Desktop Mode entries for Linux apps (GitHub #84)."""
|
|
import importlib.util
|
|
import json
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
AGENT = Path(__file__).resolve().parents[1] / "agent" / "frameport_agent.py"
|
|
|
|
|
|
def load(monkeypatch, tmp_path, extra_mounts=()):
|
|
"""The agent with HOME = <tmp>/home, removable drives under <tmp>/media and a fake /proc/mounts."""
|
|
home = tmp_path / "home"
|
|
home.mkdir(exist_ok=True)
|
|
monkeypatch.setenv("HOME", str(home))
|
|
spec = importlib.util.spec_from_file_location("frameport_agent", AGENT)
|
|
a = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(a)
|
|
media = tmp_path / "media"
|
|
(media / "steamos" / "SD Card").mkdir(parents=True, exist_ok=True)
|
|
(media / "steamos" / "STICK").mkdir(parents=True, exist_ok=True)
|
|
(media / "steamos" / "RO").mkdir(parents=True, exist_ok=True)
|
|
sd = str(media / "steamos" / "SD Card").replace(" ", "\\040")
|
|
table = tmp_path / "mounts"
|
|
table.write_text("/dev/nvme0n1p8 / btrfs rw,relatime 0 0\n"
|
|
f"/dev/mmcblk0p1 {sd} ext4 rw,nosuid,nodev,relatime 0 0\n"
|
|
f"/dev/sda1 {media}/steamos/STICK exfat rw,nosuid,nodev 0 0\n"
|
|
f"/dev/sdb1 {media}/steamos/RO ext4 ro,nosuid 0 0\n"
|
|
"proc /proc proc rw 0 0\n" + "".join(extra_mounts))
|
|
monkeypatch.setattr(a, "PROC_MOUNTS", str(table))
|
|
monkeypatch.setattr(a, "MEDIA_ROOT", str(media))
|
|
monkeypatch.setattr(a, "container_running", lambda appid: False)
|
|
monkeypatch.setattr(a, "pcvr_pids", lambda base: [])
|
|
monkeypatch.setattr(a, "as_owner", lambda: [])
|
|
return a
|
|
|
|
|
|
def sd_dir(tmp_path):
|
|
return tmp_path / "media" / "steamos" / "SD Card"
|
|
|
|
|
|
def quest_install(a, pkg="com.x.y", dest=None):
|
|
"""A Quest game as finalize leaves it (no Lepton needed: written by hand like the agent would)."""
|
|
prep = a.cmd_prepare({"package": pkg, "title": "Game", "dest": dest})
|
|
base = Path(prep["base"])
|
|
(base / "lepton-app" / "obb").mkdir(parents=True)
|
|
(base / "lepton-app" / "game.apk").write_bytes(b"apk" * 100)
|
|
(base / "lepton-app" / "obb" / "main.obb").write_bytes(b"o" * 5000)
|
|
saves = base / "lepton-data" / "external" / "Android" / "data" / pkg / "files"
|
|
saves.mkdir(parents=True)
|
|
(saves / "save.dat").write_text("progress")
|
|
shutil.rmtree(base / "incoming")
|
|
anchor = Path(prep["anchor"])
|
|
anchor.mkdir(parents=True, exist_ok=True)
|
|
(anchor / "artwork").mkdir(exist_ok=True)
|
|
(anchor / "artwork" / "icon.png").write_bytes(b"png")
|
|
a.write_launcher(str(anchor), str(base), pkg, "Game", prep["appid"], "/lepton/lepton", {"X": "1"})
|
|
(anchor / "deployment.json").write_text(json.dumps({"package": pkg, "appid": int(prep["appid"]),
|
|
"base": str(base), "title": "Game"}))
|
|
return prep
|
|
|
|
|
|
def test_drives_lists_internal_and_removable_drives(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
drives = {d["label"]: d for d in a.cmd_drives({})["drives"]}
|
|
assert set(drives) == {"Internal storage", "SD Card", "STICK", "RO"}
|
|
internal = drives["Internal storage"]
|
|
assert internal["internal"] and internal["install_dir"] == a.ANCHORS and internal["usable"]
|
|
assert internal["fstype"] == "btrfs" and internal["free_bytes"] > 0
|
|
sd = drives["SD Card"]
|
|
assert sd["usable"] and sd["removable"] and sd["fstype"] == "ext4"
|
|
assert sd["path"] == str(sd_dir(tmp_path)) and sd["install_dir"] == str(sd_dir(tmp_path) / "FramePort")
|
|
assert not drives["STICK"]["usable"] and "exfat" in drives["STICK"]["reason"]
|
|
assert drives["RO"]["read_only"] and not sd["read_only"]
|
|
assert not drives["RO"]["usable"] and "read-only" in drives["RO"]["reason"]
|
|
|
|
|
|
def test_steam_library_on_another_drive_is_listed(monkeypatch, tmp_path):
|
|
lib = tmp_path / "games"
|
|
(lib / "steamapps").mkdir(parents=True)
|
|
a = load(monkeypatch, tmp_path, [f"/dev/sdc1 {lib} ext4 rw 0 0\n"])
|
|
steamapps = Path(a.STEAM) / "steamapps"
|
|
steamapps.mkdir(parents=True)
|
|
(steamapps / "libraryfolders.vdf").write_text(f'"libraryfolders" {{ "1" {{ "path" "{lib}" }} }}')
|
|
drives = {d["path"]: d for d in a.list_drives()}
|
|
assert drives[str(lib)]["steam_library"] and drives[str(lib)]["install_dir"] == str(lib / "FramePort")
|
|
|
|
|
|
def test_resolve_dest_never_falls_back_to_internal_storage(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
for internal in (None, "", "internal", a.ANCHORS):
|
|
assert a.resolve_dest(internal) == a.ANCHORS
|
|
assert a.resolve_dest(str(sd_dir(tmp_path))) == str(sd_dir(tmp_path) / "FramePort") # the mount point
|
|
assert (sd_dir(tmp_path) / "FramePort").is_dir()
|
|
with pytest.raises(a.AgentError, match="exfat"):
|
|
a.resolve_dest(str(tmp_path / "media/steamos/STICK/FramePort"))
|
|
with pytest.raises(a.AgentError, match="read-only"):
|
|
a.resolve_dest(str(tmp_path / "media/steamos/RO"))
|
|
with pytest.raises(a.AgentError, match="isn't inserted"): # an SD card that was taken out
|
|
a.resolve_dest(str(tmp_path / "media/steamos/OLDCARD/FramePort"))
|
|
assert not (tmp_path / "media/steamos/OLDCARD").exists()
|
|
|
|
|
|
def test_new_games_go_to_the_chosen_drive_and_keep_their_base(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
dest = str(sd_dir(tmp_path) / "FramePort")
|
|
prep = quest_install(a, dest=dest)
|
|
assert prep["base"] == os.path.join(dest, "com.x.y") and prep["anchor"].startswith(a.ANCHORS)
|
|
assert prep["free_bytes"] > 0
|
|
# a reinstall keeps the game where it is, whatever the default is now
|
|
again = a.cmd_prepare({"package": "com.x.y", "title": "Game", "dest": None})
|
|
assert again["base"] == prep["base"] and again["installed"]
|
|
games = a.cmd_list_installed({})["games"]
|
|
assert games[0]["drive"] == {"internal": False, "path": str(sd_dir(tmp_path)), "label": "SD Card"}
|
|
assert games[0]["drive_missing"] is False and games[0]["apk_present"]
|
|
assert {d["label"]: d["games"] for d in a.cmd_drives({})["drives"]}["SD Card"] == 1
|
|
# Linux apps and PC VR games take dest too
|
|
p = a.cmd_prepare_linux({"package": "linux.tool", "title": "Tool", "dest": dest})
|
|
assert p["base"] == os.path.join(dest, "linux.tool")
|
|
|
|
|
|
def test_missing_sd_card(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
prep = quest_install(a, dest=str(sd_dir(tmp_path) / "FramePort"))
|
|
(tmp_path / "mounts").write_text("/dev/nvme0n1p8 / btrfs rw 0 0\n") # card taken out
|
|
game = a.cmd_list_installed({})["games"][0]
|
|
assert game["drive_missing"] is True and game["drive"]["label"] == "SD Card"
|
|
with pytest.raises(a.AgentError, match="isn't inserted"):
|
|
a.cmd_prepare({"package": "com.x.y", "title": "Game"})
|
|
with pytest.raises(a.AgentError, match="isn't inserted"):
|
|
a.cmd_launch({"package": "com.x.y"})
|
|
with pytest.raises(a.AgentError, match="isn't inserted"):
|
|
a.cmd_move({"package": "com.x.y", "dest": "internal", "detach": False})
|
|
assert Path(prep["base"]).exists()
|
|
|
|
|
|
@pytest.mark.parametrize("same_drive", [True, False])
|
|
def test_move_quest_game_to_sd_and_back(monkeypatch, tmp_path, same_drive):
|
|
a = load(monkeypatch, tmp_path)
|
|
monkeypatch.setattr(a, "same_device", lambda x, y: same_drive)
|
|
prep = quest_install(a)
|
|
anchor = Path(prep["anchor"])
|
|
assert prep["base"] == str(anchor) # internal storage: the files live next to the launcher
|
|
os.symlink("/nonexistent/elsewhere", anchor / "lepton-app" / "outside-link")
|
|
dest = str(sd_dir(tmp_path))
|
|
r = a.cmd_move({"package": "com.x.y", "dest": dest, "detach": False})
|
|
assert r["state"] == "done", r
|
|
new = sd_dir(tmp_path) / "FramePort" / "com.x.y"
|
|
assert (new / "lepton-app" / "obb" / "main.obb").stat().st_size == 5000
|
|
assert (new / "lepton-data/external/Android/data/com.x.y/files/save.dat").read_text() == "progress"
|
|
assert os.readlink(new / "lepton-app" / "outside-link") == "/nonexistent/elsewhere"
|
|
# the anchor keeps its own files only
|
|
assert sorted(os.listdir(anchor)) == ["artwork", "deployment.json", "launch.sh"]
|
|
dep = a.deployment("com.x.y")
|
|
assert dep["base"] == str(new) and dep["moved"]["from"] == str(anchor)
|
|
text = (anchor / "launch.sh").read_text()
|
|
# the card's name has a space: Lepton gets the game through a link without one (GitHub #213)
|
|
link = Path(a.LEPTON_PATHS) / "com.x.y"
|
|
assert f"ln -sfn '{new}' {link}" in text and f"\napp_dir={link}\n" in text and "export X=1" in text
|
|
assert a.launcher_base(text, "com.x.y") == str(new)
|
|
assert subprocess.run(["bash", "-n", str(anchor / "launch.sh")]).returncode == 0
|
|
assert a.cmd_move_status({})["state"] == "done"
|
|
with pytest.raises(a.AgentError, match="already there"):
|
|
a.cmd_move({"package": "com.x.y", "dest": dest, "detach": False})
|
|
# and back to internal storage: the drive's empty FramePort folder goes
|
|
r = a.cmd_move({"package": "com.x.y", "dest": "internal", "detach": False})
|
|
assert r["state"] == "done", r
|
|
assert (anchor / "lepton-app" / "game.apk").exists() and not (sd_dir(tmp_path) / "FramePort").exists()
|
|
assert a.deployment("com.x.y")["base"] == str(anchor)
|
|
assert f"app_dir={anchor}\n" in (anchor / "launch.sh").read_text()
|
|
|
|
|
|
def test_move_refusals(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
quest_install(a)
|
|
with pytest.raises(a.AgentError, match="exfat"):
|
|
a.cmd_move({"package": "com.x.y", "dest": str(tmp_path / "media/steamos/STICK"), "detach": False})
|
|
monkeypatch.setattr(a, "container_running", lambda appid: True)
|
|
with pytest.raises(a.AgentError, match="running"):
|
|
a.cmd_move({"package": "com.x.y", "dest": str(sd_dir(tmp_path)), "detach": False})
|
|
monkeypatch.setattr(a, "container_running", lambda appid: False)
|
|
monkeypatch.setattr(a, "same_device", lambda x, y: False)
|
|
monkeypatch.setattr(a, "_space", lambda path: (100 << 20, 1 << 40)) # 100 MiB free < headroom
|
|
with pytest.raises(a.AgentError, match="not enough space"):
|
|
a.cmd_move({"package": "com.x.y", "dest": str(sd_dir(tmp_path)), "detach": False})
|
|
with pytest.raises(a.AgentError, match="not installed"):
|
|
a.cmd_move({"package": "com.not.there", "dest": "internal", "detach": False})
|
|
assert a.deployment("com.x.y")["base"] == os.path.join(a.ANCHORS, "com.x.y")
|
|
|
|
|
|
def test_failed_copy_leaves_the_game_where_it_was(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
monkeypatch.setattr(a, "same_device", lambda x, y: False)
|
|
prep = quest_install(a)
|
|
real = a.tree_stats
|
|
monkeypatch.setattr(a, "tree_stats", lambda root, names: (real(root, names)[0], 1) if "SD" in root
|
|
else real(root, names)) # the copy comes up short
|
|
r = a.cmd_move({"package": "com.x.y", "dest": str(sd_dir(tmp_path)), "detach": False})
|
|
assert r["state"] == "failed" and "doesn't match" in r["error"]
|
|
assert a.deployment("com.x.y")["base"] == prep["base"]
|
|
assert (Path(prep["base"]) / "lepton-app" / "game.apk").exists()
|
|
assert not (sd_dir(tmp_path) / "FramePort" / "com.x.y").exists()
|
|
assert f"app_dir={prep['base']}\n" in (Path(prep["anchor"]) / "launch.sh").read_text()
|
|
|
|
|
|
def test_move_detaches_through_systemd_run(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
quest_install(a)
|
|
calls = []
|
|
monkeypatch.setattr(a, "run", lambda cmd, **kw: calls.append(cmd) or
|
|
subprocess.CompletedProcess(cmd, 0, "", "") if cmd[0] == "systemd-run" else
|
|
subprocess.run(cmd, capture_output=True, text=True))
|
|
r = a.cmd_move({"package": "com.x.y", "dest": str(sd_dir(tmp_path))})
|
|
assert r["started"] and r["to"].endswith("FramePort/com.x.y")
|
|
cmd = next(c for c in calls if c[0] == "systemd-run")
|
|
assert "_move_worker" in cmd and json.loads(cmd[-1])["package"] == "com.x.y"
|
|
assert a.cmd_move_status({})["state"] == "running"
|
|
|
|
|
|
def test_replace_path_keeps_shell_quoting_valid(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
old, new = "/home/steamos/Applications/quest-frame/rift.x", "/run/media/steamos/SD/FramePort/rift.x"
|
|
text = (f"base={old}\ncd {old}/game\nexec proton run {old}/revive/ReviveInjector.exe /openxr "
|
|
f"'Z:\\home\\steamos\\Applications\\quest-frame\\rift.x\\game\\G.exe' >>\"$base/launch.log\"\n"
|
|
f"other={old}2/x\n")
|
|
out = a.replace_path(text, old, new)
|
|
assert f"base={new}\n" in out and f"cd {new}/game" in out and f"{new}/revive/ReviveInjector.exe" in out
|
|
assert "'Z:\\run\\media\\steamos\\SD\\FramePort\\rift.x\\game\\G.exe'" in out
|
|
assert f"other={old}2/x" in out # another folder that only starts the same
|
|
with pytest.raises(a.AgentError): # an unquoted path can't become one that needs quotes
|
|
a.replace_path(text, old, "/run/media/steamos/SD Card/FramePort/rift.x")
|
|
spaced = "/run/media/steamos/SD Card/FramePort/rift.x"
|
|
assert a.replace_path(f"base='{spaced}'\n", spaced, old) == f"base='{old}'\n"
|
|
|
|
|
|
def test_symlinks_into_the_old_folder_follow_the_move(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
old, new = tmp_path / "old", tmp_path / "new"
|
|
(new / "game").mkdir(parents=True)
|
|
os.symlink(str(old / "revive" / "LibReviveXR64.dll"), new / "game" / "LibOVRRT64_1.dll")
|
|
os.symlink("../drive_c", new / "game" / "relative")
|
|
assert a.retarget_symlinks(str(new), ["game"], str(old), str(new)) == 1
|
|
assert os.readlink(new / "game" / "LibOVRRT64_1.dll") == str(new / "revive" / "LibReviveXR64.dll")
|
|
assert os.readlink(new / "game" / "relative") == "../drive_c"
|
|
|
|
|
|
def linux_install(a, tmp_path, pkg="linux.true", title="True Tool", tags=None, dest=None, **extra):
|
|
prep = a.cmd_prepare_linux({"package": pkg, "title": title, "dest": dest})
|
|
app_in = os.path.join(prep["incoming"], "app", "bin")
|
|
os.makedirs(app_in)
|
|
shutil.copy("/bin/true", os.path.join(app_in, "true"))
|
|
size = os.path.getsize(os.path.join(app_in, "true"))
|
|
os.makedirs(os.path.join(prep["base"], "incoming-artwork"))
|
|
Path(prep["base"], "incoming-artwork", "icon.png").write_bytes(b"png")
|
|
res = a.cmd_finalize_linux({"package": pkg, "title": title, "exe": "bin/true", "tags": tags or [],
|
|
"manifests": {"app": {"bin/true": size}}, "env": {"APP_MODE": "1"}, "dest": dest,
|
|
**extra})
|
|
return prep, res
|
|
|
|
|
|
def test_linux_app_moves_with_its_launcher(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
monkeypatch.setattr(a, "same_device", lambda x, y: False)
|
|
prep, _ = linux_install(a, tmp_path)
|
|
r = a.cmd_move({"package": "linux.true", "dest": str(sd_dir(tmp_path)), "detach": False})
|
|
assert r["state"] == "done", r
|
|
new = sd_dir(tmp_path) / "FramePort" / "linux.true"
|
|
text = (Path(prep["anchor"]) / "launch.sh").read_text()
|
|
assert f"'{new}/app/bin/true'" in text and "export APP_MODE=1" in text and prep["base"] not in text
|
|
assert subprocess.run(["bash", "-n", str(Path(prep["anchor"]) / "launch.sh")]).returncode == 0
|
|
assert (new / "app" / "bin" / "true").exists() and not (Path(prep["anchor"]) / "app").exists()
|
|
|
|
|
|
def test_pc_vr_game_moves_with_its_prefix_and_launcher(monkeypatch, tmp_path):
|
|
"""PC VR: the launcher is written again from the install record (env + game args kept since agent v63), the
|
|
Proton prefix moves with the game and the LibOVRRT redirect follows."""
|
|
from test_agent import fake_steam_tools
|
|
|
|
a = load(monkeypatch, tmp_path)
|
|
fake_steam_tools(a, Path(a.HOME))
|
|
monkeypatch.setattr(a, "same_device", lambda x, y: False)
|
|
prep = a.cmd_prepare_pcvr({"package": "rift.game", "title": "Rift Game"})
|
|
inc = Path(prep["incoming"])
|
|
(inc / "game/UEGame.exe").write_bytes(b"MZexe")
|
|
(inc / "revive/ReviveInjector.exe").write_bytes(b"MZ")
|
|
(inc / "revive/LibReviveXR64.dll").write_bytes(b"MZdll")
|
|
a.cmd_finalize_pcvr({"package": "rift.game", "title": "Rift Game", "exe": "UEGame.exe", "libovr_redirect": True,
|
|
"manifests": {"game": {"UEGame.exe": 5},
|
|
"revive": {"ReviveInjector.exe": 2, "LibReviveXR64.dll": 5}},
|
|
"env": {"FOO": "bar"}, "game_args": ["-vrmode"]})
|
|
base = Path(prep["base"])
|
|
(base / "compatdata/pfx/drive_c").mkdir(parents=True)
|
|
(base / "compatdata/pfx/drive_c/save.sav").write_text("saved")
|
|
assert os.path.islink(base / "game/LibOVRRT64_1.dll")
|
|
r = a.cmd_move({"package": "rift.game", "dest": str(sd_dir(tmp_path)), "detach": False})
|
|
assert r["state"] == "done", r
|
|
new = sd_dir(tmp_path) / "FramePort" / "rift.game"
|
|
assert (new / "compatdata/pfx/drive_c/save.sav").read_text() == "saved"
|
|
assert os.readlink(new / "game/LibOVRRT64_1.dll") == str(new / "revive/LibReviveXR64.dll")
|
|
text = (Path(prep["anchor"]) / "launch.sh").read_text()
|
|
assert f"{base}/game" not in text and f"{base}/revive" not in text # (the play log stays in the anchor)
|
|
assert "export FOO=bar" in text and "-vrmode" in text
|
|
assert f"base='{new}'" in text
|
|
assert subprocess.run(["bash", "-n", str(Path(prep["anchor"]) / "launch.sh")]).returncode == 0
|
|
|
|
|
|
def test_cleanup_and_purge_on_a_drive(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
monkeypatch.setattr(a, "stop_steam", lambda: True)
|
|
monkeypatch.setattr(a, "start_steam", lambda s: None)
|
|
fp = sd_dir(tmp_path) / "FramePort"
|
|
prep = quest_install(a, dest=str(fp))
|
|
(fp / "com.old.game").mkdir() # left by an earlier install
|
|
(fp / "com.old.game" / "x").write_bytes(b"1234")
|
|
assert a.cmd_cleanup({"paths": [str(fp / "com.old.game")]})["freed_bytes"] == 4
|
|
for bad in (prep["base"], str(fp), str(fp / "com.x.y" / "lepton-data"), str(sd_dir(tmp_path))):
|
|
with pytest.raises(a.AgentError):
|
|
a.cmd_cleanup({"paths": [bad]})
|
|
a.purge_worker(json.dumps({"keep_saves": False, "status": str(tmp_path / "st.json")}))
|
|
assert json.loads((tmp_path / "st.json").read_text())["state"] == "done"
|
|
assert not fp.exists() and sd_dir(tmp_path).exists()
|
|
|
|
|
|
# ------------------------------------------------------------------------------------------ Desktop Mode (#84)
|
|
def test_linux_app_gets_a_desktop_mode_entry(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
(Path(a.HOME) / "Desktop").mkdir()
|
|
prep, res = linux_install(a, tmp_path, title='Odd "Name" 100%', tags=["Linux", "Puzzle"])
|
|
menu = Path(a.HOME) / ".local/share/applications/frameport-true.desktop"
|
|
desk = Path(a.HOME) / "Desktop/frameport-true.desktop"
|
|
assert res["desktop_entry"]["menu"] == str(menu) and res["desktop_entry"]["desktop"] == str(desk)
|
|
text = menu.read_text()
|
|
assert text == desk.read_text() and os.access(desk, os.X_OK)
|
|
lines = dict(line.split("=", 1) for line in text.splitlines()[1:])
|
|
assert lines["Name"] == 'Odd "Name" 100%' and lines["Categories"] == "Game;"
|
|
assert lines["Exec"] == f'env FRAMEPORT_DESKTOP=1 "{prep["anchor"]}/launch.sh"'
|
|
assert lines["Icon"] == f"{prep['anchor']}/artwork/icon.png" and lines["X-FramePort-Package"] == "linux.true"
|
|
assert lines["Terminal"] == "false"
|
|
# nothing changes when it is refreshed again; an app without game tags is a utility
|
|
assert a.refresh_desktop_entries() == []
|
|
linux_install(a, tmp_path, pkg="linux.editor", title="Editor")
|
|
assert "Categories=Utility;" in (Path(a.HOME) / ".local/share/applications/frameport-editor.desktop").read_text()
|
|
# uninstall removes both files
|
|
a.cmd_uninstall({"package": "linux.true", "keep_data": False})
|
|
assert not menu.exists() and not desk.exists()
|
|
|
|
|
|
def test_exec_quoting():
|
|
spec = importlib.util.spec_from_file_location("frameport_agent", AGENT)
|
|
a = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(a)
|
|
assert a.desktop_exec_arg('/a b/$x`"\\%') == '"/a b/\\\\$x\\\\`\\\\"\\\\\\\\%%"'
|
|
assert a.desktop_value("two\nlines\\") == "two lines\\\\"
|
|
assert a.desktop_file_name("linux.My App!") == "frameport-My-App.desktop"
|
|
|
|
|
|
def test_desktop_entry_switch_and_refresh(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
linux_install(a, tmp_path, desktop_entry=False)
|
|
menu = Path(a.HOME) / ".local/share/applications/frameport-true.desktop"
|
|
assert not menu.exists() and a.deployment("linux.true")["desktop_entry"] is False
|
|
assert a.refresh_desktop_entries() == [] # off stays off
|
|
r = a.cmd_desktop_entry({"package": "linux.true", "enabled": True})
|
|
assert r["enabled"] and menu.exists()
|
|
a.cmd_desktop_entry({"package": "linux.true", "enabled": False})
|
|
assert not menu.exists()
|
|
# an install from before agent v63 (no desktop_entry field) gets one with the host fixes; stale ones go
|
|
dep_path = Path(a.ANCHORS) / "linux.true" / "deployment.json"
|
|
raw = json.loads(dep_path.read_text())
|
|
raw.pop("desktop_entry")
|
|
dep_path.write_text(json.dumps(raw))
|
|
stale = menu.parent / "frameport-gone.desktop"
|
|
stale.write_text("[Desktop Entry]\nX-FramePort-Package=linux.gone\n")
|
|
(menu.parent / "frameport-links.desktop").write_text("[Desktop Entry]\nName=not an app entry\n")
|
|
assert "Desktop Mode entries (2)" in a.ensure_host_fixes()
|
|
assert menu.exists() and not stale.exists() and (menu.parent / "frameport-links.desktop").exists()
|
|
with pytest.raises(a.AgentError):
|
|
a.cmd_desktop_entry({"package": "com.not.linux", "enabled": True})
|
|
|
|
|
|
def test_desktop_icon_apart_from_the_menu_entry(monkeypatch, tmp_path):
|
|
"""GitHub #212: a desktop icon the user deleted came back at every connection, and there was no way to keep only
|
|
the menu entry. The desktop copy has its own switch, and a refresh only updates a copy that is there."""
|
|
a = load(monkeypatch, tmp_path)
|
|
(Path(a.HOME) / "Desktop").mkdir()
|
|
linux_install(a, tmp_path)
|
|
menu = Path(a.HOME) / ".local/share/applications/frameport-true.desktop"
|
|
desk = Path(a.HOME) / "Desktop/frameport-true.desktop"
|
|
assert menu.exists() and desk.exists()
|
|
desk.unlink() # deleted by hand
|
|
a.ensure_host_fixes()
|
|
assert menu.exists() and not desk.exists()
|
|
r = a.cmd_desktop_entry({"package": "linux.true", "enabled": True, "icon": True})
|
|
assert r["desktop"] == str(desk) and desk.exists() # switched on again: back
|
|
a.cmd_desktop_entry({"package": "linux.true", "enabled": True, "icon": False})
|
|
assert menu.exists() and not desk.exists() and a.deployment("linux.true")["desktop_icon"] is False
|
|
a.ensure_host_fixes()
|
|
assert not desk.exists()
|
|
linux_install(a, tmp_path, pkg="linux.editor", title="Editor", desktop_icon=False)
|
|
assert not (Path(a.HOME) / "Desktop/frameport-editor.desktop").exists()
|
|
|
|
|
|
def test_linux_launcher_from_desktop_mode(monkeypatch, tmp_path):
|
|
"""Started from Desktop Mode (FRAMEPORT_DESKTOP=1) the launcher's parent exits at once: the app must keep running,
|
|
and the desktop's display is used instead of Steam's."""
|
|
a = load(monkeypatch, tmp_path)
|
|
prep, _ = linux_install(a, tmp_path)
|
|
text = (Path(prep["anchor"]) / "launch.sh").read_text()
|
|
assert '[[ -n "${FRAMEPORT_DESKTOP:-}${FRAMEPORT_OVERLAY:-}" ]] && parent=1' in text
|
|
assert 'if [[ -z "${FRAMEPORT_DESKTOP:-}" && -z "${DISPLAY:-}" ]]; then' in text
|
|
# older launchers are upgraded in place
|
|
old = text.replace('[[ -n "${FRAMEPORT_DESKTOP:-}${FRAMEPORT_OVERLAY:-}" ]] && parent=1\n', "").replace(
|
|
'if [[ -z "${FRAMEPORT_DESKTOP:-}" && -z "${DISPLAY:-}" ]]; then', 'if [[ -z "${DISPLAY:-}" ]]; then')
|
|
old = old.replace("# Started from Desktop Mode's menu (FRAMEPORT_DESKTOP=1, GitHub #84) the desktop's own session "
|
|
"is used.\n", "")
|
|
assert "FRAMEPORT_DESKTOP" not in old
|
|
(Path(prep["anchor"]) / "launch.sh").write_text(old)
|
|
assert "linux.true" in a.upgrade_launchers()
|
|
new = (Path(prep["anchor"]) / "launch.sh").read_text()
|
|
assert '[[ -n "${FRAMEPORT_DESKTOP:-}${FRAMEPORT_OVERLAY:-}" ]] && parent=1' in new
|
|
assert "FRAMEPORT_DESKTOP:-}\" && -z" in new
|
|
assert subprocess.run(["bash", "-n", str(Path(prep["anchor"]) / "launch.sh")]).returncode == 0
|
|
# the watchdog: a parent that exits ends the app, unless started from the desktop
|
|
script = tmp_path / "app.sh"
|
|
script.write_text("#!/bin/sh\nsleep 6\necho finished >" + str(tmp_path / "out") + "\n")
|
|
script.chmod(0o755)
|
|
program = os.path.join(prep["base"], "app", "bin", "true")
|
|
assert program in new
|
|
body = new.replace(program, str(script))
|
|
launcher = tmp_path / "l.sh"
|
|
launcher.write_text(body)
|
|
launcher.chmod(0o755)
|
|
env = dict(os.environ, FRAMEPORT_DESKTOP="1", DISPLAY=":9")
|
|
subprocess.run(["bash", "-c", f"{launcher} & exit 0"], env=env, timeout=20)
|
|
import time
|
|
|
|
deadline = time.time() + 15
|
|
while time.time() < deadline and not (tmp_path / "out").exists():
|
|
time.sleep(0.5)
|
|
assert (tmp_path / "out").read_text().strip() == "finished"
|
|
|
|
|
|
# ------------------------------------------------------------------------------------------ Linux apps' icons (#99)
|
|
def png(width: int) -> bytes:
|
|
"""Enough of a PNG for the agent (signature + IHDR size)."""
|
|
return b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR" + width.to_bytes(4, "big") * 2 + b"\x08\x06\x00\x00\x00" + b"x" * 40
|
|
|
|
|
|
SVG = b'<?xml version="1.0"?>\n<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64"></svg>\n'
|
|
|
|
|
|
def appimage_install(a, tmp_path, tree):
|
|
"""An "AppImage" whose --appimage-extract copies the folder `tree` (symlinks kept) as squashfs-root."""
|
|
prep = a.cmd_prepare_linux({"package": "linux.tool", "title": "Tool"})
|
|
exe = Path(prep["incoming"]) / "app" / "Tool-aarch64.AppImage"
|
|
exe.write_text(f"#!/bin/sh\ncp -a '{tree}' squashfs-root\nprintf '#!/bin/sh\\n' > squashfs-root/AppRun\n"
|
|
"chmod +x squashfs-root/AppRun\n")
|
|
os.makedirs(os.path.join(prep["base"], "incoming-artwork"))
|
|
Path(prep["base"], "incoming-artwork", "icon.png").write_bytes(b"placeholder")
|
|
res = a.cmd_finalize_linux({"package": "linux.tool", "title": "Tool", "exe": exe.name, "appimage": True,
|
|
"manifests": {"app": {exe.name: exe.stat().st_size}}})
|
|
return prep, res
|
|
|
|
|
|
def entry_lines(a):
|
|
text = (Path(a.HOME) / ".local/share/applications/frameport-tool.desktop").read_text()
|
|
return dict(line.split("=", 1) for line in text.splitlines()[1:])
|
|
|
|
|
|
def test_appimage_icon_from_its_diricon_symlink(monkeypatch, tmp_path):
|
|
import base64
|
|
|
|
a = load(monkeypatch, tmp_path)
|
|
tree = tmp_path / "tree"
|
|
tree.mkdir()
|
|
(tree / "tool.desktop").write_text("[Desktop Entry]\nName=Tool\nIcon=tool\nStartupWMClass=ToolWindow\n")
|
|
(tree / "tool.png").write_bytes(png(256))
|
|
(tree / ".DirIcon").symlink_to("tool.png")
|
|
prep, res = appimage_install(a, tmp_path, tree)
|
|
anchor = Path(prep["anchor"])
|
|
icon = anchor / "artwork" / "app-icon.png"
|
|
assert icon.read_bytes() == png(256) and not icon.is_symlink()
|
|
lines = entry_lines(a)
|
|
assert lines["Icon"] == str(icon) and lines["StartupWMClass"] == "ToolWindow"
|
|
assert base64.b64decode(res["app_icon"]["png"]) == png(256)
|
|
assert a.shortcut_args("linux.tool")[3] == str(icon) # the Steam shortcut too
|
|
# the user's own icon (PC: "custom") wins over the app's
|
|
(anchor / "artwork" / ".icon-source").write_text("custom")
|
|
a.refresh_desktop_entries()
|
|
assert entry_lines(a)["Icon"] == str(anchor / "artwork" / "icon.png")
|
|
assert a.shortcut_args("linux.tool")[3] == str(anchor / "artwork" / "icon.png")
|
|
# an art update replaces the artwork folder: the app's icon comes back
|
|
(anchor / "artwork" / ".icon-source").write_text("generated")
|
|
icon.unlink()
|
|
a.refresh_desktop_entries()
|
|
assert icon.exists() and entry_lines(a)["Icon"] == str(icon)
|
|
|
|
|
|
def test_appimage_icon_from_hicolor_and_svg(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
tree = tmp_path / "tree"
|
|
(tree / "usr/share/icons/hicolor/48x48/apps").mkdir(parents=True)
|
|
(tree / "usr/share/icons/hicolor/scalable/apps").mkdir(parents=True)
|
|
(tree / "org.tool.App.desktop").write_text("[Desktop Entry]\nName=Tool\nIcon=org.tool.App\n")
|
|
(tree / "usr/share/icons/hicolor/scalable/apps/org.tool.App.svg").write_bytes(SVG)
|
|
(tree / "usr/share/icons/hicolor/48x48/apps/org.tool.App.png").write_bytes(b"not a png")
|
|
prep, res = appimage_install(a, tmp_path, tree)
|
|
icon = Path(prep["anchor"]) / "artwork" / "app-icon.svg"
|
|
assert icon.exists() and entry_lines(a)["Icon"] == str(icon) and "StartupWMClass" not in entry_lines(a)
|
|
assert res["app_icon"]["file"] == "app-icon.svg" and "png" not in res["app_icon"] # the PC can't draw SVG
|
|
# Steam takes PNGs only: the shortcut keeps the art set's icon
|
|
assert a.shortcut_args("linux.tool")[3] == str(Path(prep["anchor"]) / "artwork" / "icon.png")
|
|
|
|
|
|
def test_app_icon_prefers_big_pngs_and_stays_inside_the_app(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
root = tmp_path / "root"
|
|
for size in (32, 512):
|
|
d = root / "usr/share/icons/hicolor" / f"{size}x{size}" / "apps"
|
|
d.mkdir(parents=True)
|
|
(d / "tool.png").write_bytes(png(size))
|
|
(root / "usr/share/icons/hicolor/scalable/apps").mkdir(parents=True)
|
|
(root / "usr/share/icons/hicolor/scalable/apps/tool.svg").write_bytes(SVG)
|
|
(root / "tool.desktop").write_text("[Desktop Entry]\nIcon=tool\n[Desktop Action x]\nIcon=other\n")
|
|
assert a.find_app_icon(str(root), True)["icon"].endswith("512x512/apps/tool.png")
|
|
(root / "usr/share/icons/hicolor/512x512/apps/tool.png").unlink()
|
|
assert a.find_app_icon(str(root), True)["icon"].endswith("scalable/apps/tool.svg") # SVG beats a 32 px PNG
|
|
# a symlink out of the app (or an absolute / ../ Icon=) is never followed
|
|
secret = tmp_path / "secret.png"
|
|
secret.write_bytes(png(1024))
|
|
for p in list(root.rglob("tool.*")):
|
|
if p.suffix != ".desktop":
|
|
p.unlink()
|
|
(root / ".DirIcon").symlink_to(secret)
|
|
(root / "usr/share/pixmaps").mkdir(parents=True)
|
|
(root / "usr/share/pixmaps/tool.png").symlink_to(secret)
|
|
assert a.find_app_icon(str(root), True)["icon"] is None
|
|
for name in (str(secret), "../secret.png"):
|
|
(root / "tool.desktop").write_text(f"[Desktop Entry]\nIcon={name}\n")
|
|
assert a.find_app_icon(str(root), True)["icon"] is None
|
|
|
|
|
|
def test_folder_app_icon_next_to_its_desktop_file(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
prep = a.cmd_prepare_linux({"package": "linux.tool", "title": "Tool"})
|
|
app = Path(prep["incoming"]) / "app"
|
|
(app / "Tool/share/pixmaps").mkdir(parents=True)
|
|
(app / "Tool/share/applications").mkdir(parents=True)
|
|
shutil.copy("/bin/true", app / "Tool" / "tool")
|
|
(app / "Tool/share/applications/tool.desktop").write_text("[Desktop Entry]\nIcon=tool.png\n")
|
|
(app / "Tool/share/pixmaps/tool.png").write_bytes(png(64))
|
|
manifest = {rel: (app / rel).stat().st_size for rel in
|
|
("Tool/tool", "Tool/share/applications/tool.desktop", "Tool/share/pixmaps/tool.png")}
|
|
a.cmd_finalize_linux({"package": "linux.tool", "title": "Tool", "exe": "Tool/tool", "manifests": {"app": manifest}})
|
|
icon = Path(prep["anchor"]) / "artwork" / "app-icon.png"
|
|
assert icon.read_bytes() == png(64) and entry_lines(a)["Icon"] == str(icon)
|
|
# a new version without an icon: the old copy goes
|
|
(Path(prep["base"]) / "app/Tool/share/pixmaps/tool.png").unlink()
|
|
a.ensure_app_icon(a.deployment("linux.tool"), prep["anchor"], refresh=True)
|
|
assert not icon.exists()
|
|
|
|
|
|
def test_lepton_gets_paths_without_spaces(monkeypatch, tmp_path):
|
|
"""Lepton pastes STEAM_COMPAT_DATA_PATH unquoted into `sh -c "ln -s ..."`: a game on a card named "Steam Frame
|
|
512g" never got its internal storage (GitHub #213/#214/#215/#221). The launcher links it to a path without spaces
|
|
at every start; internal games keep their plain line."""
|
|
a = load(monkeypatch, tmp_path)
|
|
prep = quest_install(a, dest=str(sd_dir(tmp_path)))
|
|
anchor, base = Path(prep["anchor"]), Path(prep["base"])
|
|
text = (anchor / "launch.sh").read_text()
|
|
head = text[:text.index('[[ -d "$app_dir/lepton-app" ]]')]
|
|
out = subprocess.run(["bash", "-c", head + 'printf %s "$app_dir"'], capture_output=True, text=True, check=True)
|
|
link = Path(out.stdout)
|
|
assert " " not in out.stdout and link.resolve() == base.resolve()
|
|
assert (link / "lepton-app" / "game.apk").exists()
|
|
# an internal game is unchanged
|
|
other = quest_install(a, pkg="com.x.z")
|
|
assert f"app_dir={other['anchor']}\n" in (Path(other["anchor"]) / "launch.sh").read_text()
|
|
# uninstalling removes the link
|
|
a.cmd_uninstall({"package": "com.x.y", "keep_data": False})
|
|
assert not os.path.lexists(link)
|
|
|
|
|
|
def test_upgrade_gives_old_launchers_the_link(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
prep = quest_install(a, dest=str(sd_dir(tmp_path)))
|
|
path = Path(prep["anchor"]) / "launch.sh"
|
|
fresh = path.read_text()
|
|
m = a.APP_DIR_RE.search(fresh)
|
|
old = fresh.replace(m.group(0), "app_dir=" + a.shlex.quote(prep["base"])) # as agent <= 82 wrote it
|
|
path.write_text(old)
|
|
assert "com.x.y" in a.upgrade_launchers()
|
|
assert path.read_text() == fresh
|
|
assert a.upgrade_launchers() == [] # nothing left to do
|
|
assert subprocess.run(["bash", "-n", str(path)]).returncode == 0
|
|
|
|
|
|
def test_read_only_exfat_reports_mount_flag(monkeypatch, tmp_path):
|
|
a = load(monkeypatch, tmp_path)
|
|
d = a._drive(str(sd_dir(tmp_path)), "/unused", ("/dev/fake", str(sd_dir(tmp_path)), "exfat", ["ro"]))
|
|
assert d["read_only"] and not d["usable"]
|
|
assert "exfat" in d["reason"]
|