erplibre/test/test_proxmox_nesting.py

#!/usr/bin/env python3
# © 2026 TechnoLibre (http://www.technolibre.ca)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
"""Combien d'étages de Proxmox tiennent, et avec quelles ressources.

L'écran de déploiement lisait la capacité de l'HÔTE et l'offrait en entier.
Sur un troisième étage à 14 cœurs et 9 Go de libre, il a proposé 12 vCPU et
9 Go à une VM qui n'a jamais démarré : même RIP à trois relevés deux minutes
d'écart, pas un octet lu de plus. Le nombre n'était pas absurde pour la
machine ; il l'était pour sa profondeur.
"""

import sys
import unittest

sys.argv = ["todo.py"]
from script.proxmox import nesting  # noqa: E402


class TestLePlanDesEtages(unittest.TestCase):
    """Le plan se dimensionne DEPUIS LE BAS, et c'est une correction.

    De haut en bas, chaque étage recevait ce que son parent pouvait céder.
    Mesuré sur une descente réelle : l'étage 4 se retrouvait avec 44 Go de RAM
    et deux vCPU sur un hôte qui en avait deux — cent pour cent de
    surengagement, à chaque étage. Son installation dépassait deux heures et
    demie contre treize minutes pour l'étage 3, et l'extrapolation donnait cinq
    ANS pour le dixième.

    Le plus profond reçoit donc ce qu'un Proxmox de test demande, et chaque
    parent ajoute son propre surcoût — un vCPU, deux gibioctets, dix
    gigaoctets. Rien de plus."""

    # La machine réelle sur laquelle l'algorithme a été réglé.
    HOTE = dict(cpu_hote=28, ram_dispo_mo=58000, disque_libre_go=165)

    def test_ten_levels_fit_on_this_machine(self):
        plan = nesting.nesting_plan(10, **self.HOTE)
        self.assertEqual(plan["atteignable"], 10)
        self.assertEqual(plan["arret"], "")

    def test_the_deepest_level_gets_exactly_the_target(self):
        """C'est de là qu'on part : ce qu'un Proxmox de test demande, pas ce
        qui reste."""
        plan = nesting.nesting_plan(10, **self.HOTE)
        fond = plan["niveaux"][-1]
        self.assertEqual(fond["ram"], nesting.PVE_RAM_CIBLE_MO)
        self.assertEqual(fond["disque"], nesting.PVE_DISQUE_CIBLE_GO)
        self.assertEqual(fond["vcpu"], nesting.VCPU_IMBRIQUE)

    def test_each_parent_adds_exactly_its_own_overhead(self):
        # Ni plus ni moins : un parent plus large que nécessaire ralentit tout
        # ce qu'il héberge, un parent trop juste ne le fait pas tourner. Vaut
        # pour la mémoire et le disque — le processeur, lui, ne croît pas avec
        # la profondeur, voir test_no_nested_level_is_ever_wide.
        niveaux = nesting.nesting_plan(8, **self.HOTE)["niveaux"]
        for parent, enfant in zip(niveaux, niveaux[1:]):
            self.assertEqual(parent["ram"] - enfant["ram"], nesting.PVE_RAM_MO)
            self.assertEqual(
                parent["disque"] - enfant["disque"], nesting.PVE_DISQUE_GO
            )

    def test_no_nested_level_is_ever_wide(self):
        """MESURÉ, deux fois : au quatrième étage un invité large GÈLE.

        Douze vCPU d'abord, sur un parent qui en avait deux : on avait imputé
        le gel au surengagement. Puis huit vCPU sur un parent qui en avait
        NEUF, charge 1,47, aucun surengagement — 32 Mio lus en 106 minutes,
        même RIP à trois relevés espacés de cinq minutes. C'est le nombre de
        vCPU de l'invité imbriqué, et rien d'autre.

        Une version de ce module donnait un vCPU de plus à chaque parent, ce
        qui rendait l'étage 4 large de huit : exactement le cas gelé. Aucun
        étage imbriqué ne doit dépasser VCPU_INTERMEDIAIRE, à AUCUNE
        profondeur demandée."""
        for profondeur in range(1, 13):
            niveaux = nesting.nesting_plan(profondeur, **self.HOTE)["niveaux"]
            for n in niveaux[1:]:
                self.assertLessEqual(
                    n["vcpu"],
                    nesting.VCPU_INTERMEDIAIRE,
                    f"profondeur {profondeur}, étage {n['niveau']}",
                )

    def test_the_three_widths_are_where_they_belong(self):
        """Le coût d'un vCPU dépend de la PROFONDEUR de l'étage, pas d'une
        largeur absolue.

        Mesuré : le troisième vCPU ne coûte rien aux étages 2 et 3 — ssh en
        37 s et 93 s, comme à deux vCPU — et coûte 4 h 20 au quatrième, contre
        1 664 s à deux. Un seul vCPU de plus, l'amorçage ×9,4."""
        niveaux = nesting.nesting_plan(6, **self.HOTE)["niveaux"]
        largeurs = {n["niveau"]: n["vcpu"] for n in niveaux}
        # Le métal : aucun risque de gel, onze vCPU y ont démarré en 42 s.
        self.assertEqual(largeurs[1], nesting.VCPU_METAL)
        # Peu profonds : le troisième vCPU est gratuit, et il enlève le
        # surengagement là où l'installation s'effondrait.
        for niveau in range(2, nesting.SEUIL_ETROIT):
            self.assertEqual(
                largeurs[niveau], nesting.VCPU_INTERMEDIAIRE, f"étage {niveau}"
            )
        # À partir du seuil : le strict minimum, sans exception.
        for niveau in range(nesting.SEUIL_ETROIT, 7):
            self.assertEqual(
                largeurs[niveau], nesting.VCPU_IMBRIQUE, f"étage {niveau}"
            )

    def test_the_level_above_the_threshold_keeps_its_headroom(self):
        """C'est le seul endroit de la descente où le surengagement disparaît,
        et c'est celui qui compte : l'étage 4 est le premier dont
        l'installation s'effondrait, faute d'un parent plus large que lui.

        Les deux combinaisons mesurées étaient (parent 2, enfant 2) — démarre
        en 1 664 s puis l'installation ne finit pas — et (parent 3, enfant 3) —
        démarre en 15 608 s. Celle-ci est (parent 3, enfant 2)."""
        niveaux = nesting.nesting_plan(6, **self.HOTE)["niveaux"]
        largeurs = {n["niveau"]: n["vcpu"] for n in niveaux}
        parent = largeurs[nesting.SEUIL_ETROIT - 1]
        enfant = largeurs[nesting.SEUIL_ETROIT]
        self.assertGreater(parent, enfant)

    def test_a_single_level_descent_runs_on_metal(self):
        niveaux = nesting.nesting_plan(1, **self.HOTE)["niveaux"]
        self.assertEqual(len(niveaux), 1)
        self.assertEqual(niveaux[0]["vcpu"], nesting.VCPU_METAL)

    def test_a_parent_is_never_narrower_than_its_child(self):
        """Deux vCPU hébergeant deux vCPU, c'est cent pour cent de
        surengagement — et l'hyperviseur à servir en plus. Mesuré : une VM
        démarrée au quatrième étage a lu DEUX KILO-OCTETS en onze minutes,
        affamée par l'installation qui tournait à côté. L'installation de
        l'étage 4 dépassait alors 2 h 50 contre 793 s pour l'étage 3.

        « Jamais plus étroit », et non « toujours plus large » : deux étages
        imbriqués voisins ont la même largeur, ce que le gel du quatrième
        étage impose. C'est le PLUS PROFOND qui descend à deux."""
        for coeurs in (6, 8, 12, 28):
            with self.subTest(coeurs=coeurs):
                niveaux = nesting.nesting_plan(
                    6,
                    cpu_hote=coeurs,
                    ram_dispo_mo=64000,
                    disque_libre_go=400,
                )["niveaux"]
                for parent, enfant in zip(niveaux, niveaux[1:]):
                    self.assertGreaterEqual(parent["vcpu"], enfant["vcpu"])
                    self.assertGreater(parent["ram"], enfant["ram"])
                    self.assertGreater(parent["disque"], enfant["disque"])

    def test_the_cpu_only_ever_refuses_outright(self):
        """Le processeur ne borne plus une profondeur INTERMÉDIAIRE : les
        étages imbriqués gardent une largeur fixe, seul le premier compte sur
        le métal. Ou la machine peut le porter, ou elle ne peut rien.

        Une version d'avant faisait croître la demande avec la profondeur —
        onze vCPU pour dix étages — et bornait donc à trois étages sur huit
        cœurs. Elle rendait aussi le quatrième étage large de huit, ce qui le
        gelait : la borne cachait un défaut."""
        large = nesting.nesting_plan(
            10, cpu_hote=8, ram_dispo_mo=64000, disque_libre_go=400
        )
        self.assertEqual(large["atteignable"], 10)
        self.assertEqual(large["arret"], "")
        # Trop petite pour le premier étage : zéro, et le dire.
        for coeurs in (1, 2, 4):
            with self.subTest(coeurs=coeurs):
                petite = nesting.nesting_plan(
                    10,
                    cpu_hote=coeurs,
                    ram_dispo_mo=64000,
                    disque_libre_go=400,
                )
                self.assertEqual(petite["atteignable"], 0)
                self.assertEqual(petite["arret"], "vcpu")
        # Et le premier étage laisse à l'hôte ce qui lui est réservé.
        self.assertLessEqual(
            large["niveaux"][0]["vcpu"], 8 - nesting.HOTE_RESERVE_VCPU
        )

    def test_the_named_resource_is_the_one_that_really_binds(self):
        """La version d'avant prenait la première d'une chaîne figée
        ram > disque > vcpu, évaluée à la profondeur DEMANDÉE. Sur deux cœurs
        et 20 Go elle annonçait « manque de ram » quand le processeur bornait à
        zéro étage : l'opérateur doublait la mémoire et n'y gagnait rien."""
        for cpu, ram, disque, attendu in (
            (2, 20000, 5000, "vcpu"),
            (2, 200000, 100, "vcpu"),
            (4, 16384, 200, "vcpu"),
            (28, 12288, 500, "ram"),
            (28, 200000, 60, "disque"),
        ):
            with self.subTest(cpu=cpu, ram=ram, disque=disque):
                plan = nesting.nesting_plan(10, cpu, ram, disque)
                self.assertEqual(plan["arret"], attendu)
                # Et c'est bien le plus BAS des trois plafonds.
                self.assertEqual(
                    plan["plafonds"][attendu], min(plan["plafonds"].values())
                )
                self.assertEqual(
                    plan["atteignable"], min(10, *plan["plafonds"].values())
                )

    def test_doubling_the_named_resource_gains_a_level(self):
        """L'épreuve utile du diagnostic : ce qu'il nomme, ajouté, PAIE."""
        base = dict(cpu_hote=28, ram_dispo_mo=12288, disque_libre_go=500)
        avant = nesting.nesting_plan(10, **base)
        self.assertEqual(avant["arret"], "ram")
        apres = nesting.nesting_plan(
            10, **{**base, "ram_dispo_mo": base["ram_dispo_mo"] * 2}
        )
        self.assertGreater(apres["atteignable"], avant["atteignable"])

    def test_a_huge_depth_costs_nothing(self):
        # Le balayage décroissant tournait autant de tours que la profondeur
        # demandée pour rendre exactement le même plan.
        plan = nesting.nesting_plan(10**6, 28, 58000, 165)
        self.assertEqual(plan["atteignable"], min(plan["plafonds"].values()))
        self.assertEqual(len(plan["niveaux"]), plan["atteignable"])

    def test_running_out_of_ram_is_named(self):
        plan = nesting.nesting_plan(
            10, cpu_hote=28, ram_dispo_mo=12288, disque_libre_go=500
        )
        self.assertEqual(plan["arret"], "ram")
        self.assertLess(plan["atteignable"], 10)
        for n in plan["niveaux"]:
            self.assertGreaterEqual(n["ram"], nesting.RAM_MIN_MO)

    def test_running_out_of_disk_is_named(self):
        plan = nesting.nesting_plan(
            10, cpu_hote=28, ram_dispo_mo=200000, disque_libre_go=60
        )
        self.assertEqual(plan["arret"], "disque")
        for n in plan["niveaux"]:
            self.assertGreaterEqual(n["disque"], nesting.DISQUE_MIN_GO)

    def test_a_depth_of_zero_asks_for_nothing(self):
        for profondeur in (0, -1, -7):
            with self.subTest(profondeur=profondeur):
                plan = nesting.nesting_plan(profondeur, **self.HOTE)
                self.assertEqual(plan["niveaux"], [])
                self.assertEqual(plan["atteignable"], 0)

    def test_a_machine_too_small_for_even_one_level(self):
        plan = nesting.nesting_plan(
            3, cpu_hote=2, ram_dispo_mo=4096, disque_libre_go=200
        )
        self.assertEqual(plan["atteignable"], 0)
        self.assertEqual(plan["niveaux"], [])
        self.assertTrue(plan["arret"])

    def test_a_plan_is_never_promised_beyond_what_fits(self):
        # Mieux vaut annoncer six étages et en réussir six que d'en promettre
        # dix et mourir au septième sans savoir pourquoi.
        for profondeur in range(-2, 13):
            plan = nesting.nesting_plan(profondeur, **self.HOTE)
            self.assertEqual(len(plan["niveaux"]), plan["atteignable"])
            self.assertLessEqual(plan["atteignable"], max(0, profondeur))


class TestCompterLesRebonds(unittest.TestCase):
    """La profondeur se lit dans ~/.ssh/config : un ProxyJump par étage.

    Hermétique — une configuration synthétique. La vraie a été nettoyée entre
    deux mesures, et un test qui dépend de la machine qui le lance ne prouve
    rien le lendemain."""

    CONFIG = """
Host niveau1
    HostName 192.168.1.10

Host niveau2
    HostName 10.10.10.150
    ProxyJump niveau1

Host niveau3
    HostName 10.10.20.150
    ProxyJump niveau2

Host niveau4
    HostName 10.10.10.150
    ProxyJump niveau3

Host boucle-a
    ProxyJump boucle-b

Host boucle-b
    ProxyJump boucle-a
"""

    def setUp(self):
        import os
        import tempfile

        sys.argv = ["todo.py"]
        from script.todo.todo import TODO

        self.maison = tempfile.mkdtemp()
        os.makedirs(os.path.join(self.maison, ".ssh"))
        with open(
            os.path.join(self.maison, ".ssh/config"), "w", encoding="utf-8"
        ) as fh:
            fh.write(self.CONFIG)
        self._vrai = os.environ.get("HOME")
        os.environ["HOME"] = self.maison
        self.TODO = TODO

    def tearDown(self):
        import os
        import shutil

        if self._vrai is not None:
            os.environ["HOME"] = self._vrai
        shutil.rmtree(self.maison, ignore_errors=True)

    def test_each_level_is_counted(self):
        for nom, attendu in (
            ("niveau1", 1),
            ("niveau2", 2),
            ("niveau3", 3),
            ("niveau4", 4),
        ):
            with self.subTest(hote=nom):
                sauts = self.TODO._ssh_jump_depth(nom)
                self.assertEqual(nesting.depth_from_jumps(sauts), attendu)

    def test_an_unknown_host_is_the_first_level(self):
        self.assertEqual(self.TODO._ssh_jump_depth("jamais-vu"), 0)

    def test_a_loop_does_not_spin_forever(self):
        # A rebondit par B qui rebondit par A : sans garde, le parcours ne
        # s'arrête jamais.
        self.assertLessEqual(self.TODO._ssh_jump_depth("boucle-a"), 2)


class TestBornerCeQueLEcranOffre(unittest.TestCase):
    def test_the_first_two_levels_are_left_alone(self):
        # L'imbrication à deux niveaux est documentée par les fabricants : on
        # n'a rien à corriger là.
        for profondeur in (1, 2):
            self.assertEqual(
                nesting.capped_for_depth(profondeur, 12, 9216),
                (12, 9216, ""),
            )

    def test_beyond_that_the_vcpu_is_capped_and_said(self):
        vcpu, ram, raison = nesting.capped_for_depth(3, 12, 9216)
        self.assertEqual(vcpu, nesting.VCPU_IMBRIQUE)
        self.assertTrue(raison)
        self.assertIn("12", raison)

    def test_the_ram_is_never_touched(self):
        """La même VM gelait au MÊME octet avec 9 Go et avec 2 Go : la
        mémoire n'est pas le levier. La rogner ne gagnerait rien et priverait
        l'étage suivant."""
        for profondeur in (1, 3, 8):
            _v, ram, _r = nesting.capped_for_depth(profondeur, 12, 9216)
            self.assertEqual(ram, 9216)

    def test_a_modest_request_is_not_reported_as_capped(self):
        # Rien n'a bougé : ne rien dire. Un avertissement à chaque
        # déploiement finit par ne plus être lu.
        self.assertEqual(nesting.capped_for_depth(5, 2, 4096), (2, 4096, ""))
        self.assertEqual(nesting.capped_for_depth(5, 1, 4096), (1, 4096, ""))


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