feat: application Courrier V1a socle et tri du jour (tt-2026-11-059)
This commit is contained in:
1 parent
0199477821
commit
b51a8bba69
19 files changed
+1731
-2
No files matched your search
Whitespace-only changes.
@@ -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
|
||||
@@ -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"
|
||||
@@ -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()
|
||||
@@ -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"
|
||||
@@ -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
|
||||
@@ -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}"
|
||||
Reference in new issue
Block a user