"""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")], 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.avoid_text, made.must_text) == ("Pure reporting.", "Permanent contract.") kept = store.save_agent("Data", "data leadership", agent_id=made.id) assert (kept.cv_text, kept.avoid_text, kept.must_text) == \ ("VP Data.", "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=[], avoid_text="", must_text="") assert (cleared.cv_text, cleared.cv_languages, 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] 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] # ---------------------------------------------------------------- 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] 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] 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("") == []