Files
jobboard/tests/test_cv_fields.py
T

239 lines
10 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")],
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]
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]
# ---------------------------------------------------------------- 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"]