"""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 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.") 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) == ("Building teams.", "Pure reporting.") kept = store.save_agent("Data", "data leadership", agent_id=made.id) assert (kept.cv_text, kept.like_text, kept.avoid_text) == \ ("VP Data.", "Building teams.", "Pure reporting.") 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="") assert (cleared.cv_text, cleared.cv_languages, cleared.like_text, cleared.avoid_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_the_cut_by_default(store: Store) -> None: made = store.save_agent("Data") assert made.limits.model_dump() == {"cut_fit_top": 500, "cut_fit_min": 0.6, "cut_cv_top": 150, "cut_cv_min": 0.6, "summarise_top": 30} # --------------------------------------------------------------- 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"): 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, 32, 33, 34] 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) == ("", [], "") 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, 32, 33, 34] # ---------------------------------------------------------------- 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, "", "", None, 0.9, "fit")]) 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, "", "", None, 0.9, "fit")]) 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(10, 10, 10) == 100.0 assert cv_score(8, 6, 4) == round(10 * (240 + 150 + 120) / 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_v34_drops_the_must_haves_and_runs_twice(tmp_path: Path) -> None: """A file from before migration 34 holds the agent's must text and the judge's verdicts on it; the columns go, the rest of the agent and the judgement stay.""" path = tmp_path / "v33.db" store = Store(path) item = posting("1") upsert(store, item) agent = store.save_agent("Data", "data leadership", cv_text="CV.", like_text="Teams.") assert store.set_judgement(agent.id, item.uid, "key", 8, 7, 9, ["Good."], ["Bad."]) with sqlite3.connect(path) as conn: conn.execute("ALTER TABLE agents ADD COLUMN must_text TEXT NOT NULL DEFAULT ''") conn.execute("ALTER TABLE role_judgements ADD COLUMN musts TEXT NOT NULL DEFAULT '[]'") conn.execute("ALTER TABLE role_judgements ADD COLUMN broken INTEGER NOT NULL DEFAULT 0") conn.execute("UPDATE agents SET must_text = 'Remote.'") conn.execute("UPDATE role_judgements SET musts = ?, broken = 1", (json.dumps([{"id": "M1", "text": "Remote.", "verdict": "broken"}]),)) conn.execute("PRAGMA user_version = 33") for _ in range(2): # runs twice without harm migrated = Store(path) assert migrated.migrations_applied == [34] with sqlite3.connect(path) as conn: assert "must_text" not in {r[1] for r in conn.execute("PRAGMA table_info(agents)")} assert not {"musts", "broken"} & { r[1] for r in conn.execute("PRAGMA table_info(role_judgements)")} conn.execute("PRAGMA user_version = 33") assert migrated.agent(agent.id).like_text == "Teams." # type: ignore[union-attr] found = migrated.judgement(agent.id, item.uid) assert found is not None and (found.career, found.cv_score) == (9, cv_score(8, 7, 9)) 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, 32, 33, 34] [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, 32, 33, 34] def test_v33_clears_every_judgement_and_lowers_the_old_summarise_default( tmp_path: Path) -> None: """A judgement on the 0 to 100 scale is never shown on the 0 to 10 one: migration 33 clears every row and gives the tries back, and the judge reads the pair again. `summarise_top` 50, migration 32's default, is 30; any other value, and a limits object without the key, stay.""" path = tmp_path / "v32.db" store = Store(path) item = posting("1") upsert(store, item) old = store.save_agent("Old", "data leadership", cv_text="CV.") own = store.save_agent("Own", "data leadership") bare = store.save_agent("Bare", "data leadership") assert store.set_judgement(old.id, item.uid, "key", 80, 70, 90, ["Good."], ["Bad."]) store.judge_missed([(own.id, item.uid)]) with sqlite3.connect(path) as conn: conn.execute("UPDATE agents SET limits = json_set(limits, '$.summarise_top', 50) " "WHERE id = ?", (old.id,)) conn.execute("UPDATE agents SET limits = json_set(limits, '$.summarise_top', 12) " "WHERE id = ?", (own.id,)) conn.execute("UPDATE agents SET limits = '{}' WHERE id = ?", (bare.id,)) conn.execute("PRAGMA user_version = 32") for _ in range(2): # runs twice without harm migrated = Store(path) assert migrated.migrations_applied == [33, 34] assert migrated.judgement(old.id, item.uid) is None with sqlite3.connect(path) as conn: rows = conn.execute( "SELECT skills, experience, career, cv_score, strengths, gaps, " "input_key, tries, judged_at FROM role_judgements").fetchall() assert rows == [(None, None, None, None, "[]", "[]", "", 0, None)] * 2 conn.execute("PRAGMA user_version = 32") assert {a.name: a.limits.summarise_top for a in migrated.agents()} == { "Old": 30, "Own": 12, "Bare": 30} with sqlite3.connect(path) as conn: assert conn.execute("SELECT limits FROM agents WHERE id = ?", (bare.id,)).fetchone() == ("{}",)