325 lines
15 KiB
Python
325 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, 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_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", "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, 32, 33]
|
|
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, 32, 33]
|
|
|
|
|
|
# ---------------------------------------------------------------- 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)
|
|
assert cv_score(8, 6, 9, broken=1) == cv_score(8, 6, 4)
|
|
|
|
|
|
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, 32, 33]
|
|
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, 32, 33]
|
|
|
|
|
|
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]
|
|
[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]
|
|
|
|
|
|
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")
|
|
musts = [{"id": "M1", "text": "Remote", "verdict": "broken"}]
|
|
assert store.set_judgement(old.id, item.uid, "key", 80, 70, 90, ["Good."], ["Bad."], musts)
|
|
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]
|
|
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, musts, broken, "
|
|
"input_key, tries, judged_at FROM role_judgements").fetchall()
|
|
assert rows == [(None, None, None, None, "[]", "[]", "[]", 0, "", 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() == ("{}",)
|
|
|
|
|
|
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("") == []
|