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>
224 lignes
10 KiB
Python
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()
|