Skip to content

Play your own Switch games on iPhone/iPad — one-click macOS app, no terminal. | 把 Switch 游戏装进 iPhone:图形界面一键构建,不用命令行。Bring your own game.

16.5 KB
Raw Blame
"""A Switch 2 game as a folder of its files or one NUP file builds with no prod.keys (LNPANDY/NX2Apple#512, #445).
The same cases as the Mac launcher's GameFolder tests. Synthetic folders and NUP bytes, no game data.

The model tests need PySide6 and are skipped without it."""
from __future__ import annotations

import os
import struct
import sys
import tempfile
import unittest
from pathlib import Path
from unittest import mock

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / 'frontend-qt'))
os.environ.setdefault('QT_QPA_PLATFORM', 'offscreen')

from nspb_qt import inputs   # noqa: E402

try:
    from nspb_qt import model as model_mod   # noqa: E402
    from nspb_qt.i18n import Lang   # noqa: E402
except ImportError:          # no PySide6
    model_mod = None

TID = 0x0400000000A00000


def npdm(program_id: int) -> bytes:
    """A minimal main.npdm: META header, the ACI0 section at 0x80 with the program ID at +0x10."""
    d = bytearray(0x100)
    d[:4] = b'META'
    struct.pack_into('<II', d, 0x70, 0x80, 0x40)
    d[0x80:0x84] = b'ACI0'
    struct.pack_into('<Q', d, 0x90, program_id)
    return bytes(d)


def nup(packages: list[tuple[int, int, int]], size_delta: int = 0, magic: bytes = b'NUP\x01') -> bytes:
    """A NUP: header, then the table of contents at 0x80 with one 0x40 entry per (title ID, version, kind)."""
    toc = 0x80
    total = toc + 0x30 + 0x40 * len(packages)
    d = bytearray(total)
    d[:4] = magic
    struct.pack_into('<Q', d, 0x08, toc)
    struct.pack_into('<Q', d, 0x40, total + size_delta)
    struct.pack_into('<I', d, 0x48, len(packages))
    d[toc:toc + 4] = b'TOC\x01'
    for i, (tid, version, kind) in enumerate(packages):
        o = toc + 0x30 + i * 0x40
        struct.pack_into('<Q', d, o, tid)
        struct.pack_into('<I', d, o + 20, version)
        d[o + 24] = kind
    return bytes(d)


class FolderTests(unittest.TestCase):
    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory()
        self.dir = Path(self._tmp.name) / 'game'
        self.dir.mkdir()

    def tearDown(self):
        self._tmp.cleanup()

    def make(self, rel: str, data: bytes = b'x') -> Path:
        p = self.dir / rel
        p.parent.mkdir(parents=True, exist_ok=True)
        p.write_bytes(data)
        return p

    def game(self, tid: int = TID):
        self.make('base/exefs/main.npdm', npdm(tid))
        (self.dir / 'base/romfs').mkdir(parents=True, exist_ok=True)

    def scan(self):
        return inputs.scan_game_folder(str(self.dir))

    def problem(self, kind: str, args: tuple = ()):
        r = self.scan()
        self.assertEqual(r, inputs.GameFolderProblem(kind, args))

    # ---- detection

    def test_candidates(self):
        self.assertFalse(inputs.is_game_folder_candidate(str(self.dir)))
        self.make('exefs/main.npdm')
        self.assertTrue(inputs.is_game_folder_candidate(str(self.dir)))   # one level too high
        (self.dir / 'base').mkdir()
        self.assertFalse(inputs.is_game_folder_candidate(str(self.dir)))

    def test_candidate_base_and_nup(self):
        self.game()
        self.assertTrue(inputs.is_game_folder_candidate(str(self.dir)))
        other = self.dir.parent / 'other'
        other.mkdir()
        (other / 'g.NUP').write_bytes(b'')
        self.assertTrue(inputs.is_game_folder_candidate(str(other)))
        self.assertTrue(inputs.is_game_folder_candidate(str(other / 'g.NUP')))
        (other / '._g.nup').write_bytes(b'')
        self.assertEqual(inputs.nup_files(str(other)), ['g.NUP'])

    # ---- a folder of files

    def test_contents(self):
        self.game()
        (self.dir / 'updates/458752/romfs').mkdir(parents=True)
        (self.dir / 'updates/65536/romfs').mkdir(parents=True)
        (self.dir / 'updates/notes').mkdir(parents=True)
        (self.dir / f'dlc/{TID + 0x1001:016x}/0/romfs').mkdir(parents=True)
        (self.dir / f'dlc/{TID + 0x1002:016X}/romfs').mkdir(parents=True)
        r = self.scan()
        self.assertIsInstance(r, inputs.GameFolderContents)
        self.assertEqual(r.title_id, TID)
        self.assertEqual(r.title_id_hex, '0400000000A00000')
        self.assertEqual([v for v, _ in r.updates], [65536, 458752])
        self.assertEqual(r.newest_update[0], 458752)
        self.assertEqual([t for t, _ in r.dlc], [TID + 0x1001, TID + 0x1002])
        self.assertIsNone(r.nup)
        self.assertEqual(r.script_input, str(self.dir))
        self.assertEqual(r.base_path, str(self.dir / 'base'))

    def test_base_without_romfs_but_update_has_one(self):
        self.make('base/exefs/main.npdm', npdm(TID))
        self.problem('missing', ('base/romfs',))
        (self.dir / 'updates/1/romfs').mkdir(parents=True)
        self.assertIsInstance(self.scan(), inputs.GameFolderContents)

    def test_problems(self):
        self.problem('missing', ('base/exefs/main.npdm',))
        self.make('exefs/main.npdm')
        self.problem('noBaseFolder')

    def test_unreadable_npdm(self):
        self.make('base/exefs/main.npdm', b'not an npdm')
        (self.dir / 'base/romfs').mkdir()
        self.problem('unreadableNPDM')
        self.make('base/exefs/main.npdm', npdm(TID)[:0x84])   # ACI0 cut short
        self.problem('unreadableNPDM')

    def test_not_base_title(self):
        self.game(TID + 0x800)
        self.problem('notBaseTitle', ('0400000000A00800',))

    def test_package_beside(self):
        self.game()
        self.make('game.NSZ')
        self.problem('packageBeside', ('game.NSZ',))
        os.remove(self.dir / 'game.NSZ')
        self.make('._x.nsp')
        self.assertIsInstance(self.scan(), inputs.GameFolderContents)

    def test_dlc_problems(self):
        self.game()
        (self.dir / 'dlc/bonus/romfs').mkdir(parents=True)
        self.problem('dlcName', ('bonus',))
        os.rename(self.dir / 'dlc/bonus', self.dir / f'dlc/{TID + 0x5000:016X}')
        self.problem('notDLC', (f'{TID + 0x5000:016X}',))
        os.rename(self.dir / f'dlc/{TID + 0x5000:016X}', self.dir / f'dlc/{TID + 0x1001:016X}')
        self.assertIsInstance(self.scan(), inputs.GameFolderContents)
        (self.dir / f'dlc/{TID + 0x1001:016X}/romfs').rmdir()
        self.problem('dlcRomFS', (f'{TID + 0x1001:016X}', 0))
        (self.dir / f'dlc/{TID + 0x1001:016X}/1/romfs').mkdir(parents=True)
        (self.dir / f'dlc/{TID + 0x1001:016X}/2/romfs').mkdir(parents=True)
        self.problem('dlcRomFS', (f'{TID + 0x1001:016X}', 2))

    def test_problem_keys_exist_in_the_shared_strings(self):
        from nspb_qt import l10n
        for kind in ('missing', 'noBaseFolder', 'unreadableNPDM', 'notBaseTitle', 'packageBeside', 'dlcName', 'notDLC',
                     'dlcRomFS', 'notNUP', 'nupPartial', 'severalNUPs'):
            self.assertIn(inputs.GameFolderProblem(kind).l10n_key, l10n.CATALOGS['en'])

    def test_program_id(self):
        self.assertEqual(inputs.program_id(npdm(TID)), TID)
        self.assertIsNone(inputs.program_id(b'META'))
        self.assertIsNone(inputs.program_id(b'XXXX' + npdm(TID)[4:]))

    # ---- a NUP

    def test_nup_base_updates_dlc(self):
        p = self.make('Game.nup', nup([(TID, 0, 0), (TID + 0x800, 65536, 1), (TID + 0x800, 458752, 1),
                                        (TID + 0x1002, 0, 2), (TID + 0x1001, 0, 2)]))
        for r in (inputs.scan_game_folder(str(p)), self.scan()):   # the file, and the folder that holds it
            self.assertIsInstance(r, inputs.GameFolderContents)
            self.assertEqual(r.title_id, TID)
            self.assertEqual(r.nup, str(p))
            self.assertEqual(r.folder, str(self.dir))
            self.assertEqual([v for v, _ in r.updates], [65536, 458752])
            self.assertEqual([t for t, _ in r.dlc], [TID + 0x1001, TID + 0x1002])
            self.assertEqual(r.script_input, str(p))
            self.assertEqual(r.base_path, str(p))

    def test_nup_title_id_from_an_update_or_none(self):
        p = self.make('a.nup', nup([(TID + 0x800, 1, 1)]))
        self.assertEqual(inputs.read_nup(str(p)).title_id, TID)
        p = self.make('a.nup', nup([(TID, 0, 0), (TID + 0x800, 1, 1)]))
        self.assertEqual(inputs.read_nup(str(p)).title_id, TID)
        p = self.make('a.nup', nup([(TID + 0x1001, 0, 2)]))
        r = inputs.read_nup(str(p))
        self.assertEqual(r.title_id, 0)
        self.assertFalse(r.has_title_id)

    def test_nup_problems(self):
        self.make('a.nup', nup([(TID, 0, 0)], magic=b'NUP\x02'))
        self.problem('notNUP', ('a.nup',))
        self.make('a.nup', nup([(TID, 0, 0)], size_delta=5))
        self.problem('nupPartial', ('a.nup',))
        self.make('a.nup', b'short')
        self.problem('notNUP', ('a.nup',))
        self.make('a.nup', nup([(TID, 0, 0)])[:-8])
        self.assertIsInstance(self.scan(), inputs.GameFolderProblem)   # cut table: partial
        self.make('a.nup', nup([(TID, 0, 0)]))
        self.make('b.nup', nup([(TID, 0, 0)]))
        self.problem('severalNUPs', (2,))

    def test_nup_beside_packages_is_refused(self):
        self.make('a.nup', nup([(TID, 0, 0)]))
        self.make('g.xci')
        self.problem('packageBeside', ('g.xci',))


@unittest.skipIf(model_mod is None, 'PySide6 is not installed')
class ModelTests(unittest.TestCase):
    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory()
        root = Path(self._tmp.name)
        self.eng = root / 'engine'   # an engine tree: the marker file makes it the repo itself
        (self.eng / 'dm/tools/nx_extract').mkdir(parents=True)
        (self.eng / 'dm/tools/nx_extract/Program.cs').write_text('')
        (self.eng / 'scripts').mkdir()
        for n in ('pack_dump.py', 'pack_nup.py'):
            (self.eng / 'scripts' / n).write_text('')
        (self.eng / 'scripts/build_ipa_from_nsp.py').write_text("p.add_argument('--work-dir')\n")
        (self.eng / f'dm/games/{TID:016X}').mkdir(parents=True)
        (self.eng / f'dm/games/{TID:016X}/game.tsv').write_text('name\tGame\n')
        self.game = root / 'game'
        (self.game / 'base/exefs').mkdir(parents=True)
        (self.game / 'base/romfs').mkdir()
        (self.game / 'base/exefs/main.npdm').write_bytes(npdm(TID))
        self.m = model_mod.Model()
        self.m.lang = Lang('en')
        self.m.repo_path = str(self.eng)
        self.m.python_path = '/usr/bin/python3'

    def tearDown(self):
        self._tmp.cleanup()

    def ready(self):
        """Pass the dependency gate: this is about the inputs."""
        p = mock.patch.object(model_mod.Model, 'all_deps_ok', new_callable=mock.PropertyMock, return_value=True)
        p.start()
        self.addCleanup(p.stop)

    def test_folder_fills_rows_and_needs_no_keys(self):
        self.ready()
        (self.game / 'updates/458752/romfs').mkdir(parents=True)
        (self.game / f'dlc/{TID + 0x1001:016X}/0/romfs').mkdir(parents=True)
        self.m.scan_game_dir(str(self.game))
        self.assertEqual(self.m.keys_path, '')
        self.assertTrue(self.m.can_build)
        self.assertEqual(self.m.input_row_text('base'), 'Game folder, title ID 0400000000A00000 from main.npdm')
        self.assertEqual(self.m.input_row_text('update'), 'Update version 458752')
        self.assertEqual(self.m.input_row_text('dlc'), 'Add-on content folders: 1')
        self.assertIn('Not needed', self.m.input_row_text('keys'))

    def test_several_updates_text_uses_both_numbers(self):
        (self.game / 'updates/1/romfs').mkdir(parents=True)
        (self.game / 'updates/2/romfs').mkdir(parents=True)
        self.m.scan_game_dir(str(self.game))
        self.assertEqual(self.m.input_row_text('update'), 'Update version 2, the newest of 2')

    def test_nup_rows(self):
        self.ready()
        p = self.game.parent / 'g.nup'
        p.write_bytes(nup([(TID, 0, 0)]))
        self.m.scan_game_dir(str(p))
        self.assertTrue(self.m.can_build)
        self.assertEqual(self.m.base_path, str(p))
        self.assertEqual(self.m.input_row_text('base'), f'NUP file, title ID {TID:016X}')
        p.write_bytes(nup([(TID + 0x1001, 0, 2)]))
        self.m.scan_game_dir(str(p))
        self.assertEqual(self.m.input_row_text('base'), 'NUP file. The build reads its title ID.')

    def test_refused_with_the_reason(self):
        self.ready()
        (self.game / 'base/romfs').rmdir()
        self.m.scan_game_dir(str(self.game))
        self.assertFalse(self.m.can_build)
        self.assertEqual(self.m.game_folder_problem, 'This game folder has no base/romfs.')
        self.assertIsNone(self.m.input_row_text('base'))

    def test_refused_without_a_profile_or_with_an_old_engine(self):
        (self.eng / f'dm/games/{TID:016X}/game.tsv').unlink()
        self.m.scan_game_dir(str(self.game))
        self.assertIn(f'The engine has no profile for {TID:016X}.', self.m.game_folder_problem)
        self.assertIsNone(self.m.game_folder)
        (self.eng / 'scripts/pack_dump.py').unlink()
        self.m.scan_game_dir(str(self.game))
        self.assertEqual(self.m.game_folder_problem, 'This engine does not build game folders. Update the engine first.')
        p = self.game.parent / 'g.nup'
        p.write_bytes(nup([(TID, 0, 0)]))
        (self.eng / 'scripts/pack_nup.py').unlink()
        self.m.scan_game_dir(str(p))
        self.assertEqual(self.m.game_folder_problem, 'This engine does not build NUP files. Update the engine first.')

    def test_dlc_problem_text_has_both_numbers(self):
        (self.game / f'dlc/{TID + 0x1001:016X}/romfs').mkdir(parents=True)
        (self.game / f'dlc/{TID + 0x1001:016X}/romfs').rmdir()
        (self.game / f'dlc/{TID + 0x1001:016X}').mkdir(exist_ok=True)
        self.m.scan_game_dir(str(self.game))
        self.assertEqual(self.m.game_folder_problem, f'dlc/{TID + 0x1001:016X} needs one romfs folder and has 0.')

    def test_picking_packages_leaves_the_mode(self):
        self.m.scan_game_dir(str(self.game))
        self.assertIsNotNone(self.m.game_folder)
        self.m.leave_game_folder()
        self.assertIsNone(self.m.game_folder)
        self.assertEqual((self.m.base_path, self.m.update_path, self.m.dlc_paths), ('', '', []))
        self.assertIsNone(self.m.input_row_text('keys'))
        self.assertFalse(self.m.can_build)   # packages need the keys again

    def run_build(self, out_dir: str = '') -> tuple[list[str], 'model_mod.Model']:
        self.m.out_dir = out_dir
        seen: list[list[str]] = []

        class Fake:
            returncode = 1
            stdout: list[str] = []

            def __init__(self, cmd, **kw):
                seen.append(cmd)

            def wait(self):
                pass

        with mock.patch.object(model_mod.subprocess, 'Popen', Fake), \
                mock.patch.object(model_mod.pu, 'IS_WIN', False):
            self.m.start_build()
            self.m._thread.join(10)
        builds = [c for c in seen if '--progress' in c]   # other processes may start too (the dependency checks)
        self.assertTrue(builds, 'the script was not started')
        return builds[0], self.m

    def test_build_arguments_for_a_folder(self):
        self.ready()
        self.m.scan_game_dir(str(self.game))
        args, m = self.run_build()
        self.assertNotIn('-k', args)
        self.assertEqual(args[args.index(str(self.eng / 'scripts/build_ipa_from_nsp.py')) + 1], str(self.game))
        self.assertEqual(args[args.index('--work-dir') + 1], str(self.game / f'{TID:016X}_build'))
        self.assertEqual(m.effective_work_dir, str(self.game / f'{TID:016X}_build'))

    def test_build_arguments_for_a_nup_with_an_output_folder(self):
        self.ready()
        p = self.game.parent / 'g.nup'
        p.write_bytes(nup([(TID, 0, 0)]))
        self.m.scan_game_dir(str(p))
        out = str(self.game.parent / 'out')
        self.m.target = 'mac-app'
        args, _ = self.run_build(out)
        self.assertNotIn('-k', args)
        self.assertEqual(args[args.index(str(self.eng / 'scripts/build_ipa_from_nsp.py')) + 1], str(p))
        self.assertEqual(args[args.index('--work-dir') + 1], str(Path(out, f'{TID:016X}_build')))
        self.assertEqual(args[args.index('-o') + 1], str(Path(out, f'{TID:016X}.app')))

    def test_a_nup_without_a_title_id_names_the_build_after_the_file(self):
        self.ready()
        p = self.game.parent / 'g.nup'
        p.write_bytes(nup([(TID + 0x1001, 0, 2)]))
        self.m.scan_game_dir(str(p))
        self.assertEqual(self.m.build_key, inputs.build_key(str(p)))

    def test_packages_still_pass_the_keys(self):
        self.ready()
        pk = self.game.parent / 'pk'
        pk.mkdir()
        (pk / '0100AAAA0000A000.nsp').write_bytes(b'x')
        (pk / 'prod.keys').write_bytes(b'x')
        self.m.scan_game_dir(str(pk))
        self.assertIsNone(self.m.game_folder)
        args, _ = self.run_build()
        self.assertEqual(args[args.index('-k') + 1], str(pk / 'prod.keys'))


if __name__ == '__main__':
    unittest.main()