From acdb96f6164d9a2bf5e52e69002c590e9fa5b4df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= <264859180+gastinelt@users.noreply.github.com> Date: Fri, 6 Nov 2026 21:27:47 +0100 Subject: [PATCH] =?UTF-8?q?forum=20:=20statuts=20m=C3=A9t=C3=A9o=20lus=20d?= =?UTF-8?q?epuis=20le=20Hub=20(source=20de=20v=C3=A9rit=C3=A9,=20panneau?= =?UTF-8?q?=20admin)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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 --- forum/connexion.py | 56 ++++++++- forum/forum.py | 62 +++++++++- forum/migrer_roles_hub.py | 109 +++++++++++++++++ forum/server.py | 5 + forum/tests/test_roles_hub.py | 223 ++++++++++++++++++++++++++++++++++ 5 files changed, 450 insertions(+), 5 deletions(-) create mode 100644 forum/migrer_roles_hub.py create mode 100644 forum/tests/test_roles_hub.py diff --git a/forum/connexion.py b/forum/connexion.py index 2fa5940..f57c323 100644 --- a/forum/connexion.py +++ b/forum/connexion.py @@ -5,6 +5,10 @@ Contrat du Hub (Plan-connexion-Gastinel.md) : POST {hub}/oauth/jeton (formulaire) grant_type=authorization_code, code, redirect_uri, client_id, code_verifier[, client_secret] -> {"access_token", "token_type": "Bearer", "expires_in": 3600} ; erreurs {"error"} en 400/401/429 GET {hub}/oauth/moi (Authorization: Bearer ) -> {"id": "", "pseudo": "..."} ; sinon 401 {"error": "invalid_token"} + GET {hub}/oauth/roles?id= (Basic client_id:secret) -> {"id", "roles": [...]} ; 404 si le compte n'a jamais + utilisé le forum. Mode FORUM_ROLES_DEPUIS_HUB=1 : le Hub est la source de vérité des rôles + (gérés depuis le panneau admin) ; le forum les relit à chaque connexion / renouvellement. + POST {hub}/oauth/roles (Basic) {"id", "roles"} : remplace les rôles (gestes faits dans le forum, reprise). Le forum ne voit jamais le mot de passe ni l'e-mail : seulement l'identifiant et le pseudo. """ @@ -52,7 +56,7 @@ class Reglages: def __init__(self, hub_url="", client_id="forum-vercors", redirect_uri=None, client_secret="", - mode_test=False, relais=("127.0.0.1", "::1"), prefixe=""): + mode_test=False, relais=("127.0.0.1", "::1"), prefixe="", roles_depuis_hub=False): self.prefixe = normaliser_prefixe(prefixe) self.hub_url = (hub_url or "").rstrip("/") if self.hub_url: @@ -65,6 +69,8 @@ class Reglages: self.client_secret = client_secret self.mode_test = bool(mode_test) self.relais = frozenset(relais) + # Hub = source de vérité des rôles (exige le secret client pour lire /oauth/roles). + self.roles_depuis_hub = bool(roles_depuis_hub) @property def configuree(self): @@ -87,7 +93,8 @@ class Reglages: prefixe=env.get("FORUM_PREFIXE", ""), client_secret=secret, mode_test=_bool(env.get("FORUM_MODE_TEST")), - relais=relais) + relais=relais, + roles_depuis_hub=_bool(env.get("FORUM_ROLES_DEPUIS_HUB"))) # --- PKCE et adresse d'autorisation ------------------------------------------ @@ -207,3 +214,48 @@ def pousser_roles(r, hub_id, roles_forum): pass except (urllib.error.URLError, OSError): pass # le Hub rattrapera à la prochaine connexion ou au prochain changement de rôle + + +ROLES_HUB = ("adherent", "moderateur", "proprietaire_station", "proprietaire_adjoint", "proprietaire") + + +def _basic(r): + return "Basic " + base64.b64encode(("%s:%s" % (r.client_id, r.client_secret)).encode("utf-8")).decode("ascii") + + +def lire_roles(r, hub_id): + """GET {hub}/oauth/roles?id= : rôles du compte selon le Hub (liste triée, rôles connus seulement). + [] si le Hub ne connaît pas ce compte pour le forum (404) ; None si le Hub ne répond pas ou si rien n'est + configuré : l'appelant garde alors les rôles qu'il a déjà.""" + if not r.client_secret or not r.hub_url or not ID_HUB_OK.match(hub_id or ""): + return None + req = urllib.request.Request(r.hub_url + "/oauth/roles?" + urllib.parse.urlencode({"id": hub_id}), + headers={"Authorization": _basic(r), "Accept": "application/json"}) + try: + with _OUVREUR.open(req, timeout=DELAI) as rep: + brut = rep.read(REPONSE_MAX + 1) + except urllib.error.HTTPError as ex: + return [] if ex.code == 404 else None + except (urllib.error.URLError, OSError): + return None + try: + d = json.loads(brut[:REPONSE_MAX].decode("utf-8")) + except ValueError: + return None + rs = d.get("roles") if isinstance(d, dict) else None + if not isinstance(rs, list) or str(d.get("id", "")) != hub_id: + return None + return sorted(set(x for x in rs if isinstance(x, str) and x in ROLES_HUB)) + + +def modifier_roles(r, hub_id, ajouts, retraits): + """Écrit dans le Hub un changement fait dans le forum (adhésion validée, rôle donné au panneau du forum) : + relit les rôles du Hub et n'applique que le changement, sans écraser ce que le panneau admin a changé + entre-temps. Hub injoignable : rien n'est envoyé (False).""" + actuels = lire_roles(r, hub_id) + if actuels is None: + return False + nouveaux = (set(actuels) | set(ajouts)) - set(retraits) + if nouveaux != set(actuels): + pousser_roles(r, hub_id, nouveaux) + return True diff --git a/forum/forum.py b/forum/forum.py index c1911c6..f22c8ca 100644 --- a/forum/forum.py +++ b/forum/forum.py @@ -70,8 +70,49 @@ class Forum: self.dossier_photos = dossier_photos self.proprietaire_id = proprietaire_id or None # id Gastinel de Théo (FORUM_PROPRIETAIRE_ID) self.apres_roles = None # fonction(hub_id, roles) : envoie les rôles au Hub (branchée par server.py) + # Mode « Hub = source de vérité » (FORUM_ROLES_DEPUIS_HUB=1, branché par server.py) : + # lire_roles_hub(hub_id) -> liste | None : relu à chaque connexion / renouvellement de session ; + # maj_roles_hub(hub_id, ajouts, retraits) : écrit dans le Hub un changement fait dans le forum. + self.lire_roles_hub = None + self.maj_roles_hub = None self.version = 0 # augmente à chaque changement visible sur les fiches de station (cache de server.py) + def _noms_roles(self, user_id): + return {r[0] for r in self.con.execute("SELECT role FROM user_roles WHERE user_id=?", (user_id,))} + + def _signaler(self, hub_id, avant, apres): + """Après un changement de rôles fait dans le forum. Mode Hub : seul le changement part vers le Hub + (relu puis modifié). Sinon : l'ancienne poussée de tous les rôles.""" + if self.maj_roles_hub: + ajouts, retraits = sorted(apres - avant), sorted(avant - apres) + if ajouts or retraits: + threading.Thread(target=self.maj_roles_hub, args=(hub_id, ajouts, retraits), daemon=True).start() + return + self._pousser_roles(hub_id) + + # Rôles que le Hub fixe en mode Hub. « proprietaire » reste fixé par la configuration (FORUM_PROPRIETAIRE_ID). + SYNCHRONISES = (roles.ADHERENT, roles.MODERATEUR, roles.ADJOINT, roles.STATION) + + def synchroniser_roles(self, hub_id, roles_hub): + """Aligne les rôles locaux sur ceux du Hub. Le lien d'un propriétaire de station avec SA station reste + local (le Hub ne connaît que le rôle) : gardé tant que le Hub donne le rôle, retiré sinon.""" + u = self._cible(hub_id) + voulu = set(roles_hub or ()) & set(self.SYNCHRONISES) + locaux = self._noms_roles(u["id"]) + for role in self.SYNCHRONISES: + if role in voulu and role not in locaux: + self.con.execute("INSERT OR IGNORE INTO user_roles(user_id, role, station) VALUES (?, ?, '')", (u["id"], role)) + elif role not in voulu and role in locaux: + self.con.execute("DELETE FROM user_roles WHERE user_id=? AND role=?", (u["id"], role)) + self._nettoyer_station(u["id"]) + self.con.commit() + + def _nettoyer_station(self, user_id): + # Ligne « propriétaire de station » sans station : inutile dès qu'une vraie station est liée. + self.con.execute("DELETE FROM user_roles WHERE user_id=? AND role=? AND station=''" + " AND EXISTS (SELECT 1 FROM user_roles WHERE user_id=? AND role=? AND station<>'')", + (user_id, roles.STATION, user_id, roles.STATION)) + def _pousser_roles(self, hub_id): if not self.apres_roles: return @@ -98,7 +139,14 @@ class Forum: u = self.con.execute("SELECT * FROM users WHERE id=?", (u["id"],)).fetchone() if self.proprietaire_id and hub_id == self.proprietaire_id: u = self.fixer_proprietaire(hub_id, pseudo) - self._pousser_roles(hub_id) + if self.lire_roles_hub: + # Hub = source de vérité : relu ici, avant d'ouvrir la session. Hub injoignable (None) : on garde + # les rôles locaux, relus au prochain renouvellement. + rs = self.lire_roles_hub(hub_id) + if rs is not None: + self.synchroniser_roles(hub_id, rs) + else: + self._pousser_roles(hub_id) return u def ouvrir_session(self, user, jours=None, portee=""): @@ -222,19 +270,22 @@ class Forum: else: station = "" cible = self._cible(hub_id) + avant = self._noms_roles(cible["id"]) self.con.execute("INSERT OR IGNORE INTO user_roles(user_id, role, station, given_by) VALUES (?, ?, ?, ?)", (cible["id"], role, station, acteur["id"])) + self._nettoyer_station(cible["id"]) self.con.commit() - self._pousser_roles(hub_id) + self._signaler(hub_id, avant, self._noms_roles(cible["id"])) def retirer_role(self, acteur, hub_id, role, station=""): if not roles.peut_donner(self.roles_de(acteur), role): raise Refus("retirer le rôle %s" % role) cible = self._cible(hub_id) + avant = self._noms_roles(cible["id"]) self.con.execute("DELETE FROM user_roles WHERE user_id=? AND role=? AND station=?", (cible["id"], role, station if role == roles.STATION else "")) self.con.commit() - self._pousser_roles(hub_id) + self._signaler(hub_id, avant, self._noms_roles(cible["id"])) # --- lecture ------------------------------------------------------- def _visible(self, user, t): @@ -592,10 +643,15 @@ class Forum: raise Invalide("demande déjà traitée") self.con.execute("UPDATE adhesions SET status=?, decided_by=?, decided_at=datetime('now') WHERE id=?", ("acceptee" if accepte else "refusee", acteur["id"], demande_id)) + avant = self._noms_roles(d["user_id"]) if accepte: self.con.execute("INSERT OR IGNORE INTO user_roles(user_id, role, given_by) VALUES (?, ?, ?)", (d["user_id"], roles.ADHERENT, acteur["id"])) self.con.commit() + if self.maj_roles_hub and accepte: + h = self.con.execute("SELECT hub_id FROM users WHERE id=?", (d["user_id"],)).fetchone() + if h is not None: + self._signaler(h[0], avant, self._noms_roles(d["user_id"])) def photo_adhesion(self, acteur, nom): """Chemin d'une photo de demande, si l'acteur a le droit de la voir et qu'elle appartient à une demande.""" diff --git a/forum/migrer_roles_hub.py b/forum/migrer_roles_hub.py new file mode 100644 index 0000000..4aad6ca --- /dev/null +++ b/forum/migrer_roles_hub.py @@ -0,0 +1,109 @@ +"""Reprise des rôles du forum dans le Hub (06/11/2026), avant de passer en mode FORUM_ROLES_DEPUIS_HUB=1. + +Le Hub devient la source de vérité des statuts météo (panneau admin, onglet « Statuts météo »). Ce script copie +dans le Hub les rôles que la base du forum connaît et que le Hub n'a pas encore. Il n'en retire jamais aucun : +cible = rôles du Hub ∪ rôles du forum. Idempotent : un second passage n'envoie plus rien. + +Par défaut : simulation (rien n'est écrit, rien ne part). --appliquer : envoie POST /oauth/roles. +Configuration : mêmes variables que le forum (FORUM_HUB_URL, FORUM_CLIENT_ID, FORUM_OAUTH_SECRET_FILE). +Aucun secret n'est affiché. + + python migrer_roles_hub.py --db /chemin/forum.sqlite3 # simulation + python migrer_roles_hub.py --db /chemin/forum.sqlite3 --appliquer +""" +import argparse +import json +import sqlite3 +import sys +import urllib.error +import urllib.request + +import connexion +import db + + +def roles_locaux(con, proprietaire_id=None): + """{hub_id: {rôles}} depuis la base du forum (compte système et comptes supprimés exclus).""" + out = {} + for hub_id, role in con.execute( + "SELECT u.hub_id, r.role FROM user_roles r JOIN users u ON u.id = r.user_id" + " WHERE u.hub_id <> ? AND COALESCE(u.supprime, 0) = 0", (db.SYSTEME,)): + if role in connexion.ROLES_HUB: + out.setdefault(hub_id, set()).add(role) + if proprietaire_id and proprietaire_id in out: + out[proprietaire_id].add("proprietaire") + return out + + +def planifier(locaux, lire): + """Liste de (hub_id, état, rôles du Hub, rôles cibles). lire(hub_id) -> liste | [] (absent) | None (erreur). + état : « envoyer », « a_jour », « erreur ».""" + plan = [] + for hub_id in sorted(locaux): + actuels = lire(hub_id) + if actuels is None: + plan.append((hub_id, "erreur", None, None)) + continue + cible = sorted(set(actuels) | locaux[hub_id]) + plan.append((hub_id, "a_jour" if set(cible) == set(actuels) else "envoyer", sorted(actuels), cible)) + return plan + + +def envoyer(r, hub_id, roles): + """POST /oauth/roles ; renvoie le code HTTP (0 si le Hub est injoignable).""" + corps = json.dumps({"id": hub_id, "roles": sorted(roles)}).encode("utf-8") + req = urllib.request.Request(r.hub_url + "/oauth/roles", data=corps, method="POST", + headers={"Content-Type": "application/json", "Authorization": connexion._basic(r)}) + try: + with connexion._OUVREUR.open(req, timeout=connexion.DELAI) as rep: + return rep.status + except urllib.error.HTTPError as ex: + return ex.code + except (urllib.error.URLError, OSError): + return 0 + + +def executer(con, reglages, appliquer, proprietaire_id=None, lire=None, envoi=None, sortie=print): + lire = lire or (lambda h: connexion.lire_roles(reglages, h)) + envoi = envoi or (lambda h, rs: envoyer(reglages, h, rs)) + plan = planifier(roles_locaux(con, proprietaire_id), lire) + compte = {"envoyer": 0, "a_jour": 0, "erreur": 0, "envoye": 0, "refuse": 0} + for hub_id, etat, actuels, cible in plan: + compte[etat] += 1 + if etat == "erreur": + sortie("%s : Hub illisible, ignoré" % hub_id) + elif etat == "a_jour": + sortie("%s : déjà à jour (%s)" % (hub_id, ",".join(actuels) or "aucun")) + else: + sortie("%s : %s -> %s%s" % (hub_id, ",".join(actuels) or "aucun", ",".join(cible), + "" if appliquer else " (simulation)")) + if appliquer: + code = envoi(hub_id, cible) + if code == 204: + compte["envoye"] += 1 + else: + compte["refuse"] += 1 + sortie("%s : refusé par le Hub (%s)%s" % (hub_id, code, + " : compte jamais connecté au forum" if code == 404 else "")) + sortie("Bilan : %(envoyer)d à envoyer, %(a_jour)d déjà à jour, %(erreur)d illisibles, " + "%(envoye)d envoyés, %(refuse)d refusés" % compte) + return compte + + +def main(argv=None): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("--db", required=True, help="base SQLite du forum (ouverte en lecture seule)") + ap.add_argument("--proprietaire", default=None, help="id Gastinel du propriétaire (défaut : FORUM_PROPRIETAIRE_ID)") + ap.add_argument("--appliquer", action="store_true", help="envoyer au Hub (sans : simulation)") + a = ap.parse_args(argv) + import os + reglages = connexion.Reglages.depuis_env() + if not reglages.hub_url or not reglages.client_secret: + sys.exit("FORUM_HUB_URL et le secret client (FORUM_OAUTH_SECRET_FILE) sont nécessaires") + con = sqlite3.connect("file:%s?mode=ro" % a.db, uri=True) + compte = executer(con, reglages, a.appliquer, a.proprietaire or os.environ.get("FORUM_PROPRIETAIRE_ID")) + return 1 if compte["erreur"] or compte["refuse"] else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/forum/server.py b/forum/server.py index 1942444..62388d8 100644 --- a/forum/server.py +++ b/forum/server.py @@ -2054,6 +2054,11 @@ def main(): proprietaire_id=os.environ.get("FORUM_PROPRIETAIRE_ID")) f.creer_sujets_stations() f.apres_roles = lambda h, rs: connexion.pousser_roles(reglages, h, rs) + if reglages.roles_depuis_hub: + if not reglages.client_secret: + sys.exit("FORUM_ROLES_DEPUIS_HUB=1 exige le secret client (FORUM_OAUTH_SECRET_FILE)") + f.lire_roles_hub = lambda h: connexion.lire_roles(reglages, h) + f.maj_roles_hub = lambda h, plus, moins: connexion.modifier_roles(reglages, h, plus, moins) if a.seed: semer(f) s = creer_serveur(f, a.port, a.hote, reglages=reglages) diff --git a/forum/tests/test_roles_hub.py b/forum/tests/test_roles_hub.py new file mode 100644 index 0000000..d6a4fc2 --- /dev/null +++ b/forum/tests/test_roles_hub.py @@ -0,0 +1,223 @@ +"""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()