feat: auth fail-closed, regles par defaut idempotentes et conteneur non root (tt-2026-11-061)

This commit is contained in:
gemini-ops committed 2026-11-17 13:09:53 +01:00
1 parent b51a8bba69
commit 6aef9e83e7
11 files changed
+424 -95

No files matched your search

+1
View File
@@ -20,3 +20,4 @@ htmlcov/
.env
.venv/
venv/
*.bak
+7
View File
@@ -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"]
+38 -35
View File
@@ -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"
)
+77 -31
View File
@@ -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
+23
View File
@@ -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")
+58 -19
View File
@@ -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:
+8 -2
View File
@@ -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(
+8 -1
View File
@@ -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})
+127 -4
View File
@@ -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
+44
View File
@@ -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": "<mail-tunis-01@domain.tn>",
"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": "<mail-manual-01@domain.tn>",
"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"
+33 -3
View File
@@ -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 = "<msg-001@domain.com>"