"""launcher/ and tools/make_game.py's bookkeeping, without game files or Windows. Run: python tests/launcher_test.py (Python 3.14 for the zstd tests; the window test needs tkinter, numpy and a display) - versions, settings - toolchain: the package database, dependency resolution and an install from a local fake repository - net: downloads that resume, check their sha256 and stop on cancel - feed: GitHub releases (stable, preview, private with a token) and a plain manifest URL, served locally - updater: staging a release, switching, rollback, pruning, refusing unsafe archives - gamefiles: the .bfotf font wrapping and zstd dictionaries, on a font of this system made into a fake RomFS - make_game.py: a synthetic .nup through the check, exefs and romfs steps with --events, skipped steps on a second run, --rebuild without the game files, and the object cache of the compile step with the system's C compiler - jobs: an install driven by a fake make_game.py - the window: --selftest draws every screen (skipped without a display) """ import hashlib import http.server import io import json import os import shutil import struct import subprocess import sys import tarfile import tempfile import threading import unittest import zipfile from pathlib import Path ROOT = Path(__file__).resolve().parent.parent sys.path.insert(0, str(ROOT)) sys.path.insert(0, str(ROOT / 'tools')) from launcher import build, feed, gamefiles, jobs, net, settings, toolchain, updater, versions # noqa: E402 from launcher.context import Context # noqa: E402 from launcher.paths import Layout # noqa: E402 try: from compression import zstd as ZSTD except ImportError: ZSTD = None # ---------------------------------------------------------------- helpers class Server: """A local HTTP server for a folder, with extra routes (path -> (status, headers, body)) and Range support.""" def __init__(self, folder, routes=None): folder, routes = Path(folder), routes if routes is not None else {} self.hits = [] server = self class H(http.server.BaseHTTPRequestHandler): def log_message(self, *a): pass def do_GET(self): server.hits.append((self.path, dict(self.headers))) if self.path in routes: status, headers, body = routes[self.path] self.send_response(status) for k, v in headers.items(): self.send_header(k, v) self.send_header('Content-Length', str(len(body))) self.end_headers() self.wfile.write(body) return p = folder / self.path.lstrip('/').split('?')[0] if not p.is_file(): self.send_error(404) return data = p.read_bytes() rng = self.headers.get('Range') if rng and rng.startswith('bytes='): start = int(rng[6:].split('-')[0]) if start >= len(data): self.send_error(416) return self.send_response(206) self.send_header('Content-Range', f'bytes {start}-{len(data) - 1}/{len(data)}') data = data[start:] else: self.send_response(200) self.send_header('Content-Length', str(len(data))) self.end_headers() try: self.wfile.write(data) except ConnectionError: # the client stopped reading (the cancel test) pass self.httpd = http.server.ThreadingHTTPServer(('127.0.0.1', 0), H) self.url = f'http://127.0.0.1:{self.httpd.server_address[1]}/' threading.Thread(target=self.httpd.serve_forever, daemon=True).start() def close(self): self.httpd.shutdown() def sha(data): return hashlib.sha256(data).hexdigest() def tar_bytes(files, compress=True): """A tar (zstd-compressed when the stdlib has zstd, else gzip) of {name: bytes}.""" buf = io.BytesIO() mode = 'w:gz' if not (compress and ZSTD) else 'w' with tarfile.open(fileobj=buf, mode=mode) as t: for name, data in files.items(): info = tarfile.TarInfo(name) info.size = len(data) t.addfile(info, io.BytesIO(data)) data = buf.getvalue() return ZSTD.compress(data) if compress and ZSTD else data def desc(name, version, filename, data, depends=(), provides=()): lines = ['%FILENAME%', filename, '', '%NAME%', name, '', '%VERSION%', version, '', '%CSIZE%', str(len(data)), '', '%ISIZE%', str(len(data) * 3), '', '%SHA256SUM%', sha(data), ''] if depends: lines += ['%DEPENDS%', *depends, ''] if provides: lines += ['%PROVIDES%', *provides, ''] return '\n'.join(lines).encode() def fake_repo(folder, damage=None): """A pacman repository with the ten root packages (each holding one of make_game.py's required files), one dependency and one name provided by another package.""" P = toolchain.PREFIX files = {'clang': {'ucrt64/bin/clang.exe': b'clang', 'ucrt64/bin/clang++.exe': b'clang++'}, 'sdl3': {'ucrt64/bin/SDL3.dll': b'sdl', 'ucrt64/lib/libSDL3.dll.a': b'implib'}, 'vulkan-memory-allocator': {'ucrt64/include/vma/vk_mem_alloc.h': b'// vma'}, 'vulkan-loader': {'ucrt64/lib/libvulkan-1.dll.a': b'implib'}, 'llvm-libs': {'ucrt64/bin/libLLVM.dll': b'llvm', 'ucrt64/share/doc/llvm/README': b'skipped'}} deps = {'clang': [P + 'llvm-libs=23.1', P + 'gcc'], 'sdl3': [P + 'vulkan']} entries = {} for root in list(toolchain.ROOTS) + ['llvm-libs']: name = P + root fn = f'{name}-1.0-1-any.pkg.tar.zst' data = tar_bytes({'.PKGINFO': b'pkg', **files.get(root, {f'ucrt64/share/{root}/x': b'x'})}) if damage == root: (folder / fn).write_bytes(data[:-3] + b'bad') else: (folder / fn).write_bytes(data) entries[f'{name}-1.0-1/desc'] = desc(name, '1.0-1', fn, data, deps.get(root, ()), [P + 'vulkan'] if root == 'vulkan-loader' else ()) (folder / 'ucrt64.db').write_bytes(tar_bytes(entries)) class Tmp(unittest.TestCase): def setUp(self): self.tmp = Path(tempfile.mkdtemp(prefix='nx2navi-test-')) self.addCleanup(shutil.rmtree, self.tmp, True) self.layout = Layout(root=self.tmp / 'launcher', app=ROOT).ensure() # ---------------------------------------------------------------- versions, settings class VersionTest(unittest.TestCase): def test_order(self): self.assertTrue(versions.newer('0.3.11', '0.3.10')) self.assertTrue(versions.newer('0.4', '0.3.99')) self.assertFalse(versions.newer('0.3.10+abc', '0.3.10')) self.assertTrue(versions.newer('1.0.0', '1.0.0-rc1')) self.assertEqual(versions.display('0.3.11+abc1234'), '0.3.11') with self.assertRaises(ValueError): versions.parse('banana') class SettingsTest(Tmp): def test_roundtrip_and_reset(self): s = settings.Settings(self.layout.settings) self.assertTrue(s['auto_check']) s['auto_check'], s['game_dir'], s['channel'] = False, 'D:/g', 'preview' s.save() t = settings.Settings(self.layout.settings) self.assertEqual((t['auto_check'], t['game_dir'], t['channel']), (False, 'D:/g', 'preview')) t.reset() self.assertEqual((t['auto_check'], t['game_dir'], t['channel']), (True, 'D:/g', 'stable')) def test_bad_types_ignored(self): self.layout.settings.write_text(json.dumps({'auto_check': 'yes', 'channel': 'preview', 'junk': 1})) s = settings.Settings(self.layout.settings) self.assertEqual((s['auto_check'], s['channel']), (True, 'preview')) self.assertNotIn('junk', s) # ---------------------------------------------------------------- toolchain class ToolchainTest(Tmp): def test_resolve_and_install(self): repo = self.tmp / 'repo' repo.mkdir() fake_repo(repo) srv = Server(repo) self.addCleanup(srv.close) lock = toolchain.make_lock(srv.url) names = [p['name'] for p in lock['packages']] self.assertEqual(names[0], toolchain.PREFIX + 'clang') self.assertIn(toolchain.PREFIX + 'llvm-libs', names) # a dependency with a version constraint self.assertEqual(names.count(toolchain.PREFIX + 'vulkan-loader'), 1) # 'vulkan' resolves to its provider self.assertFalse(toolchain.is_current(self.layout, lock)) phases = [] toolchain.install(self.layout, lock, progress=lambda ph, d, t: phases.append(ph), log=lambda m: None) self.assertTrue(toolchain.is_current(self.layout, lock)) self.assertTrue((self.layout.msys / 'bin' / 'clang.exe').is_file()) self.assertFalse((self.layout.msys / 'share' / 'doc').exists()) # documentation left out self.assertIn('download', phases) self.assertIn('unpack', phases) hits = len(srv.hits) toolchain.install(self.layout, lock, log=lambda m: None) # cached package files: no download self.assertEqual(len(srv.hits), hits) self.assertEqual(toolchain.lock_digest(lock), toolchain.installed(self.layout)['digest']) def test_damaged_package_refused(self): repo = self.tmp / 'repo' repo.mkdir() fake_repo(repo, damage='opus') srv = Server(repo) self.addCleanup(srv.close) lock = toolchain.make_lock(srv.url) with self.assertRaises(toolchain.ToolchainError): toolchain.install(self.layout, lock, log=lambda m: None) self.assertFalse(toolchain.is_current(self.layout, lock)) def test_wheel_tag(self): tag = toolchain.wheel_tag()[0] self.assertTrue(tag.startswith(f'cp{sys.version_info.major}{sys.version_info.minor}-')) # ---------------------------------------------------------------- net class NetTest(Tmp): def test_download_resume_and_checks(self): data = os.urandom(3 * net.CHUNK + 123) (self.tmp / 'f.bin').write_bytes(data) srv = Server(self.tmp) self.addCleanup(srv.close) dest = self.tmp / 'out' / 'f.bin' dest.parent.mkdir() (dest.parent / 'f.bin.part').write_bytes(data[:1000]) # a part file from a cut connection net.download(srv.url + 'f.bin', dest, sha256=sha(data), size=len(data)) self.assertEqual(dest.read_bytes(), data) self.assertEqual(srv.hits[-1][1].get('Range'), 'bytes=1000-') with self.assertRaises(net.DownloadError): net.download(srv.url + 'f.bin', self.tmp / 'out' / 'g.bin', sha256='0' * 64) self.assertFalse((self.tmp / 'out' / 'g.bin').exists()) with self.assertRaises(net.Cancelled): net.download(srv.url + 'f.bin', self.tmp / 'out' / 'h.bin', cancel=lambda: True) with self.assertRaises(net.DownloadError): net.download(srv.url + 'missing.bin', self.tmp / 'out' / 'm.bin') # ---------------------------------------------------------------- feed and updater def make_app_zip(folder, ver, extra=None): app = folder / f'app-{ver}' (app / 'launcher').mkdir(parents=True) (app / 'launcher' / 'start.pyw').write_text('# test\n') (app / 'VERSION').write_text(ver + '\n') z = folder / f'NX2navi-app-{ver}.zip' with zipfile.ZipFile(z, 'w') as zf: for p in app.rglob('*'): if p.is_file(): zf.write(p, p.relative_to(app).as_posix()) for name, data in (extra or {}).items(): zf.writestr(name, data) return z def manifest_for(z, ver): return {'format': 1, 'version': ver, 'notes': '- One\n- Two', 'app': {'name': z.name, 'size': z.stat().st_size, 'sha256': sha(z.read_bytes())}} class FeedTest(Tmp): def serve_github(self): self.routes = {} srv = Server(self.tmp, self.routes) self.addCleanup(srv.close) return srv def publish(self, releases): self.routes['/repos/o/r/releases?per_page=20'] = (200, {'Content-Type': 'application/json'}, json.dumps(releases).encode()) def release(self, srv, tag, ver, pre=False, manifest=True): z = make_app_zip(self.tmp, ver) m = self.tmp / f'm-{ver}.json' m.write_text(json.dumps(manifest_for(z, ver))) assets = [{'name': z.name, 'browser_download_url': srv.url + z.name, 'url': srv.url + z.name}] if manifest: assets.append({'name': feed.MANIFEST, 'browser_download_url': srv.url + m.name, 'url': srv.url + m.name}) return {'tag_name': tag, 'prerelease': pre, 'draft': False, 'body': 'notes', 'html_url': 'x', 'assets': assets} def test_github_channels(self): srv = self.serve_github() self.publish([self.release(srv, 'v0.4.0-rc1', '0.4.0-rc1', pre=True), self.release(srv, 'v0.3.12', '0.3.12', manifest=False), self.release(srv, 'v0.3.11', '0.3.11')]) f = {'type': 'github', 'repo': 'o/r', 'api': srv.url.rstrip('/')} self.assertEqual(feed.latest(f, 'stable').version, '0.3.11') # 0.3.12 lacks a manifest self.assertEqual(feed.latest(f, 'preview').version, '0.4.0-rc1') r = feed.latest(f, 'stable', token='secret') self.assertEqual(r.headers.get('Authorization'), 'Bearer secret') self.assertTrue(any(h.get('Authorization') == 'Bearer secret' for _, h in srv.hits)) self.assertEqual(feed.plain_notes('## Head\n- **One**\n* `Two`\n'), ['Head', 'One', 'Two']) def test_url_feed_and_update(self): z = make_app_zip(self.tmp, '0.9.0') (self.tmp / feed.MANIFEST).write_text(json.dumps(manifest_for(z, '0.9.0'))) srv = Server(self.tmp) self.addCleanup(srv.close) rel = feed.latest({'type': 'url', 'url': srv.url + feed.MANIFEST}) self.assertEqual(rel.version, '0.9.0') self.layout.apps.mkdir(parents=True) (self.layout.apps / 'current.txt').write_text('0.8.0\n') old = self.layout.apps / '0.8.0' / 'launcher' old.mkdir(parents=True) (old / 'start.pyw').write_text('') for stale in ('0.7.0', '0.6.0'): (self.layout.apps / stale).mkdir() folder = updater.stage_app(self.layout, rel) self.assertTrue((folder / 'launcher' / 'start.pyw').is_file()) updater.switch_to(self.layout, '0.9.0') self.assertEqual((updater.current(self.layout), updater.previous(self.layout)), ('0.9.0', '0.8.0')) updater.prune(self.layout) self.assertEqual(sorted(p.name for p in self.layout.apps.iterdir() if p.is_dir()), ['0.8.0', '0.9.0']) self.assertTrue(updater.rollback(self.layout)) self.assertEqual(updater.current(self.layout), '0.8.0') self.assertFalse(updater.rollback(self.layout)) # nothing further back def test_unsafe_or_wrong_archives(self): z = make_app_zip(self.tmp, '1.0.0', extra={'../evil.txt': 'x'}) with self.assertRaises(updater.UpdateError): updater.safe_extract(z, self.tmp / 'x') self.assertFalse((self.tmp / 'evil.txt').exists()) z2 = make_app_zip(self.tmp, '1.0.1') m = manifest_for(z2, '1.0.2') # the archive says 1.0.1 (self.tmp / feed.MANIFEST).write_text(json.dumps(m)) srv = Server(self.tmp) self.addCleanup(srv.close) rel = feed.Release(m, assets={z2.name: srv.url + z2.name}) with self.assertRaises(updater.UpdateError): updater.stage_app(self.layout, rel) self.assertFalse((self.layout.apps / '1.0.2').exists()) # ---------------------------------------------------------------- gamefiles def sarc(files): names = b'' offs = [] for n in files: offs.append(len(names)) b = n.encode() + b'\0' names += b + b'\0' * (-len(b) % 4) data, ents = b'', b'' for (n, d), no in zip(files.items(), offs): start = len(data) data += d ents += struct.pack('{len(body) // 4}I', body) return struct.pack('>II', 0x7F9A0218 ^ key, len(otf) ^ key) + struct.pack(f'>{len(words)}I', *(w ^ key for w in words)) @unittest.skipUnless(ZSTD, 'needs compression.zstd (Python 3.14)') class FontTest(Tmp): FONT = Path('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf') @unittest.skipUnless(FONT.is_file(), 'needs DejaVu Sans') def test_font_from_romfs_image(self): otf = self.FONT.read_bytes() self.assertEqual(gamefiles.bfotf_to_otf(bfotf(otf)), otf) self.assertIsNone(gamefiles.bfotf_to_otf(b'\0' * 64)) samples = [otf[i:i + 512] for i in range(0, min(len(otf), 400000), 997)] d = ZSTD.train_dict(samples, 16384) packed = ZSTD.compress(bfotf(otf), zstd_dict=d) self.assertNotEqual(ZSTD.get_frame_info(packed).dictionary_id, 0) files = {'Pack/ZsDic.pack.zs': ZSTD.compress(sarc({'zs.zsdic': d.dict_content})), gamefiles.FONTS['title']: packed} romfs = self.tmp / 'game' / 'romfs' romfs.mkdir(parents=True) entries, blob = [], b'' for path, data in sorted(files.items()): blob += b'\0' * (-len(blob) % 16) entries.append({'path': path, 'offset': len(blob), 'size': len(data)}) blob += data (romfs / 'romfs.bin').write_bytes(blob) (romfs / 'index.json').write_text(json.dumps({'files': entries})) got = gamefiles.extract_fonts(self.layout, self.tmp / 'game') self.assertEqual(got['title'][1], 'DejaVu Sans') self.assertEqual(Path(got['title'][0]).read_bytes(), otf) self.assertEqual(gamefiles.cached_fonts(self.layout)['title'][1], 'DejaVu Sans') # ---------------------------------------------------------------- make_game.py def nso(build_id=b'\0' * 16, size=0x300): head = bytearray(0x100) head[0:4] = b'NSO0' segs = [(0x100 + i * size, i * 0x10000, size) for i in range(3)] for i, (fo, mo, sz) in enumerate(segs): struct.pack_into('