Files
jobboard/tests/test_fetch_text.py
T

503 lines
23 KiB
Python

"""The `fetch_text` stage: the roles in the cut without text, read on their
own pages after scoring. Which roles and in what order, the budgets, what is
stored, the cascade around it, and what triggers it. No network: a fake host
stands in, answering from a dict."""
from __future__ import annotations
import json
import sys
import types
from collections.abc import Iterator
from datetime import UTC, datetime
from pathlib import Path
from typing import Any
import httpx
import numpy as np
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
sys.path.insert(0, str(ROOT))
from app.config import Config, ServerConfig # noqa: E402
from app.jobs import cascade, embed, fetch_text, stages # noqa: E402
from app.main import create_app # noqa: E402
from app.storage import Store # noqa: E402
from desk.models import Item # noqa: E402
from pipeline import FINAL, JobQueue, Jobs, Tally # noqa: E402
from plugins import ats, readers # noqa: E402
BASE = "https://jobs.fake.example"
def _fake_host(name: str = "fake", *, detail: bool = True) -> types.ModuleType:
"""A host whose role pages are `BASE/<slug>/<id>`, answered by `web`."""
module: Any = types.ModuleType(name)
module.NAME, module.LABEL, module.PATTERNS = name, name.title(), ()
module.slug_ok = lambda slug: slug.isalnum()
module.allowed = lambda slug: lambda h: h == "jobs.fake.example"
module.careers_url = lambda slug: f"{BASE}/{slug}"
module.feed_url = lambda slug: f"{BASE}/{slug}/list"
module.parse = lambda body, slug: []
if detail:
module.detail = lambda get, slug, row: {
"description": get(f"{BASE}/{slug}/{row['source_id']}").decode(),
"location": "Copenhagen"}
return module
@pytest.fixture
def web(monkeypatch: pytest.MonkeyPatch) -> dict[str, Any]:
"""`ats._get` answering from `answers` (URL -> body), 404 otherwise,
remembering what it was asked; hosts `fake` and `plain` (no detail)."""
answers: dict[str, Any] = {}
asked: list[str] = []
def fake_get(client, url, host, slug, *, method="GET", payload=None, headers=None):
asked.append(url)
answer = answers.get(url)
if answer is None:
request = httpx.Request("GET", url)
raise httpx.HTTPStatusError("404", request=request,
response=httpx.Response(404, request=request))
return answer
monkeypatch.setattr(ats, "_get", fake_get)
monkeypatch.setattr(ats, "PAGE_DELAY", 0)
monkeypatch.setitem(readers.HOSTS, "fake", _fake_host())
monkeypatch.setitem(readers.HOSTS, "plain", _fake_host("plain", detail=False))
return {"answers": answers, "asked": asked}
@pytest.fixture
def store(tmp_path: Path) -> Store:
return Store(tmp_path / "roledesk.db")
def config(tmp_path: Path, **settings: Any) -> Config:
return Config(database=str(tmp_path / "roledesk.db"), embed={"model": "fake"},
fetch_text=settings)
def board(store: Store, target: str) -> Any:
host = target.partition(":")[0]
return store.add_subscription("ats", target, label=target, company=target, board=host)
def role(store: Store, target: str, native: str, *, body: str = "",
title: str = "Backend Engineer") -> str:
"""A role of board `target` as a pull stores it: without text on a host
with `detail`."""
sub = next(s for s in store.subscriptions(source="ats") if s.target == target)
host, _, slug = target.partition(":")
item = Item(source_id=f"{target}:{native}", location=f"{BASE}/{slug}/{native}",
title=title, body=body, published_at=datetime(2026, 9, 20, tzinfo=UTC),
raw={"company": target, "place": "2 Locations", "board": host, "slug": slug})
item.source = "ats"
store.upsert_role(item, sub)
return item.uid
def scored(store: Store, name: str, scores: dict[str, float], *,
gated: tuple[str, ...] = (), out: tuple[str, ...] = ()) -> Any:
"""An agent whose scores are these, every ungated role in its cut by fit
but those in `out`."""
agent = store.save_agent(name, f"{name} python backend")
store.replace_scores(agent.id, [
(uid, value, "gated" if uid in gated else "", "", None, value,
"" if uid in gated or uid in out else "fit")
for uid, value in scores.items()])
return agent
# -------------------------------------------------------------- which roles
def test_roles_in_the_cut_go_best_first_by_their_best_agent_score(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
board(store, "fake:acme")
board(store, "fake:beta")
a1, a2 = role(store, "fake:acme", "1"), role(store, "fake:acme", "2")
b1 = role(store, "fake:beta", "1")
scored(store, "One", {a1: 0.6, a2: 0.9, b1: 0.55})
scored(store, "Two", {a1: 0.95, b1: 0.7})
assert [(r["uid"], r["score"]) for r in store.fetch_text_waiting()] == [
(a1, 0.95), (a2, 0.9), (b1, 0.7)]
assert fetch_text.plan(config(tmp_path), store) == [("fake:acme", [a1, a2]),
("fake:beta", [b1])]
def test_a_role_in_no_cut_gets_no_call(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
board(store, "fake:acme")
low, gated, deep, kept = (role(store, "fake:acme", n) for n in ("1", "2", "3", "4"))
scored(store, "One", {low: 0.4, gated: 0.0, deep: 0.8, kept: 0.9}, gated=(gated,),
out=(low,))
assert fetch_text.plan(config(tmp_path), store) == [("fake:acme", [kept, deep])]
# In another agent's cut, it is read.
scored(store, "Two", {low: 0.4})
assert fetch_text.plan(config(tmp_path), store) == [("fake:acme", [kept, deep, low])]
store.delete_agent(store.agents()[1].id)
# A disabled agent ranks nothing.
agent = store.agents()[0]
store.save_agent(agent.name, gates=agent.gates, weights=agent.weights, enabled=False,
agent_id=agent.id, limits=agent.limits, prompts=agent.prompts)
assert fetch_text.plan(config(tmp_path), store) == []
def test_roles_with_text_hosts_without_pages_and_failing_boards_are_left_out(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
for target in ("fake:acme", "plain:acme", "fake:down"):
board(store, target)
wanted = role(store, "fake:acme", "1")
has_text = role(store, "fake:acme", "2", body="Python in full")
plain = role(store, "plain:acme", "1")
down = role(store, "fake:down", "1")
store.state["ats:failing:fake:down"] = json.dumps({"since": "2026-09-29", "reason": "500"})
scored(store, "One", {wanted: 0.9, has_text: 0.95, plain: 0.9, down: 0.9})
assert fetch_text.plan(config(tmp_path), store) == [("fake:acme", [wanted])]
def test_a_role_read_already_waits_for_the_retry_and_a_failed_one_goes_last(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
board(store, "fake:acme")
read, failed, fresh = (role(store, "fake:acme", n) for n in ("1", "2", "3"))
now = datetime.now(UTC).isoformat(timespec="seconds")
store.state["ats:detailed:fake:acme"] = json.dumps(["fake:acme:1"])
store.state["ats:detailempty:fake:acme"] = json.dumps({"fake:acme:1": now})
store.state["ats:detailfailed:fake:acme"] = json.dumps(["fake:acme:2"])
scored(store, "One", {read: 0.9, failed: 0.8, fresh: 0.6})
assert fetch_text.plan(config(tmp_path), store) == [("fake:acme", [fresh, failed])]
# ------------------------------------------------------------------ budgets
def test_the_budgets_per_board_and_per_run(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
board(store, "fake:acme")
board(store, "fake:beta")
acme = [role(store, "fake:acme", str(n)) for n in range(4)]
beta = [role(store, "fake:beta", str(n)) for n in range(4)]
# Interleaved: acme 0.99, beta 0.98, acme 0.97, ...
scored(store, "One", {uid: 0.99 - 0.01 * n
for n, uid in enumerate(u for pair in zip(acme, beta, strict=True)
for u in pair)})
assert fetch_text.plan(config(tmp_path, per_board=2), store) == [
("fake:acme", acme[:2]), ("fake:beta", beta[:2])]
assert fetch_text.plan(config(tmp_path, per_run=3), store) == [
("fake:acme", acme[:2]), ("fake:beta", beta[:1])]
assert fetch_text.plan(config(tmp_path, per_board=1, per_run=5), store) == [
("fake:acme", acme[:1]), ("fake:beta", beta[:1])]
def test_the_stage_off_finds_nothing(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
board(store, "fake:acme")
scored(store, "One", {role(store, "fake:acme", "1"): 0.9})
assert len(fetch_text.batches(config(tmp_path), store)) == 1
assert fetch_text.batches(config(tmp_path, enabled=False), store) == []
stages.set_stage(store, "fetch_text", True)
assert len(fetch_text.batches(config(tmp_path, enabled=False), store)) == 1
stages.set_stage(store, "fetch_text", False)
assert fetch_text.batches(config(tmp_path), store) == []
# ------------------------------------------------------------ what is stored
def test_a_batch_stores_what_the_pages_filled_and_drops_those_vectors(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
board(store, "fake:acme")
one, two, gone = (role(store, "fake:acme", n) for n in ("1", "2", "3"))
store.put_vectors("fake", [(uid, np.ones(3, dtype=np.float32)) for uid in (one, two, gone)])
web["answers"].update({f"{BASE}/acme/1": b"Python in full", f"{BASE}/acme/2": b"Go too"})
out = fetch_text.run_batch(config(tmp_path), store, target="fake:acme", uids=[two, gone, one])
assert out == {"target": "fake:acme", "read": 3, "filled": 2, "texts": 2}
assert web["asked"] == [f"{BASE}/acme/2", f"{BASE}/acme/3", f"{BASE}/acme/1"]
first = store.role(one)
assert first is not None and first.description == "Python in full"
assert first.place == "Copenhagen" and first.title == "Backend Engineer"
assert set(store.vectors("fake")) == {gone}
assert json.loads(store.state["ats:detailed:fake:acme"]) == [
"fake:acme:1", "fake:acme:2", "fake:acme:3"]
# A later pull of the same listing keeps the text and the page's place.
item = ats.item_of({"source_id": "1", "title": "Backend Engineer", "url": f"{BASE}/acme/1",
"description": "", "location": "", "places": [], "remote": None},
"fake:acme", "fake:acme")
item.source = "ats"
store.upsert_role(item, store.subscriptions(source="ats")[0])
again = store.role(one)
assert again is not None and again.description == "Python in full"
assert again.place == "Copenhagen"
def test_a_role_extract_read_without_text_waits_for_it_again_once_its_page_is_read(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
"""Extract read the title alone; the page's text puts the role back in
its queue, and a page that gave nothing leaves it read."""
board(store, "fake:acme")
filled, empty = (role(store, "fake:acme", n) for n in ("1", "2"))
with store.transaction() as conn:
conn.execute("UPDATE roles SET extracted_at = '2026-09-22T00:00:00+00:00', "
"extract_tries = 1")
web["answers"].update({f"{BASE}/acme/1": b"Python in full"})
fetch_text.run_batch(config(tmp_path), store, target="fake:acme", uids=[filled, empty])
first, second = store.role(filled), store.role(empty)
assert first is not None and first.extracted_at is None
assert second is not None and second.extracted_at == "2026-09-22T00:00:00+00:00"
def test_a_board_switched_off_since_the_plan_reads_nothing(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
sub = board(store, "fake:acme")
uid = role(store, "fake:acme", "1")
store.update_subscription(sub.id, fetch=0)
assert fetch_text.run_batch(config(tmp_path), store, target="fake:acme", uids=[uid])["filled"] == 0
assert web["asked"] == []
# ----------------------------------------------------------- search roles
AD = (ROOT / "tests" / "fixtures" / "search" / "jobbank-detail.html").read_bytes()
AD_URL = "https://jobbank.dk/job/1234/acme/role"
def search(store: Store, target: str = "jobbank:cph") -> Any:
return store.add_subscription("search", target, label=target, params={"q": "x"})
def search_role(store: Store, target: str, native: str, *, provider: str = "") -> str:
"""A role of search `target` as a pull stores it: `provider:id`, the
employer in `raw` and no text."""
provider = provider or target.partition(":")[0]
sub = next(s for s in store.subscriptions(source="search") if s.target == target)
row = {"source_id": native, "title": "Researcher", "url": AD_URL.replace("1234", native),
"description": "", "company": "Acme A/S", "places": [{"text": "Fyn", "remote": None}]}
item = ats.item_of(row, target, sub.label)
item.source = "search"
assert item.source_id == f"{provider}:{native}"
store.upsert_role(item, sub)
return item.uid
def test_a_search_whose_reader_has_detail_is_planned_like_a_board(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
search(store)
search(store, "jobindex:cph") # no `detail`: left out
board(store, "fake:acme")
a, b = search_role(store, "jobbank:cph", "1234"), search_role(store, "jobbank:cph", "99")
j = search_role(store, "jobindex:cph", "7")
f = role(store, "fake:acme", "1")
scored(store, "One", {a: 0.9, b: 0.6, j: 0.95, f: 0.7})
assert fetch_text.plan(config(tmp_path), store) == [("jobbank:cph", [a, b]), ("fake:acme", [f])]
# The budgets are a board's: `per_board` and `per_run` count the search as one.
assert fetch_text.plan(config(tmp_path, per_board=1), store) == [("jobbank:cph", [a]),
("fake:acme", [f])]
assert fetch_text.plan(config(tmp_path, per_run=2), store) == [("jobbank:cph", [a]),
("fake:acme", [f])]
# A failing search is left out, as a failing board is.
store.state["search:failing:jobbank:cph"] = "{}"
assert fetch_text.plan(config(tmp_path), store) == [("fake:acme", [f])]
def test_a_search_role_read_waits_for_the_retry_and_a_failed_one_goes_last(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
search(store)
one, two, three = (search_role(store, "jobbank:cph", n) for n in ("1", "2", "3"))
scored(store, "One", {one: 0.9, two: 0.8, three: 0.7})
store.state["ats:detailed:jobbank:cph"] = json.dumps(["jobbank:cph:1", "jobbank:cph:2"])
store.state["ats:detailfailed:jobbank:cph"] = json.dumps(["jobbank:cph:2"])
store.state["ats:detailempty:jobbank:cph"] = json.dumps(
{"jobbank:cph:1": datetime.now(UTC).isoformat(timespec="seconds"),
"jobbank:cph:2": "2020-01-01T00:00:00+00:00"})
# 1 gave no text a moment ago and waits; 2 failed and is due, after 3.
assert fetch_text.plan(config(tmp_path), store) == [("jobbank:cph", [three, two])]
def test_a_batch_reads_a_search_roles_page_and_stores_its_text(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
search(store)
uid = search_role(store, "jobbank:cph", "1234")
store.put_vectors("fake", [(uid, np.ones(3, dtype=np.float32))])
web["answers"][AD_URL] = AD
out = fetch_text.run_batch(config(tmp_path), store, target="jobbank:cph", uids=[uid])
assert out == {"target": "jobbank:cph", "read": 1, "filled": 1, "texts": 1}
assert web["asked"] == [AD_URL]
got = store.role(uid)
assert got is not None and got.description
assert (got.source, got.source_id, got.company) == ("search", "jobbank:1234", "Acme A/S")
assert got.raw["search"] == "jobbank:cph" and got.raw["provider"] == "jobbank"
assert store.vectors("fake") == {}
assert json.loads(store.state["ats:detailed:jobbank:cph"]) == ["jobbank:cph:1234"]
# Read, it is not planned again, and has no text left to wait for.
scored(store, "One", {uid: 0.9})
assert fetch_text.plan(config(tmp_path), store) == []
def test_a_search_batch_counts_a_404_as_read_as_a_board_does(
store: Store, tmp_path: Path, web: dict[str, Any]) -> None:
search(store)
one, two = search_role(store, "jobbank:cph", "1"), search_role(store, "jobbank:cph", "2")
out = fetch_text.run_batch(config(tmp_path), store, target="jobbank:cph", uids=[one, two])
assert out["filled"] == 0 and out["read"] == 2
assert json.loads(store.state["ats:detailed:jobbank:cph"]) == [
"jobbank:cph:1", "jobbank:cph:2"]
def test_a_reader_is_found_for_a_board_and_a_search_and_one_without_detail_is_refused(
web: dict[str, Any]) -> None:
assert ats.reader_of("fake:acme") is readers.HOSTS["fake"]
assert ats.reader_of("jobbank:cph") is readers.PROVIDERS["jobbank"]
assert ats.reader_of("nowhere:x") is None
with httpx.Client() as client:
for target in ("jobindex:cph", "plain:acme", "nowhere:x"):
with pytest.raises(ValueError, match="no reader"):
ats.read_detail(client, target, {"source_id": "1", "url": BASE})
with pytest.raises(ValueError, match="no reader"):
ats.read_board_details({}, target, [{"source_id": "1", "url": BASE}],
client=client)
# ------------------------------------------------------------------ cascade
class _Context:
def __init__(self) -> None:
self.made: list[Any] = []
def task(self, t: Any) -> Any:
self.made.append(t)
return t
def test_nothing_filled_passes_over_the_prep_embed_and_score_behind_fetch_text() -> None:
context = _Context()
empty = Tally(results=({"filled": 0},))
out = cascade.step(None, None, empty, {"cascade": "pull", "task": "fetch_text", "at": 4},
context=context)
assert out["next"] == "extract" and context.made[0].carries["at"] == 8
out = cascade.step(None, None, Tally(results=({"filled": 2}, {"filled": 0})),
{"cascade": "pull", "task": "fetch_text", "at": 4}, context=context)
assert out["next"] == "prep" and context.made[1].carries["at"] == 5
out = cascade.step(None, None, empty,
{"cascade": "fetch_text", "task": "fetch_text", "at": 0},
context=context)
assert out["next"] == "extract" and context.made[2].carries["at"] == 4
class _Embedder:
def encode(self, texts: list[str]) -> np.ndarray:
return np.vstack([np.asarray([t.lower().count("python"), 0.1], dtype=np.float32)
for t in texts])
def test_the_fetch_text_job_reads_the_pages_then_embeds_and_scores_those_roles(
store: Store, tmp_path: Path, web: dict[str, Any],
monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(embed, "load_embedder", lambda model: _Embedder())
board(store, "fake:acme")
one, two = role(store, "fake:acme", "1"), role(store, "fake:acme", "2")
store.put_vectors("fake", [(uid, np.ones(2, dtype=np.float32)) for uid in (one, two)])
agent = scored(store, "One", {one: 0.9, two: 0.1}, out=(two,))
web["answers"][f"{BASE}/acme/1"] = b"Python in full"
queue = JobQueue(Jobs(tmp_path / "roledesk.db"), config(tmp_path), store,
workers={"cpu": 1, "http": 1, "llm": 1})
started = queue.enqueue("fetch_text")
queue.drain(timeout=60)
assert started is not None
jobs = sorted(queue.jobs.of_cascade(queue.jobs.last(fetch_text.KIND).cascade_id), # type: ignore[union-attr]
key=lambda j: j.id)
assert [j.result.get("task") for j in jobs if j.kind == FINAL] == \
["fetch_text", "prep", "embed", "score", "extract", "score", "judge", "summarise"]
assert [j.kind for j in jobs if j.kind != FINAL] == \
["fetch_text", fetch_text.KIND, "prep", "embed", "score", "score"]
assert web["asked"] == [f"{BASE}/acme/1"]
embedded = next(j for j in jobs if j.kind == "embed")
assert embedded.result["embedded"] == 1
assert set(store.vectors("fake")) == {one, two}
assert store.scores(agent.id)
# ----------------------------------------------------------------- triggers
@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 client(app: FastAPI) -> Iterator[TestClient]:
with TestClient(app) as c:
yield c
ANY_STATE = ("queued", "running", "done", "failed", "cancelled")
def _fetch_text_behind_a_score(queue: Any) -> Any:
found = queue.jobs.last("fetch_text", states=ANY_STATE)
assert found is not None
assert [queue.jobs.get(i).kind for i in found.depends_on] == ["score"]
assert found.after == "done"
return found
def test_saving_an_agent_queues_a_score_then_fetch_text(client: TestClient, app: FastAPI) -> None:
res = client.post("/api/agents", json={"name": "Backend", "intent": "python backend"})
assert res.status_code == 200
_fetch_text_behind_a_score(app.state.queue)
res = client.post("/api/agents", json={"id": res.json()["id"], "name": "Backend",
"intent": "go backend"})
assert res.status_code == 200
def test_a_company_affinity_queues_a_score_then_fetch_text(
client: TestClient, app: FastAPI) -> None:
store: Store = app.state.store
store.save_agent("Backend", "python backend")
store.add_company("Acme")
res = client.post("/api/companies/acme/affinity", json={"affinity": 2})
assert res.status_code == 200
found = _fetch_text_behind_a_score(app.state.queue)
assert found.depends_on == [res.json()["score_job"]]
def test_one_score_is_one_fetch_text(app: FastAPI) -> None:
queue = app.state.queue
score = queue.enqueue("score")
first = cascade.fetch_text_after(queue, score)
assert cascade.fetch_text_after(queue, score).id == first.id
assert cascade.fetch_text_after(queue, None) is None
def test_a_vote_queues_neither_score_nor_fetch_text(client: TestClient, app: FastAPI) -> None:
store: Store = app.state.store
store.save_agent("Backend", "python backend")
item = Item(source_id="fake:acme:1", location=f"{BASE}/acme/1", title="Backend Engineer",
body="", published_at=datetime(2026, 9, 20, tzinfo=UTC), raw={"company": "Acme"})
item.source = "ats"
store.upsert_role(item)
assert client.post(f"/api/roles/{item.uid}/vote", json={"value": 1}).status_code == 200
assert client.delete(f"/api/roles/{item.uid}/vote").status_code == 200
queue = app.state.queue
assert queue.jobs.last("fetch_text", states=ANY_STATE) is None
assert queue.jobs.last("score", states=ANY_STATE) is None