mirror of
https://git.triforceproject.com/triforce/source
synced 2026-11-19 16:20:01 -04:00
420 lines
19 KiB
Python
420 lines
19 KiB
Python
"""scripts/oot_saves.py, game-free: finding every emulator's folders, importing and exporting, the backups, the guards.
|
|
Temp folders only: HOME, XDG_DATA_HOME, APPDATA and LOCALAPPDATA all point into one.
|
|
|
|
python -I -B tests/test_oot_saves.py
|
|
"""
|
|
import contextlib
|
|
import importlib.util
|
|
import io
|
|
import os
|
|
from pathlib import Path
|
|
import tempfile
|
|
import unittest
|
|
from unittest import mock
|
|
|
|
# (Linux only)
|
|
RUN_ALL_SKIP = {
|
|
"windows": "the save script's folder discovery is the Linux one"
|
|
" (on Windows Hookshot's saves are in the game folder: --hookshot)",
|
|
}
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
spec = importlib.util.spec_from_file_location("oot_saves", ROOT / "scripts" / "oot_saves.py")
|
|
oot = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(oot)
|
|
|
|
UID = "0123456789abcdef0123456789abcdef"
|
|
PROFILE = "FEDCBA9876543210FEDCBA9876543210"
|
|
ACCOUNT = "00112233445566778899aabbccddeeff"
|
|
|
|
|
|
def make_save(folder, tag, slots=("slot_00", "slot_01")):
|
|
folder.mkdir(parents=True, exist_ok=True)
|
|
(folder / "account.sav").write_bytes(b"account-" + tag)
|
|
(folder / "option.sav").write_bytes(b"option-" + tag)
|
|
for s in slots:
|
|
(folder / s).mkdir()
|
|
(folder / s / "progress.sav").write_bytes(b"progress-" + tag + s.encode())
|
|
(folder / s / "caption.sav").write_bytes(b"caption-" + tag + s.encode())
|
|
|
|
|
|
def tree(folder):
|
|
return {str(p.relative_to(folder)): p.read_bytes() for p in sorted(folder.rglob("*")) if p.is_file()}
|
|
|
|
|
|
def eden_save(data, profile=PROFILE):
|
|
return data / "nand" / "user" / "save" / oot.NO_ACCOUNT / profile / oot.TITLE
|
|
|
|
|
|
class Case(unittest.TestCase):
|
|
def setUp(self):
|
|
self._tmp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self._tmp.cleanup)
|
|
self.tmp = Path(self._tmp.name)
|
|
self.home = self.tmp / "home"
|
|
self.data = self.home / ".local" / "share"
|
|
self.appdata = self.home / "AppData" / "Roaming"
|
|
self.localappdata = self.home / "AppData" / "Local"
|
|
self.hs = self.data / "hookshot" / "save" / UID
|
|
self.li = eden_save(self.data / "eden")
|
|
make_save(self.hs, b"HS")
|
|
make_save(self.li, b"LI", slots=("slot_00",))
|
|
self.backups = self.tmp / "backups"
|
|
env = mock.patch.dict(os.environ, {"HOME": str(self.home), "USERPROFILE": str(self.home), "XDG_DATA_HOME": str(self.data),
|
|
"APPDATA": str(self.appdata), "LOCALAPPDATA": str(self.localappdata)})
|
|
env.start()
|
|
self.addCleanup(env.stop)
|
|
idle = mock.patch.object(oot, "running_games", return_value=[])
|
|
self.running = idle.start()
|
|
self.addCleanup(idle.stop)
|
|
|
|
def run_main(self, *args):
|
|
out, err = io.StringIO(), io.StringIO()
|
|
with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
|
|
code = oot.main(list(args) + ["--backup-dir", str(self.backups)])
|
|
return code, out.getvalue(), err.getvalue()
|
|
|
|
def backup_dirs(self):
|
|
return sorted(self.backups.iterdir()) if self.backups.exists() else []
|
|
|
|
|
|
class Discovery(Case):
|
|
def test_every_entry_on_linux(self):
|
|
make_save(eden_save(self.data / "eglantine"), b"EG")
|
|
nx = self.home / "Games" / "Ocarina" / "profile" / "save" / ACCOUNT
|
|
make_save(nx, b"NX")
|
|
expect = {"lichii": self.li, "frizti": self.li, "orchid": self.li, "pokedinner": self.li, "eden": self.li,
|
|
"eglantine": eden_save(self.data / "eglantine"), "nx2navi": nx}
|
|
self.assertEqual(sorted(expect), sorted(p.name for p in oot.EMULATORS))
|
|
for program in oot.EMULATORS:
|
|
folder, found = oot.locate(program, None, "--from")
|
|
self.assertEqual(list(found.values()), [str(expect[program.name])], program.name)
|
|
self.assertEqual(oot.locate(oot.HOOKSHOT, None, "--hookshot")[1], {UID: str(self.hs)})
|
|
|
|
def test_every_entry_on_windows(self):
|
|
win_li = eden_save(self.appdata / "eden")
|
|
win_eg = eden_save(self.appdata / "eglantine")
|
|
win_nx = self.localappdata / "Programs" / "NX2navi" / "game" / "profile" / "save" / ACCOUNT
|
|
for folder in (win_li, win_eg, win_nx):
|
|
make_save(folder, b"W")
|
|
expect = {"lichii": win_li, "frizti": win_li, "orchid": win_li, "pokedinner": win_li, "eden": win_li,
|
|
"eglantine": win_eg, "nx2navi": win_nx}
|
|
with mock.patch.object(oot, "WINDOWS", True):
|
|
for program in oot.EMULATORS:
|
|
self.assertEqual(list(oot.locate(program, None, "--from")[1].values()), [str(expect[program.name])])
|
|
with self.assertRaises(oot.Fail) as e:
|
|
oot.locate(oot.HOOKSHOT, None, "--hookshot")
|
|
self.assertIn("--hookshot", str(e.exception))
|
|
game = self.tmp / "Hookshot"
|
|
make_save(game / "user" / "save" / UID, b"W")
|
|
self.assertEqual(oot.locate(oot.HOOKSHOT, str(game), "--hookshot")[1], {UID: str(game / "user" / "save" / UID)})
|
|
|
|
def test_aliases_of_names(self):
|
|
self.assertIs(oot.program_named("Fritchii"), oot.program_named("frizti"))
|
|
with self.assertRaises(oot.Fail):
|
|
oot.program_named("ryujinx")
|
|
|
|
def test_deeper_and_shallower_folders(self):
|
|
data = self.data / "eden"
|
|
for root in (data, data / "nand", data / "nand" / "user" / "save", self.li.parent.parent, self.li.parent,
|
|
self.li):
|
|
self.assertEqual(oot.find_saves(str(root)), {PROFILE: str(self.li)}, root)
|
|
for root in (self.data / "hookshot", self.hs.parent, self.hs):
|
|
self.assertEqual(oot.find_saves(str(root)), {UID: str(self.hs)}, root)
|
|
|
|
def test_empty_title_folder_is_a_target(self):
|
|
empty = eden_save(self.tmp / "portable" / "user", "11111111111111111111111111111111")
|
|
empty.mkdir(parents=True)
|
|
self.assertEqual(oot.find_saves(str(self.tmp / "portable" / "user")),
|
|
{"11111111111111111111111111111111": str(empty)})
|
|
self.assertEqual(oot.find_saves(str(empty)), {"11111111111111111111111111111111": str(empty)})
|
|
|
|
def test_eden_newer_layout(self):
|
|
data = self.tmp / "newer"
|
|
uuid = "a1b2c3d4e5f60718293a4b5c6d7e8f90"
|
|
save = data / "nand" / "user" / "save" / "account" / uuid / oot.TITLE / "0"
|
|
make_save(save, b"NEW")
|
|
for root in (data, save.parent, save):
|
|
self.assertEqual(oot.find_saves(str(root)), {uuid: str(save)}, root)
|
|
|
|
def test_unrelated_folders_are_not_saves(self):
|
|
(self.tmp / "junk" / "a" / "0").mkdir(parents=True)
|
|
(self.tmp / "junk" / "b" / "save" / UID).mkdir(parents=True)
|
|
self.assertEqual(oot.find_saves(str(self.tmp / "junk")), {})
|
|
|
|
def test_missing_folders(self):
|
|
with self.assertRaises(oot.Fail):
|
|
oot.locate(oot.FOLDER, str(self.tmp / "nothing"), "--from")
|
|
(self.tmp / "empty").mkdir()
|
|
with self.assertRaises(oot.Fail):
|
|
oot.locate(oot.FOLDER, str(self.tmp / "empty"), "--from")
|
|
with self.assertRaises(oot.Fail) as e:
|
|
oot.locate(oot.program_named("eglantine"), None, "--from")
|
|
self.assertIn(str(self.data / "eglantine"), str(e.exception))
|
|
|
|
def test_ambiguous_profiles_listed(self):
|
|
other = "11111111111111111111111111111111"
|
|
make_save(eden_save(self.data / "eden", other), b"O")
|
|
before = tree(self.li)
|
|
code, out, err = self.run_main("export", "lichii")
|
|
self.assertEqual(code, 1)
|
|
self.assertIn(PROFILE, err)
|
|
self.assertIn(other, err)
|
|
self.assertIn("--profile", err)
|
|
self.assertEqual(tree(self.li), before)
|
|
self.assertEqual(self.backup_dirs(), [])
|
|
code, out, err = self.run_main("export", "lichii", "--profile", other.lower())
|
|
self.assertEqual(code, 0, err)
|
|
|
|
def test_list(self):
|
|
make_save(self.home / "Games" / "Ocarina" / "profile" / "save" / ACCOUNT, b"NX")
|
|
code, out, err = self.run_main("list")
|
|
self.assertEqual(code, 0, err)
|
|
for text in (UID, PROFILE, ACCOUNT, "slot_01", "Lichii / Frizti (Fritchii) / Orchid / PokeDinner / Eden", "NX2navi",
|
|
"Eglantine: nothing in"):
|
|
self.assertIn(text, out)
|
|
|
|
def test_list_without_hookshot(self):
|
|
(self.hs / "account.sav").unlink()
|
|
for s in ("slot_00", "slot_01"):
|
|
for f in (self.hs / s).iterdir():
|
|
f.unlink()
|
|
(self.hs / s).rmdir()
|
|
code, out, err = self.run_main("list")
|
|
self.assertEqual(code, 0, err)
|
|
self.assertIn("Hookshot: no Hookshot save found", out)
|
|
self.assertIn(PROFILE, out)
|
|
|
|
|
|
class Copy(Case):
|
|
def test_export(self):
|
|
before = tree(self.li)
|
|
code, out, err = self.run_main("export", "lichii")
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual(tree(self.li), tree(self.hs))
|
|
(backup,) = self.backup_dirs()
|
|
self.assertTrue(backup.name.startswith("export-lichii-"))
|
|
self.assertEqual(tree(backup), before)
|
|
|
|
def test_import(self):
|
|
before = tree(self.hs)
|
|
code, out, err = self.run_main("import", "orchid")
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual(tree(self.hs), tree(self.li))
|
|
self.assertNotIn("slot_01", tree(self.hs))
|
|
(backup,) = self.backup_dirs()
|
|
self.assertTrue(backup.name.startswith("import-orchid-"))
|
|
self.assertEqual(tree(backup), before)
|
|
|
|
def test_old_names_still_work(self):
|
|
code, out, err = self.run_main("to-lichii")
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual(tree(self.li), tree(self.hs))
|
|
make_save(self.li / "slot_02", b"X", slots=())
|
|
code, out, err = self.run_main("to-hookshot", "--lichii", str(self.data / "eden"))
|
|
self.assertEqual(code, 0, err)
|
|
self.assertIn("slot_02", {Path(k).parts[0] for k in tree(self.hs)})
|
|
names = [b.name for b in self.backup_dirs()]
|
|
self.assertTrue(names[0].startswith("export-lichii-") and names[1].startswith("import-lichii-"), names)
|
|
|
|
def test_from_a_save_folder_and_a_data_folder(self):
|
|
other = self.tmp / "backup of a save"
|
|
make_save(other, b"F", slots=("slot_03",))
|
|
code, out, err = self.run_main("import", "--from", str(other))
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual(tree(self.hs), tree(other))
|
|
portable = self.tmp / "Lichii" / "user"
|
|
make_save(eden_save(portable), b"P", slots=("slot_04",))
|
|
code, out, err = self.run_main("import", "--from", str(portable))
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual(tree(self.hs), tree(eden_save(portable)))
|
|
self.assertTrue(all(b.name.startswith("import-folder-") for b in self.backup_dirs()))
|
|
|
|
def test_to_a_folder(self):
|
|
portable = self.tmp / "Eglantine" / "user"
|
|
target = eden_save(portable)
|
|
target.mkdir(parents=True) # (the game started once, nothing saved yet)
|
|
code, out, err = self.run_main("export", "eglantine", "--to", str(portable))
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual(tree(target), tree(self.hs))
|
|
|
|
def test_from_and_to_belong_to_their_command(self):
|
|
with contextlib.redirect_stderr(io.StringIO()):
|
|
with self.assertRaises(SystemExit):
|
|
oot.main(["export", "--from", str(self.li)])
|
|
with self.assertRaises(SystemExit):
|
|
oot.main(["import", "--to", str(self.li)])
|
|
code, out, err = self.run_main("import")
|
|
self.assertEqual(code, 1)
|
|
self.assertIn("--from", err)
|
|
|
|
def test_links_in_a_save_refused(self):
|
|
secret = self.tmp / "secret.txt"
|
|
secret.write_bytes(b"not a save")
|
|
before = tree(self.hs)
|
|
for make in (lambda o: (o / "slot_00" / "progress.sav").unlink() or (o / "slot_00" / "progress.sav").symlink_to(secret),
|
|
lambda o: (o / "account.sav").unlink() or (o / "account.sav").symlink_to(secret),
|
|
lambda o: (o / "slot_00" / "deep").symlink_to(self.tmp, target_is_directory=True)):
|
|
other = self.tmp / ("linked-%d" % len(list(self.tmp.glob("linked-*"))))
|
|
make_save(other, b"L", slots=("slot_00",))
|
|
make(other)
|
|
code, out, err = self.run_main("import", "--from", str(other))
|
|
self.assertEqual(code, 1, out)
|
|
self.assertIn("is a link", err)
|
|
self.assertEqual(tree(self.hs), before)
|
|
self.assertEqual(secret.read_bytes(), b"not a save")
|
|
|
|
def test_junction_refused(self):
|
|
# (a Windows junction is a reparse point, not a symbolic link; os.path.isjunction is only in Python 3.12 and newer)
|
|
other = self.tmp / "junction"
|
|
make_save(other, b"J", slots=("slot_00",))
|
|
deep = other / "slot_00" / "deep"
|
|
deep.mkdir()
|
|
real_lstat = os.lstat
|
|
|
|
class Junction:
|
|
def __init__(self, st):
|
|
self.st_mode, self.st_file_attributes = st.st_mode, 0x400 | 0x10
|
|
|
|
def lstat(path, *a, **k):
|
|
st = real_lstat(path, *a, **k)
|
|
return Junction(st) if os.path.abspath(path) == str(deep) else st
|
|
before = tree(self.hs)
|
|
with mock.patch.object(oot.os, "lstat", lstat):
|
|
code, out, err = self.run_main("import", "--from", str(other))
|
|
self.assertEqual(code, 1, out)
|
|
self.assertIn("is a link", err)
|
|
self.assertEqual(tree(self.hs), before)
|
|
|
|
def test_same_folder_refused(self):
|
|
code, out, err = self.run_main("import", "--from", str(self.hs))
|
|
self.assertEqual(code, 1)
|
|
self.assertIn("both the source and the target", err)
|
|
|
|
def test_backup_inside_target_refused_before_copy(self):
|
|
self.backups = self.hs / "backups"
|
|
before = tree(self.hs)
|
|
for extra in ((), ("--dry-run",)):
|
|
with self.subTest(extra=extra), mock.patch.object(
|
|
oot.shutil, "copytree", side_effect=AssertionError("recursive backup copy started")
|
|
):
|
|
code, _, err = self.run_main("import", "--from", str(self.li), "--hookshot", str(self.hs), *extra)
|
|
self.assertEqual(code, 1)
|
|
self.assertIn("--backup-dir outside the target save folder", err)
|
|
self.assertFalse(self.backups.exists())
|
|
self.assertEqual(tree(self.hs), before)
|
|
|
|
def test_keep_settings(self):
|
|
code, out, err = self.run_main("export", "lichii", "--keep-settings")
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual((self.li / "option.sav").read_bytes(), b"option-LI")
|
|
self.assertEqual((self.li / "account.sav").read_bytes(), b"account-HS")
|
|
self.assertEqual((self.li / "slot_01" / "progress.sav").read_bytes(), b"progress-HSslot_01")
|
|
|
|
def test_dry_run_changes_nothing(self):
|
|
before = (tree(self.hs), tree(self.li))
|
|
self.running.return_value = ["Lichii"] # (a dry run does not mind)
|
|
code, out, err = self.run_main("export", "lichii", "--dry-run")
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual((tree(self.hs), tree(self.li)), before)
|
|
self.assertEqual(self.backup_dirs(), [])
|
|
self.assertIn("Would copy", out)
|
|
|
|
def test_source_without_slots(self):
|
|
for s in ("slot_00", "slot_01"):
|
|
for f in (self.hs / s).iterdir():
|
|
f.unlink()
|
|
(self.hs / s).rmdir()
|
|
before = tree(self.li)
|
|
code, out, err = self.run_main("export", "lichii")
|
|
self.assertEqual(code, 1)
|
|
self.assertEqual(tree(self.li), before)
|
|
|
|
|
|
class NX2navi(Case):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.game = self.home / "Games" / "Ocarina"
|
|
self.nx = self.game / "profile" / "save" / ACCOUNT
|
|
make_save(self.nx, b"NX", slots=("slot_05",))
|
|
(self.game / "profile" / "account.uid").write_bytes(bytes(16))
|
|
(self.game / "profile" / "save-tx").mkdir()
|
|
|
|
def test_both_ways(self):
|
|
code, out, err = self.run_main("import", "nx2navi")
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual(tree(self.hs), tree(self.nx))
|
|
make_save(self.hs / "slot_00", b"Z", slots=())
|
|
code, out, err = self.run_main("export", "nx2navi", "--to", str(self.game))
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual(tree(self.nx), tree(self.hs))
|
|
self.assertEqual((self.game / "profile" / "account.uid").read_bytes(), bytes(16))
|
|
|
|
def test_waiting_save_refused(self):
|
|
(self.game / "profile" / "save-tx" / "commit").write_bytes(b"pending")
|
|
before = (tree(self.hs), tree(self.nx))
|
|
for command in ("import", "export"):
|
|
code, out, err = self.run_main(command, "nx2navi")
|
|
self.assertEqual(code, 1)
|
|
self.assertIn("save-tx", err)
|
|
self.assertEqual((tree(self.hs), tree(self.nx)), before)
|
|
self.assertEqual(self.backup_dirs(), [])
|
|
code, out, err = self.run_main("import", "nx2navi", "--force")
|
|
self.assertEqual(code, 0, err)
|
|
|
|
|
|
class Guard(Case):
|
|
def test_refuses_while_running(self):
|
|
self.running.return_value = ["Hookshot"]
|
|
before = (tree(self.hs), tree(self.li))
|
|
code, out, err = self.run_main("export", "lichii")
|
|
self.assertEqual(code, 1)
|
|
self.assertIn("Hookshot", err)
|
|
self.assertEqual((tree(self.hs), tree(self.li)), before)
|
|
self.assertEqual(self.backup_dirs(), [])
|
|
|
|
def test_force(self):
|
|
self.running.return_value = ["Lichii"]
|
|
code, out, err = self.run_main("export", "lichii", "--force")
|
|
self.assertEqual(code, 0, err)
|
|
self.assertEqual(tree(self.li), tree(self.hs))
|
|
|
|
def real(self):
|
|
# (the real running_games, not the test's mock of it)
|
|
real = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(real)
|
|
return real
|
|
|
|
def test_every_process_name_on_windows(self):
|
|
real = self.real()
|
|
names = real.process_names()
|
|
for program in [real.HOOKSHOT] + real.EMULATORS:
|
|
self.assertTrue(program.processes, program.name)
|
|
for p in program.processes:
|
|
self.assertIn(program.display, names[p])
|
|
out = "".join('"%s.exe","%d","Console","1","10 K"\r\n' % (p.upper() if i % 2 else p, i)
|
|
for i, p in enumerate(names))
|
|
out += '"notepad.exe","4","x","1","1 K"\r\n'
|
|
with mock.patch.object(real, "WINDOWS", True), \
|
|
mock.patch.object(real.subprocess, "run", return_value=mock.Mock(stdout=out)):
|
|
self.assertEqual(real.running_games(), sorted(set(names.values())))
|
|
|
|
def test_linux_processes_and_appimages(self):
|
|
real = self.real()
|
|
procs = {"10": ("orchid", "/opt/orchid/orchid"), "11": ("AppRun", "/home/x/eglantine-linux-x86_64.AppImage"),
|
|
"12": ("ocarina", "./ocarina"), "13": ("bash", "/bin/bash")}
|
|
|
|
def fake_open(path, *a, **k):
|
|
pid, what = path.split("/")[2:4]
|
|
comm, argv0 = procs[pid]
|
|
return io.BytesIO(argv0.encode() + b"\0-g\0") if what == "cmdline" else io.StringIO(comm + "\n")
|
|
|
|
with mock.patch.object(real, "WINDOWS", False), \
|
|
mock.patch.object(real.os, "listdir", return_value=list(procs) + ["self"]), \
|
|
mock.patch("builtins.open", fake_open):
|
|
self.assertEqual(real.running_games(), ["NX2navi", "Orchid", "PokeDinner or Eglantine"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|