Merge branch 'main' into hub21-reglages-obsigate
CI / lint (pull_request) Successful in 1m16s
CI / security (pull_request) Failing after 18s
CI / test (pull_request) Successful in 3m48s
CI / build (pull_request) Successful in 13s
CI / e2e (pull_request) Failing after 15m6s

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:
2026-11-17 17:16:57 -05:00
34 changed files with 2190 additions and 27 deletions
+100
View File
@@ -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
+344
View File
@@ -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"
+38
View File
@@ -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):