Spaces:
Runtime error
Runtime error
Download tests/test_api/test_auth_routes.py from rahim237cm/jurix-api: direct link, hf CLI and curl.
- Browser
- Download file 7.59 kB
-
https://huggingface.co/spaces/rahim237cm/jurix-api/resolve/main/tests/test_api/test_auth_routes.py
- Command line
-
hf download hf://spaces/rahim237cm/jurix-api/tests/test_api/test_auth_routes.py
-
curl -L -o test_auth_routes.py https://huggingface.co/spaces/rahim237cm/jurix-api/resolve/main/tests/test_api/test_auth_routes.py
7.59 kB
| """ | |
| Tests des routes d'authentification. | |
| Aucun test ne couvrait l'authentification : elle n'existait pas (les endpoints | |
| d'administration passaient par des stubs renvoyant un dictionnaire en dur). | |
| """ | |
| import pytest | |
| from httpx import AsyncClient | |
| PASSWORD = "MotDePasseTest123" | |
| class TestLogin: | |
| """Connexion.""" | |
| async def test_login_json_succeeds(self, client: AsyncClient, test_admin_user): | |
| r = await client.post( | |
| "/api/v1/auth/login/json", | |
| json={"email": test_admin_user.email, "password": PASSWORD}, | |
| ) | |
| assert r.status_code == 200 | |
| body = r.json() | |
| assert body["access_token"] | |
| assert body["token_type"] == "bearer" | |
| assert body["role"] == "admin" | |
| async def test_login_form_succeeds(self, client: AsyncClient, test_admin_user): | |
| """Le formulaire OAuth2 alimente le bouton Authorize de /docs.""" | |
| r = await client.post( | |
| "/api/v1/auth/login", | |
| data={"username": test_admin_user.email, "password": PASSWORD}, | |
| ) | |
| assert r.status_code == 200 | |
| assert r.json()["access_token"] | |
| async def test_wrong_password_is_rejected(self, client: AsyncClient, test_user): | |
| r = await client.post( | |
| "/api/v1/auth/login/json", | |
| json={"email": test_user.email, "password": "mauvais"}, | |
| ) | |
| assert r.status_code == 401 | |
| async def test_unknown_email_gives_same_message( | |
| self, client: AsyncClient, test_user | |
| ): | |
| """ | |
| Message identique pour email inconnu et mot de passe faux. | |
| Les distinguer permettrait d'énumérer les comptes existants. | |
| """ | |
| wrong_pw = await client.post( | |
| "/api/v1/auth/login/json", | |
| json={"email": test_user.email, "password": "mauvais"}, | |
| ) | |
| unknown = await client.post( | |
| "/api/v1/auth/login/json", | |
| json={"email": "personne@nulle-part.cm", "password": "mauvais"}, | |
| ) | |
| assert wrong_pw.status_code == unknown.status_code == 401 | |
| assert wrong_pw.json()["detail"] == unknown.json()["detail"] | |
| async def test_last_login_is_recorded( | |
| self, client: AsyncClient, test_admin_user, db_session | |
| ): | |
| assert test_admin_user.last_login_at is None | |
| await client.post( | |
| "/api/v1/auth/login/json", | |
| json={"email": test_admin_user.email, "password": PASSWORD}, | |
| ) | |
| await db_session.refresh(test_admin_user) | |
| assert test_admin_user.last_login_at is not None | |
| class TestMe: | |
| """Identité associée au jeton.""" | |
| async def test_me_requires_a_token(self, client: AsyncClient): | |
| assert (await client.get("/api/v1/auth/me")).status_code == 401 | |
| async def test_me_rejects_a_bogus_token(self, client: AsyncClient): | |
| r = await client.get( | |
| "/api/v1/auth/me", headers={"Authorization": "Bearer pas-un-jeton"} | |
| ) | |
| assert r.status_code == 401 | |
| async def test_me_returns_the_account( | |
| self, client: AsyncClient, test_user, auth_headers | |
| ): | |
| r = await client.get("/api/v1/auth/me", headers=auth_headers) | |
| assert r.status_code == 200 | |
| assert r.json()["email"] == test_user.email | |
| class TestAuthorization: | |
| """Contrôle d'accès par rôle.""" | |
| # (méthode, chemin) — endpoints qui ne doivent jamais être publics | |
| PROTECTED = [ | |
| ("get", "/api/v1/admin/users"), | |
| ("post", "/api/v1/search/reindex"), | |
| ("get", "/api/v1/search/stats"), | |
| ("post", "/api/v1/upload/cleanup"), | |
| ("get", "/api/v1/batch-upload/status"), | |
| # Le texte des questions et des avis des autres utilisateurs. | |
| ("get", "/api/v1/personas/citoyen/questions"), | |
| ("get", "/api/v1/personas/feedback/1"), | |
| ] | |
| async def test_anonymous_access_is_refused(self, client: AsyncClient, method, path): | |
| r = await getattr(client, method)(path) | |
| assert r.status_code == 401, f"{path} accessible sans jeton" | |
| async def test_plain_user_cannot_reach_admin( | |
| self, client: AsyncClient, auth_headers | |
| ): | |
| """Un jeton valide mais sans privilège doit donner 403, pas 200.""" | |
| r = await client.get("/api/v1/admin/users", headers=auth_headers) | |
| assert r.status_code == 403 | |
| async def test_admin_reaches_admin(self, client: AsyncClient, admin_headers): | |
| r = await client.get("/api/v1/admin/users", headers=admin_headers) | |
| assert r.status_code == 200 | |
| async def test_no_protected_route_lacks_a_guard(self): | |
| """ | |
| Filet de sécurité : parcourt les routes montées et échoue si l'une des | |
| préfixes protégés n'a aucune dépendance d'authentification. | |
| C'est ce test qui rattrapera le prochain endpoint ajouté sans garde. | |
| """ | |
| from app.main import app | |
| prefixes = ("/api/v1/admin/", "/api/v1/ocr/") | |
| # Sondes de sante, publiques par conception. | |
| exempt = {"/api/v1/admin/health", "/api/v1/ocr/health"} | |
| # Hors des prefixes : les questions et les avis des utilisateurs. | |
| reservees = { | |
| "/api/v1/personas/{persona}/questions", | |
| "/api/v1/personas/feedback/{message_id}", | |
| } | |
| # Une garde d'ADMINISTRATEUR : `get_current_user` laisserait passer | |
| # n'importe quel compte, `get_current_user_optional` tout le monde. | |
| gardes = {"get_current_admin_user", "get_current_superadmin_user"} | |
| vues, unguarded = set(), [] | |
| for route in _iter_routes(app): | |
| dependant = getattr(route, "dependant", None) | |
| path = getattr(route, "path", "") | |
| if dependant is None or path in exempt: | |
| continue | |
| if not (path.startswith(prefixes) or path in reservees): | |
| continue | |
| vues.add(path) | |
| if not gardes & _appels(dependant): | |
| unguarded.append(f"{sorted(route.methods)} {path}") | |
| assert not unguarded, f"routes sans garde : {unguarded}" | |
| # Le filet ne doit plus jamais etre vide : depuis FastAPI 0.141, les | |
| # routeurs inclus n'ont plus d'attribut `routes`, et ce test passait | |
| # sans avoir verifie une seule route. | |
| assert reservees <= vues, f"routes reservees introuvables : {reservees - vues}" | |
| assert any(p.startswith("/api/v1/admin/") for p in vues) | |
| def _iter_routes(app): | |
| """ | |
| Parcourt les routes, y compris celles des routeurs inclus. | |
| Depuis FastAPI 0.141, `app.routes` contient des `_IncludedRouter` sans | |
| attribut `routes` : leurs routes, avec le prefixe et les dependances du | |
| routeur, sont dans `effective_candidates()`. | |
| """ | |
| stack = list(app.routes) | |
| while stack: | |
| route = stack.pop() | |
| yield route | |
| if hasattr(route, "effective_candidates"): | |
| stack.extend(route.effective_candidates()) | |
| stack.extend(getattr(route, "routes", []) or []) | |
| def _appels(dependant) -> set: | |
| """Noms des fonctions de toutes les dependances, sous-dependances comprises.""" | |
| pile, noms = list(dependant.dependencies), set() | |
| while pile: | |
| d = pile.pop() | |
| noms.add(getattr(d.call, "__name__", "")) | |
| pile.extend(d.dependencies) | |
| return noms | |