feat: application Courrier V1a socle et tri du jour (tt-2026-11-059)

This commit is contained in:
gemini-ops committed 2026-11-17 12:14:55 +01:00
1 parent 0199477821
commit b51a8bba69
19 files changed
+1731 -2

No files matched your search

View File
Whitespace-only changes.
+45
View File
@@ -0,0 +1,45 @@
import os
import tempfile
import pytest
from fastapi.testclient import TestClient
import jwt
# Configure test environment variables before importing app
TEST_SECRET = "secret-test-courrier-tt-2026-11-059"
os.environ["CF_TEST_SECRET"] = TEST_SECRET
os.environ["CF_ACCESS_AUD"] = "courrier-test-aud"
from app.main import app
from app.db import init_db
@pytest.fixture
def temp_db():
"""Crée une base SQLite temporaire isolée pour chaque test."""
with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
db_path = f.name
init_db(db_path)
yield db_path
if os.path.exists(db_path):
os.remove(db_path)
@pytest.fixture
def valid_jwt_token():
"""Génère un jeton JWT valide pour les tests d'API."""
payload = {
"sub": "user@example.com",
"email": "user@example.com",
"aud": "courrier-test-aud",
"iss": "https://test.cloudflareaccess.com",
"exp": 9999999999
}
return jwt.encode(payload, TEST_SECRET, algorithm="HS256")
@pytest.fixture
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)
init_db(temp_db)
with TestClient(app) as c:
c.headers.update({"Cf-Access-Jwt-Assertion": valid_jwt_token})
yield c
+89
View File
@@ -0,0 +1,89 @@
import pytest
def test_api_categories_crud(client):
# 1. Lister les catégories initiales
r = client.get("/api/v1/categories")
assert r.status_code == 200
initial_count = len(r.json()["categories"])
# 2. Créer une catégorie
r_create = client.post("/api/v1/categories", json={"name": "Nouvelle Catégorie"})
assert r_create.status_code == 201
cat_id = r_create.json()["id"]
# 3. Mettre à jour
r_edit = client.put(f"/api/v1/categories/{cat_id}", json={"name": "Catégorie Renommée"})
assert r_edit.status_code == 200
assert r_edit.json()["name"] == "Catégorie Renommée"
# 4. Supprimer
r_del = client.delete(f"/api/v1/categories/{cat_id}")
assert r_del.status_code == 200
def test_api_regles_crud(client):
# 1. Créer une règle
payload = {
"categorie": "Tunis",
"expediteur": "fournisseur@test.tn",
"mot_cle": "commande",
"etiquette_miroir": "courses",
"statut": "active"
}
r = client.post("/api/v1/regles", json=payload)
assert r.status_code == 201
rule_id = r.json()["id"]
# 2. Lister
r_list = client.get("/api/v1/regles?statut=active")
assert r_list.status_code == 200
assert any(x["id"] == rule_id for x in r_list.json()["regles"])
# 3. Modifier
r_edit = client.put(f"/api/v1/regles/{rule_id}", json={"mot_cle": "livraison"})
assert r_edit.status_code == 200
assert r_edit.json()["mot_cle"] == "livraison"
# 4. Supprimer
r_del = client.delete(f"/api/v1/regles/{rule_id}")
assert r_del.status_code == 200
def test_api_manual_classement_and_traite(client):
mid = "<test-api-mail-01@domain.tn>"
# Classement manuel
r = client.post(
f"/api/v1/classements/{mid}",
json={
"categorie": "Demande FB",
"traite": False,
"mail_info": {
"expediteur": "client@fb.com",
"objet": "Demande de contact",
"date": "2026-11-17"
}
}
)
assert r.status_code == 200
res = r.json()
assert res["classement"]["source"] == "manuel"
assert res["classement"]["categorie"] == "Demande FB"
assert res["regle_proposee"] is not None
assert res["regle_proposee"]["statut"] == "proposee"
# Modification de la case traité
r_traite = client.patch(f"/api/v1/classements/{mid}/traite", json={"traite": True})
assert r_traite.status_code == 200
assert r_traite.json()["traite"] is True
def test_api_confirm_proposed_rule(client):
# Créer règle proposée
r_rule = client.post(
"/api/v1/regles",
json={"categorie": "Câbles", "mot_cle": "optique", "statut": "proposee"}
)
assert r_rule.status_code == 201
rule_id = r_rule.json()["id"]
# Confirmer
r_conf = client.post(f"/api/v1/regles/{rule_id}/confirmer")
assert r_conf.status_code == 200
assert r_conf.json()["regle"]["statut"] == "active"
+32
View File
@@ -0,0 +1,32 @@
import pytest
from fastapi.testclient import TestClient
from app.main import app
def test_health_endpoint_no_auth_required():
client = TestClient(app)
resp = client.get("/health")
assert resp.status_code == 200
data = resp.json()
assert data["status"] == "healthy"
assert data["service"] == "courrier"
assert "+01:00" in data["horodatage"]
def test_missing_cf_access_jwt_returns_401():
client = TestClient(app)
resp = client.get("/api/v1/categories")
assert resp.status_code == 401
assert "Cf-Access-Jwt-Assertion manquant" in resp.json()["detail"]
def test_invalid_cf_access_jwt_returns_401():
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_valid_cf_access_jwt_returns_200(client):
resp = client.get("/api/v1/categories")
assert resp.status_code == 200
assert "categories" in resp.json()
+134
View File
@@ -0,0 +1,134 @@
import pytest
from app.db import (
add_regle,
list_regles,
get_classement,
save_classement_regle,
save_classement_manuel
)
from app.classifier import (
match_mail_to_rules,
classify_mail,
manual_classify_and_propose,
confirm_and_apply_rule,
extract_keywords
)
def test_extract_keywords():
assert extract_keywords("Re: Demande de câbles pour le site") == "Demande câbles site"
assert extract_keywords("TR: facture urgente") == "facture urgente"
assert extract_keywords("") == ""
def test_match_mail_to_rules():
rules = [
{"id": 1, "etiquette_miroir": "courses", "categorie": "Tunis", "statut": "active"},
{"id": 2, "expediteur": "fournisseur-cable.tn", "categorie": "Câbles", "statut": "active"},
{"id": 3, "mot_cle": "facturation", "categorie": "CI", "statut": "active"}
]
# Match par étiquette
mail_tag = {"etiquettes": ["courses"], "expediteur": "autre@test.tn", "objet": "Rien"}
assert match_mail_to_rules(mail_tag, rules) == "Tunis"
# Match par expéditeur
mail_exp = {"etiquettes": [], "expediteur": "commercial@fournisseur-cable.tn", "objet": "Devis"}
assert match_mail_to_rules(mail_exp, rules) == "Câbles"
# Match par mot-clé
mail_mot = {"etiquettes": [], "expediteur": "inconnu@test.tn", "objet": "Note de facturation annuelle"}
assert match_mail_to_rules(mail_mot, rules) == "CI"
# Défaut
mail_def = {"etiquettes": [], "expediteur": "newsletter@spam.com", "objet": "Bonjour"}
assert match_mail_to_rules(mail_def, rules) == "À classer"
def test_manual_correction_proposes_rule_unapplied(temp_db):
"""
Une correction manuelle propose une règle (même expéditeur et mêmes mots),
qui ne s'applique qu'une fois confirmée.
"""
mid1 = "<mail-target-01@domain.tn>"
mail1 = {
"message_id": mid1,
"expediteur": "client-important@domain.tn",
"objet": "Demande de contrat spécifique",
"date": "2026-11-17"
}
# 1. Classement automatique initial par défaut
c1 = classify_mail(mail1, db_path=temp_db)
assert c1["categorie"] == "À classer"
assert c1["source"] == "regle"
# 2. Correction manuelle par l'utilisateur -> proposition de règle
c1_man, regle_prop = manual_classify_and_propose(
message_id=mid1,
new_category="Demande FB",
mail_info=mail1,
db_path=temp_db
)
assert c1_man["categorie"] == "Demande FB"
assert c1_man["source"] == "manuel"
assert regle_prop is not None
assert regle_prop["statut"] == "proposee"
assert regle_prop["categorie"] == "Demande FB"
assert "client-important@domain.tn" in regle_prop["expediteur"]
# 3. Un second mail similaire arrive : la règle PROPOSÉE ne doit PAS s'appliquer !
mid2 = "<mail-target-02@domain.tn>"
mail2 = {
"message_id": mid2,
"expediteur": "client-important@domain.tn",
"objet": "Autre question",
"date": "2026-11-17"
}
c2 = classify_mail(mail2, db_path=temp_db)
assert c2["categorie"] == "À classer", "Une règle proposée ne doit pas s'appliquer avant confirmation"
def test_confirm_proposed_rule_applies_to_non_manual_mails_only(temp_db):
"""
Une règle confirmée s'applique à tous les mails non-manuels, sans jamais toucher
les classements manuels.
"""
# Mail 1: classé manuellement en 'Tunis'
mid1 = "<mail-prop-01@domain.tn>"
save_classement_manuel(
message_id=mid1,
categorie="Tunis",
expediteur="partenaire@domain.tn",
objet="Sujet projet",
db_path=temp_db
)
# Mail 2: classé automatiquement en 'À classer'
mid2 = "<mail-prop-02@domain.tn>"
save_classement_regle(
message_id=mid2,
categorie="À classer",
expediteur="partenaire@domain.tn",
objet="Sujet projet",
db_path=temp_db
)
# Création d'une règle proposée pour 'Demande FB'
prop_rule = add_regle(
categorie="Demande FB",
expediteur="partenaire@domain.tn",
statut="proposee",
db_path=temp_db
)
# Confirmation de la règle proposée
res_confirm = confirm_and_apply_rule(prop_rule["id"], db_path=temp_db)
assert res_confirm["statut"] == "active"
# Vérification:
# Mail 2 (automatique) a été réévalué et requalifié en 'Demande FB'
c2_after = get_classement(mid2, db_path=temp_db)
assert c2_after["categorie"] == "Demande FB"
assert c2_after["source"] == "regle"
# Mail 1 (manuel) est STRICTEMENT inchangé ('Tunis', 'manuel')
c1_after = get_classement(mid1, db_path=temp_db)
assert c1_after["categorie"] == "Tunis"
assert c1_after["source"] == "manuel"
+129
View File
@@ -0,0 +1,129 @@
import pytest
from app.db import (
list_categories,
add_category,
update_category,
delete_category,
list_regles,
add_regle,
update_regle,
delete_regle,
save_classement_regle,
save_classement_manuel,
get_classement,
set_traite
)
def test_init_db_creates_tables_and_default_categories(temp_db):
cats = list_categories(db_path=temp_db)
cat_names = [c["name"] for c in cats]
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_crud_categories(temp_db):
# Création
new_cat = add_category("Factures", db_path=temp_db)
assert new_cat["name"] == "Factures"
assert new_cat["id"] > 0
# Modification
updated = update_category(new_cat["id"], "Factures Fournisseurs", db_path=temp_db)
assert updated["name"] == "Factures Fournisseurs"
# Liste
cats = list_categories(db_path=temp_db)
assert any(c["name"] == "Factures Fournisseurs" for c in cats)
# Suppression
assert delete_category(new_cat["id"], db_path=temp_db) is True
cats_after = list_categories(db_path=temp_db)
assert not any(c["name"] == "Factures Fournisseurs" for c in cats_after)
def test_crud_regles(temp_db):
# Création
rule = add_regle(
categorie="Tunis",
expediteur="direction@entreprise.tn",
mot_cle="mission",
etiquette_miroir="tunis",
statut="active",
db_path=temp_db
)
assert rule["id"] > 0
assert rule["categorie"] == "Tunis"
assert rule["statut"] == "active"
# Modification
updated = update_regle(rule["id"], categorie="Demande FB", db_path=temp_db)
assert updated["categorie"] == "Demande FB"
# Liste
rules = list_regles(statut="active", db_path=temp_db)
assert len(rules) == 1
assert rules[0]["categorie"] == "Demande FB"
# Suppression
assert delete_regle(rule["id"], db_path=temp_db) is True
assert len(list_regles(db_path=temp_db)) == 0
def test_manual_classification_persistence(temp_db):
mid = "<msg-001@domain.com>"
res = save_classement_manuel(
message_id=mid,
categorie="Tunis",
traite=True,
expediteur="expediteur@test.tn",
objet="Objet test",
date_mail="2026-11-17",
db_path=temp_db
)
assert res["message_id"] == mid
assert res["categorie"] == "Tunis"
assert res["source"] == "manuel"
assert res["traite"] is True
assert "+01:00" in res["horodatage"], "L'horodatage doit comporter l'offset +01:00"
def test_manual_classification_never_overwritten_by_rule(temp_db):
"""
RÈGLE ABSOLUE : Un classement manuel n'est jamais écrasé par une règle.
"""
mid = "<msg-002@domain.com>"
# 1. Pose d'un classement manuel
save_classement_manuel(
message_id=mid,
categorie="Demande FB",
traite=False,
expediteur="contact@fb.com",
objet="Message direct",
db_path=temp_db
)
# 2. Tentative d'écrasement par une règle automatique
res_regle = save_classement_regle(
message_id=mid,
categorie="Sans objet",
expediteur="contact@fb.com",
objet="Message direct",
db_path=temp_db
)
# 3. Vérification : le classement doit impérativement rester 'Demande FB' et 'manuel'
current = get_classement(mid, db_path=temp_db)
assert current["categorie"] == "Demande FB"
assert current["source"] == "manuel"
assert res_regle["categorie"] == "Demande FB"
assert res_regle["source"] == "manuel"
def test_set_traite_toggle(temp_db):
mid = "<msg-003@domain.com>"
save_classement_regle(message_id=mid, categorie="À classer", db_path=temp_db)
c1 = get_classement(mid, db_path=temp_db)
assert c1["traite"] is False
set_traite(mid, True, db_path=temp_db)
c2 = get_classement(mid, db_path=temp_db)
assert c2["traite"] is True
set_traite(mid, False, db_path=temp_db)
c3 = get_classement(mid, db_path=temp_db)
assert c3["traite"] is False
+63
View File
@@ -0,0 +1,63 @@
import pytest
from app.mirror_client import MirrorClient
from app.classifier import classify_mail
from app.db import list_categories
def test_mirror_health_and_status():
client = MirrorClient()
status = client.get_status()
donnees = status.get("donnees", {}) if isinstance(status, dict) else {}
service = donnees.get("service") or status.get("service")
statut = donnees.get("statut") or status.get("status")
assert service == "o365-mirror-mcp"
assert statut in ("actif", "healthy")
assert status.get("stale") is False
total_idx = donnees.get("index_meta", {}).get("total_indexed", {}).get("valeur") or status.get("total_mails_indexes")
assert int(total_idx) > 3000
def test_mirror_rate_limiter_and_cache():
client = MirrorClient(cache_ttl_seconds=30)
# Premier appel : effectue l'appel réseau
st1 = client.call_tool("mirror_status", {}, use_cache=True)
calls_after_first = len(client._call_times)
# Deuxième appel : doit provenir du cache (aucun nouvel appel réseau)
st2 = client.call_tool("mirror_status", {}, use_cache=True)
calls_after_second = len(client._call_times)
assert st1 == st2
assert calls_after_second == calls_after_first, "Le deuxième appel doit être servi depuis le cache"
def test_classify_10_real_mails(temp_db):
"""
Récupère 10 emails réels du miroir O365, applique le tri par règles,
et valide les critères de conformité (0 écriture vers le miroir).
AUCUN CONTENU DE MAIL N'EST AFFICHÉ OU JOURNALISÉ.
"""
client = MirrorClient()
real_mails = client.get_latest_mails(folder="*", n=10)
assert len(real_mails) >= 10, f"Nombre de mails reçus: {len(real_mails)}"
valid_cats = {c["name"] for c in list_categories(db_path=temp_db)}
classified_count = 0
for mail in real_mails[:10]:
mid = mail.get("message_id") or mail.get("id") or mail.get("hash")
assert mid, "Chaque mail réel doit posséder un identifiant"
m_dict = {
"message_id": mid,
"expediteur": mail.get("from") or mail.get("expediteur") or "",
"objet": mail.get("subject") or mail.get("objet") or "",
"date": mail.get("date") or mail.get("date_reception") or "",
"etiquettes": mail.get("tags") or mail.get("etiquettes") or [],
"apercu": mail.get("snippet") or mail.get("apercu") or ""
}
res = classify_mail(m_dict, db_path=temp_db)
assert res["message_id"] == mid
assert res["categorie"] in valid_cats
assert res["source"] in ("regle", "manuel")
assert "+01:00" in res["horodatage"]
assert res["traite"] is False
classified_count += 1
assert classified_count == 10, f"Attendu: 10 mails classés, obtenu: {classified_count}"