erplibre/test/test_mobile_bundle_transfer.py

#!/usr/bin/env python3
# © 2026 TechnoLibre (http://www.technolibre.ca)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
"""Transfert des dépôts ERPLibre dans l'application mobile.

L'application embarque le code des dépôts du manifeste pour le parcourir hors
ligne. Ils y entrent en PACKS, et c'est ce qui rend la chose possible : un APK
est un ZIP borné à 65535 entrées, quand les 139 dépôts pèsent plus de 116 000
fichiers. Un fichier par source donnait « Too many zip entries 123678
(MAX=65535) » — la compilation s'arrêtait là, et l'application ne portait rien.

Regroupés en tranches de 4 Mo, ces fichiers tiennent en 391 entrées. Mesuré sur
la VM : 3 002 entrées dans l'APK, 282 Mo, et 20 fichiers relus depuis les packs
identiques octet pour octet à leur source.

Ce que ces tests vérifient : qu'un transfert vide, tronqué ou incohérent est
DIT, et non pris pour bon. Les trois pannes correspondantes ont chacune leur
fixture.
"""

import json
import sys
import tempfile
import unittest
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
from script.mobile import check_bundle_transfer as cbt  # noqa: E402

# Contenu des sources factices : le nom du fichier -> ses octets.
SOURCES = {
    "odoo/release.py": b"version_info = (18, 0)\n",
    "odoo/api.py": b"def method():\n    return 1\n",
    "addons/sale/i18n/fr.po": b'msgid "x"\nmsgstr "y"\n',
    "README.md": b"# ERPLibre\n",
}


def build_bundle(
    tmp: Path,
    sources=None,
    *,
    with_workspace=True,
    break_pack=False,
    drop_pack=False,
    drop_index=False,
    no_manifest=False,
):
    """Fabrique un faux bundle, et la source qui va avec.

    Les avaries sont paramétrées plutôt que codées en dur : chaque test nomme
    celle qu'il éprouve, et la fixture reste unique."""
    sources = SOURCES if sources is None else sources
    mobile = tmp / "mobile" / "erplibre_home_mobile"
    repos = mobile / "dist" / "repos"
    slug = "github-com-ERPLibre-odoo"
    repo_dir = repos / slug
    repo_dir.mkdir(parents=True)
    if not no_manifest:
        (repos / "manifest.json").write_text(
            json.dumps(
                [
                    {
                        "url": "https://github.com/ERPLibre/odoo",
                        "name": "odoo",
                        "path": "odoo18.0/odoo",
                        "slug": slug,
                        "revision": "18.0",
                    }
                ]
            )
        )
    index = [{"path": "odoo", "type": "dir"}]
    blob = b""
    items = list(sources.items())
    for pos, (rel, data) in enumerate(items):
        # L'avarie ne touche que la DERNIÈRE entrée : gonfler toutes les
        # tailles décalerait chaque lecture et ferait échouer la comparaison
        # avant le contrôle de bornes — ce n'est pas la panne qu'on éprouve.
        last = pos == len(items) - 1
        index.append(
            {
                "path": rel,
                "type": "file",
                "chunk": 0,
                "offset": len(blob),
                "size": len(data) + (7 if (break_pack and last) else 0),
            }
        )
        blob += data
    if not drop_index:
        (repo_dir / "index.json").write_text(json.dumps(index))
    if not drop_pack:
        (repo_dir / "pack-000.bin").write_bytes(blob)
    if with_workspace:
        for rel, data in sources.items():
            src = tmp / "odoo18.0/odoo" / rel
            src.parent.mkdir(parents=True, exist_ok=True)
            src.write_bytes(data)
    return mobile


class TestAGoodTransfer(unittest.TestCase):
    def test_it_counts_repos_files_and_packs(self):
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp)
            rep = cbt.check(mobile, tmp, min_files=1)
        self.assertEqual(1, rep["repos"])
        self.assertEqual(len(SOURCES), rep["files"])
        self.assertEqual(1, rep["packs"])

    def test_it_reads_the_files_back_from_the_pack(self):
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp)
            rep = cbt.check(mobile, tmp, min_files=1)
        self.assertEqual(len(SOURCES), rep["checked"])

    def test_it_compares_them_to_the_source(self):
        """La seule vérification qui prouve un transfert FIDÈLE, et pas
        seulement cohérent."""
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp)
            rep = cbt.check(mobile, tmp, min_files=1)
        self.assertEqual(len(SOURCES), rep["compared"])

    def test_without_a_workspace_it_still_reads_the_packs(self):
        """Hors du checkout, la comparaison n'est pas possible ; la lecture,
        elle, l'est toujours."""
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp, with_workspace=False)
            rep = cbt.check(mobile, None, min_files=1)
        self.assertEqual(len(SOURCES), rep["checked"])
        self.assertEqual(0, rep["compared"])

    def test_read_from_pack_returns_the_exact_bytes(self):
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp)
            repo_dir = mobile / "dist/repos/github-com-ERPLibre-odoo"
            index = json.loads((repo_dir / "index.json").read_text())
            entry = next(
                e for e in index if e["path"] == "addons/sale/i18n/fr.po"
            )
            got = cbt.read_from_pack(repo_dir, entry)
        self.assertEqual(SOURCES["addons/sale/i18n/fr.po"], got)


class TestTheThreeFailures(unittest.TestCase):
    """Vide, tronqué, incohérent : trois pannes qu'un « build OK » ne dit pas."""

    def test_no_manifest_names_the_build(self):
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp, no_manifest=True)
            with self.assertRaises(FileNotFoundError) as ctx:
                cbt.check(mobile, tmp, min_files=1)
        self.assertIn("build", str(ctx.exception))

    def test_a_repo_without_index_is_named(self):
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp, drop_index=True)
            with self.assertRaises(FileNotFoundError) as ctx:
                cbt.check(mobile, tmp, min_files=1)
        self.assertIn("odoo", str(ctx.exception))

    def test_a_missing_pack_is_named(self):
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp, drop_pack=True)
            with self.assertRaises(FileNotFoundError) as ctx:
                cbt.check(mobile, tmp, min_files=1)
        self.assertIn("pack-000.bin", str(ctx.exception))

    def test_an_index_that_promises_too_much_is_refused(self):
        """Index et pack d'une compilation différente : le message doit nommer
        la tranche et les tailles, pas rendre un octet manquant en silence."""
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp, break_pack=True)
            with self.assertRaises(ValueError) as ctx:
                cbt.check(mobile, tmp, min_files=1)
        self.assertIn("pack-000.bin", str(ctx.exception))

    def test_an_empty_transfer_is_refused(self):
        """C'est le cas qui a existé pendant un temps : le bundle compilait,
        sans un seul dépôt dedans. « Réussi » ne voulait rien dire."""
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp, sources={"a.py": b"x\n"})
            with self.assertRaises(ValueError) as ctx:
                cbt.check(mobile, tmp)  # seuil par défaut
        self.assertIn("maigre", str(ctx.exception))

    def test_a_file_that_differs_from_the_source_is_named(self):
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp)
            (tmp / "odoo18.0/odoo/README.md").write_bytes(b"autre chose\n")
            with self.assertRaises(ValueError) as ctx:
                cbt.check(mobile, tmp, min_files=1)
        self.assertIn("README.md", str(ctx.exception))


class TestTheThreshold(unittest.TestCase):
    def test_the_default_threshold_rules_out_an_empty_bundle(self):
        """Le seul dépôt odoo en porte près de 40 000 : mille est un plancher
        qu'un vrai transfert dépasse de deux ordres de grandeur."""
        self.assertGreaterEqual(cbt.MIN_FILES, 1000)

    def test_the_sample_is_deterministic(self):
        """Une graine fixe : deux exécutions lisent les MÊMES fichiers, donc un
        échec est reproductible."""
        self.assertIsInstance(cbt.SEED, int)
        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp)
            first = cbt.check(mobile, tmp, min_files=1)
            second = cbt.check(mobile, tmp, min_files=1)
        self.assertEqual(first, second)


class TestTheCommandLine(unittest.TestCase):
    def test_it_says_the_counts_and_returns_zero(self):
        import io
        import contextlib

        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            mobile = build_bundle(tmp, sources=SOURCES)
            argv = [
                "check_bundle_transfer.py",
                str(mobile),
                "--workspace",
                str(tmp),
            ]
            buf = io.StringIO()
            with unittest.mock.patch.object(sys, "argv", argv), mock_min(1):
                with contextlib.redirect_stdout(buf):
                    code = cbt.main()
        self.assertEqual(0, code)
        self.assertIn("dépôts", buf.getvalue())

    def test_a_failure_is_one_line_not_a_traceback(self):
        """Le message part dans un journal d'installation : une trace Python y
        serait illisible, et la cause noyée."""
        import io
        import contextlib

        with tempfile.TemporaryDirectory() as d:
            tmp = Path(d)
            argv = ["check_bundle_transfer.py", str(tmp / "nulle-part")]
            buf = io.StringIO()
            with unittest.mock.patch.object(sys, "argv", argv):
                with contextlib.redirect_stdout(buf):
                    code = cbt.main()
        self.assertEqual(1, code)
        self.assertIn("⚠", buf.getvalue())
        self.assertNotIn("Traceback", buf.getvalue())


REPO = Path(__file__).resolve().parent.parent
MOBILE = REPO / "mobile" / "erplibre_home_mobile"
# Le plafond d'entrees d'un ZIP, et donc d'un APK.
ZIP_ENTRY_LIMIT = 65535


class TestTheRealBundle(unittest.TestCase):
    """Le VRAI transfert, quand le dépôt mobile est installé et compilé.

    C'est ici que ces tests DÉCLARENT leur dépendance : sans
    mobile/erplibre_home_mobile, ils se disent ignorés plutôt que de passer en
    silence — un test vert sans son dépôt ne prouve rien. Le lanceur
    (script/test/run_unit_test.sh) annonce la même dépendance avant de
    commencer.

    Ce qu'ils gardent : qu'une compilation réelle range les sources dans des
    CONTENEURS — archives tar.gz ou tranches pack, les deux dispositions
    conviennent. Un retour au fichier-par-source ferait revenir la limite du
    ZIP — 123 678 entrées pour un plafond de 65 535, silencieusement, jusqu'à
    l'APK. C'est le nombre d'entrées qui compte, pas la forme du conteneur.
    """

    @classmethod
    def setUpClass(cls):
        if not MOBILE.is_dir():
            # Pas de « relative_to » : il lève quand le chemin sort du
            # dépôt, et une erreur n'est pas un « ignoré » — mesuré en
            # simulant l'absence.
            raise unittest.SkipTest(
                "mobile/erplibre_home_mobile absent :"
                " ./mobile/install_mobile_dev.sh"
            )
        cls.repos = MOBILE / "dist" / "repos"
        manifeste = cls.repos / "manifest.json"
        if not manifeste.is_file():
            raise unittest.SkipTest(
                "dépôt mobile présent mais pas compilé :"
                " ./mobile/compile_and_run.sh (ou npm run build)"
            )
        # Manifeste PRÉSENT mais VIDE : l'application a été compilée sans le
        # transfert des dépôts. C'est un choix légitime, pas une régression —
        # et le distinguer importe, car ces tests échouaient alors sur
        # « aucun dépôt à vérifier », ce qui se lit comme une panne du
        # transfert. Vu le 23 août 2026 sur un build de 07:55 : manifeste à
        # zéro entrée, aucun pack.
        try:
            entrees = json.loads(manifeste.read_text())
        except (OSError, ValueError) as exc:
            raise unittest.SkipTest(f"manifeste illisible : {exc}")
        if not entrees:
            raise unittest.SkipTest(
                "compilé SANS les dépôts (manifeste vide) :"
                " relancer ./mobile/compile_and_run.sh pour les inclure"
            )
        # Manifeste PLEIN mais index MANQUANTS : un transfert interrompu, ou
        # un build qui a écrit le manifeste avant les paquets. Vu le
        # 24 août 2026 — « <slug> : index.json absent » remontait en ERREUR,
        # ce qui se lit comme une régression du transfert alors que rien
        # n'était encore transféré. Un état incomplet s'IGNORE ; seule une
        # incohérence entre ce qui est là et le dépôt doit échouer.
        # L'index se cherche par la MÊME résolution que le vérificateur : la
        # chercher ici en dur, sous `<slug>/index.json`, faisait sauter ces
        # tests sur toute compilation en archives — ils regardaient ailleurs au
        # lieu de vérifier.
        for entree in entrees:
            if not isinstance(entree, dict):
                continue
            try:
                cbt.index_path(cls.repos, entree)
            except (OSError, KeyError) as exc:
                raise unittest.SkipTest(
                    f"paquet incomplet ({exc}) :"
                    " relancer ./mobile/compile_and_run.sh"
                )

    def test_the_transfer_is_coherent(self):
        rep = cbt.check(MOBILE, REPO)
        self.assertGreater(rep["repos"], 1)
        self.assertGreater(rep["files"], cbt.MIN_FILES)
        # Peu importe la disposition : ce qui doit être vrai, c'est que les
        # sources soient dans des conteneurs et non une entrée ZIP chacune.
        self.assertGreater(rep["packs"] + rep["archives"], 0)

    def test_a_sample_matches_the_source(self):
        """La seule vérification qui prouve un transfert FIDÈLE."""
        rep = cbt.check(MOBILE, REPO)
        self.assertGreater(rep["compared"], 0)

    def test_the_apk_stays_under_the_zip_entry_limit(self):
        """Le garde-fou de la limite du ZIP, énoncé comme l'invariant qu'il est.

        Ce test exigeait un champ « chunk » sur chaque fichier, c'est-à-dire la
        disposition en packs. Il échouait donc sur une compilation en archives
        alors que la limite y est tenue — il testait la FORME au lieu de ce qui
        importe : combien d'entrées le ZIP de l'APK va porter. Un fichier par
        source en réclamerait 124 350 pour un plafond de 65 535."""
        man = json.loads((self.repos / "manifest.json").read_text())
        entries_in_apk = 0
        files = 0
        for proj in man:
            index = cbt.index_path(self.repos, proj)
            listing = json.loads(index.read_text())
            files += len([e for e in listing if e.get("type") == "file"])
            entries_in_apk += 1  # l'index lui-même
            if cbt.archive_path(self.repos, proj) is not None:
                entries_in_apk += 1  # une archive
                continue
            entries_in_apk += len(
                list((self.repos / proj["slug"]).glob("pack-*.bin"))
            )
        self.assertGreater(files, cbt.MIN_FILES, "aucun dépôt à vérifier")
        self.assertLess(
            entries_in_apk,
            ZIP_ENTRY_LIMIT,
            f"{entries_in_apk} entrées dans l'APK pour {files} fichiers",
        )
        # Et pas seulement « sous la limite » : l'écart doit rester d'un ordre
        # de grandeur, sans quoi le prochain dépôt ajouté la ferait sauter.
        self.assertLess(entries_in_apk, files // 10)

    def test_no_bundled_test_file_lingers_as_a_source(self):
        """Effet de bord mesuré, et il compte : empaquetés, les 1 599 fichiers
        de test des dépôts Odoo ne sont plus ramassés par vitest — 1 423
        fichiers de test ramenés à 75, 35 s ramenées à 3 s."""
        stray = list(self.repos.glob("*/**/*.test.ts"))
        self.assertEqual([], stray)


import contextlib as _contextlib  # noqa: E402
import unittest.mock  # noqa: E402


@_contextlib.contextmanager
def mock_min(value):
    """Abaisse le plancher le temps d'un test de ligne de commande."""
    old = cbt.MIN_FILES
    cbt.MIN_FILES = value
    try:
        yield
    finally:
        cbt.MIN_FILES = old


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