Files
jobboard/tests/test_cv_fields.py
T
WolfandClaude Opus 5.5 c23594507a Score each role's closeness to the agent's CV, let the judge also read the 50 closest the score leaves out, and order CV match's unjudged roles by it
The CV is cut into chunks inside e5's window, embedded like a prompt and
cached per agent under a hash of the model, chunking and text. A role's
cv_fit (scores.cv_fit, migration 31) is its best chunk cosine, scaled with
its own calibration band: fit's clipped 88 of agent 2's ungated roles to 1.
It is no term of the Agent match score. judge_cv_top (default 50) sits
beside judge_top and judge_min on the agents page and card.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 23:35:21 +02:00

281 lines
12 KiB
Python

"""The CV match's fields: an agent's CV, languages, avoid and must texts,
migration 28, the deadline from host and model, the languages extract reads
with a level, and the language flag. Nothing here reaches a model."""
from __future__ import annotations
import json
import sqlite3
from datetime import UTC, datetime
from pathlib import Path
from typing import Any
import pytest
from pydantic import ValidationError
from app import prep
from app.config import Config
from app.jobs import extract
from app.models import CvLanguage, RoleLanguage, cv_score, iso_day, language_flag, must_lines
from app.storage import Store
from desk import modeltask
from desk.models import Item
from desk.tools import agent
from prepped import upsert
@pytest.fixture
def store(tmp_path: Path) -> Store:
return Store(tmp_path / "roledesk.db")
def posting(source_id: str, body: str = "We build things.", **raw: object) -> Item:
item = Item(source_id=source_id, location=f"https://boards.example/{source_id}",
title="Head of Data", body=body,
published_at=datetime(2026, 9, 20, tzinfo=UTC), raw=dict(raw))
item.source = "search"
return item
# ------------------------------------------------------------------ agents
def test_an_agent_keeps_its_cv_fields_when_a_save_leaves_them_out(store: Store) -> None:
made = store.save_agent("Data", "data leadership", cv_text=" VP Data. ",
cv_languages=[CvLanguage(language="DA", level="native"),
CvLanguage(language="en", level="fluent"),
CvLanguage(language="da", level="basic")],
like_text=" Building teams. ", avoid_text="Pure reporting.",
must_text="Permanent contract.")
assert made.cv_text == "VP Data."
assert [(lang.language, lang.level) for lang in made.cv_languages] == \
[("da", "native"), ("en", "fluent")]
assert (made.like_text, made.avoid_text, made.must_text) == \
("Building teams.", "Pure reporting.", "Permanent contract.")
kept = store.save_agent("Data", "data leadership", agent_id=made.id)
assert (kept.cv_text, kept.like_text, kept.avoid_text, kept.must_text) == \
("VP Data.", "Building teams.", "Pure reporting.", "Permanent contract.")
assert len(kept.cv_languages) == 2
cleared = store.save_agent("Data", "data leadership", agent_id=made.id, cv_text="",
cv_languages=[], like_text="", avoid_text="",
must_text="")
assert (cleared.cv_text, cleared.cv_languages, cleared.like_text, cleared.avoid_text,
cleared.must_text) == ("", [], "", "", "")
def test_a_cv_language_is_a_code_and_a_level_of_the_ladder() -> None:
with pytest.raises(ValidationError):
CvLanguage(language="Danish", level="native")
with pytest.raises(ValidationError):
CvLanguage(language="da", level="good")
def test_new_agents_have_judge_limits_by_default(store: Store) -> None:
made = store.save_agent("Data")
assert (made.limits.judge_top, made.limits.judge_min) == (150, 0.55)
# --------------------------------------------------------------- migration
def test_v28_adds_the_cv_columns_and_the_host_deadline_and_runs_twice(tmp_path: Path) -> None:
path = tmp_path / "v27.db"
store = Store(path)
store.save_agent("Data", "data leadership")
store.upsert_role(posting("a", applicationDeadline="2026-10-18T00:00:00"))
store.upsert_role(posting("b"))
with sqlite3.connect(path) as conn:
conn.execute("DROP INDEX idx_roles_deadline")
conn.execute("DROP INDEX idx_role_judgements_agent")
conn.execute("DROP TABLE role_judgements")
for column in ("languages_required", "deadline_host", "deadline_model", "deadline"):
conn.execute(f"ALTER TABLE roles DROP COLUMN {column}")
for column in ("cv_text", "cv_languages", "avoid_text", "must_text"):
conn.execute(f"ALTER TABLE agents DROP COLUMN {column}")
conn.execute("PRAGMA user_version = 27")
migrated = Store(path)
assert migrated.migrations_applied == [28, 29, 30, 31]
rows = {r["source_id"]: r for r in migrated._rows(
"SELECT source_id, languages_required, deadline_host, deadline FROM roles")}
assert (rows["a"]["deadline_host"], rows["a"]["deadline"]) == ("2026-10-18", None)
assert rows["a"]["languages_required"] is None and rows["b"]["deadline_host"] == ""
[data] = migrated.agents()
assert (data.cv_text, data.cv_languages, data.avoid_text, data.must_text) == \
("", [], "", "")
prep.run(migrated, remap=True, dupes=False)
assert migrated.role(posting("a").uid).deadline == "2026-10-18"
with sqlite3.connect(path) as conn:
conn.execute("PRAGMA user_version = 27")
assert Store(path).migrations_applied == [28, 29, 30, 31]
# ---------------------------------------------------------------- deadline
def test_iso_day_reads_a_date_or_a_timestamp() -> None:
assert iso_day("2026-10-18T00:00:00") == "2026-10-18"
assert iso_day("2026-10-18") == "2026-10-18"
assert iso_day("18.10.2026") == iso_day("2026-13-01") == iso_day(None) == ""
def test_the_deadline_is_the_hosts_first_then_the_models(store: Store) -> None:
host = posting("host", applicationDeadline="2026-10-18T00:00:00")
model = posting("model")
upsert(store, host)
upsert(store, model)
store.set_extracted(host.uid, {"deadline": "2026-11-01"})
store.set_extracted(model.uid, {"deadline": "2026-11-01"})
prep.run_roles(store, [host.uid, model.uid])
assert store.role(host.uid).deadline == "2026-10-18"
assert store.role(model.uid).deadline == "2026-11-01"
# A pull whose host no longer states one leaves the model's.
upsert(store, posting("host"))
assert store.role(host.uid).deadline == "2026-11-01"
# ----------------------------------------------------------------- extract
class Model:
def __init__(self, reply: Any) -> None:
self.reply = reply
self.asked: list[list[dict[str, Any]]] = []
def __call__(self, settings: Any, **kwargs: Any) -> agent.Reply:
roles = kwargs["question"]["roles"]
self.asked.append(roles)
return agent.Reply(data={"roles": self.reply(roles)}, backend="api")
def answer(uid: str, **fields: Any) -> dict[str, Any]:
return {"uid": uid, "place": "", "country": "", "remote": "", "remote_where": [],
"seniority": "director", "salary_min": None, "salary_max": None,
"currency": "", "function": "", "permit": "", "languages_required": [],
"deadline": "", **fields}
def test_extract_reads_levels_kinds_and_the_deadline(
store: Store, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
item = posting("1")
upsert(store, item)
store.replace_scores(store.save_agent("Data", "data").id, [(item.uid, 0.9, "")])
model = Model(lambda roles: [answer(r["uid"], deadline="2026-10-30", languages_required=[
{"language": "DA", "level": "fluent", "kind": "required"},
{"language": "en", "level": "", "kind": "required"},
{"language": "sv", "level": "excellent", "kind": "plus"},
{"language": "da", "level": "basic", "kind": "plus"},
{"language": "danish", "level": "", "kind": "required"}]) for r in roles])
monkeypatch.setattr(agent, "backend", lambda settings: "api")
monkeypatch.setattr(agent, "ask_json", model)
config = Config(database=str(tmp_path / "roledesk.db"), extract={"enabled": True})
modeltask.run(extract.TASK, config, store)
role = store.role(item.uid)
assert role.languages == ["da", "en"]
assert [lang.model_dump() for lang in role.languages_required] == [
{"language": "da", "level": "fluent", "kind": "required"},
{"language": "en", "level": "", "kind": "required"},
{"language": "sv", "level": "", "kind": "plus"}]
assert role.deadline == "2026-10-30"
assert model.asked[0][0]["posted"] == role.posted_at[:10]
assert store.extract_pending() == 0
def test_a_role_extracted_before_is_read_once_more_for_the_new_fields(store: Store) -> None:
item = posting("1")
upsert(store, item)
store.replace_scores(store.save_agent("Data", "data").id, [(item.uid, 0.9, "")])
store.set_extracted(item.uid, {"seniority": "director"})
assert store.extract_pending() == 0
with store.transaction() as conn:
conn.execute("UPDATE roles SET languages_required = NULL")
assert store.extract_pending() == 1
def test_the_excerpt_keeps_the_opening_and_the_closing_lines() -> None:
short = "word " * 100
assert extract.excerpt(short) == short.strip()
long = "A" * 3000 + " " + "Z" * 3000
cut = extract.excerpt(long)
assert cut.startswith("A" * extract.HEAD) and cut.endswith("Z" * extract.TAIL)
assert len(cut) == extract.HEAD + extract.TAIL + 3
# ------------------------------------------------------------------- flags
def langs(*pairs: tuple[str, str]) -> list[CvLanguage]:
return [CvLanguage(language=code, level=level) for code, level in pairs]
def asks(*triples: tuple[str, str, str]) -> list[RoleLanguage]:
return [RoleLanguage(language=code, level=level, kind=kind) for code, level, kind in triples]
def test_the_language_flag() -> None:
mine = langs(("da", "native"), ("en", "fluent"), ("de", "professional"))
assert language_flag(asks(("sv", "fluent", "required")), mine) == \
("missing", "requires Swedish (fluent); yours: none")
assert language_flag(asks(("de", "fluent", "required")), mine) == \
("below", "requires German (fluent); yours: professional")
assert language_flag(asks(("de", "", "required"), ("da", "", "plus")), mine) == \
("plus", "Danish is a plus; yours: native")
assert language_flag(asks(("en", "fluent", "required"), ("fr", "", "plus")), mine) == \
("", "")
assert language_flag(asks(("sv", "fluent", "required")), []) == ("", "")
def test_the_cv_score_weighs_skills_and_career_above_experience() -> None:
assert cv_score(100, 100, 100) == 100.0
assert cv_score(80, 60, 40) == round((2400 + 1500 + 1200) / 85, 1)
def test_a_stored_language_list_survives_a_bad_entry(store: Store) -> None:
item = posting("1")
upsert(store, item)
with store.transaction() as conn:
conn.execute("UPDATE roles SET languages_required = ? WHERE uid = ?",
(json.dumps([{"language": "da", "level": "fluent", "kind": "required"},
{"language": "en", "level": "superb"}]), item.uid))
assert [lang.language for lang in store.role(item.uid).languages_required] == ["da"]
def test_v29_adds_the_musts_and_broken_columns_and_runs_twice(tmp_path: Path) -> None:
path = tmp_path / "v28.db"
Store(path)
with sqlite3.connect(path) as conn:
for column in ("musts", "broken"):
conn.execute(f"ALTER TABLE role_judgements DROP COLUMN {column}")
conn.execute("PRAGMA user_version = 28")
assert Store(path).migrations_applied == [29, 30, 31]
with sqlite3.connect(path) as conn:
columns = {r[1] for r in conn.execute("PRAGMA table_info(role_judgements)")}
assert {"musts", "broken"} <= columns
conn.execute("PRAGMA user_version = 28")
assert Store(path).migrations_applied == [29, 30, 31]
def test_v30_adds_like_text_and_runs_twice(tmp_path: Path) -> None:
path = tmp_path / "v29.db"
Store(path).save_agent("Data", "data leadership", avoid_text="Reporting.")
with sqlite3.connect(path) as conn:
conn.execute("ALTER TABLE agents DROP COLUMN like_text")
conn.execute("PRAGMA user_version = 29")
migrated = Store(path)
assert migrated.migrations_applied == [30, 31]
[data] = migrated.agents()
assert (data.like_text, data.avoid_text) == ("", "Reporting.")
with sqlite3.connect(path) as conn:
conn.execute("PRAGMA user_version = 29")
assert Store(path).migrations_applied == [30, 31]
def test_the_musts_text_is_one_must_have_per_line() -> None:
assert must_lines("- A\n* B c\n\u2022 D\n1. E\n2) F\n \nG\n-H") == [
"A", "B c", "D", "E", "F", "G", "-H"]
assert must_lines("") == []