"""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")