libretro/tests/test_hidden_extras.py

"""A core file the builder holds but cannot place is not counted packed.

The builder skips a core extra whose destination a case-insensitive
filesystem folds onto a packed file, or that a packed file blocks as a
directory. verify counted both in "Core files: N in pack": RetroPie's
openmsx fmpac.rom (the pack carries the platform's FMPAC.ROM, other bytes),
ROCKNIX's higan SGB1.sfc/program.rom under the file SGB1.sfc.
"""

from __future__ import annotations

import os
import sys
import unittest
from pathlib import Path

REPO_ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO_ROOT / "scripts"))

from packpaths import placement_block  # noqa: E402


class OneRule(unittest.TestCase):
    def test_reasons(self):
        seen = {"bios/FMPAC.ROM", "bios/SGB1.sfc"}
        lower = {d.lower() for d in seen}
        parents = {"bios"}
        cases = {
            "bios/FMPAC.ROM": "taken",
            "bios/fmpac.rom": "case_twin",
            "bios/SGB1.sfc/program.rom": "path_conflict",
            "bios/other.rom": None,
        }
        for dest, reason in cases.items():
            with self.subTest(dest=dest):
                self.assertEqual(
                    placement_block(dest, seen, lower, parents, True), reason
                )
        self.assertIsNone(
            placement_block("bios/fmpac.rom", seen, lower, parents, False)
        )

    def test_builder_and_report_read_it(self):
        for module in ("generate_pack.py", "packextras.py"):
            source = (REPO_ROOT / "scripts" / module).read_text(encoding="utf-8")
            self.assertIn("placement_block(", source, module)
        builder = (REPO_ROOT / "scripts" / "generate_pack.py").read_text(
            encoding="utf-8"
        )
        self.assertNotIn("if full_dest.lower() in seen_lower and case_insensitive", builder)

    def test_a_refused_declaration_occupies_nothing(self):
        """verify counted a declaration whose hash the frontend refuses as
        occupying its path; the builder leaves it out, and the core file
        that then takes the path was reported missing from the pack."""
        source = (REPO_ROOT / "scripts" / "verify.py").read_text(encoding="utf-8")
        compact = " ".join(source.split())
        self.assertRegex(
            compact,
            r"baseline_verdict\( file_entry, local_path, resolve_status, mode.{0,60}?\)\[1\] is None",
        )


class TheIntegrityCheckFoldsCaseLikeTheBuilder(unittest.TestCase):
    """--verify-packs counted a file present through its case twin on Lakka,
    whose filesystem keeps bios.col and BIOS.col apart: a pack missing one
    of the two passed step 6."""

    def test_case_folding_reads_the_platform(self):
        source = (REPO_ROOT / "scripts" / "packverify.py").read_text(encoding="utf-8")
        compact = " ".join(source.split())
        self.assertRegex(
            compact,
            r"zip_lower = \( \{n\.lower\(\): n for n in zip_set\} "
            r"if config\.get\(\"case_insensitive_fs\", False\) else \{\} \)",
        )


class TheReportSaysSo(unittest.TestCase):
    """Reads the repository: skips when the database is absent."""

    @classmethod
    def setUpClass(cls):
        if not (REPO_ROOT / "database.json").exists():
            raise unittest.SkipTest("database.json is not built")
        previous = os.getcwd()
        os.chdir(REPO_ROOT)
        try:
            from common import load_database, load_emulator_profiles
            from verify import verify_platform
            from common import load_platform_config

            db = load_database("database.json")
            profiles = load_emulator_profiles("emulators")
            # Platforms whose filesystem folds case; RetroPie and Lakka run on
            # Linux and keep both names.
            cls.results = {
                name: verify_platform(
                    load_platform_config(name, "platforms"), db, "emulators", profiles
                )
                for name in ("retroarch", "retrobat")
            }
        finally:
            os.chdir(previous)

    def _entry(self, emulator: str, path: str, platform: str = "retroarch") -> dict:
        for u in self.results[platform]["undeclared_files"]:
            if u.get("emulator") == emulator and (u.get("path") or u.get("name")) == path:
                return u
        self.skipTest(f"{emulator} {path} is not in the cross-reference")

    def test_a_case_twin_with_other_bytes_is_left_out(self):
        entry = self._entry("NP2kai", "np2kai/bios.rom", "retrobat")
        self.assertIs(entry.get("in_pack"), False)
        self.assertIn("another case", entry.get("omitted", ""))

    def test_a_twin_with_the_same_bytes_serves_the_core(self):
        # MesenCE opens bios.col; RetroArch's pack folds it onto BIOS.col,
        # the same bytes, which serves the core on a folding filesystem.
        entry = self._entry("MesenCE", "bios.col")
        self.assertIsNot(entry.get("in_pack"), False)

    def test_a_directory_under_a_packed_file_is_left_out(self):
        entry = self._entry("nSide (SFC Balanced)", "SGB1.sfc/lr35902.boot.rom")
        self.assertIs(entry.get("in_pack"), False)



class TheGapReportIsComputedOnce(unittest.TestCase):
    """verify_platform ran find_undeclared_files twice with the same
    arguments, once itself and once through hidden_extras: every
    resolution twice, 8% of verify --all."""

    def test_one_call_per_platform(self):
        if not (REPO_ROOT / "database.json").exists():
            self.skipTest("database.json is not built")
        from unittest import mock

        previous = os.getcwd()
        os.chdir(REPO_ROOT)
        try:
            import verify
            from common import load_database, load_emulator_profiles, load_platform_config

            db = load_database("database.json")
            profiles = load_emulator_profiles("emulators")
            config = load_platform_config("emudeck", "platforms")
            with mock.patch.object(
                verify, "find_undeclared_files", wraps=verify.find_undeclared_files
            ) as counted:
                verify.verify_platform(config, db, "emulators", profiles)
        finally:
            os.chdir(previous)
        self.assertEqual(counted.call_count, 1)


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