Spaces:
Running on Zero
Running on Zero
Download tests/test_scoring.py from Myz0/CV-Matching: direct link, hf CLI and curl.
- Browser
- Download file 16.5 kB
-
https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/tests/test_scoring.py
- Command line
-
hf download hf://spaces/Myz0/CV-Matching/tests/test_scoring.py
-
curl -L -o test_scoring.py https://huggingface.co/spaces/Myz0/CV-Matching/resolve/main/tests/test_scoring.py
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") | |