refactor: build every manifest entry in one place

tests/test_manifest_entry.py

@@ -0,0 +1,100 @@
+"""A manifest entry always names somewhere to fetch it from.
+
+The entry was built twice, once for the platform's files and once for the
+core extras, and only the first copy turned a file with no repo path and no
+release asset into an omission. An extra whose hash matched nothing in the
+database (a copy not yet indexed, or a hash computed wrong) was written with
+an empty repo_path, and the installer refused the whole manifest.
+"""
+
+from __future__ import annotations
+
+import ast
+import json
+import sys
+import unittest
+from pathlib import Path
+from unittest import mock
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+
+import generate_pack as gp  # noqa: E402
+
+
+def _held_file(db: dict) -> tuple[str, dict] | None:
+    for sha1, record in db.get("files", {}).items():
+        path = REPO_ROOT / record.get("path", "")
+        if record.get("size", 0) < 4096 and path.is_file():
+            return sha1, record
+    return None
+
+
+class AnEntryWithoutSourceIsAnOmission(unittest.TestCase):
+    def setUp(self):
+        db_path = REPO_ROOT / "database.json"
+        if not db_path.exists():
+            self.skipTest("database.json is not built")
+        self.db = json.loads(db_path.read_text(encoding="utf-8"))
+        held = _held_file(self.db)
+        if held is None:
+            self.skipTest("no small indexed file on disk")
+        self.sha1, self.record = held
+
+    def _run_core_entries(self, hashes: dict) -> tuple[list, dict, list]:
+        name = Path(self.record["path"]).name
+        extra = {
+            "name": name,
+            "sha1": self.sha1,
+            "destination": f"probe/{name}",
+            "source_emulator": "probe",
+        }
+        files: list = []
+        omitted: dict = {}
+        pack_only: list = []
+
+        def record(full_dest, entry, system, reason, cores):
+            omitted[full_dest] = reason
+
+        with mock.patch.object(gp, "compute_hashes", return_value=hashes):
+            gp._manifest_core_entries(
+                [extra], {}, self.db, str(REPO_ROOT / "bios"), "", str(REPO_ROOT),
+                {}, True, set(), False, set(), set(), set(), files, {},
+                record, pack_only,
+            )
+        return files, omitted, pack_only
+
+    def test_a_hash_the_database_lacks_is_omitted(self):
+        files, omitted, pack_only = self._run_core_entries(
+            {"sha1": "0" * 40, "sha256": "0" * 64}
+        )
+        self.assertEqual(files, [])
+        self.assertEqual(list(omitted.values()), ["not_found"])
+        self.assertEqual(pack_only, [self.record["size"]])
+
+    def test_a_held_file_is_an_entry_with_its_repo_path(self):
+        files, omitted, _pack_only = self._run_core_entries(
+            {"sha1": self.sha1, "sha256": self.record.get("sha256", "")}
+        )
+        self.assertEqual(omitted, {})
+        self.assertEqual(len(files), 1)
+        self.assertTrue(files[0]["repo_path"])
+
+
+class OneBuilderForEveryEntry(unittest.TestCase):
+    """Two copies of the entry let one drift: the guard lived in one only."""
+
+    def test_the_download_record_is_built_in_one_place(self):
+        tree = ast.parse((REPO_ROOT / "scripts" / "generate_pack.py").read_text())
+        builders = [
+            node.lineno
+            for node in ast.walk(tree)
+            if isinstance(node, ast.Dict)
+            and {"repo_path", "sha256"}
+            <= {k.value for k in node.keys if isinstance(k, ast.Constant)}
+        ]
+        self.assertEqual(len(builders), 1, f"entry dicts at lines {builders}")
+
+
+if __name__ == "__main__":
+    unittest.main()