CV-Matching / tests /test_scoring.py
Myz0's picture
Avis calibré sur des notes humaines : Profil adapté / à étudier / peu adapté
a462430 verified
Raw History Blame Contribute Delete
16.5 kB
"""Tests du moteur de score, sans télécharger bge-m3 ni le dataset.
On remplace bge-m3 par un encodeur factice (trigrammes de caractères) : les scores
absolus ne ressemblent pas à ceux de bge-m3, mais la logique (extraction, poids,
tri, explications, routes) est vérifiée. Lancer : python -m tests.test_scoring
"""
import numpy as np
from app import config, scoring
from tests.factices import AVPS, CVS, SOFT, Encodeur
# Rampe adaptée à l'encodeur factice (ses similarités sont plus basses que celles de bge-m3)
scoring.SIM_BAS, scoring.SIM_HAUT = 0.15, 0.55
import copy
from datetime import date
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.avp_store import (AVPStore, CHAMPS_ATTENDUS, est_ouvert, est_savoir_etre, extraire,
texte_embedding)
from app.classement import classer_candidats
from app.matching import matcher
from app.routes_api import ajouter_routes
enc = Encodeur(); store = AVPStore(enc); store.installer(AVPS)
# 1. Extraction : contexte exclu des attendus, prérequis séparés, doublon normalisé
a = extraire({"experienceRequirements": "Expérience X.", "educationRequirements": {"competencyRequired": ["Expérience X"]}}, CHAMPS_ATTENDUS)
assert len(a) == 1, a
p = store.prepares["3134-26-1269/SR"]
assert all(c not in ("title", "description", "qualifications") for _, c in p.attendus)
assert [t for t, _ in p.prerequis] == ["Permis B", "Bac+3"], p.prerequis
assert [t for t, _ in store.prepares["3134-26-1270/SR"].prerequis][:2] == ["Permis B", "A2"]
assert "Permis B" in texte_embedding(AVPS[0])
# 2. Spécificité : les soft skills communs aux 4 AVP pèsent moins que les compétences métier
idx = {t: k for k, (t, _) in enumerate(p.attendus)}
w_soft = p.poids[idx["Maîtrise de soi"]]; w_metier = p.poids[idx["Droit du travail et fonction publique"]]
print(f"poids 'Maîtrise de soi' = {w_soft:.3f} vs 'Droit du travail...' = {w_metier:.3f}")
assert w_soft < 0.2 and w_metier > 0.9 # n=4 AVP : log(5/4)/log(5)=0.14
# 3. validThrough
assert not store.prepares["3134-26-1267/SR"].ouvert
assert est_ouvert({"validThrough": "2026-10-07T00:00:00"}, date(2026, 10, 7))
# 4. Classement côté recruteur
for id_avp, bon in [("3134-26-1269/SR", 0), ("3134-26-1268/SR", 1), ("3134-26-1270/SR", 2)]:
r = classer_candidats(id_avp, CVS, store, enc, seuil=0.35)
ordre = [(c.index, c.score, c.specificite, c.rang_de_cet_avp_pour_le_candidat) for c in r.candidats]
print(r.titre, "->", ordre, "| écartés:", [e.index for e in r.ecartes])
assert r.candidats[0].index == bon
cuisinier = next(c for c in r.candidats if c.index == 3)
assert cuisinier.score < r.candidats[0].score - 15, "le hors-domaine doit être loin derrière"
assert r.ecartes[0].index == 4
r = classer_candidats("3134-26-1270/SR", CVS, store, enc, seuil=0.35)
top = r.candidats[0]
print("forces facteur:", [(f.attendu, f.phrase_cv, f.source_cv) for f in top.forces])
print("prérequis facteur:", [(x.prerequis, x.statut) for x in top.prerequis])
print("plus discriminants:", r.attendus_les_plus_discriminants)
# 5. Identité jamais utilisée : changer le nom ne change rien
cv2 = copy.deepcopy(CVS[0]); cv2["basics"]["name"] = "Quelqu'un d'autre"
s1 = classer_candidats("3134-26-1269/SR", [CVS[0]], store, enc, 0.35).candidats[0].score
s2 = classer_candidats("3134-26-1269/SR", [cv2], store, enc, 0.35).candidats[0].score
assert s1 == s2
# 6. Côté candidat : schémas existants, AVP fermé exclu par défaut
rm = matcher(CVS[0], store, enc, seuil=0.35, top=10)
print("matching juriste:", [(x.titre, x.score_qualite, x.score_global) for x in rm.resultats])
assert rm.resultats[0].id_avp == "3134-26-1269/SR"
assert all(x.id_avp != "3134-26-1267/SR" for x in rm.resultats) and rm.nb_avps_analyses == 3
assert len(matcher(CVS[0], store, enc, 0.35, 10, inclure_fermes=True).resultats) == 4
# 7. Route HTTP (id avec "/")
app = FastAPI(); ajouter_routes(app, lambda: (store, enc))
c = TestClient(app)
resp = c.post("/avps/3134-26-1268/SR/candidats?top=3", json={"cvs": CVS})
assert resp.status_code == 200, resp.text
print("HTTP:", [(x["index"], x["score"], x["ex_aequo_avec_precedent"]) for x in resp.json()["candidats"]])
assert c.post("/avps/inconnu/candidats", json={"cvs": CVS}).status_code == 404
assert c.post("/avps/3134-26-1268/SR/candidats", json={"cvs": []}).status_code == 422
# 7 bis. /score : un CV face à UN AVP (cas d'une candidature), même score que le classement
resp = c.post("/score", json={"reference": "3134-26-1269/SR", "cv": CVS[0]})
assert resp.status_code == 200, resp.text
r = resp.json()
assert r["score"] == classer_candidats("3134-26-1269/SR", [CVS[0]], store, enc, 0.35).candidats[0].score
assert r["libelle"] and r["niveau"] and 0 <= r["pourcentage"] <= 100 and r["nb_competences"] > 0
print("score:", r["titre"], r["score"], r["pourcentage"], r["libelle"], f'{r["competences_couvertes"]}/{r["nb_competences"]}')
assert c.post("/score", json={"reference": "inconnu", "cv": CVS[0]}).status_code == 404
assert c.post("/score", json={"reference": "3134-26-1269/SR", "cv": {}}).status_code == 422
# 7 ter. Clé API : exigée sur les routes de calcul quand elle est configurée, pas sur /avps
config.API_KEY = "cle-de-test"
assert c.post("/score", json={"reference": "3134-26-1269/SR", "cv": CVS[0]}).status_code == 401
assert c.post("/score", json={"reference": "3134-26-1269/SR", "cv": CVS[0]},
headers={"X-API-Key": "mauvaise"}).status_code == 401
assert c.post("/score", json={"reference": "3134-26-1269/SR", "cv": CVS[0]},
headers={"X-API-Key": "cle-de-test"}).status_code == 200
assert c.post("/avps/3134-26-1268/SR/candidats", json={"cvs": CVS}).status_code == 401
assert c.get("/avps").status_code == 200
config.API_KEY = None
# 8. Refresh atomique : un AVP qui disparaît sort du cache
store.installer(AVPS[:3]); assert "3134-26-1267/SR" not in store.prepares and len(store._cache) == 3
# 9. Savoir-être : repérés pour l'affichage, mais toujours comptés dans le score
assert est_savoir_etre("Être rigoureux", "skills") and est_savoir_etre("Autonomie", "skills")
assert est_savoir_etre("Faire preuve de discrétion", "skills")
assert not est_savoir_etre("Savoir rédiger", "skills")
assert not est_savoir_etre("Construire un diagnostic", "skills")
assert not est_savoir_etre("Autonomie", "responsibilities") # seul le champ skills
p = store.prepares["3134-26-1270/SR"]
assert int(p.savoir_etre.sum()) == len(SOFT), [t for (t, _), se in zip(p.attendus, p.savoir_etre) if se]
rm = matcher(CVS[2], store, enc, seuil=0.35, top=1)
r0 = rm.resultats[0]
assert r0.nb_savoir_faire == r0.nb_competences - len(SOFT) and len(r0.savoir_etre) == len(SOFT)
assert all(c.attendu not in SOFT for c in r0.competences_couvertes + r0.ecarts)
print("facteur :", r0.libelle, f"{r0.nb_savoir_faire_couverts}/{r0.nb_savoir_faire}",
[(s.attendu, s.statut) for s in r0.savoir_etre])
# 10. Reranker : la couverture d'un attendu est la meilleure des deux notes (rampe, reranker)
class RerankerFactice:
nom = "factice"
def probas(self, paires):
return np.array([1.0 if "scooter" in a.lower() and "scooter" in b.lower() else 0.0
for a, b in paires], dtype=np.float32)
phrases = [("Facteur", "work[0]"), ("Tournée en deux-roues (scooter)", "work[0].highlights[0]"),
("Ponctualité", "skills[0]")] * 2
vecs = enc.encoder([t for t, _ in phrases])
sans = scoring.scorer(p.attendus, p.vecs_attendus, p.poids, phrases, vecs, 0.5)
assert scoring.probas_reranker_avps({"x": p}, [t for t, _ in phrases], vecs) == {} # pas de reranker
scoring.RERANKER = RerankerFactice()
try:
rr = scoring.probas_reranker_avps(store.prepares, [t for t, _ in phrases], vecs)
assert set(rr) == set(store.prepares) # un seul appel, tous les AVP
avec = scoring.scorer(p.attendus, p.vecs_attendus, p.poids, phrases, vecs, 0.5,
rr=rr["3134-26-1270/SR"])
finally:
scoring.RERANKER = None
d = next(x for x in avec.details if x.attendu == "Conduire un scooter en sécurité")
assert d.degre == 1.0 and "scooter" in d.phrase_cv, d
assert avec.adequation > sans.adequation
assert all(a.degre >= s.degre for a, s in zip(avec.details, sans.details)) # jamais pire
print(f"reranker factice : {100 * sans.adequation:.1f} -> {100 * avec.adequation:.1f}")
# 11. Explications du front : points obtenus = score, obtenus + perdus = 100
from app.explications import expliquer_cv, expliquer_vivier
r = expliquer_cv(store, enc, CVS[2])
p0 = r["postes"][0]
d = p0["decomposition"]
assert p0["avp"]["id"] == "3134-26-1270/SR" and p0["rang_pour_cv"] == 1
assert abs(d["obtenus"] - p0["score"]) < 0.2, (d, p0["score"])
assert abs(sum(d.values()) - 100) < 0.3, d
assert all(f["attendu"] not in SOFT for f in p0["forces"] + p0["ecarts"])
# Pourcentage affiché = points obtenus sur les compétences / points possibles sur les compétences
sf = p0["forces"] + p0["ecarts"]
attendu_pct = 100 * sum(x["points"] for x in sf) / sum(x["points"] + x["perte"] for x in sf)
assert abs(p0["pourcentage"] - attendu_pct) < 0.5 and p0["pourcentage"] >= p0["score"] - 0.1, (p0["pourcentage"], attendu_pct)
assert rm.resultats[0].pourcentage_competences >= 0
v = expliquer_vivier(store, enc, "3134-26-1270/SR", CVS)
assert v["candidats"][0]["cv"]["index"] == 2 and v["ecartes"][0]["cv"]["index"] == 4
print("explications :", p0["score"], d)
# 12. Niveaux lus sur le pourcentage AFFICHÉ (arrondi comme la page) : le mot suit le chiffre
assert scoring.niveau(0.40) == "adapte" and scoring.libelle(0.40) == "Profil adapté"
assert scoring.niveau(0.2150) == "adapte" # API 21,5 -> page « 22 % » -> adapté, comme affiché
assert scoring.niveau(0.2144) == "a_etudier" and scoring.libelle(0.18) == "Profil à étudier"
assert scoring.niveau(0.1644) == "peu_adapte" and scoring.libelle(0.05) == "Profil peu adapté"
assert scoring.pourcentage_entier(0.3246) == 33 and scoring.pourcentage_entier(0.3244) == 32
assert p0["niveau"] == scoring.niveau(p0["pourcentage"] / 100), p0["niveau"]
rc = classer_candidats("3134-26-1270/SR", CVS, store, enc, 0.35)
assert all(c.niveau == scoring.niveau(c.pourcentage_competences / 100) for c in rc.candidats)
# 13. Outils (ROME) : une phrase qui cite un outil est complétée pour le calcul, les autres non
from app.outils import completer_outils, textes_pour_calcul
c = completer_outils("Excel, Word, PowerPoint")
assert c.startswith("Excel, Word, PowerPoint (") and "bureautiques" in c, c
assert "SAP" in completer_outils("Gestion des stocks sur SAP")[len("Gestion des stocks sur SAP"):]
for t in ("Gestion des stocks et inventaires", "Cuisine traditionnelle et pâtisserie", "Analyse des risques"):
assert completer_outils(t) == t, t # pas d'outil : phrase intacte
assert completer_outils("Maîtrise du Pack Office") != "Maîtrise du Pack Office"
assert textes_pour_calcul([("Word et Excel", "skills[0]")])[0] != "Word et Excel"
config.OUTILS_ROME = False
assert completer_outils("Excel, Word") == "Excel, Word" # désactivable
config.OUTILS_ROME = True
print("outils :", c[:90], "…")
# 14. Prérequis par règles : niveaux de diplôme, permis et équivalences, années ; jamais notés
from app.avp_store import _decouper_prerequis
from app.prerequis import verifier_par_regles as regle
assert _decouper_prerequis("Permis B obligatoire. Permis A2 et aptitude au scooter appréciés.") == \
["Permis B obligatoire", "Permis A2 et aptitude au scooter appréciés"]
master = [("Master Informatique Université", "education[0]")]
bts = [("BTS Services informatiques", "education[0]")]
assert regle("Bac+3", None, master)["statut"] == "rempli"
r = regle("Bac+3", None, bts)
assert r["statut"] == "non_rempli" and r["motif"] == "Bac+2 pour Bac+3 demandé", r
assert regle("Bac", None, bts)["statut"] == "rempli"
assert regle("Bac+3", None, [("Développement Java", "work[0].highlights[0]")])["statut"] == "a_verifier"
assert regle("Bac+3", None, [("Licence", "formation")])["statut"] == "rempli" # CV du hub (structure libre)
assert regle("Bac+3", None, [("BTS SIO", "formations[0].diplome")])["statut"] == "non_rempli"
assert regle("Bac+3", None, [("Licence de mathématiques", "experiences[0].poste")])["statut"] == "a_verifier"
permis = [("Permis : permis B, permis poids lourd", "skills[0]"), ("Logistique : CACES 1, 3 et 5", "skills[1]"),
("Distribution en scooter du courrier", "work[0].highlights[0]")]
for condition in ("Permis VL", "PL et cariste", "Permis de conduire B", "aptitude à la conduite d'un deux roues (scooter)",
"obligation d'utiliser un véhicule de service"):
assert regle(condition, None, permis)["statut"] == "rempli", condition
assert regle("A2", None, permis)["statut"] == "a_verifier" # absent du CV : à vérifier, jamais « non rempli »
assert regle("A2", None, [("Permis : permis B, permis A2", "skills[0]")])["statut"] == "rempli"
assert regle("Permis B souhaité", None, permis)["obligatoire"] is False
annees = [("6 ans en administration d'applications SI", "basics.summary")]
r = regle("2 ans d'expérience dans une activité similaire", None, annees)
assert r["statut"] == "rempli" and "activité similaire à vérifier" in r["motif"], r
assert regle("3 ans d'expérience", None, [("1 an en développement web", "basics.summary")])["statut"] == "non_rempli"
cv_dates = {"work": [{"startDate": "2018-01-01", "endDate": "2023-01-01"}]}
assert regle("3 ans d'expérience", cv_dates, [("Développeur", "work[0]")])["statut"] == "rempli"
assert regle("Habilitation électrique", None, permis) is None # aucune règle : rapprochement bge-m3
pf = [(x.prerequis, x.statut) for x in top.prerequis]
assert ("Permis B", "a_verifier") in pf or ("Permis B", "rempli") in pf, pf
print("prérequis :", r["motif"], "|", pf)
# 15. Conditions du poste (affichées, jamais notées) : horaires pas répétés, valeurs vides ignorées
from app.explications import conditions_du_poste
avp_c = {"workHours": "Du lundi au vendredi, 7h30-16h30",
"eligibilityToWorkRequirement": "10 ans de résidence en Nouvelle-Calédonie",
"specialCommitments": "Du lundi au vendredi, 7h30-16h30", # = horaires : pas répété
"physicalRequirement": "Néant", # vide : ignoré
"additionalType": {"informationsLibres": [{"name": "Conditions de travail", "value": "Travail en extérieur"},
{"name": "Durée de résidence exigée", "value": "5 ans"}]}}
assert conditions_du_poste(avp_c) == [["Durée de résidence", "10 ans de résidence en Nouvelle-Calédonie"],
["Conditions de travail", "Travail en extérieur"]], conditions_du_poste(avp_c)
assert conditions_du_poste({"additionalType": {"informationsLibres": [{"name": "Durée de résidence exigée",
"value": "5 ans"}]}}) == [["Durée de résidence", "5 ans"]]
assert conditions_du_poste({}) == []
# 16. Limites des demandes : CV trop long refusé (ou écarté d'un vivier), vivier trop grand refusé
from app.cv_texte import phrases_du_cv, verifier_taille_vivier
cv_long = {"basics": {"label": "Juriste", "summary": "droit " * (config.MAX_CARACTERES_CV // 6 + 1)}}
try:
phrases_du_cv(cv_long); raise AssertionError("CV trop long accepté")
except ValueError as e:
assert "trop long" in str(e)
assert phrases_du_cv(cv_long, limite=False) # fiche du CV : pas de limite
try:
verifier_taille_vivier([{}] * (config.MAX_CV_VIVIER + 1)); raise AssertionError("vivier trop grand accepté")
except ValueError as e:
assert "Vivier trop grand" in str(e)
rv = classer_candidats("3134-26-1270/SR", [CVS[2], cv_long], store, enc, 0.35)
assert len(rv.candidats) == 1 and "trop long" in rv.ecartes[0].raison, rv.ecartes
v2 = expliquer_vivier(store, enc, "3134-26-1270/SR", [CVS[2], cv_long])
assert len(v2["candidats"]) == 1 and "trop long" in v2["ecartes"][0]["raison"]
print("limites : CV de", sum(len(t) for t, _ in phrases_du_cv(cv_long, limite=False)), "caractères écarté")
print("\nTOUS LES TESTS PASSENT")