diff --git a/.gitignore b/.gitignore index ad86379..c0fadcd 100644 --- a/.gitignore +++ b/.gitignore @@ -20,3 +20,4 @@ htmlcov/ .env .venv/ venv/ +*.bak diff --git a/Dockerfile b/Dockerfile index c8bfc41..1aa7833 100644 --- a/Dockerfile +++ b/Dockerfile @@ -17,8 +17,15 @@ COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY app/ /app/app/ +COPY tests/ /app/tests/ COPY README.md /app/ +# Préparation du répertoire persistant data/ et droits non-root +RUN mkdir -p /app/data && chown -R 1037:100 /app + +# Exécution en conteneur non root (uid=1037, gid=100) +USER 1037:100 + EXPOSE 8000 CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] diff --git a/app/auth.py b/app/auth.py index 7f3d9ad..70a84d2 100644 --- a/app/auth.py +++ b/app/auth.py @@ -5,15 +5,36 @@ from typing import Dict, Any, Optional from fastapi import Request, HTTPException, Security from fastapi.security import APIKeyHeader import jwt -from app.config import CF_ACCESS_CERTS_URL, CF_ACCESS_AUD, CF_TEST_SECRET +from app.config import ENV, CF_ACCESS_CERTS_URL, CF_ACCESS_AUD, CF_TEST_SECRET cf_access_header = APIKeyHeader(name="Cf-Access-Jwt-Assertion", auto_error=False) def verify_cf_access_jwt(request: Request) -> Dict[str, Any]: """ - Vérifie la présence et la validité du jeton Cloudflare Access. - Rejette toute requête sans jeton ou avec un jeton invalide (HTTP 401). + Vérifie la présence et la validité de la signature du jeton Cloudflare Access. + Fail-closed : aucun décodage sans vérification de signature n'est autorisé. + - Si l'environnement n'est pas configuré avec les clés nécessaires : HTTP 503. + - Le mode CF_TEST_SECRET n'existe que si ENV='test'. + - Toute absence de jeton, jeton forgé (alg none ou fausse signature) ou invalide : HTTP 401. """ + is_test_env = (ENV == "test") + + # 1. Contrôle préalable de la configuration (Fail-closed) + # Sans clés de vérification, le service répond 503 sur les routes API + if is_test_env and CF_TEST_SECRET: + # Configuration valide pour le mode test + pass + elif CF_ACCESS_CERTS_URL and CF_ACCESS_AUD: + # Configuration valide pour la production (JWKS Cloudflare Access) + pass + else: + # Clés obligatoires manquantes : refus immédiat de servir les routes /api + raise HTTPException( + status_code=503, + detail="Authentification Cloudflare Access non configurée : CF_ACCESS_CERTS_URL et CF_ACCESS_AUD obligatoires" + ) + + # 2. Présence obligatoire du jeton Cloudflare Access token = request.headers.get("Cf-Access-Jwt-Assertion") if not token or not token.strip(): raise HTTPException( @@ -23,25 +44,25 @@ def verify_cf_access_jwt(request: Request) -> Dict[str, Any]: token = token.strip() - # 1. Mode test avec secret HMAC (utilisé dans les tests unitaires et d'intégration) - if CF_TEST_SECRET: + # 3. Mode test avec secret HMAC (strictement restreint à ENV=test) + if is_test_env and CF_TEST_SECRET: try: payload = jwt.decode( token, CF_TEST_SECRET, algorithms=["HS256"], audience=CF_ACCESS_AUD if CF_ACCESS_AUD else None, - options={"verify_aud": bool(CF_ACCESS_AUD)} + options={"verify_aud": bool(CF_ACCESS_AUD), "verify_signature": True} ) return payload except jwt.PyJWTError as e: raise HTTPException( status_code=401, - detail=f"Jeton Cloudflare Access invalide : {str(e)}" + detail=f"Jeton Cloudflare Access invalide ou signature non vérifiée : {str(e)}" ) - # 2. Mode production avec JWKS Cloudflare Access si configuré - if CF_ACCESS_CERTS_URL: + # 4. Mode production avec vérification de signature JWKS Cloudflare Access + if CF_ACCESS_CERTS_URL and CF_ACCESS_AUD: try: jwks_client = jwt.PyJWKClient(CF_ACCESS_CERTS_URL) signing_key = jwks_client.get_signing_key_from_jwt(token) @@ -49,36 +70,18 @@ def verify_cf_access_jwt(request: Request) -> Dict[str, Any]: token, signing_key.key, algorithms=["RS256"], - audience=CF_ACCESS_AUD if CF_ACCESS_AUD else None, - options={"verify_aud": bool(CF_ACCESS_AUD)} + audience=CF_ACCESS_AUD, + options={"verify_aud": True, "verify_signature": True} ) return payload except Exception as e: raise HTTPException( status_code=401, - detail=f"Jeton Cloudflare Access non vérifié par JWKS : {str(e)}" + detail=f"Jeton Cloudflare Access invalide ou signature non vérifiée : {str(e)}" ) - # 3. Mode par défaut : vérification de structure et d'expiration - try: - # Décodage des en-têtes et du payload sans clé (avant configuration finale par Claude) - unverified_header = jwt.get_unverified_header(token) - if not unverified_header: - raise ValueError("En-tête JWT manquant") - payload = jwt.decode( - token, - options={"verify_signature": False, "verify_exp": True} - ) - if not payload or not isinstance(payload, dict): - raise ValueError("Payload JWT non dictionnaire") - return payload - except jwt.ExpiredSignatureError: - raise HTTPException( - status_code=401, - detail="Jeton Cloudflare Access expiré" - ) - except Exception as e: - raise HTTPException( - status_code=401, - detail=f"Jeton Cloudflare Access malformé : {str(e)}" - ) + # Si aucun mode n'a pu valider la signature (sécurité absolue) + raise HTTPException( + status_code=401, + detail="Jeton Cloudflare Access rejeté : signature non vérifiée" + ) diff --git a/app/classifier.py b/app/classifier.py index 827a718..55616ce 100644 --- a/app/classifier.py +++ b/app/classifier.py @@ -1,5 +1,7 @@ import re +import json from typing import Optional, Dict, Any, List, Tuple +from app.config import get_tunis_now_iso from app.db import ( list_regles, get_regle, @@ -21,7 +23,6 @@ def extract_keywords(text: Optional[str]) -> str: """Extrait les mots significatifs d'un objet de mail.""" if not text: return "" - # Nettoyage des préfixes et caractères spéciaux clean = re.sub(r"^(?:re|fwd|tr)\s*:\s*", "", text, flags=re.IGNORECASE) words = re.findall(r"\b[\w\u00C0-\u017F-]{3,}\b", clean, flags=re.UNICODE) meaningful = [w for w in words if w.lower() not in STOPWORDS] @@ -35,7 +36,7 @@ def match_mail_to_rules(mail: Dict[str, Any], rules: List[Dict[str, Any]]) -> st mail_exp = (mail.get("expediteur") or mail.get("from") or "").lower() mail_obj = (mail.get("objet") or mail.get("subject") or "").lower() mail_snip = (mail.get("apercu") or mail.get("snippet") or "").lower() - mail_tags = [t.lower() for t in (mail.get("etiquettes") or mail.get("tags") or [])] + mail_tags = [t.strip().lower() for t in (mail.get("etiquettes") or mail.get("tags") or [])] for rule in rules: if rule.get("statut") != "active": @@ -51,12 +52,11 @@ def match_mail_to_rules(mail: Dict[str, Any], rules: List[Dict[str, Any]]) -> st if rule_exp and rule_exp in mail_exp: return rule["categorie"] - # 3. Correspondance sur les mots-clés + # 3. Correspondance sur les mots-clés (avec frontières de mots pour éviter les faux-positifs) rule_mot = (rule.get("mot_cle") or "").strip().lower() if rule_mot: - # Vérifier si l'un des mots-clés de la règle est présent - mot_parts = rule_mot.split() - if any(p in mail_obj or p in mail_snip for p in mot_parts): + pattern = rf"\b{re.escape(rule_mot)}\b" + if re.search(pattern, mail_obj, re.IGNORECASE) or re.search(pattern, mail_snip, re.IGNORECASE): return rule["categorie"] return "À classer" @@ -78,12 +78,16 @@ def classify_mail(mail: Dict[str, Any], db_path: Optional[str] = None) -> Dict[s rules = list_regles(statut="active", db_path=db_path) categorie = match_mail_to_rules(mail, rules) + tags = mail.get("etiquettes") or mail.get("tags") or [] + tags_json = json.dumps(tags) if isinstance(tags, list) else str(tags) + return save_classement_regle( message_id=mid, categorie=categorie, expediteur=mail.get("expediteur") or mail.get("from") or "", objet=mail.get("objet") or mail.get("subject") or "", date_mail=mail.get("date") or "", + etiquettes=tags_json, db_path=db_path ) @@ -104,6 +108,9 @@ def manual_classify_and_propose( obj = (mail_info.get("objet") if mail_info else None) or (existing.get("objet") if existing else "") date_m = (mail_info.get("date") if mail_info else None) or (existing.get("date_mail") if existing else "") + tags = (mail_info.get("etiquettes") if mail_info else None) or (existing.get("etiquettes") if existing else "[]") + tags_json = json.dumps(tags) if isinstance(tags, list) else str(tags) + classement = save_classement_manuel( message_id=message_id, categorie=new_category, @@ -111,6 +118,7 @@ def manual_classify_and_propose( expediteur=exp, objet=obj, date_mail=date_m, + etiquettes=tags_json, db_path=db_path ) @@ -128,6 +136,68 @@ def manual_classify_and_propose( return classement, proposed_rule +def reclassify_all_non_manual(db_path: Optional[str] = None, date_prefix: Optional[str] = None) -> int: + """ + Réévalue et reclasse tous les emails non-manuels enregistrés en base. + RÈGLE ABSOLUE : Les classements manuels ne sont jamais touchés. + """ + active_rules = list_regles(statut="active", db_path=db_path) + all_classements = list_classements(date_prefix=date_prefix, db_path=db_path) + reclassified_count = 0 + + for c in all_classements: + if c.get("source") == "manuel": + continue + + raw_tags = c.get("etiquettes") or "[]" + try: + tags = json.loads(raw_tags) if isinstance(raw_tags, str) else raw_tags + except Exception: + tags = [] + + mail_repr = { + "message_id": c["message_id"], + "expediteur": c.get("expediteur", ""), + "objet": c.get("objet", ""), + "apercu": "", + "etiquettes": tags if isinstance(tags, list) else [] + } + new_cat = match_mail_to_rules(mail_repr, active_rules) + if new_cat != c.get("categorie"): + save_classement_regle( + message_id=c["message_id"], + categorie=new_cat, + expediteur=c.get("expediteur", ""), + objet=c.get("objet", ""), + date_mail=c.get("date_mail", ""), + etiquettes=raw_tags if isinstance(raw_tags, str) else json.dumps(raw_tags), + db_path=db_path + ) + reclassified_count += 1 + + return reclassified_count + +def reclassify_today_mails(mirror_client: Optional[Any] = None, db_path: Optional[str] = None, target_date: Optional[str] = None) -> int: + """ + Reclasse les mails du jour : interroge le miroir pour synchroniser les étiquettes et applique + les règles actives, sans jamais écraser un classement manuel. + """ + t_date = target_date or get_tunis_now_iso()[:10] + total_processed = 0 + + if mirror_client: + try: + mails = mirror_client.get_mails_for_day(t_date, max_items=50) + for m in mails: + classify_mail(m, db_path=db_path) + total_processed += 1 + except Exception: + pass + + # Reclassement de sécurité sur les données déjà en base + reclassify_all_non_manual(db_path=db_path, date_prefix=t_date) + return total_processed + def confirm_and_apply_rule(regle_id: int, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]: """ Confirme une règle proposée (statut='active') et applique les règles actives @@ -138,29 +208,5 @@ def confirm_and_apply_rule(regle_id: int, db_path: Optional[str] = None) -> Opti if not rule: return None - # Réévaluation des emails non manuels en base - active_rules = list_regles(statut="active", db_path=db_path) - all_classements = list_classements(db_path=db_path) - - for c in all_classements: - if c.get("source") == "manuel": - continue - mail_repr = { - "message_id": c["message_id"], - "expediteur": c.get("expediteur", ""), - "objet": c.get("objet", ""), - "apercu": "", - "etiquettes": [] - } - new_cat = match_mail_to_rules(mail_repr, active_rules) - if new_cat != c.get("categorie"): - save_classement_regle( - message_id=c["message_id"], - categorie=new_cat, - expediteur=c.get("expediteur", ""), - objet=c.get("objet", ""), - date_mail=c.get("date_mail", ""), - db_path=db_path - ) - + reclassify_all_non_manual(db_path=db_path) return rule diff --git a/app/config.py b/app/config.py index ae957f4..3c6e2b5 100644 --- a/app/config.py +++ b/app/config.py @@ -2,6 +2,8 @@ import os from datetime import datetime from zoneinfo import ZoneInfo +ENV = os.getenv("ENV", "production") + DATA_DIR = os.getenv("DATA_DIR", os.path.join(os.path.dirname(os.path.dirname(__file__)), "data")) DB_PATH = os.getenv("DB_PATH", os.path.join(DATA_DIR, "courrier.db")) MIRROR_TOKEN_PATH = os.getenv("MIRROR_TOKEN_PATH", os.path.join(os.path.dirname(os.path.dirname(__file__)), "secrets", "mirror.token")) @@ -20,6 +22,27 @@ DEFAULT_CATEGORIES = [ "À classer" ] +DEFAULT_RULES = [ + # 1. Étiquettes du miroir O365 + {"categorie": "Sans objet", "etiquette_miroir": "sans_objet", "expediteur": None, "mot_cle": None, "statut": "active"}, + {"categorie": "Tunis", "etiquette_miroir": "tunis", "expediteur": None, "mot_cle": None, "statut": "active"}, + {"categorie": "Tunis", "etiquette_miroir": "courses", "expediteur": None, "mot_cle": None, "statut": "active"}, + # 2. Catégories spécifiques et mots-clés évidents + {"categorie": "Sans objet", "etiquette_miroir": None, "expediteur": None, "mot_cle": "sans objet", "statut": "active"}, + {"categorie": "Tunis", "etiquette_miroir": None, "expediteur": None, "mot_cle": "tunis", "statut": "active"}, + {"categorie": "Tunis", "etiquette_miroir": None, "expediteur": None, "mot_cle": "courses", "statut": "active"}, + {"categorie": "Demande FB", "etiquette_miroir": "demande fb", "expediteur": None, "mot_cle": None, "statut": "active"}, + {"categorie": "Demande FB", "etiquette_miroir": "demande_fb", "expediteur": None, "mot_cle": None, "statut": "active"}, + {"categorie": "Demande FB", "etiquette_miroir": None, "expediteur": None, "mot_cle": "demande fb", "statut": "active"}, + {"categorie": "Demande FB", "etiquette_miroir": None, "expediteur": None, "mot_cle": "facebook", "statut": "active"}, + {"categorie": "CI", "etiquette_miroir": "ci", "expediteur": None, "mot_cle": None, "statut": "active"}, + {"categorie": "CI", "etiquette_miroir": None, "expediteur": None, "mot_cle": "ci", "statut": "active"}, + {"categorie": "Câbles", "etiquette_miroir": "câbles", "expediteur": None, "mot_cle": None, "statut": "active"}, + {"categorie": "Câbles", "etiquette_miroir": "cables", "expediteur": None, "mot_cle": None, "statut": "active"}, + {"categorie": "Câbles", "etiquette_miroir": None, "expediteur": None, "mot_cle": "câbles", "statut": "active"}, + {"categorie": "Câbles", "etiquette_miroir": None, "expediteur": None, "mot_cle": "cables", "statut": "active"}, +] + def get_tunis_now_iso() -> str: """Retourne l'horodatage actuel en fuseau Africa/Tunis avec offset +01:00.""" return datetime.now(ZoneInfo("Africa/Tunis")).strftime("%Y-%m-%dT%H:%M:%S+01:00") diff --git a/app/db.py b/app/db.py index 45f9686..a7ad6bd 100644 --- a/app/db.py +++ b/app/db.py @@ -1,7 +1,8 @@ import os +import json import sqlite3 from typing import Optional, List, Dict, Any -from app.config import DB_PATH, DEFAULT_CATEGORIES, get_tunis_now_iso +from app.config import DB_PATH, DEFAULT_CATEGORIES, DEFAULT_RULES, get_tunis_now_iso def get_connection(db_path: Optional[str] = None) -> sqlite3.Connection: path = db_path or DB_PATH @@ -45,18 +46,50 @@ def init_db(db_path: Optional[str] = None) -> None: traite INTEGER NOT NULL DEFAULT 0, expediteur TEXT, objet TEXT, - date_mail TEXT + date_mail TEXT, + etiquettes TEXT DEFAULT '[]' ); """) - # Initialisation des catégories par défaut si vide - cursor = conn.execute("SELECT COUNT(*) as cnt FROM categories") - if cursor.fetchone()["cnt"] == 0: - now = get_tunis_now_iso() - for cat in DEFAULT_CATEGORIES: + # Migration douce si la table classements existait sans la colonne etiquettes + cols = [r["name"] for r in conn.execute("PRAGMA table_info(classements)").fetchall()] + if "etiquettes" not in cols: + conn.execute("ALTER TABLE classements ADD COLUMN etiquettes TEXT DEFAULT '[]'") + + now = get_tunis_now_iso() + + # Initialisation idempotente des catégories par défaut + for cat in DEFAULT_CATEGORIES: + conn.execute( + "INSERT OR IGNORE INTO categories (name, created_at) VALUES (?, ?)", + (cat, now) + ) + + # Initialisation idempotente des règles de départ + for rule in DEFAULT_RULES: + cat = rule["categorie"] + eti = rule.get("etiquette_miroir") + exp = rule.get("expediteur") + mot = rule.get("mot_cle") + sta = rule.get("statut", "active") + + cursor = conn.execute( + """ + SELECT COUNT(*) as cnt FROM regles + WHERE categorie = ? + AND (etiquette_miroir IS ? OR etiquette_miroir = ?) + AND (expediteur IS ? OR expediteur = ?) + AND (mot_cle IS ? OR mot_cle = ?) + """, + (cat, eti, eti, exp, exp, mot, mot) + ) + if cursor.fetchone()["cnt"] == 0: conn.execute( - "INSERT OR IGNORE INTO categories (name, created_at) VALUES (?, ?)", - (cat, now) + """ + INSERT INTO regles (categorie, etiquette_miroir, expediteur, mot_cle, statut, created_at) + VALUES (?, ?, ?, ?, ?, ?) + """, + (cat, eti, exp, mot, sta, now) ) finally: conn.close() @@ -223,7 +256,7 @@ def get_classement(message_id: str, db_path: Optional[str] = None) -> Optional[D conn = get_connection(db_path) try: row = conn.execute( - "SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail FROM classements WHERE message_id = ?", + "SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes FROM classements WHERE message_id = ?", (message_id,) ).fetchone() if not row: @@ -242,7 +275,7 @@ def list_classements( ) -> List[Dict[str, Any]]: conn = get_connection(db_path) try: - query = "SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail FROM classements WHERE 1=1" + query = "SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes FROM classements WHERE 1=1" params: list = [] if date_prefix: query += " AND (date_mail LIKE ? OR horodatage LIKE ?)" @@ -270,6 +303,7 @@ def save_classement_regle( expediteur: str = "", objet: str = "", date_mail: str = "", + etiquettes: Optional[str] = None, db_path: Optional[str] = None ) -> Dict[str, Any]: """ @@ -288,22 +322,24 @@ def save_classement_regle( exp = expediteur or (existing["expediteur"] if existing else "") obj = objet or (existing["objet"] if existing else "") d_mail = date_mail or (existing["date_mail"] if existing else "") + etiq = etiquettes or (existing.get("etiquettes") if existing else "[]") with conn: conn.execute( """ - INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail) - VALUES (?, ?, 'regle', ?, ?, ?, ?, ?) + INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes) + VALUES (?, ?, 'regle', ?, ?, ?, ?, ?, ?) ON CONFLICT(message_id) DO UPDATE SET categorie = excluded.categorie, source = 'regle', horodatage = excluded.horodatage, expediteur = excluded.expediteur, objet = excluded.objet, - date_mail = excluded.date_mail + date_mail = excluded.date_mail, + etiquettes = CASE WHEN excluded.etiquettes != '[]' THEN excluded.etiquettes ELSE classements.etiquettes END WHERE classements.source != 'manuel' """, - (message_id, categorie, now, 1 if traite else 0, exp, obj, d_mail) + (message_id, categorie, now, 1 if traite else 0, exp, obj, d_mail, etiq) ) return get_classement(message_id, db_path) finally: @@ -316,6 +352,7 @@ def save_classement_manuel( expediteur: Optional[str] = None, objet: Optional[str] = None, date_mail: Optional[str] = None, + etiquettes: Optional[str] = None, db_path: Optional[str] = None ) -> Dict[str, Any]: """ @@ -329,12 +366,13 @@ def save_classement_manuel( exp = expediteur if expediteur is not None else (existing["expediteur"] if existing else "") obj = objet if objet is not None else (existing["objet"] if existing else "") d_mail = date_mail if date_mail is not None else (existing["date_mail"] if existing else "") + etiq = etiquettes if etiquettes is not None else (existing.get("etiquettes") if existing else "[]") with conn: conn.execute( """ - INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail) - VALUES (?, ?, 'manuel', ?, ?, ?, ?, ?) + INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes) + VALUES (?, ?, 'manuel', ?, ?, ?, ?, ?, ?) ON CONFLICT(message_id) DO UPDATE SET categorie = excluded.categorie, source = 'manuel', @@ -342,9 +380,10 @@ def save_classement_manuel( traite = excluded.traite, expediteur = CASE WHEN excluded.expediteur != '' THEN excluded.expediteur ELSE classements.expediteur END, objet = CASE WHEN excluded.objet != '' THEN excluded.objet ELSE classements.objet END, - date_mail = CASE WHEN excluded.date_mail != '' THEN excluded.date_mail ELSE classements.date_mail END + date_mail = CASE WHEN excluded.date_mail != '' THEN excluded.date_mail ELSE classements.date_mail END, + etiquettes = CASE WHEN excluded.etiquettes != '[]' THEN excluded.etiquettes ELSE classements.etiquettes END """, - (message_id, categorie, now, is_traite, exp, obj, d_mail) + (message_id, categorie, now, is_traite, exp, obj, d_mail, etiq) ) return get_classement(message_id, db_path) finally: diff --git a/app/main.py b/app/main.py index 6074acb..e5499d3 100644 --- a/app/main.py +++ b/app/main.py @@ -22,7 +22,8 @@ from app.db import ( from app.classifier import ( classify_mail, manual_classify_and_propose, - confirm_and_apply_rule + confirm_and_apply_rule, + reclassify_today_mails ) from app.mirror_client import MirrorClient from app.auth import verify_cf_access_jwt @@ -59,8 +60,13 @@ class TraiteRequest(BaseModel): # --- Lifespan --- @asynccontextmanager async def lifespan(app: FastAPI): - # Démarrage : initialisation de la base SQLite + # Démarrage : initialisation de la base SQLite et des règles par défaut init_db() + # Reclassement des mails du jour après ajout des règles de départ + try: + reclassify_today_mails(mirror_client=mirror_client) + except Exception: + pass yield app = FastAPI( diff --git a/tests/conftest.py b/tests/conftest.py index dc12607..5e17088 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -4,8 +4,9 @@ import pytest from fastapi.testclient import TestClient import jwt -# Configure test environment variables before importing app +# Configuration impérative de l'environnement de test avant l'importation de l'application TEST_SECRET = "secret-test-courrier-tt-2026-11-059" +os.environ["ENV"] = "test" os.environ["CF_TEST_SECRET"] = TEST_SECRET os.environ["CF_ACCESS_AUD"] = "courrier-test-aud" @@ -39,6 +40,12 @@ def client(valid_jwt_token, temp_db, monkeypatch): """Client de test FastAPI avec injecteur d'en-tête Cloudflare Access et DB isolée.""" monkeypatch.setattr("app.config.DB_PATH", temp_db) monkeypatch.setattr("app.db.DB_PATH", temp_db) + monkeypatch.setattr("app.config.ENV", "test") + monkeypatch.setattr("app.auth.ENV", "test") + monkeypatch.setattr("app.config.CF_TEST_SECRET", TEST_SECRET) + monkeypatch.setattr("app.auth.CF_TEST_SECRET", TEST_SECRET) + monkeypatch.setattr("app.config.CF_ACCESS_AUD", "courrier-test-aud") + monkeypatch.setattr("app.auth.CF_ACCESS_AUD", "courrier-test-aud") init_db(temp_db) with TestClient(app) as c: c.headers.update({"Cf-Access-Jwt-Assertion": valid_jwt_token}) diff --git a/tests/test_auth.py b/tests/test_auth.py index 4276121..e601625 100644 --- a/tests/test_auth.py +++ b/tests/test_auth.py @@ -1,8 +1,11 @@ import pytest +import jwt from fastapi.testclient import TestClient from app.main import app +from tests.conftest import TEST_SECRET def test_health_endpoint_no_auth_required(): + """/health reste public et répond 200 avec l'horodatage de Tunis.""" client = TestClient(app) resp = client.get("/health") assert resp.status_code == 200 @@ -11,22 +14,142 @@ def test_health_endpoint_no_auth_required(): assert data["service"] == "courrier" assert "+01:00" in data["horodatage"] -def test_missing_cf_access_jwt_returns_401(): +def test_missing_cf_access_jwt_returns_401(monkeypatch): + """Une requête API sans en-tête JWT est rejetée en 401.""" + monkeypatch.setattr("app.auth.ENV", "test") + monkeypatch.setattr("app.auth.CF_TEST_SECRET", TEST_SECRET) + monkeypatch.setattr("app.auth.CF_ACCESS_AUD", "courrier-test-aud") client = TestClient(app) resp = client.get("/api/v1/categories") assert resp.status_code == 401 - assert "Cf-Access-Jwt-Assertion manquant" in resp.json()["detail"] + assert "manquant" in resp.json()["detail"] -def test_invalid_cf_access_jwt_returns_401(): +def test_invalid_cf_access_jwt_returns_401(monkeypatch): + """Un jeton malformé est rejeté en 401.""" + monkeypatch.setattr("app.auth.ENV", "test") + monkeypatch.setattr("app.auth.CF_TEST_SECRET", TEST_SECRET) + monkeypatch.setattr("app.auth.CF_ACCESS_AUD", "courrier-test-aud") client = TestClient(app) - # Token malformé resp = client.get( "/api/v1/categories", headers={"Cf-Access-Jwt-Assertion": "ceci.n-est-pas.un-jwt-valide"} ) assert resp.status_code == 401 +def test_forged_alg_none_jwt_returns_401(monkeypatch): + """ + Preuve T1 : Un jeton forgé avec l'algorithme 'none' est formellement + rejeté en 401 (aucun décodage non vérifié permis). + """ + monkeypatch.setattr("app.auth.ENV", "test") + monkeypatch.setattr("app.auth.CF_TEST_SECRET", TEST_SECRET) + monkeypatch.setattr("app.auth.CF_ACCESS_AUD", "courrier-test-aud") + + payload = { + "sub": "hacker@evil.com", + "email": "hacker@evil.com", + "aud": "courrier-test-aud", + "exp": 9999999999 + } + # Jeton non signé (alg: none) + forged_token = jwt.encode(payload, key="", algorithm="none") + + client = TestClient(app) + resp = client.get( + "/api/v1/categories", + headers={"Cf-Access-Jwt-Assertion": forged_token} + ) + assert resp.status_code == 401 + assert "signature non vérifiée" in resp.json()["detail"].lower() or "invalide" in resp.json()["detail"].lower() + +def test_forged_bad_signature_jwt_returns_401(monkeypatch): + """ + Preuve T1 : Un jeton signé avec une fausse clé secrète est formellement + rejeté en 401. + """ + monkeypatch.setattr("app.auth.ENV", "test") + monkeypatch.setattr("app.auth.CF_TEST_SECRET", TEST_SECRET) + monkeypatch.setattr("app.auth.CF_ACCESS_AUD", "courrier-test-aud") + + payload = { + "sub": "hacker@evil.com", + "email": "hacker@evil.com", + "aud": "courrier-test-aud", + "exp": 9999999999 + } + # Signé avec une clé pirate différente + forged_token = jwt.encode(payload, "mauvaise-cle-pirate-123-longueur-securisee-32-bytes", algorithm="HS256") + + client = TestClient(app) + resp = client.get( + "/api/v1/categories", + headers={"Cf-Access-Jwt-Assertion": forged_token} + ) + assert resp.status_code == 401 + +def test_bad_audience_jwt_returns_401(monkeypatch): + """Un jeton portant un audience différent de CF_ACCESS_AUD est rejeté en 401.""" + monkeypatch.setattr("app.auth.ENV", "test") + monkeypatch.setattr("app.auth.CF_TEST_SECRET", TEST_SECRET) + monkeypatch.setattr("app.auth.CF_ACCESS_AUD", "courrier-test-aud") + + payload = { + "sub": "user@example.com", + "aud": "autre-audience-invalide", + "exp": 9999999999 + } + token = jwt.encode(payload, TEST_SECRET, algorithm="HS256") + + client = TestClient(app) + resp = client.get( + "/api/v1/categories", + headers={"Cf-Access-Jwt-Assertion": token} + ) + assert resp.status_code == 401 + def test_valid_cf_access_jwt_returns_200(client): + """Un jeton correctement signé en environnement de test donne accès en 200.""" resp = client.get("/api/v1/categories") assert resp.status_code == 200 assert "categories" in resp.json() + +def test_unconfigured_auth_returns_503_on_api_and_200_on_health(monkeypatch): + """ + Preuve T1 : En production (ENV!=test) sans CF_ACCESS_CERTS_URL et CF_ACCESS_AUD, + toutes les routes /api répondent 503 tandis que /health reste 200. + """ + monkeypatch.setattr("app.auth.ENV", "production") + monkeypatch.setattr("app.auth.CF_ACCESS_CERTS_URL", "") + monkeypatch.setattr("app.auth.CF_ACCESS_AUD", "") + + client = TestClient(app) + + # 1. /health reste fonctionnel en 200 + r_health = client.get("/health") + assert r_health.status_code == 200 + + # 2. Les routes /api renvoient 503 Fail-Closed + r_api = client.get( + "/api/v1/categories", + headers={"Cf-Access-Jwt-Assertion": "dummy.token"} + ) + assert r_api.status_code == 503 + assert "obligatoires" in r_api.json()["detail"] + +def test_cf_test_secret_ignored_when_not_in_test_env(monkeypatch): + """ + Preuve T1 : Le mode CF_TEST_SECRET n'existe que si ENV=test. + Si ENV=production, CF_TEST_SECRET est strictement ignoré et le service + répond 503 si les clés JWKS de production ne sont pas configurées. + """ + monkeypatch.setattr("app.auth.ENV", "production") + monkeypatch.setattr("app.auth.CF_TEST_SECRET", TEST_SECRET) + monkeypatch.setattr("app.auth.CF_ACCESS_CERTS_URL", "") + monkeypatch.setattr("app.auth.CF_ACCESS_AUD", "") + + client = TestClient(app) + r = client.get( + "/api/v1/categories", + headers={"Cf-Access-Jwt-Assertion": "token"} + ) + assert r.status_code == 503 diff --git a/tests/test_classifier.py b/tests/test_classifier.py index 71b9015..e6d2c7e 100644 --- a/tests/test_classifier.py +++ b/tests/test_classifier.py @@ -11,6 +11,7 @@ from app.classifier import ( classify_mail, manual_classify_and_propose, confirm_and_apply_rule, + reclassify_all_non_manual, extract_keywords ) @@ -132,3 +133,46 @@ def test_confirm_proposed_rule_applies_to_non_manual_mails_only(temp_db): c1_after = get_classement(mid1, db_path=temp_db) assert c1_after["categorie"] == "Tunis" assert c1_after["source"] == "manuel" + +def test_reclassify_preserves_manual_and_uses_non_default_category(temp_db): + """ + Preuve T2 : Au moins une catégorie autre que 'À classer' est utilisée sur les mails du jour, + et les classements manuels ne sont JAMAIS écrasés. + """ + # Mail A avec étiquette 'tunis' + mail_a = { + "message_id": "", + "expediteur": "contact@tunis.tn", + "objet": "Point d'avancement", + "date": "2026-11-17", + "etiquettes": ["tunis"] + } + cA = classify_mail(mail_a, db_path=temp_db) + assert cA["categorie"] == "Tunis", "L'étiquette 'tunis' doit classer en 'Tunis'" + assert cA["source"] == "regle" + + # Mail B classé manuellement en 'CI' + mail_b = { + "message_id": "", + "expediteur": "contact@autre.tn", + "objet": "Point sans objet", + "date": "2026-11-17", + "etiquettes": ["sans_objet"] + } + cB_manual = save_classement_manuel( + message_id=mail_b["message_id"], + categorie="CI", + db_path=temp_db + ) + assert cB_manual["categorie"] == "CI" + assert cB_manual["source"] == "manuel" + + # Reclassement général + reclassify_all_non_manual(db_path=temp_db) + + # Vérifications : + # 1. Le mail A est resté 'Tunis' + assert get_classement(mail_a["message_id"], db_path=temp_db)["categorie"] == "Tunis" + # 2. Le mail B manuel n'a JAMAIS été écrasé vers 'Sans objet' + assert get_classement(mail_b["message_id"], db_path=temp_db)["categorie"] == "CI" + assert get_classement(mail_b["message_id"], db_path=temp_db)["source"] == "manuel" diff --git a/tests/test_db.py b/tests/test_db.py index a88ae96..c28fa82 100644 --- a/tests/test_db.py +++ b/tests/test_db.py @@ -1,5 +1,6 @@ import pytest from app.db import ( + init_db, list_categories, add_category, update_category, @@ -20,6 +21,33 @@ def test_init_db_creates_tables_and_default_categories(temp_db): expected = ["Tunis", "Demande FB", "CI", "Câbles", "Sans objet", "À classer"] assert cat_names == expected, f"Catégories par défaut attendues: {expected}, obtenu: {cat_names}" +def test_init_db_creates_default_rules_idempotently(temp_db): + """ + Preuve T2 : Les règles de départ sont créées à partir des étiquettes miroir + (sans_objet, tunis, courses) et catégories (Demande FB, CI, Câbles) de façon idempotente. + """ + rules_initial = list_regles(statut="active", db_path=temp_db) + assert len(rules_initial) >= 6 + + # Vérification des règles sur étiquettes miroir + tags = {r["etiquette_miroir"] for r in rules_initial if r["etiquette_miroir"]} + assert "sans_objet" in tags + assert "tunis" in tags + assert "courses" in tags + + # Vérification des catégories cibles + rule_cats = {r["categorie"] for r in rules_initial} + assert "Sans objet" in rule_cats + assert "Tunis" in rule_cats + assert "Demande FB" in rule_cats + assert "CI" in rule_cats + assert "Câbles" in rule_cats + + # Idempotence : un second init_db ne doit pas créer de doublons + init_db(temp_db) + rules_after = list_regles(statut="active", db_path=temp_db) + assert len(rules_after) == len(rules_initial) + def test_crud_categories(temp_db): # Création new_cat = add_category("Factures", db_path=temp_db) @@ -40,6 +68,8 @@ def test_crud_categories(temp_db): assert not any(c["name"] == "Factures Fournisseurs" for c in cats_after) def test_crud_regles(temp_db): + initial_count = len(list_regles(db_path=temp_db)) + # Création rule = add_regle( categorie="Tunis", @@ -59,12 +89,12 @@ def test_crud_regles(temp_db): # Liste rules = list_regles(statut="active", db_path=temp_db) - assert len(rules) == 1 - assert rules[0]["categorie"] == "Demande FB" + assert len(rules) == initial_count + 1 + assert any(r["id"] == rule["id"] and r["categorie"] == "Demande FB" for r in rules) # Suppression assert delete_regle(rule["id"], db_path=temp_db) is True - assert len(list_regles(db_path=temp_db)) == 0 + assert len(list_regles(db_path=temp_db)) == initial_count def test_manual_classification_persistence(temp_db): mid = ""