329 lines
15 KiB
Python
329 lines
15 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
|
|
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() == ("{}",)
|