From bd5357f5890f433b0330f6779fea00d8cc407aa8 Mon Sep 17 00:00:00 2001 From: Spark Date: Fri, 6 Nov 2026 15:36:56 +0000 Subject: [PATCH] =?UTF-8?q?Flowdeck=207.85.2=20=E2=80=94=20HUB-19=20:=20pr?= =?UTF-8?q?opagation=20des=20r=C3=B4les=20du=20Hub=20(registre=20D3(a))?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 8 + VERSION | 2 +- app/main.py | 2 +- app/routers/admin.py | 10 ++ app/routers/agent.py | 8 + app/routers/audit.py | 8 + app/routers/auth.py | 31 +++- app/routers/scim.py | 8 + app/routers/sso.py | 9 ++ app/services/draco.py | 34 ++++- app/services/hub_roles.py | 155 +++++++++++++++++++ tests/test_hub_roles.py | 308 ++++++++++++++++++++++++++++++++++++++ 12 files changed, 579 insertions(+), 4 deletions(-) create mode 100644 app/services/hub_roles.py create mode 100644 tests/test_hub_roles.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 2b3860a..db36622 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,11 @@ +## v7.85.2 (2026-11-06) — HUB-19 : propagation des rôles du Hub (registre D3(a)) + +- **Client des rôles du Hub** (`app/services/hub_roles.py`, nouveau) : portage Python du pilote ShaarIt 0.7.0 (`hub_roles.rs`). À l'ouverture de session draco, consultation de `GET {hub}/api/roles/flowdeck` — en-tête Cookie complet de la requête relayé tel quel, `Accept: application/json`, délai 2 s. URL du Hub résolue comme la barre commune (`draco_urls.hub_url()` : explicite `HUB_URL` > hôte de la requête > dérivation par l'hôte de l'agent > défaut officiel), jamais d'URL dev figée. Cache mémoire par `sub`, TTL 60 s, horodatage posé **avant** l'appel : un échec conserve l'ancien cache, pas de rafale. Toute erreur (401/404/réseau/JSON illisible/rôle hors ensemble {`aucun`, `utilisateur`, `administrateur`}) = rôle **inconnu** → comportement actuel conservé, intégralement. +- **Refus `aucun` avant la session** : le pont `GET /auth/draco` (seul point où un cookie draco aboutit à une session locale) appelle `user_for_draco(..., refuser_aucun=True)` ; un rôle connu `aucun` lève `draco.RoleAucunRefuse` **avant** la résolution de compte et donc avant le provisionnement JIT HUB-15 — aucun compte ni lien n'est créé pour un `sub` refusé. Réponse 403 en français nommant le registre des rôles du Hub. Exemptions (patron du pilote) : session locale préexistante (accès de secours par mot de passe, le pont ne refuse pas), page de connexion, santé et statiques (jamais passées par le pont), contrats API propres (OAuth externe Gitea/GitHub, jetons Bearer/SCIM de Flowdeck — non draco, intacts) et recherche fédérée (`/api/search`, repli draco sans création de session : défaut `refuser_aucun=False`, aucun refus nouveau). +- **Surfaces d'administration d'instance gardées** (`hub_roles.admin_hub_ok` : session draco + rôle connu → `administrateur` exigé ; sinon comportement actuel) : `/api/admin/*` (`admin_required`), configuration des fournisseurs de l'agent (`agent._current_admin`), journal d'audit unifié (branche session de `audit._admin_user`), administration SCIM/domaines (branche session de `scim._admin_session`), configuration SSO (branche session de `sso._require_admin`). Les voies Bearer de ces mêmes surfaces (contrats d'API propres) et l'administration d'espace de travail (rôles de membre) ne sont pas touchées. +- **Provisionnement JIT inchangé** (HUB-15) : le refus intervient au même point que l'établissement de session, avant toute création. +- Tests : `tests/test_hub_roles.py` (nouveau, 28 tests — client : contrat exact de l'appel, cache par `sub`, ancien cache après échec, erreurs → inconnu ; intégration : 403 français au pont, refus avant JIT — compte et lien absents —, rôle `utilisateur` avec JIT intact, repli rôle inconnu, session préexistante exemptée, garde `/api/admin/*` selon le rôle). Balayage draco/SSO/recherche existant reconfirmé sans régression (voir PR). + ## v7.85.1 (2026-11-06) — Barre commune v0.5.0 : thème commun (HUB-18, fusion #132) > **Hypothèse d'ordre** : cette version suppose la fusion préalable de la PR HUB-15 #51 (Flowdeck 7.85.0) ; branchée sur `main` (7.84.15), elle vise **7.85.1**. diff --git a/VERSION b/VERSION index 7884bee..f1ff083 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -7.85.1 +7.85.2 diff --git a/app/main.py b/app/main.py index 8726cec..8da03e8 100644 --- a/app/main.py +++ b/app/main.py @@ -216,7 +216,7 @@ def _lire_version() -> str: # Littéral de version synchronisé avec le fichier VERSION : -# version="7.85.1" +# version="7.85.2" # Patron historique des bumps (voir scripts/bump_version.py, qui cherche # ce littéral) et contrôle de tests/test_pwa_offline.py. La version # runtime reste lue dynamiquement depuis VERSION par _lire_version() diff --git a/app/routers/admin.py b/app/routers/admin.py index fde9e8c..24ab861 100644 --- a/app/routers/admin.py +++ b/app/routers/admin.py @@ -11,6 +11,16 @@ async def admin_required(request: Request): user = get_current_user(request) if not user: raise HTTPException(status_code=403, detail="Admin access required") + # HUB-19 (registre des rôles du Hub) : session draco + rôle connu + # pour Flowdeck → exiger « administrateur » dans le registre, + # en plus du drapeau local. Pas de session draco ou rôle inconnu + # (Hub injoignable) : comportement actuel. + from app.services import hub_roles + if not hub_roles.admin_hub_ok(request): + raise HTTPException( + status_code=403, + detail="Niveau « administrateur » requis dans le registre " + "des rôles du Hub pour FlowDeck") # Also check DB directly (session cookie may be stale) if not user.get("is_admin"): from app.db import get_conn diff --git a/app/routers/agent.py b/app/routers/agent.py index 8fc33ca..322355d 100644 --- a/app/routers/agent.py +++ b/app/routers/agent.py @@ -127,6 +127,14 @@ def _current_admin(request: Request) -> dict: row = conn.execute("SELECT is_admin FROM users WHERE id=?", (user.get("id"),)).fetchone() if not row or not row["is_admin"]: raise HTTPException(status_code=403, detail="Accès administrateur requis") + # HUB-19 : session draco + rôle Hub connu → exiger « administrateur » + # dans le registre du Hub (voir app.services.hub_roles.admin_hub_ok). + from app.services import hub_roles + if not hub_roles.admin_hub_ok(request): + raise HTTPException( + status_code=403, + detail="Niveau « administrateur » requis dans le registre " + "des rôles du Hub pour FlowDeck") return user diff --git a/app/routers/audit.py b/app/routers/audit.py index c87d48b..f674ce5 100644 --- a/app/routers/audit.py +++ b/app/routers/audit.py @@ -27,6 +27,14 @@ def _admin_user(request: Request) -> dict: row = conn.execute("SELECT is_admin FROM users WHERE id=?", (sess.get("id"),)).fetchone() if row and row["is_admin"]: + # HUB-19 : session draco + rôle Hub connu → exiger + # « administrateur » dans le registre du Hub (la voie + # Bearer ci-dessous, contrat d'API propre, est exemptée). + from app.services import hub_roles + if not hub_roles.admin_hub_ok(request): + raise HTTPException( + 403, "Niveau « administrateur » requis dans le " + "registre des rôles du Hub pour FlowDeck") return sess raise HTTPException(403, "Admin required") auth = request.headers.get("authorization") or request.headers.get("Authorization") or "" diff --git a/app/routers/auth.py b/app/routers/auth.py index 2e2ccad..335a67b 100644 --- a/app/routers/auth.py +++ b/app/routers/auth.py @@ -483,10 +483,39 @@ def draco_bridge(request: Request, next: str = "/workspaces"): Point de retour de ``GET /sso/authorize`` de l'émettrice : si le cookie est valide et résolu vers un compte local, une session Flowdeck native est créée ; sinon, retour à la connexion locale. + + HUB-19 (registre des rôles du Hub, contrat D3(a)) : rôle connu + ``aucun`` pour Flowdeck → refus 403 en français nommant le + registre du Hub, **avant** la création de la session locale et + avant tout provisionnement JIT (aucun compte créé pour un + ``sub`` refusé). Exemption, patron du pilote ShaarIt : une + session locale préexistante (accès de secours) n'est pas + refusée — le pont la laisse simplement se poursuivre. Rôle + inconnu (Hub injoignable/erreur) : comportement actuel. """ + from fastapi.responses import HTMLResponse + from app.services import draco - user = draco.user_for_draco(request) + _cookie_session = request.cookies.get("flowdeck_session", "") + session_existante = (SessionManager.decode_session(_cookie_session) + if _cookie_session else None) + try: + user = draco.user_for_draco( + request, refuser_aucun=not session_existante) + except draco.RoleAucunRefuse: + return HTMLResponse( + """ +Accès refusé — FlowDeck
+

Accès refusé

+

Le registre des rôles de la suite (Hub Dracodev) attribue le niveau +« aucun » à votre compte pour FlowDeck : l'accès par la session draco +est refusé. L'administrateur de suite peut modifier ce niveau dans la +matrice des rôles du Hub. L'accès de secours par le mot de passe local +de l'instance reste possible par la page de connexion.

+
""", + status_code=403, + ) if user is None: return RedirectResponse(url="/auth/login?provider=local", status_code=302) session = SessionManager.create_session(user, request) diff --git a/app/routers/scim.py b/app/routers/scim.py index c99f7bb..32ed9dd 100644 --- a/app/routers/scim.py +++ b/app/routers/scim.py @@ -46,6 +46,14 @@ def _admin_session(request: Request) -> dict: row = conn.execute("SELECT is_admin FROM users WHERE id=?", (user["id"],)).fetchone() if not row or not row["is_admin"]: raise HTTPException(403, "Admin required") + # HUB-19 : session draco + rôle Hub connu → exiger « administrateur » + # dans le registre du Hub (les jetons SCIM Bearer, contrat propre, + # passent par _scim_guard et sont exemptés). + from app.services import hub_roles + if not hub_roles.admin_hub_ok(request): + raise HTTPException( + 403, "Niveau « administrateur » requis dans le registre " + "des rôles du Hub pour FlowDeck") return user diff --git a/app/routers/sso.py b/app/routers/sso.py index 4a6d894..3f65b83 100644 --- a/app/routers/sso.py +++ b/app/routers/sso.py @@ -527,6 +527,15 @@ def _require_admin(request: Request, *, write: bool) -> dict: ).fetchone() if not row or not row["is_admin"]: raise HTTPException(status_code=403, detail="Admin access required") + # HUB-19 : session draco + rôle Hub connu → exiger « administrateur » + # dans le registre du Hub (la voie Bearer ci-dessus, contrat d'API + # propre, est exemptée). + from app.services import hub_roles + if not hub_roles.admin_hub_ok(request): + raise HTTPException( + status_code=403, + detail="Niveau « administrateur » requis dans le registre " + "des rôles du Hub pour FlowDeck") if write and request.method in ("POST", "PUT", "PATCH", "DELETE"): cookie = request.cookies.get("csrf_token", "") header = request.headers.get("X-CSRF-Token", "") diff --git a/app/services/draco.py b/app/services/draco.py index 5ddc1b5..5c8f7e4 100644 --- a/app/services/draco.py +++ b/app/services/draco.py @@ -26,6 +26,12 @@ admin), aucun mot de passe local (``password_hash`` NULL, connexion locale par mot de passe reste impossible pour ce compte et inchangée pour les autres). Une pierre tombale (dissociation explicite) interdit toute re-création automatique pour ce ``sub``. + +HUB-19 (registre des rôles du Hub) : le pont d'ouverture de session +peut demander le refus d'un ``sub`` au rôle connu ``aucun`` +(``user_for_draco(..., refuser_aucun=True)`` → +``RoleAucunRefuse``), levé avant la résolution de compte et le +provisionnement JIT — voir ``app.services.hub_roles``. """ from __future__ import annotations @@ -45,6 +51,16 @@ logger = logging.getLogger(__name__) COOKIE_NAME = "draco_session" _REVOCATIONS_TTL = 60 # secondes de cache, comme le prévoit le design + +class RoleAucunRefuse(Exception): + """HUB-19 : le registre des rôles du Hub attribue le niveau + ``aucun`` à ce ``sub`` pour Flowdeck — l'ouverture de session + draco est refusée (403), avant tout provisionnement JIT.""" + + def __init__(self, sub: str): + super().__init__(sub) + self.sub = sub + _revoked_cache: dict[str, int] = {} _revoked_fetched_at: float = 0.0 @@ -215,12 +231,22 @@ def _provision_jit(conn, claims: dict) -> dict | None: return dict(row) if row is not None else None -def user_for_draco(request) -> dict | None: +def user_for_draco(request, refuser_aucun: bool = False) -> dict | None: """Utilisateur Flowdeck prouvé par le cookie draco_session, ou None. Résolution : lien ``draco_links`` existant, sinon repli mono-utilisateur, sinon provisionnement JIT (HUB-15) — le pendant local est créé depuis les claims et lié au ``sub``. + + HUB-19 (registre des rôles du Hub, contrat D3(a)) : avec + ``refuser_aucun=True`` — le pont d'ouverture de session + ``GET /auth/draco``, seul appelant qui crée une session locale — + un rôle **connu** ``aucun`` dans le registre du Hub lève + ``RoleAucunRefuse`` **avant** toute résolution de compte et donc + avant tout provisionnement JIT : aucun compte n'est créé pour un + ``sub`` refusé. Rôle inconnu (Hub injoignable/erreur) : repli, + comportement actuel inchangé. Les autres appelants (recherche + fédérée) gardent le défaut ``False`` : aucun refus nouveau. """ if not enabled(): return None @@ -233,6 +259,12 @@ def user_for_draco(request) -> dict | None: sub = str(claims.get("sub", "")) if not sub: return None + if refuser_aucun: + from app.services import hub_roles + + if hub_roles.role_pour( + request.headers.get("cookie", ""), sub) == "aucun": + raise RoleAucunRefuse(sub) with get_conn() as conn: user = _linked_user(conn, sub) if user is None: diff --git a/app/services/hub_roles.py b/app/services/hub_roles.py new file mode 100644 index 0000000..68f98ea --- /dev/null +++ b/app/services/hub_roles.py @@ -0,0 +1,155 @@ +"""Rôles par application — consommation du registre du Hub (HUB-19). + +Propagation du pilote ShaarIt (0.7.0, en production) à Flowdeck, +sur le contrat D3(a) du plan Hub v2 : à l'ouverture de session +draco, Flowdeck demande au Hub le niveau du porteur du cookie pour +l'application ``flowdeck`` (``GET {hub}/api/roles/flowdeck``, en-tête +Cookie complet de la requête relayé tel quel, ``Accept: +application/json``, délai 2 s) et met la réponse en cache 60 s par +``sub`` — patron du client Rust ``hub_roles.rs`` de ShaarIt et du +cache de révocations de ``app.services.draco`` (horodatage posé +**avant** l'appel : un échec ne déclenche pas de rafale, l'ancien +cache reste en vigueur). + +Réponse attendue (200) : ``{"app", "sub", "role", "explicite", +"ttl_secondes": 60}``, rôle ∈ {``aucun``, ``utilisateur``, +``administrateur``}. + +**Repli obligatoire** : Hub injoignable, erreur (401/404/…), réseau, +réponse illisible ou rôle hors ensemble → rôle **inconnu** (None), +et l'appelant garde son comportement actuel. Le registre ne crée +jamais un verrouillage nouveau. + +L'URL du Hub est résolue comme la barre commune de Flowdeck +(``app.services.draco_urls.hub_url()`` : variable explicite +``HUB_URL`` / réglage, dérivation par l'hôte de la requête, puis par +l'hôte sœur de l'agent, puis défaut officiel) — jamais d'URL dev +figée. +""" + +from __future__ import annotations + +import logging +import time + +logger = logging.getLogger(__name__) + +#: Identifiant de Flowdeck dans le registre des applications du Hub. +APP = "flowdeck" + +#: TTL du cache, aligné sur ``ttl_secondes`` annoncé par le Hub et +#: sur le cache de révocations draco. +CACHE_TTL = 60 # secondes + +ROLES_CONNUS = ("aucun", "utilisateur", "administrateur") + +# Cache mémoire par sub : sub -> rôle connu (str) ou None (échec déjà +# tenté dans la fenêtre — l'ancien résultat reste servi, voir +# ``role_pour``). ``_cache_fetched_at`` est l'horodatage global du +# dernier appel, posé avant l'appel (patron révocations). +_cache: dict[str, str | None] = {} +_cache_fetched_at: float = 0.0 + + +def _consulter_hub(cookie: str) -> str | None: + """Un appel au Hub ; retourne le rôle validé ou None (inconnu).""" + from app.services import draco_urls + + base = draco_urls.hub_url() + url = f"{base}/api/roles/{APP}" + try: + import httpx + + r = httpx.get( + url, + headers={"Cookie": cookie, "Accept": "application/json"}, + timeout=2.0, + ) + if r.status_code != 200: + return None + role = r.json().get("role") + except Exception as exc: # réseau, JSON illisible… → repli + logger.debug("Registre des rôles du Hub indisponible (%s): %s", url, exc) + return None + if role not in ROLES_CONNUS: + return None + return role + + +def role_pour(cookie: str, sub: str) -> str | None: + """Niveau connu pour ce ``sub`` : ``aucun`` | ``utilisateur`` | + ``administrateur`` si le Hub a répondu, None si le rôle est + inconnu (Hub injoignable/erreur) — repli = comportement actuel. + + ``cookie`` est l'en-tête Cookie complet de la requête, relayé tel + quel au Hub ; ``sub`` est le sujet draco prouvé localement. + Cache mémoire par ``sub``, TTL 60 s, horodatage posé avant + l'appel : pendant la fenêtre qui suit un échec, l'ancien cache + reste en vigueur (pas de rafale vers le Hub). + """ + global _cache_fetched_at + if not sub: + return None + now = time.monotonic() + if now - _cache_fetched_at < CACHE_TTL and sub in _cache: + return _cache[sub] + # Horodatage posé AVANT l'appel (patron révocations du pilote). + ancien = _cache.get(sub) + _cache_fetched_at = now + resultat = _consulter_hub(cookie) + if resultat is not None: + _cache[sub] = resultat + return resultat + # Échec : l'ancien cache reste en vigueur. + logger.debug( + "Registre des rôles du Hub indisponible — comportement actuel conservé") + return ancien + + +def role_draco(request) -> str | None: + """Rôle du porteur draco de cette requête, ou None (inconnu). + + None aussi quand il n'y a pas de session draco prouvée : pas de + cookie ``draco_session``, jeton invalide/expiré/révoqué, ou SSO + draco non configuré — l'appelant garde son comportement actuel. + Le ``sub`` vient de la vérification locale du jeton (mêmes + sémantiques que ``user_for_draco``, sans résolution de compte ni + provisionnement). + """ + from app.services import draco + + if not draco.enabled(): + return None + claims = draco.verify_token(request.cookies.get(draco.COOKIE_NAME, "")) + if not claims: + return None + jti = str(claims.get("jti", "")) + if jti and draco.is_revoked(jti): + return None + sub = str(claims.get("sub", "")) + if not sub: + return None + # En-tête Cookie complet de la requête, relayé tel quel au Hub. + cookie = request.headers.get("cookie", "") + return role_pour(cookie, sub) + + +def admin_hub_ok(request) -> bool: + """Vrai si les surfaces d'administration restent ouvertes. + + Session draco + rôle connu → exiger ``administrateur``. Pas de + session draco (session locale par mot de passe, jeton d'API + propre à Flowdeck, OAuth externe) ou rôle inconnu (Hub + injoignable) : comportement actuel (True). + """ + from app.services import draco + + if not draco.enabled(): + return True + claims = draco.verify_token(request.cookies.get(draco.COOKIE_NAME, "")) + if not claims: + return True + role = role_draco(request) + if role is None: + return True + return role == "administrateur" diff --git a/tests/test_hub_roles.py b/tests/test_hub_roles.py new file mode 100644 index 0000000..583f988 --- /dev/null +++ b/tests/test_hub_roles.py @@ -0,0 +1,308 @@ +"""HUB-19 — propagation des rôles du Hub à Flowdeck (suite du pilote +ShaarIt 0.7.0) : client ``app.services.hub_roles`` et ses effets. + +Contrat D3(a) : à l'ouverture de session draco, consultation de +``GET {hub}/api/roles/flowdeck`` (cookie complet relayé, délai 2 s), +cache mémoire par ``sub`` TTL 60 s, horodatage posé avant l'appel. +Toute erreur = rôle inconnu → comportement actuel conservé. + +Effets vérifiés ici : +- rôle connu ``aucun`` → 403 en français au pont ``GET /auth/draco``, + avant la création de la session locale et avant le provisionnement + JIT HUB-15 (aucun compte créé pour un ``sub`` refusé) ; +- session locale préexistante exemptée (accès de secours) ; +- surfaces d'administration d'instance (``/api/admin/*``) : session + draco + rôle connu → ``administrateur`` exigé ; +- rôle inconnu (Hub injoignable/erreur/rôle hors ensemble) → repli + intégral. +""" + +import base64 +import hashlib +import hmac +import json +import time +from types import SimpleNamespace + +import pytest +from conftest import anon + +from app.db import get_conn +from app.services import draco, hub_roles + +SECRET = "secret-partage-de-test" + + +def _jeton(sub="admin-1", secret=SECRET, exp=None, jti="jti-hub19", name="Bruno"): + def b64(d: bytes) -> str: + return base64.urlsafe_b64encode(d).rstrip(b"=").decode() + + header = b64(json.dumps({"alg": "HS256", "typ": "JWT"}).encode()) + payload = b64(json.dumps({ + "sub": sub, "name": name, "iat": int(time.time()), + "exp": exp if exp is not None else int(time.time()) + 3600, + "jti": jti, + }).encode()) + sig = hmac.new(secret.encode(), f"{header}.{payload}".encode(), + hashlib.sha256).digest() + return f"{header}.{payload}.{b64(sig)}" + + +def _requete(cookie_complet="", draco_token=None): + cookies = {} + headers = {} + if draco_token is not None: + cookies["draco_session"] = draco_token + complet = f"draco_session={draco_token}" + headers["cookie"] = complet if not cookie_complet else cookie_complet + elif cookie_complet: + headers["cookie"] = cookie_complet + return SimpleNamespace(cookies=cookies, headers=headers) + + +@pytest.fixture(autouse=True) +def _caches_propres(monkeypatch): + monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET) + monkeypatch.setattr(draco, "_refresh_revocations", lambda: None) + draco._revoked_cache.clear() + hub_roles._cache.clear() + hub_roles._cache_fetched_at = 0.0 + yield + draco._revoked_cache.clear() + hub_roles._cache.clear() + hub_roles._cache_fetched_at = 0.0 + + +def _pose_role(monkeypatch, role, compteur=None): + """Simule la réponse du Hub pour ``role_pour`` (appel réseau évité).""" + def faux_consulter(cookie): + if compteur is not None: + compteur.append(cookie) + return role + monkeypatch.setattr(hub_roles, "_consulter_hub", faux_consulter) + + +# ── Client : cache par sub, TTL, horodatage avant l'appel ─────────── + +def test_role_connu_mis_en_cache_par_sub(monkeypatch): + appels = [] + _pose_role(monkeypatch, "utilisateur", appels) + assert hub_roles.role_pour("cookie-a", "sub-1") == "utilisateur" + assert hub_roles.role_pour("cookie-a", "sub-1") == "utilisateur" + assert len(appels) == 1 # 2e lecture : cache + assert hub_roles.role_pour("cookie-b", "sub-2") == "utilisateur" + assert len(appels) == 2 # autre sub : nouvel appel + + +def test_echec_ancien_cache_conserve_pas_de_rafale(monkeypatch): + appels = [] + _pose_role(monkeypatch, "utilisateur", appels) + assert hub_roles.role_pour("c", "sub-1") == "utilisateur" + # Fenêtre expirée, Hub désormais en échec : l'ancien cache reste. + hub_roles._cache_fetched_at = time.monotonic() - 61 + _pose_role(monkeypatch, None, appels) + assert hub_roles.role_pour("c", "sub-1") == "utilisateur" + assert len(appels) == 2 + # Pas de rafale : dans la fenêtre qui suit l'échec, aucun rappel. + assert hub_roles.role_pour("c", "sub-1") == "utilisateur" + assert len(appels) == 2 + + +def test_echec_sans_cache_role_inconnu(monkeypatch): + # Fidèle au pilote : sans entrée en cache pour ce sub, l'échec + # rend « inconnu » et la demande suivante retente (la protection + # anti-rafale de l'horodatage posé avant l'appel ne sert que les + # subs déjà en cache — test précédent). + appels = [] + _pose_role(monkeypatch, None, appels) + assert hub_roles.role_pour("c", "sub-x") is None + assert hub_roles.role_pour("c", "sub-x") is None + assert len(appels) == 2 + + +def test_role_sans_sub_inconnu(monkeypatch): + _pose_role(monkeypatch, "aucun") + assert hub_roles.role_pour("c", "") is None + + +# ── Client : validation de la réponse du Hub ──────────────────────── + +class _Reponse: + def __init__(self, status_code, payload=None): + self.status_code = status_code + self._payload = payload + + def json(self): + if isinstance(self._payload, Exception): + raise self._payload + return self._payload + + +def _pose_http(monkeypatch, reponse_ou_exception, appels=None): + import httpx + + from app.services import draco_urls + monkeypatch.setattr(draco_urls, "hub_url", lambda: "https://hub.example") + + def faux_get(url, headers=None, timeout=None): + if appels is not None: + appels.append((url, headers, timeout)) + if isinstance(reponse_ou_exception, Exception): + raise reponse_ou_exception + return reponse_ou_exception + + monkeypatch.setattr(httpx, "get", faux_get) + + +def test_consultation_contrat_exact(monkeypatch): + appels = [] + _pose_http(monkeypatch, _Reponse(200, { + "app": "flowdeck", "sub": "sub-1", "role": "administrateur", + "explicite": True, "ttl_secondes": 60}), appels) + cookie = "draco_session=jeton; autre=1" + assert hub_roles._consulter_hub(cookie) == "administrateur" + url, headers, timeout = appels[0] + assert url == "https://hub.example/api/roles/flowdeck" + assert headers["Cookie"] == cookie # cookie complet relayé + assert headers["Accept"] == "application/json" + assert timeout == 2.0 + + +@pytest.mark.parametrize("reponse", [ + _Reponse(401, {}), _Reponse(404, {}), _Reponse(500, {}), + _Reponse(200, {"role": "superadmin"}), # hors ensemble + _Reponse(200, {"role": None}), + _Reponse(200, ValueError("json illisible")), + ConnectionError("hub injoignable"), +]) +def test_consultation_erreurs_role_inconnu(monkeypatch, reponse): + _pose_http(monkeypatch, reponse) + assert hub_roles._consulter_hub("c") is None + + +# ── role_draco / admin_hub_ok ─────────────────────────────────────── + +def test_role_draco_sans_cookie_inconnu(): + assert hub_roles.role_draco(_requete()) is None + + +def test_role_draco_avec_cookie(monkeypatch): + _pose_role(monkeypatch, "administrateur") + assert hub_roles.role_draco(_requete(draco_token=_jeton())) == "administrateur" + + +def test_admin_hub_ok_sans_draco_comportement_actuel(): + assert hub_roles.admin_hub_ok(_requete()) is True + + +@pytest.mark.parametrize("role,attendu", [ + ("administrateur", True), ("utilisateur", False), ("aucun", False), + (None, True), # inconnu → repli +]) +def test_admin_hub_ok_selon_role(monkeypatch, role, attendu): + _pose_role(monkeypatch, role) + assert hub_roles.admin_hub_ok(_requete(draco_token=_jeton())) is attendu + + +# ── Intégration : pont /auth/draco ────────────────────────────────── + +def _compte_utilisateurs(): + with get_conn() as conn: + return conn.execute("SELECT COUNT(*) FROM users").fetchone()[0] + + +def _ajoute_deuxieme_utilisateur(): + with get_conn() as conn: + conn.execute( + "INSERT INTO users (login, email, password_hash, full_name, is_active) " + "VALUES ('deuxieme', 'deux@example.com', 'x', 'Deuxième', 1)") + conn.commit() + + +def test_pont_refus_aucun_403_en_francais(client, monkeypatch): + c = anon(client) + _pose_role(monkeypatch, "aucun") + c.cookies.set("draco_session", _jeton(sub="admin-1")) + r = c.get("/auth/draco", follow_redirects=False) + assert r.status_code == 403 + assert "registre des rôles" in r.text and "Hub" in r.text + assert "« aucun »" in r.text + assert "flowdeck_session" not in r.headers.get("set-cookie", "") + assert c.get("/auth/user").json()["authenticated"] is False + + +def test_pont_refus_aucun_avant_provisionnement_jit(client, monkeypatch): + c = anon(client) + _ajoute_deuxieme_utilisateur() + avant = _compte_utilisateurs() + _pose_role(monkeypatch, "aucun") + c.cookies.set("draco_session", _jeton(sub="og-refuse", name="Refusée")) + r = c.get("/auth/draco", follow_redirects=False) + assert r.status_code == 403 + # Ordre vérifié : refus avant JIT — aucun compte, aucun lien créés. + assert _compte_utilisateurs() == avant + with get_conn() as conn: + assert conn.execute( + "SELECT COUNT(*) FROM draco_links WHERE sub = 'og-refuse'" + ).fetchone()[0] == 0 + + +def test_pont_role_utilisateur_jit_inchange(client, monkeypatch): + c = anon(client) + _ajoute_deuxieme_utilisateur() + avant = _compte_utilisateurs() + _pose_role(monkeypatch, "utilisateur") + c.cookies.set("draco_session", _jeton(sub="og-nouveau", name="Nouvelle")) + r = c.get("/auth/draco", follow_redirects=False) + assert r.status_code == 302 + assert r.headers["location"] == "/workspaces" + assert _compte_utilisateurs() == avant + 1 # JIT HUB-15 intact + + +def test_pont_role_inconnu_repli_comportement_actuel(client, monkeypatch): + c = anon(client) + _pose_role(monkeypatch, None) # Hub injoignable + c.cookies.set("draco_session", _jeton(sub="admin-1")) + r = c.get("/auth/draco", follow_redirects=False) + assert r.status_code == 302 + assert r.headers["location"] == "/workspaces" + + +def test_pont_session_locale_preexistante_exemptee(client, monkeypatch): + # Le client de la fixture porte déjà une session locale (admin de + # test) : patron du pilote — l'accès de secours n'est pas refusé. + _pose_role(monkeypatch, "aucun") + client.cookies.set("draco_session", _jeton(sub="admin-1")) + r = client.get("/auth/draco", follow_redirects=False) + assert r.status_code == 302 + assert r.headers["location"] == "/workspaces" + + +# ── Intégration : surfaces d'administration (/api/admin/*) ────────── + +def test_admin_instance_role_utilisateur_refuse(client, monkeypatch): + _pose_role(monkeypatch, "utilisateur") + client.cookies.set("draco_session", _jeton(sub="admin-1")) + r = client.get("/api/admin/users") + assert r.status_code == 403 + assert "registre" in r.text and "Hub" in r.text + + +def test_admin_instance_role_administrateur_accepte(client, monkeypatch): + _pose_role(monkeypatch, "administrateur") + client.cookies.set("draco_session", _jeton(sub="admin-1")) + r = client.get("/api/admin/users") + assert r.status_code == 200 + + +def test_admin_instance_role_inconnu_repli(client, monkeypatch): + _pose_role(monkeypatch, None) + client.cookies.set("draco_session", _jeton(sub="admin-1")) + r = client.get("/api/admin/users") + assert r.status_code == 200 # comportement actuel + + +def test_admin_instance_sans_draco_inchange(client, monkeypatch): + _pose_role(monkeypatch, "aucun") # jamais consulté sans draco + r = client.get("/api/admin/users") + assert r.status_code == 200