Fichiers
meteo-vercors/forum/tests/test_roles_hub.py
T
Théo GastineletClaude Opus 5.5 acdb96f616 forum : statuts météo lus depuis le Hub (source de vérité, panneau admin)
Mode FORUM_ROLES_DEPUIS_HUB=1 (désactivé par défaut) :
- à chaque connexion / renouvellement de session, GET /oauth/roles et
  alignement des rôles locaux (adhérent, modérateur, adjoint, station) ;
  « proprietaire » reste fixé par FORUM_PROPRIETAIRE_ID ; le lien d'un
  propriétaire de station avec SA station reste local ; Hub injoignable :
  rôles locaux gardés.
- un changement fait dans le forum (panneau du forum, adhésion acceptée)
  part vers le Hub en delta (relu puis modifié), sans écraser le panneau admin.
- migrer_roles_hub.py : reprise idempotente des rôles de la base du forum
  vers le Hub (union, jamais de retrait ; simulation par défaut).
Tests : tests/test_roles_hub.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 21:27:47 +01:00

224 lignes
10 KiB
Python

"""Hub = source de vérité des statuts météo (06/11/2026) : synchronisation à la connexion, écriture des changements
faits dans le forum, lecture GET /oauth/roles, script de reprise idempotent.
python -m unittest discover -s tests
"""
import json
import os
import sys
import threading
import unittest
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import parse_qs, urlparse
ICI = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
sys.path.insert(0, ICI)
import connexion # noqa: E402
import migrer_roles_hub as migr # noqa: E402
import roles # noqa: E402
from forum import Forum # noqa: E402
STATIONS = {"geve": "Gêve", "oscence": "Combe de l'Oscence"}
THEO, ALICE, BOB = "id-theo", "id-alice", "id-bob"
class _Synchrone(threading.Thread):
"""Remplace threading.Thread dans forum : exécute tout de suite (tests déterministes)."""
def __init__(self, target, args=(), daemon=None):
self._t, self._a = target, args
def start(self):
self._t(*self._a)
class ModeHub(unittest.TestCase):
def setUp(self):
import forum as forum_mod
self._thread = forum_mod.threading.Thread
forum_mod.threading.Thread = _Synchrone
self.addCleanup(setattr, forum_mod.threading, "Thread", self._thread)
self.hub = {} # hub_id -> liste de rôles (faux Hub)
self.ecrits = []
self.f = Forum(stations=STATIONS, proprietaire_id=THEO)
self.f.lire_roles_hub = lambda h: self.hub.get(h, [])
self.f.maj_roles_hub = self._maj
self.poussees = []
self.f.apres_roles = lambda h, rs: self.poussees.append((h, rs))
def _maj(self, h, plus, moins):
self.ecrits.append((h, plus, moins))
self.hub[h] = sorted((set(self.hub.get(h, [])) | set(plus)) - set(moins))
def noms(self, hub_id):
return self.f.roles_de(self.f.utilisateur_existant(hub_id)) - {roles.MEMBRE}
def test_connexion_aligne_sur_le_hub(self):
self.f.connexion_gastinel(ALICE, "Alice")
self.assertEqual(self.noms(ALICE), set())
self.hub[ALICE] = ["adherent", "moderateur"]
self.f.connexion_gastinel(ALICE, "Alice") # renouvellement de session
self.assertEqual(self.noms(ALICE), {roles.ADHERENT, roles.MODERATEUR})
self.hub[ALICE] = ["adherent"]
self.f.connexion_gastinel(ALICE, "Alice")
self.assertEqual(self.noms(ALICE), {roles.ADHERENT})
self.assertEqual(self.poussees, [], "mode Hub : plus de poussée complète à la connexion")
def test_proprietaire_reste_fixe_par_la_configuration(self):
self.hub[ALICE] = ["proprietaire"]
self.f.connexion_gastinel(ALICE, "Alice")
self.assertNotIn(roles.PROPRIETAIRE, self.noms(ALICE))
self.f.connexion_gastinel(THEO, "Théo") # Hub vide pour Théo
self.assertIn(roles.PROPRIETAIRE, self.noms(THEO))
def test_hub_injoignable_garde_les_roles_locaux(self):
self.hub[ALICE] = ["moderateur"]
self.f.connexion_gastinel(ALICE, "Alice")
self.f.lire_roles_hub = lambda h: None
self.f.connexion_gastinel(ALICE, "Alice")
self.assertEqual(self.noms(ALICE), {roles.MODERATEUR})
def test_station_liee_dans_le_forum_gardee_tant_que_le_hub_donne_le_role(self):
theo = self.f.connexion_gastinel(THEO, "Théo")
self.hub[ALICE] = ["proprietaire_station"]
self.f.connexion_gastinel(ALICE, "Alice")
self.f.donner_role(theo, ALICE, roles.STATION, "geve")
u = self.f.utilisateur_existant(ALICE)
self.assertEqual(self.f.stations_de(u), {"geve"}) # la ligne sans station a disparu
self.f.connexion_gastinel(ALICE, "Alice")
self.assertEqual(self.f.stations_de(u), {"geve"})
self.hub[ALICE] = []
self.f.connexion_gastinel(ALICE, "Alice")
self.assertEqual(self.f.stations_de(u), set())
def test_changement_dans_le_forum_ecrit_seulement_le_delta(self):
theo = self.f.connexion_gastinel(THEO, "Théo")
self.f.connexion_gastinel(ALICE, "Alice")
self.hub[ALICE] = ["moderateur"] # donné au panneau admin, Alice pas encore reconnectée
self.f.donner_role(theo, ALICE, roles.ADHERENT)
self.assertEqual(self.ecrits[-1], (ALICE, ["adherent"], []))
self.assertEqual(self.hub[ALICE], ["adherent", "moderateur"], "le modérateur du panneau admin est gardé")
self.f.retirer_role(theo, ALICE, roles.ADHERENT)
self.assertEqual(self.hub[ALICE], ["moderateur"])
n = len(self.ecrits)
self.f.retirer_role(theo, ALICE, roles.ADHERENT) # rien ne change : rien n'est écrit
self.assertEqual(len(self.ecrits), n)
def test_adhesion_acceptee_ecrite_dans_le_hub(self):
theo = self.f.connexion_gastinel(THEO, "Théo")
alice = self.f.connexion_gastinel(ALICE, "Alice")
demande = self.f.demander_adhesion(alice, "Je relève la station de mon village depuis 2019.")
self.f.decider_adhesion(theo, demande, True)
self.assertIn("adherent", self.hub[ALICE])
class _FauxHub(BaseHTTPRequestHandler):
roles = {}
secret = "s3cret"
def log_message(self, *a):
pass
def _auth(self):
attendu = connexion._basic(connexion.Reglages(hub_url="http://127.0.0.1", client_secret=self.secret))
return self.headers.get("Authorization") == attendu
def do_GET(self):
q = parse_qs(urlparse(self.path).query)
h = q.get("id", [""])[0]
if not self._auth():
self.send_response(401); self.end_headers(); return
if h == "id-bizarre":
corps = json.dumps({"id": "autre", "roles": ["adherent"]}).encode()
elif h not in self.roles:
self.send_response(404); self.end_headers(); return
else:
corps = json.dumps({"id": h, "roles": self.roles[h] + ["inconnu"]}).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.end_headers()
self.wfile.write(corps)
def do_POST(self):
d = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
if not self._auth() or d["id"] not in self.roles:
self.send_response(404 if self._auth() else 401); self.end_headers(); return
self.roles[d["id"]] = d["roles"]
self.send_response(204); self.end_headers()
class LectureHub(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.srv = ThreadingHTTPServer(("127.0.0.1", 0), _FauxHub)
threading.Thread(target=cls.srv.serve_forever, daemon=True).start()
cls.url = "http://127.0.0.1:%d" % cls.srv.server_address[1]
@classmethod
def tearDownClass(cls):
cls.srv.shutdown()
def setUp(self):
_FauxHub.roles = {ALICE: ["moderateur"], BOB: []}
self.r = connexion.Reglages(hub_url=self.url, client_secret=_FauxHub.secret)
def test_lire_roles(self):
self.assertEqual(connexion.lire_roles(self.r, ALICE), ["moderateur"]) # « inconnu » filtré
self.assertEqual(connexion.lire_roles(self.r, "id-absent"), [])
self.assertIsNone(connexion.lire_roles(self.r, "id-bizarre"), "id différent : réponse ignorée")
self.assertIsNone(connexion.lire_roles(connexion.Reglages(hub_url=self.url, client_secret="faux"), ALICE))
self.assertIsNone(connexion.lire_roles(connexion.Reglages(hub_url=self.url), ALICE), "sans secret : rien")
self.assertIsNone(connexion.lire_roles(connexion.Reglages(hub_url="http://127.0.0.1:1", client_secret="x"), ALICE))
def test_modifier_roles_applique_le_delta(self):
self.assertTrue(connexion.modifier_roles(self.r, ALICE, ["adherent"], []))
self.assertEqual(sorted(_FauxHub.roles[ALICE]), ["adherent", "moderateur"])
self.assertTrue(connexion.modifier_roles(self.r, ALICE, [], ["moderateur"]))
self.assertEqual(_FauxHub.roles[ALICE], ["adherent"])
def test_reglages_depuis_env(self):
self.assertFalse(connexion.Reglages.depuis_env({}).roles_depuis_hub)
self.assertTrue(connexion.Reglages.depuis_env({"FORUM_ROLES_DEPUIS_HUB": "1"}).roles_depuis_hub)
def test_reprise_idempotente(self):
f = Forum(stations=STATIONS, proprietaire_id=THEO)
theo = f.connexion_gastinel(THEO, "Théo")
for h in (ALICE, BOB, "id-absent"):
f.connexion_gastinel(h, h)
f.donner_role(theo, ALICE, roles.ADHERENT)
f.donner_role(theo, BOB, roles.STATION, "geve")
f.donner_role(theo, "id-absent", roles.MODERATEUR)
_FauxHub.roles[THEO] = []
lignes = []
# Simulation : rien n'est envoyé.
c = migr.executer(f.con, self.r, False, THEO, sortie=lignes.append)
self.assertEqual(_FauxHub.roles[ALICE], ["moderateur"])
self.assertEqual(c["envoyer"], 4)
self.assertTrue(any("simulation" in l for l in lignes))
# Application : union, aucun rôle du Hub retiré ; compte inconnu du Hub signalé.
c = migr.executer(f.con, self.r, True, THEO, sortie=lignes.append)
self.assertEqual(sorted(_FauxHub.roles[ALICE]), ["adherent", "moderateur"])
self.assertEqual(_FauxHub.roles[BOB], ["proprietaire_station"])
self.assertEqual(_FauxHub.roles[THEO], ["proprietaire"])
self.assertEqual((c["envoye"], c["refuse"]), (3, 1)) # id-absent : jamais connecté (404)
self.assertEqual(c["a_jour"], 0)
# Second passage : plus rien à envoyer (seul le compte inconnu du Hub est encore signalé).
c = migr.executer(f.con, self.r, True, THEO, sortie=lignes.append)
self.assertEqual((c["envoye"], c["a_jour"], c["refuse"]), (0, 3, 1))
self.assertFalse(any("s3cret" in l for l in lignes), "aucun secret affiché")
def test_reprise_compte_jamais_connecte_au_hub(self):
f = Forum(stations=STATIONS, proprietaire_id=THEO)
theo = f.connexion_gastinel(THEO, "Théo")
f.connexion_gastinel("id-nouveau", "N")
f.donner_role(theo, "id-nouveau", roles.ADHERENT)
_FauxHub.roles[THEO] = ["proprietaire"]
envois = []
c = migr.executer(f.con, self.r, True, THEO, lire=lambda h: [] if h == "id-nouveau" else ["proprietaire"],
envoi=lambda h, rs: envois.append(h) or 404, sortie=lambda l: None)
self.assertEqual(envois, ["id-nouveau"])
self.assertEqual(c["refuse"], 1)
if __name__ == "__main__":
unittest.main()