Merge branch 'main' into hub21-reglages-obsigate
Résolution des conflits de version : la PR visait 2.85.2 depuis le main 2.85.1, mais main est passé à 2.87.0 entre-temps. La livraison HUB-21 (#229) devient 2.87.1 — VERSION, package.json, desktop (Cargo.toml, Cargo.lock, tauri.conf.json), README FR/EN, CHANGELOG (section [2.87.1] — 2026-11-17 au-dessus de [2.87.0]) et ROADMAP resynchronisés. backend/main.py fusionné automatiquement (HUB-21 + liaison d'appareil #75 cohabitent). Tests : hub_reglages, hub_roles, version, barre, CSP, recherche verts ; suite complète verte ; ruff et mypy propres.
This commit is contained in:
@@ -101,6 +101,96 @@ def test_barre_v030_liens_hub_menu_compte():
|
||||
assert "v0.3.0" in html
|
||||
|
||||
|
||||
def test_barre_v060_entree_administration():
|
||||
# Barre v0.6.0 (dracodev-commons, demande de Bruno du
|
||||
# 2026-11-06) : entrée « Administration » du menu compte —
|
||||
# lien Hub <hub>/admin à visibilité conditionnelle. Le JS
|
||||
# vendangé la construit (data-hub-link="admin"), masquée tant
|
||||
# que l'hôte n'affirme pas le statut d'administrateur
|
||||
# (cfg.admin / DRACO_BAR.setAdmin) ; le CSS porte la règle
|
||||
# [hidden] qui la masque malgré le display:flex des items.
|
||||
# Branchement hôte : index.html affirme le statut depuis le
|
||||
# rôle global de /api/auth/me — la définition même de
|
||||
# l'administrateur de suite (garde /admin/* du Hub).
|
||||
js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
|
||||
assert 'data-hub-link", "admin"' in js
|
||||
assert '"Administration"' in js
|
||||
assert "setAdmin" in js
|
||||
assert "compteAdmin = cfg.admin === true" in js
|
||||
css = _css()
|
||||
assert ".draco-menu-item[hidden]" in css
|
||||
html = _index()
|
||||
assert 'window.DRACO_BAR.setAdmin(u.role === "admin")' in html
|
||||
# Le fetch d'amorçage d'index.html tourne avant toute
|
||||
# connexion : le branchement qui couvre la connexion par le
|
||||
# formulaire vit dans renderUserSection() (js/auth.js — le
|
||||
# frontend servi est en modules ES ; le app.js monolithique
|
||||
# à la racine n'est plus chargé), appelée par showApp() pour
|
||||
# toutes les sessions établies, au même endroit que la
|
||||
# rangée d'administration native.
|
||||
auth_js = (FRONTEND / "js" / "auth.js").read_text(encoding="utf-8")
|
||||
assert "window.DRACO_BAR.setAdmin(user.role === \"admin\")" in auth_js
|
||||
assert "window.DRACO_BAR.setAdmin(false)" in auth_js
|
||||
|
||||
|
||||
def test_barre_v070_setuser_et_retour_sso_restauration():
|
||||
# Barre v0.7.0 (dracodev-commons) + BUG-123/BUG-124 (chantier
|
||||
# « entrée SSO de bout en bout », écarts constatés par Bruno le
|
||||
# 2026-11-08) :
|
||||
# - BUG-124 : le JS vendangé expose DRACO_BAR.setUser ; l'hôte
|
||||
# le branche dans renderUserSection() (toutes les sessions
|
||||
# établies, comme setAdmin) et dans le fetch d'amorçage
|
||||
# d'index.html — sans quoi le menu compte affichait
|
||||
# « Compte » jusqu'au rechargement après un login SPA.
|
||||
# - BUG-123 : _honorReturnTo signale la redirection (return)
|
||||
# et initAuth() l'invoque sur ses deux chemins de
|
||||
# restauration au démarrage (jeton valide, refresh
|
||||
# silencieux) — sans quoi l'aller-retour SSO ne se refermait
|
||||
# pas quand la session ObsiGate existait déjà.
|
||||
js = (FRONTEND / "draco-barre.js").read_text(encoding="utf-8")
|
||||
assert "setUser: function (u)" in js
|
||||
assert "v0.7.0" in js
|
||||
html = _index()
|
||||
assert "window.DRACO_BAR.setUser(nom)" in html
|
||||
auth_js = (FRONTEND / "js" / "auth.js").read_text(encoding="utf-8")
|
||||
assert "window.DRACO_BAR.setUser(name || null)" in auth_js
|
||||
assert "window.DRACO_BAR.setUser(null)" in auth_js
|
||||
# BUG-123 : le retour est honoré à la restauration, et
|
||||
# _honorReturnTo rapporte s'il a redirigé.
|
||||
assert "if (this._honorReturnTo()) return true;" in auth_js
|
||||
assert auth_js.count("if (this._honorReturnTo()) return true;") == 2
|
||||
assert "window.location.replace(rt);\n return true;" in auth_js
|
||||
# Le login frais continue de passer par saveToken.
|
||||
assert "this._honorReturnTo();\n }," in auth_js
|
||||
|
||||
|
||||
def test_retour_sso_refresh_force_bug_125():
|
||||
# BUG-125 (suite du chantier « entrée SSO », retest réel de
|
||||
# Bruno le 2026-11-08 après BUG-123) : à l'arrivée d'un
|
||||
# /sso/authorize (return_to présent), le chemin court
|
||||
# d'initAuth (« session valide en sessionStorage ») repartait
|
||||
# sans aucun échange serveur — donc sans réémission du
|
||||
# cookie draco_session par DracoRenewalMiddleware. Cookies
|
||||
# access_token et draco_session absents (sessionStorage
|
||||
# encore « valide ») : le pont de l'application sœur ne
|
||||
# recevait aucun jeton et déposait l'utilisateur devant son
|
||||
# formulaire, sans message (reproduit en navigateur réel
|
||||
# dans la pile « conteneur dev réel », requête du pont
|
||||
# journalisée sans cookie draco). Garde : le chemin court
|
||||
# est conditionné à l'ABSENCE de return_to ; avec return_to,
|
||||
# initAuth passe par le refresh silencieux + /api/auth/me
|
||||
# (réémission du cookie) avant d'honorer le retour — le
|
||||
# nombre d'appels _honorReturnTo des chemins de restauration
|
||||
# reste celui de BUG-123 (2).
|
||||
auth_js = (FRONTEND / "js" / "auth.js").read_text(encoding="utf-8")
|
||||
assert 'get("return_to")' in auth_js
|
||||
assert "&& !retourDemande) {" in auth_js
|
||||
bloc = auth_js.split("async initAuth()", 1)[1]
|
||||
assert bloc.index("!retourDemande") < bloc.index(
|
||||
"await this.refreshAccessToken()")
|
||||
assert auth_js.count("if (this._honorReturnTo()) return true;") == 2
|
||||
|
||||
|
||||
def test_panneau_spark_integre_218():
|
||||
# #218 : le bouton Spark de la barre ouvre le panneau de l'agent
|
||||
# commun (mêmes assets partagés que TikTak / Flowdeck / Kanbante).
|
||||
@@ -184,6 +274,16 @@ def test_urls_ecosysteme_via_injection_hote_223():
|
||||
assert "DRACO_URLS[a.dataset.app]" in html
|
||||
|
||||
|
||||
def test_barre_deconnexion_branchee():
|
||||
# BUG-122 (fusion #141) : la barre d'ObsiGate elle-même branche
|
||||
# l'action « deconnexion » sur son point d'entrée de déconnexion
|
||||
# globale (GET /sso/logout, retour à la racine) — avant, le clic
|
||||
# ne faisait rien ici non plus.
|
||||
html = _index()
|
||||
assert 'act === "deconnexion"' in html
|
||||
assert '"/sso/logout?return_to="' in html
|
||||
|
||||
|
||||
def test_rail_mobile_vers_le_vrai_hamburger():
|
||||
html = _index()
|
||||
assert 'matchMedia("(max-width: 768px)")' in html
|
||||
|
||||
@@ -0,0 +1,344 @@
|
||||
# tests/test_draco_liaison.py
|
||||
# Liaison d'appareil (#75) — flux « code d'appareil » émettant un
|
||||
# jeton draco : démarrer -> approuver -> sonder -> jeton -> lister
|
||||
# -> révoquer. Cas nominaux + refus / expiration / mauvais code /
|
||||
# double livraison / révocation effective / jeton d'appareil refusé
|
||||
# sur la gestion des appareils. Vérification runtime sur la vraie
|
||||
# application (TestClient), pas de conclusion statique seule.
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import tempfile
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from backend import draco_appareils, draco_session, hub_roles
|
||||
from backend.auth.password import hash_password
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client_liaison(tmp_path, monkeypatch):
|
||||
"""Application réelle, données isolées, admin connecté, secret draco."""
|
||||
tmp = Path(tempfile.mkdtemp())
|
||||
data_dir = tmp / "data"
|
||||
data_dir.mkdir()
|
||||
users = {
|
||||
"version": 1,
|
||||
"users": {
|
||||
"admin": {
|
||||
"id": "admin-1",
|
||||
"username": "admin",
|
||||
"display_name": "Admin",
|
||||
"password_hash": hash_password("chab30"),
|
||||
"role": "admin",
|
||||
"vaults": ["*"],
|
||||
"active": True,
|
||||
"created_at": "2026-01-01T00:00:00",
|
||||
}
|
||||
},
|
||||
}
|
||||
(data_dir / "users.json").write_text(json.dumps(users), encoding="utf-8")
|
||||
src_secret = Path("data/secret.key")
|
||||
if src_secret.exists():
|
||||
shutil.copy2(str(src_secret), str(data_dir / "secret.key"))
|
||||
|
||||
orig_cwd = os.getcwd()
|
||||
os.chdir(str(tmp))
|
||||
monkeypatch.setenv("VAULT_1_NAME", "TestVault")
|
||||
monkeypatch.setenv("VAULT_1_PATH", os.path.abspath("test-vault"))
|
||||
monkeypatch.setenv("OBSIGATE_AUTH_ENABLED", "true")
|
||||
monkeypatch.setenv("OBSIGATE_ADMIN_USER", "admin")
|
||||
monkeypatch.setenv("OBSIGATE_ADMIN_PASSWORD", "chab30")
|
||||
monkeypatch.setenv("OBSIGATE_WATCHER_ENABLED", "false")
|
||||
monkeypatch.setenv("DRACO_SESSION_SECRET", "secret-de-test")
|
||||
|
||||
# Fichiers de liaison/appareils isolés + caches remis à zéro.
|
||||
monkeypatch.setattr(draco_appareils, "LIAISONS_FILE",
|
||||
tmp_path / "draco_liaisons.json")
|
||||
monkeypatch.setattr(draco_appareils, "APPAREILS_FILE",
|
||||
tmp_path / "draco_appareils.json")
|
||||
monkeypatch.setattr(draco_session, "REVOKED_FILE",
|
||||
tmp_path / "draco_revoked.json")
|
||||
monkeypatch.setattr(draco_session, "ISSUED_FILE",
|
||||
tmp_path / "draco_issued.json")
|
||||
draco_appareils._liaisons = None
|
||||
draco_appareils._appareils = None
|
||||
draco_session._revoked = None
|
||||
draco_session._issued = None
|
||||
# Rôle Hub inconnu par défaut (Hub injoignable en test) : le
|
||||
# comportement actuel s'applique, sans appel réseau.
|
||||
monkeypatch.setattr(hub_roles, "role_pour", lambda sub, cookie: None)
|
||||
|
||||
import backend.main
|
||||
backend.main._load_config = lambda: {"watcher_enabled": False}
|
||||
from backend.main import app
|
||||
from backend.indexer import build_index, index
|
||||
for key in list(index.keys()):
|
||||
del index[key]
|
||||
loop = asyncio.new_event_loop()
|
||||
asyncio.set_event_loop(loop)
|
||||
loop.run_until_complete(build_index())
|
||||
from backend.search import init_inverted_index
|
||||
init_inverted_index()
|
||||
|
||||
client = TestClient(app)
|
||||
resp = client.post("/api/auth/login",
|
||||
json={"username": "admin", "password": "chab30"})
|
||||
assert resp.status_code == 200, resp.text
|
||||
yield client
|
||||
if hasattr(client, "close"):
|
||||
client.close()
|
||||
loop.run_until_complete(asyncio.sleep(0))
|
||||
os.chdir(orig_cwd)
|
||||
shutil.rmtree(str(tmp), ignore_errors=True)
|
||||
draco_appareils._liaisons = None
|
||||
draco_appareils._appareils = None
|
||||
draco_session._revoked = None
|
||||
draco_session._issued = None
|
||||
|
||||
|
||||
def _demarrer(client, nom="poste-test", type_appareil="tiktak"):
|
||||
resp = client.post("/api/v1/liaison",
|
||||
json={"nom": nom, "type": type_appareil})
|
||||
assert resp.status_code == 201, resp.text
|
||||
return resp.json()
|
||||
|
||||
|
||||
def _lier(client, nom="poste-test", type_appareil="tiktak"):
|
||||
"""Flux nominal jusqu'au jeton : retourne (demande, jeton, appareil)."""
|
||||
demande = _demarrer(client, nom, type_appareil)
|
||||
resp = client.post("/api/v1/liaison/approuver",
|
||||
json={"code": demande["code_utilisateur"]})
|
||||
assert resp.status_code == 200, resp.text
|
||||
appareil = resp.json()["appareil"]
|
||||
assert "jeton" not in resp.text # l'approbation ne livre jamais le jeton
|
||||
resp = client.post("/api/v1/liaison/sonder", json={
|
||||
"demande_id": demande["demande_id"],
|
||||
"code_appareil": demande["code_appareil"]})
|
||||
assert resp.status_code == 200, resp.text
|
||||
data = resp.json()
|
||||
assert data["statut"] == "approuvee"
|
||||
return demande, data["jeton"], data["appareil"]
|
||||
|
||||
|
||||
# ── Flux nominal ─────────────────────────────────────────────────────────
|
||||
|
||||
def test_flux_complet(client_liaison):
|
||||
client = client_liaison
|
||||
demande, jeton, appareil = _lier(client)
|
||||
assert demande["code_utilisateur"][4] == "-"
|
||||
assert len(demande["code_utilisateur"]) == 9
|
||||
assert demande["expire_dans_s"] <= 10 * 60
|
||||
assert demande["url_liaison"] == \
|
||||
"/liaison?code=" + demande["code_utilisateur"]
|
||||
assert demande["url_liaison_absolue"].endswith(demande["url_liaison"])
|
||||
# Le jeton est un JWS draco de longue durée, portant le claim appareil.
|
||||
claims = draco_session.verify_token(jeton)
|
||||
assert claims is not None
|
||||
assert claims["sub"] == "admin-1"
|
||||
assert claims["appareil"] == appareil["id"]
|
||||
assert claims["exp"] - claims["iat"] == \
|
||||
draco_appareils.DEVICE_TOKEN_TTL_SECONDS
|
||||
# L'appareil est listé, actif.
|
||||
resp = client.get("/api/v1/appareils")
|
||||
assert resp.status_code == 200
|
||||
appareils = resp.json()["appareils"]
|
||||
assert len(appareils) == 1
|
||||
assert appareils[0]["id"] == appareil["id"]
|
||||
assert appareils[0]["nom"] == "poste-test"
|
||||
assert appareils[0]["type"] == "tiktak"
|
||||
assert appareils[0]["revoque"] is False
|
||||
# Révocation : le jeton est rejeté dès l'appel suivant.
|
||||
resp = client.post(f"/api/v1/appareils/{appareil['id']}/revoquer")
|
||||
assert resp.status_code == 200
|
||||
assert resp.json() == {"revoque": True}
|
||||
assert draco_session.verify_token(jeton) is None
|
||||
assert any(r["jti"] == claims["jti"]
|
||||
for r in draco_session.revoked_list())
|
||||
resp = client.get("/api/v1/appareils")
|
||||
assert resp.json()["appareils"][0]["revoque"] is True
|
||||
# Révocation d'un appareil déjà révoqué : 404.
|
||||
resp = client.post(f"/api/v1/appareils/{appareil['id']}/revoquer")
|
||||
assert resp.status_code == 404
|
||||
|
||||
|
||||
def test_page_liaison_publique(client_liaison):
|
||||
resp = client_liaison.get("/liaison?code=ABCD-EFGH")
|
||||
assert resp.status_code == 200
|
||||
assert "text/html" in resp.headers["content-type"]
|
||||
assert "Liaison d'appareil" in resp.text
|
||||
assert "/static/liaison.js" in resp.text
|
||||
# Aucun script inline (CSP) : le seul <script> est externe.
|
||||
assert resp.text.count("<script") == 1
|
||||
resp = client_liaison.get("/liaison")
|
||||
assert resp.status_code == 200
|
||||
|
||||
|
||||
def test_types_inconnus_retombent_sur_desktop(client_liaison):
|
||||
demande = _demarrer(client_liaison, type_appareil="inconnu")
|
||||
assert demande["type"] == "desktop"
|
||||
|
||||
|
||||
def test_dedoublonnage_meme_nom_type(client_liaison):
|
||||
client = client_liaison
|
||||
_, jeton1, appareil1 = _lier(client, nom="poste-dup", type_appareil="tiktak")
|
||||
_, jeton2, appareil2 = _lier(client, nom="poste-dup", type_appareil="tiktak")
|
||||
assert appareil1["id"] != appareil2["id"]
|
||||
# Le premier jeton a été révoqué par la seconde liaison.
|
||||
assert draco_session.verify_token(jeton1) is None
|
||||
assert draco_session.verify_token(jeton2) is not None
|
||||
resp = client.get("/api/v1/appareils")
|
||||
par_id = {a["id"]: a for a in resp.json()["appareils"]}
|
||||
assert par_id[appareil1["id"]]["revoque"] is True
|
||||
assert par_id[appareil2["id"]]["revoque"] is False
|
||||
|
||||
|
||||
# ── Refus / erreurs ──────────────────────────────────────────────────────
|
||||
|
||||
def test_refus(client_liaison):
|
||||
client = client_liaison
|
||||
demande = _demarrer(client)
|
||||
resp = client.post("/api/v1/liaison/refuser",
|
||||
json={"code": demande["code_utilisateur"]})
|
||||
assert resp.status_code == 200
|
||||
assert resp.json() == {"refusee": True}
|
||||
resp = client.post("/api/v1/liaison/sonder", json={
|
||||
"demande_id": demande["demande_id"],
|
||||
"code_appareil": demande["code_appareil"]})
|
||||
assert resp.json()["statut"] == "refusee"
|
||||
# Approuver une demande refusée : 404.
|
||||
resp = client.post("/api/v1/liaison/approuver",
|
||||
json={"code": demande["code_utilisateur"]})
|
||||
assert resp.status_code == 404
|
||||
# Refuser deux fois : False.
|
||||
resp = client.post("/api/v1/liaison/refuser",
|
||||
json={"code": demande["code_utilisateur"]})
|
||||
assert resp.json() == {"refusee": False}
|
||||
|
||||
|
||||
def test_sonder_inconnu_ou_mauvais_code_404(client_liaison):
|
||||
client = client_liaison
|
||||
demande = _demarrer(client)
|
||||
resp = client.post("/api/v1/liaison/sonder", json={
|
||||
"demande_id": "inexistant", "code_appareil": "nimporte"})
|
||||
assert resp.status_code == 404
|
||||
resp = client.post("/api/v1/liaison/sonder", json={
|
||||
"demande_id": demande["demande_id"],
|
||||
"code_appareil": "mauvais-code"})
|
||||
assert resp.status_code == 404
|
||||
# Demande inconnue et mauvais code sont indiscernables.
|
||||
assert resp.json()["detail"] == "Demande de liaison inconnue."
|
||||
|
||||
|
||||
def test_expiration(client_liaison, monkeypatch):
|
||||
client = client_liaison
|
||||
monkeypatch.setattr(draco_appareils, "_expiration_min", lambda: 0.0)
|
||||
# Expiration immédiate : la demande naît déjà expirée.
|
||||
demande = _demarrer(client)
|
||||
assert demande["expire_dans_s"] == 0
|
||||
resp = client.post("/api/v1/liaison/approuver",
|
||||
json={"code": demande["code_utilisateur"]})
|
||||
assert resp.status_code == 410
|
||||
resp = client.post("/api/v1/liaison/sonder", json={
|
||||
"demande_id": demande["demande_id"],
|
||||
"code_appareil": demande["code_appareil"]})
|
||||
assert resp.json()["statut"] == "expiree"
|
||||
|
||||
|
||||
def test_double_livraison(client_liaison):
|
||||
client = client_liaison
|
||||
demande, jeton, _appareil = _lier(client)
|
||||
resp = client.post("/api/v1/liaison/sonder", json={
|
||||
"demande_id": demande["demande_id"],
|
||||
"code_appareil": demande["code_appareil"]})
|
||||
assert resp.status_code == 200
|
||||
assert resp.json()["statut"] == "livree"
|
||||
assert "jeton" not in resp.json()
|
||||
|
||||
|
||||
def test_plafond_demandes_en_attente(client_liaison, monkeypatch):
|
||||
monkeypatch.setattr(draco_appareils, "LIAISONS_MAX_EN_ATTENTE", 2)
|
||||
_demarrer(client_liaison, nom="a")
|
||||
_demarrer(client_liaison, nom="b")
|
||||
resp = client_liaison.post("/api/v1/liaison",
|
||||
json={"nom": "c", "type": "desktop"})
|
||||
assert resp.status_code == 429
|
||||
|
||||
|
||||
def test_sans_session_401(client_liaison):
|
||||
# Client vierge (sans cookies de session) : les décisions exigent
|
||||
# une session.
|
||||
from backend.main import app
|
||||
vierge = TestClient(app)
|
||||
resp = vierge.get("/api/v1/appareils")
|
||||
assert resp.status_code == 401
|
||||
resp = vierge.post("/api/v1/liaison/approuver", json={"code": "ABCD-EFGH"})
|
||||
assert resp.status_code == 401
|
||||
resp = vierge.get("/api/v1/liaison/en-attente")
|
||||
assert resp.status_code == 401
|
||||
# Mais démarrer et sonder restent publics (l'app n'a pas d'identité).
|
||||
resp = vierge.post("/api/v1/liaison", json={"nom": "x", "type": "desktop"})
|
||||
assert resp.status_code == 201
|
||||
|
||||
|
||||
# ── Jeton d'appareil : ni gestion, ni décision ──────────────────────────
|
||||
|
||||
def test_jeton_appareil_refuse_sur_gestion(client_liaison):
|
||||
from backend.main import app
|
||||
client = client_liaison
|
||||
_, jeton, appareil = _lier(client)
|
||||
# Client vierge ne portant QUE le jeton d'appareil : sans la
|
||||
# session native, c'est le jeton qui authentifie.
|
||||
nu = TestClient(app)
|
||||
# En cookie draco (session draco) : 403 explicite.
|
||||
nu.cookies.set("draco_session", jeton)
|
||||
resp = nu.get("/api/v1/appareils")
|
||||
assert resp.status_code == 403
|
||||
resp = nu.post("/api/v1/liaison/approuver",
|
||||
json={"code": "ABCD-EFGH"})
|
||||
assert resp.status_code == 403
|
||||
resp = nu.post(f"/api/v1/appareils/{appareil['id']}/revoquer")
|
||||
assert resp.status_code == 403
|
||||
# En Bearer : pas un jeton natif -> 401 (rejet dès get_current_user).
|
||||
nu.cookies.delete("draco_session")
|
||||
resp = nu.get("/api/v1/appareils",
|
||||
headers={"Authorization": f"Bearer {jeton}"})
|
||||
assert resp.status_code == 401
|
||||
|
||||
|
||||
def test_role_hub_aucun_refuse_le_jeton_appareil(client_liaison, monkeypatch):
|
||||
# HUB-19 : si le Hub attribue « aucun » au porteur, le jeton
|
||||
# d'appareil ne vaut pas session — comme la session draco.
|
||||
monkeypatch.setattr(hub_roles, "role_pour",
|
||||
lambda sub, cookie: "aucun")
|
||||
from backend.main import app
|
||||
_, jeton, _appareil = _lier(client_liaison)
|
||||
nu = TestClient(app)
|
||||
nu.cookies.set("draco_session", jeton)
|
||||
resp = nu.get("/api/v1/appareils")
|
||||
# HUB-19 : refus explicite 403 (pas le 401 générique), message en
|
||||
# français sur le rôle « aucun ».
|
||||
assert resp.status_code == 403
|
||||
assert "aucun" in resp.json()["detail"]
|
||||
|
||||
|
||||
# ── issue_token : ttl et claims supplémentaires ─────────────────────────
|
||||
|
||||
def test_issue_token_ttl_et_claims(client_liaison):
|
||||
# La fixture pose le secret draco et isole les fichiers de registre.
|
||||
token, _jti, exp = draco_session.issue_token(
|
||||
{"id": "admin-1", "username": "admin"},
|
||||
ttl_seconds=3600, extra_claims={"appareil": "abc"})
|
||||
claims = draco_session.verify_token(token)
|
||||
assert claims["exp"] - claims["iat"] == 3600
|
||||
assert claims["appareil"] == "abc"
|
||||
# Les claims réservés ne sont jamais écrasés.
|
||||
token2, _j, _e = draco_session.issue_token(
|
||||
{"id": "admin-1", "username": "admin"},
|
||||
extra_claims={"sub": "intrus", "exp": 1})
|
||||
assert draco_session.verify_token(token2)["sub"] == "admin-1"
|
||||
@@ -189,6 +189,44 @@ def test_sso_authorize_liste_blanche(client):
|
||||
assert r.headers["location"] == "/" # refusé, pas de relais
|
||||
|
||||
|
||||
# ── Déconnexion globale navigable (BUG-122, fusion #141) ────────────────
|
||||
|
||||
def test_sso_logout_revoque_et_redirige(admin_client):
|
||||
token = _token_depuis_login(admin_client)
|
||||
assert draco_session.verify_token(token)
|
||||
r = admin_client.get(
|
||||
"/sso/logout",
|
||||
params={"return_to": "https://tiktak.dracodev.net/"},
|
||||
headers={"Cookie": f"draco_session={token}"},
|
||||
follow_redirects=False)
|
||||
assert r.status_code == 302
|
||||
assert r.headers["location"] == "https://tiktak.dracodev.net/"
|
||||
assert draco_session.verify_token(token) is None # jti révoqué
|
||||
cookie = _draco_cookie(r) # cookie effacé
|
||||
assert cookie is not None and "Max-Age=0" in cookie
|
||||
|
||||
|
||||
def test_sso_logout_liste_blanche(admin_client):
|
||||
r = admin_client.get("/sso/logout",
|
||||
params={"return_to": "https://evil.com/phish"},
|
||||
follow_redirects=False)
|
||||
assert r.status_code == 302
|
||||
assert r.headers["location"] == "/" # refusé, pas de relais
|
||||
r = admin_client.get("/sso/logout", follow_redirects=False)
|
||||
assert r.status_code == 302
|
||||
assert r.headers["location"] == "/" # sans return_to
|
||||
|
||||
|
||||
def test_sso_logout_sans_session_idempotent(client):
|
||||
# Aucun cookie : la route reste une redirection propre (les autres
|
||||
# applications y naviguent même si la session a déjà expiré).
|
||||
r = client.get("/sso/logout",
|
||||
params={"return_to": "https://hub.dracodev.net/"},
|
||||
follow_redirects=False)
|
||||
assert r.status_code == 302
|
||||
assert r.headers["location"] == "https://hub.dracodev.net/"
|
||||
|
||||
|
||||
# ── Validation locale (ACC-3.2, #9) ──────────────────────────────────────
|
||||
|
||||
def test_me_avec_cookie_draco_seul(admin_client):
|
||||
|
||||
Reference in New Issue
Block a user