diff --git a/tests/test_draco_liaison.py b/tests/test_draco_liaison.py new file mode 100644 index 0000000..7a5fe54 --- /dev/null +++ b/tests/test_draco_liaison.py @@ -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