179 lines
8.5 KiB
Python
179 lines
8.5 KiB
Python
"""The CV match in the feed and the API: Best CV match, Closing soon, the
|
|
new row and role fields, the agent's CV fields over `/api/agents`, and the
|
|
languages suggested from a CV. Nothing here reaches a model."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from collections.abc import Iterator
|
|
from datetime import UTC, datetime
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import pytest
|
|
from fastapi import FastAPI
|
|
from fastapi.testclient import TestClient
|
|
|
|
from app.config import Config, ServerConfig
|
|
from app.main import create_app
|
|
from app.models import CvLanguage, Prompt
|
|
from app.storage import Store
|
|
from desk.models import Item
|
|
from desk.tools import agent
|
|
from prepped import upsert
|
|
|
|
|
|
def posting(source_id: str, **raw: object) -> Item:
|
|
item = Item(source_id=source_id, location=f"https://boards.example/{source_id}",
|
|
title=f"Head of Data {source_id}", body="Lead the data team.",
|
|
published_at=datetime(2026, 9, 20, tzinfo=UTC), raw=dict(raw))
|
|
item.source = "search"
|
|
return item
|
|
|
|
|
|
@pytest.fixture
|
|
def app(tmp_path: Path) -> FastAPI:
|
|
return create_app(Config(server=ServerConfig(host="127.0.0.1", port=0),
|
|
database=tmp_path / "roledesk.db"))
|
|
|
|
|
|
@pytest.fixture
|
|
def store(app: FastAPI) -> Store:
|
|
found: Store = app.state.store
|
|
found.clock = lambda: datetime(2026, 10, 3, 9, 0, tzinfo=UTC)
|
|
return found
|
|
|
|
|
|
@pytest.fixture
|
|
def client(app: FastAPI) -> Iterator[TestClient]:
|
|
with TestClient(app) as c:
|
|
yield c
|
|
|
|
|
|
def setup(store: Store) -> tuple[Any, dict[str, str]]:
|
|
"""Four roles scored a > b > c > d for an agent with a CV and languages;
|
|
c is judged 90 and b 60, a and d not at all; d is gated."""
|
|
owner = store.save_agent("Data", prompts=[Prompt(name="Lead", text="Head of data")],
|
|
cv_text="VP Data.",
|
|
cv_languages=[CvLanguage(language="da", level="native"),
|
|
CvLanguage(language="de", level="professional")])
|
|
uid = {}
|
|
for sid, deadline in (("a", "2026-10-03"), ("b", "2026-10-07"), ("c", "2026-10-08"),
|
|
("d", "2026-10-04")):
|
|
upsert(store, posting(sid, applicationDeadline=deadline))
|
|
uid[sid] = posting(sid).uid
|
|
store.replace_scores(owner.id, [(uid["a"], 0.9, ""), (uid["b"], 0.8, ""),
|
|
(uid["c"], 0.7, ""), (uid["d"], 0.6, "gated")])
|
|
store.set_judgement(owner.id, uid["c"], "k", 90, 90, 90, ["Leads data."], ["Small team."])
|
|
store.set_judgement(owner.id, uid["b"], "k", 60, 60, 60, ["Data."], ["Junior."])
|
|
with store.transaction() as conn:
|
|
conn.execute("UPDATE roles SET languages_required = ? WHERE uid = ?", (json.dumps(
|
|
[{"language": "sv", "level": "fluent", "kind": "required"}]), uid["a"]))
|
|
conn.execute("UPDATE roles SET languages_required = ? WHERE uid = ?", (json.dumps(
|
|
[{"language": "de", "level": "fluent", "kind": "required"}]), uid["b"]))
|
|
conn.execute("UPDATE roles SET languages_required = ? WHERE uid = ?", (json.dumps(
|
|
[{"language": "da", "level": "", "kind": "plus"}]), uid["c"]))
|
|
return owner, uid
|
|
|
|
|
|
def test_best_cv_match_puts_the_judged_first_by_cv_score(
|
|
client: TestClient, store: Store) -> None:
|
|
owner, uid = setup(store)
|
|
page = client.get("/api/roles", params={"agent": owner.id, "order": "cv"}).json()
|
|
assert [r["uid"] for r in page["items"]] == [uid["c"], uid["b"], uid["a"]]
|
|
assert [r["cv_score"] for r in page["items"]] == [90.0, 60.0, None]
|
|
assert page["total"] == 3
|
|
scored = client.get("/api/roles", params={"agent": owner.id}).json()["items"]
|
|
assert [r["uid"] for r in scored] == [uid["a"], uid["b"], uid["c"]]
|
|
assert scored[1]["cv_score"] == 60.0, "the total rides on every order"
|
|
assert client.get("/api/roles", params={"agent": owner.id,
|
|
"order": "best"}).status_code == 422
|
|
|
|
|
|
def test_a_row_carries_the_deadline_and_the_language_flag(
|
|
client: TestClient, store: Store) -> None:
|
|
owner, uid = setup(store)
|
|
rows = {r["uid"]: r for r in
|
|
client.get("/api/roles", params={"agent": owner.id}).json()["items"]}
|
|
assert rows[uid["a"]]["deadline"] == "2026-10-03"
|
|
assert (rows[uid["a"]]["lang_flag"], rows[uid["a"]]["lang_note"]) == \
|
|
("missing", "requires Swedish (fluent); yours: none")
|
|
assert (rows[uid["b"]]["lang_flag"], rows[uid["b"]]["lang_note"]) == \
|
|
("below", "requires German (fluent); yours: professional")
|
|
assert (rows[uid["c"]]["lang_flag"], rows[uid["c"]]["lang_note"]) == \
|
|
("plus", "Danish is a plus; yours: native")
|
|
|
|
|
|
def test_closing_soon_keeps_today_to_four_days_on(client: TestClient, store: Store) -> None:
|
|
owner, uid = setup(store)
|
|
params = {"agent": owner.id, "order": "newest", "closing": 1}
|
|
page = client.get("/api/roles", params=params).json()
|
|
assert sorted(r["uid"] for r in page["items"]) == sorted([uid["a"], uid["b"], uid["d"]])
|
|
assert page["total"] == 3
|
|
facets = client.get("/api/roles/facets", params=params).json()
|
|
assert sum(f["count"] for f in facets["pay"]) == 3
|
|
|
|
|
|
def test_the_role_carries_its_judgement_and_languages(
|
|
client: TestClient, store: Store) -> None:
|
|
owner, uid = setup(store)
|
|
role = client.get(f"/api/roles/{uid['c']}", params={"agent": owner.id}).json()
|
|
judgement = role["judgement"]
|
|
assert (judgement["skills"], judgement["cv_score"]) == (90, 90.0)
|
|
assert judgement["strengths"] == ["Leads data."] and judgement["gaps"] == ["Small team."]
|
|
assert judgement["judged_at"]
|
|
assert role["cv_score"] == 90.0 and role["lang_flag"] == "plus"
|
|
assert role["languages_required"] == [{"language": "da", "level": "", "kind": "plus"}]
|
|
assert role["deadline"] == "2026-10-08"
|
|
plain = client.get(f"/api/roles/{uid['a']}", params={"agent": owner.id}).json()
|
|
assert plain["judgement"] is None and plain["cv_score"] is None
|
|
|
|
|
|
def test_an_agent_without_languages_flags_nothing(client: TestClient, store: Store) -> None:
|
|
owner, uid = setup(store)
|
|
store.save_agent("Data", prompts=owner.prompts, agent_id=owner.id, cv_languages=[])
|
|
rows = client.get("/api/roles", params={"agent": owner.id}).json()["items"]
|
|
assert {r["lang_flag"] for r in rows} == {""}
|
|
|
|
|
|
def test_the_cv_fields_round_trip_and_are_kept_when_left_out(client: TestClient) -> None:
|
|
body = {"name": "Data", "cv_text": "VP Data.", "avoid_text": "Reporting.",
|
|
"must_text": "Permanent.",
|
|
"cv_languages": [{"language": "da", "level": "native"},
|
|
{"language": "EN", "level": "fluent"}]}
|
|
made = client.post("/api/agents", json=body).json()
|
|
assert made["cv_languages"] == [{"language": "da", "level": "native"},
|
|
{"language": "en", "level": "fluent"}]
|
|
kept = client.post("/api/agents", json={"id": made["id"], "name": "Data"}).json()
|
|
assert (kept["cv_text"], kept["avoid_text"], kept["must_text"]) == \
|
|
("VP Data.", "Reporting.", "Permanent.")
|
|
assert len(kept["cv_languages"]) == 2
|
|
nulls = client.post("/api/agents", json={"id": made["id"], "name": "Data",
|
|
"cv_text": None, "cv_languages": None}).json()
|
|
assert nulls["cv_text"] == "VP Data." and len(nulls["cv_languages"]) == 2
|
|
bad = client.post("/api/agents", json={"name": "Bad", "cv_languages": [
|
|
{"language": "da", "level": "good"}]})
|
|
assert bad.status_code == 422
|
|
|
|
|
|
def test_the_languages_of_a_cv_are_suggested_and_nothing_stored(
|
|
client: TestClient, store: Store, monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setattr(agent, "backend", lambda settings: "api")
|
|
monkeypatch.setattr(agent, "ask_json", lambda settings, **kwargs: agent.Reply(
|
|
data={"languages": [{"language": "da", "level": "native"}]}, backend="api"))
|
|
res = client.post("/api/agents/cv-languages", json={"cv_text": "Dansk modersmål."})
|
|
assert res.status_code == 200
|
|
assert res.json() == {"languages": [{"language": "da", "level": "native"}]}
|
|
assert store.agents() == []
|
|
assert client.post("/api/agents/cv-languages", json={"cv_text": " "}).status_code == 422
|
|
|
|
def fails(settings: Any, **kwargs: Any) -> agent.Reply:
|
|
raise agent.AgentError("timed out")
|
|
|
|
monkeypatch.setattr(agent, "ask_json", fails)
|
|
assert client.post("/api/agents/cv-languages", json={"cv_text": "CV"}).status_code == 502
|
|
|
|
monkeypatch.setattr(agent, "backend", lambda settings: "")
|
|
res = client.post("/api/agents/cv-languages", json={"cv_text": "CV"})
|
|
assert res.status_code == 503 and "No model is reachable" in res.json()["detail"]
|