"""Entrée SSO automatique sans session locale (0.46.8). Chantier « entrée SSO de bout en bout » — écart constaté par Bruno en test réel le 2026-11-08 : arrivé chez Kanbante avec une session centrale valide (cookie ``draco_session``) mais aucune session locale, l'application servait son formulaire de connexion comme si le cookie n'existait pas. Attendu : à l'arrivée sur une page, passage automatique par le pont ``/auth/draco`` et service de l'application connectée au compte désigné par le cookie. Couvert : redirection du middleware vers le pont (compte lié et création JIT), chaîne complète jusqu'à la session ouverte, API jamais redirigées, absence de cookie et cookie invalide inchangés, rôle « aucun » (le pont tranche : 403, pas de boucle), échec de résolution signalé au formulaire (``draco=echec``, pas d'échec silencieux), et identité de SESSION dans la barre commune (le nom du compte connecté, pas l'opérateur). Montage repris de tests/test_coherence_identite.py. """ import base64 import hashlib import hmac import json import time import pytest from fastapi.testclient import TestClient import app.main as main from app import accounts, draco, hub_roles, models SECRET = "entree-test" SUB_LIE = "ent-sub-lie" SUB_INCONNU = "ent-sub-inconnu" SUB_INACTIF = "ent-sub-inactif" NOMS = ("ent-lie", "ent-inactif", "ent-inconnu-test") def _jeton(sub, secret=SECRET): 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": "Testeur Test", "iat": int(time.time()), "exp": int(time.time()) + 3600, "jti": f"jti-{sub}", }).encode()) sig = hmac.new(secret.encode(), f"{header}.{payload}".encode(), hashlib.sha256).digest() return f"{header}.{payload}.{b64(sig)}" def _nettoyer(): with models.get_db() as conn: ids = [r[0] for r in conn.execute( "SELECT id FROM users WHERE username IN ({})".format( ",".join("?" * len(NOMS))), NOMS).fetchall()] ids += [r[0] for r in conn.execute( "SELECT id FROM users WHERE draco_sub IN (?, ?, ?)", (SUB_LIE, SUB_INCONNU, SUB_INACTIF)).fetchall()] for uid in ids: conn.execute("DELETE FROM users WHERE id = ?", (uid,)) @pytest.fixture() def client_ent(monkeypatch, fake_gitea): monkeypatch.setenv("KANBANTE_AUTH_USER", "operateur") monkeypatch.setenv("KANBANTE_AUTH_PASSWORD", "motdepasse") monkeypatch.setenv("DRACO_SESSION_SECRET", SECRET) monkeypatch.setattr(draco, "_refresh_revocations", lambda: None) monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: None) draco._revoked_cache.clear() _nettoyer() models.create_user( "ent-lie", accounts.hash_password("local-lie"), role="member", draco_sub=SUB_LIE) with models.get_db() as conn: conn.execute( "UPDATE users SET display_name = 'Testeur Test' " "WHERE username = 'ent-lie'") inactif_id = models.create_user( "ent-inactif", accounts.hash_password("local-inactif"), role="member", draco_sub=SUB_INACTIF) models.update_user(inactif_id, active=False) with TestClient(main.app) as client: # Le TestClient doit parler comme un navigateur : sans # Accept text/html, le middleware classe la requête en # cliente d'API (401) — c'est l'en-tête, pas le correctif, # qui décide de la famille de la requête. client.headers["Accept"] = ( "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8") yield client _nettoyer() draco._revoked_cache.clear() # ── Entrée automatique par le pont ─────────────────────────────── def test_page_sans_session_cookie_valide_renvoyee_au_pont(client_ent): client_ent.cookies.set("draco_session", _jeton(SUB_LIE)) r = client_ent.get("/", follow_redirects=False) assert r.status_code == 303 assert r.headers["location"].startswith("/auth/draco") def test_chaine_complete_session_ouverte_pour_le_compte_du_cookie(client_ent): client_ent.cookies.set("draco_session", _jeton(SUB_LIE)) r = client_ent.get("/", follow_redirects=False) pont = r.headers["location"] r2 = client_ent.get(pont, follow_redirects=False) assert r2.status_code == 303 assert "kanbante_session" in r2.headers.get("set-cookie", "") r3 = client_ent.get("/", follow_redirects=False) assert r3.status_code == 200 def test_page_sans_session_sub_inconnu_jit_par_le_pont(client_ent): client_ent.cookies.set("draco_session", _jeton(SUB_INCONNU)) r = client_ent.get("/", follow_redirects=False) assert r.headers["location"].startswith("/auth/draco") r2 = client_ent.get(r.headers["location"], follow_redirects=False) assert r2.status_code == 303 assert models.get_user_by_draco(SUB_INCONNU) is not None def test_api_sans_session_cookie_valide_reste_401(client_ent): client_ent.cookies.set("draco_session", _jeton(SUB_LIE)) r = client_ent.get("/api/projects", follow_redirects=False) assert r.status_code == 401 # ── Régressions : sans session centrale, rien ne change ───────── def test_sans_cookie_formulaire_comme_avant(client_ent): r = client_ent.get("/", follow_redirects=False) assert r.status_code == 303 assert r.headers["location"].startswith("/login?next=") def test_cookie_invalide_formulaire_comme_avant(client_ent): client_ent.cookies.set("draco_session", _jeton(SUB_LIE, secret="mauvais")) r = client_ent.get("/", follow_redirects=False) assert r.status_code == 303 assert r.headers["location"].startswith("/login?next=") def test_cookie_invalide_signale_au_formulaire(client_ent): # 0.46.11 : la destination reste le formulaire (contrat du # test précédent inchangé), mais l'échec du parcours central # est NOMMÉ — draco=invalide, traduit en message par la page # de connexion. Avant : retour muet, indistinguable d'une # absence de session centrale. client_ent.cookies.set( "draco_session", _jeton(SUB_LIE, secret="mauvais")) r = client_ent.get("/", follow_redirects=False) assert r.status_code == 303 assert "draco=invalide" in r.headers["location"] r2 = client_ent.get(r.headers["location"], follow_redirects=False) assert r2.status_code == 200 assert "n'a pas pu être validé" in r2.text.replace("'", "'") def test_page_login_jamais_interceptee(client_ent): client_ent.cookies.set("draco_session", _jeton(SUB_LIE)) r = client_ent.get("/login", follow_redirects=False) assert r.status_code == 200 # ── Gardes du pont : refus explicite, échec signalé ───────────── def test_role_aucun_le_pont_tranche_403_sans_boucle(client_ent, monkeypatch): monkeypatch.setattr(hub_roles, "role_pour", lambda *a, **k: "aucun") client_ent.cookies.set("draco_session", _jeton(SUB_LIE)) r = client_ent.get("/", follow_redirects=False) assert r.headers["location"].startswith("/auth/draco") r2 = client_ent.get(r.headers["location"], follow_redirects=False) assert r2.status_code == 403 def test_echec_de_resolution_signale_au_formulaire(client_ent): client_ent.cookies.set("draco_session", _jeton(SUB_INACTIF)) r = client_ent.get("/auth/draco", follow_redirects=False) assert r.status_code == 303 assert "draco=echec" in r.headers["location"] r2 = client_ent.get(r.headers["location"], follow_redirects=False) assert r2.status_code == 200 # L'apostrophe du message est échappée par Jinja (n') : # on cherche le fragment invariant. assert "pas abouti pour ce compte" in r2.text # ── Barre commune : l'identité de session, pas l'opérateur ────── def test_barre_affiche_le_nom_du_compte_de_session(client_ent): client_ent.cookies.set( "kanbante_session", main._make_session("ent-lie")) r = client_ent.get("/", follow_redirects=False) assert r.status_code == 200 assert 'user: "Testeur Test"' in r.text assert 'user: "O"' not in r.text # initiale de l'opérateur