# 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