Files
jobboard/tests/test_web.py
T
WolfandClaude Opus 5.5 6b40702a9a Sources tab: searches, company boards and the prune by region, in the app
What a pull reads can now be changed on a page instead of only the command
line: try a search and see its first ten results before saving it, edit or
remove one, follow a company's ATS board, switch any board or search on or
off, and preview and apply a prune by region. Each row shows its open roles
and the countries they are in.

The page and `app companies`/`app searches` call the same functions in
app/jobs/sources.py. Switching a target off closes its open roles, and the
pull's settle closes them again if a batch in flight reopened them. Roles
pulled before `country` existed are backfilled at startup.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-24 15:15:04 +02:00

449 lines
20 KiB
Python

"""The tabs and the JSON API they call, against a temp database and FastAPI's
TestClient. No network — nothing here touches an ATS host or the queue's own
worker beyond starting and stopping it with the app."""
from __future__ import annotations
from collections.abc import Iterator
from datetime import UTC, datetime, timedelta
from pathlib import Path
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.storage import Store
from app.web import TABS
from auth import AuthConfig
from desk.models import Item
class Clock:
"""A controllable `Store.clock`, for tests that need upserts to land at
distinct, known moments — see `test_storage.py`'s twin of this."""
def __init__(self) -> None:
self.at = datetime(2026, 9, 23, 9, 0, tzinfo=UTC)
def __call__(self) -> datetime:
return self.at
def tick(self, hours: float = 1) -> None:
self.at += timedelta(hours=hours)
def posting(source_id: str = "1", **raw: object) -> Item:
item = Item(source_id=source_id, location=f"https://boards.example/acme/{source_id}",
title="Senior Backend Engineer", body="Build things.",
published_at=datetime(2026, 9, 20, tzinfo=UTC), raw=dict(raw))
item.source = "ats"
return item
@pytest.fixture
def app(tmp_path: Path) -> FastAPI:
"""The database in `tmp_path` and the config passed in, so a test never
touches `roledesk.db` and two tests never share a jobs table."""
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:
return app.state.store
@pytest.fixture
def client(app: FastAPI) -> Iterator[TestClient]:
with TestClient(app) as c:
yield c
# ------------------------------------------------------------------- roles
def test_list_roles_filters_by_query_place_and_function(
client: TestClient, store: Store) -> None:
store.upsert_role(posting("1", company="Acme", place="Berlin", function="engineering"))
store.upsert_role(posting("2", company="Acme", place="Munich", function="sales"))
store.upsert_role(posting("3", company="Other", place="Berlin", function="engineering"))
res = client.get("/api/roles", params={"q": "engineer", "place": "Berlin"})
assert res.status_code == 200
assert {r["source_id"] for r in res.json()} == {"1", "3"}
res = client.get("/api/roles", params={"function": "sales"})
assert [r["source_id"] for r in res.json()] == ["2"]
res = client.get("/api/roles", params={"company": "other"})
assert [r["source_id"] for r in res.json()] == ["3"]
def test_list_roles_limit_is_bounded(client: TestClient, store: Store) -> None:
for i in range(3):
store.upsert_role(posting(str(i)))
assert len(client.get("/api/roles", params={"limit": 1}).json()) == 1
assert client.get("/api/roles", params={"limit": 0}).status_code == 422
assert client.get("/api/roles", params={"limit": 1001}).status_code == 422
def test_muted_roles_are_hidden_unless_show_muted(client: TestClient, store: Store) -> None:
store.add_company("Acme", key="acme")
store.upsert_role(posting("1", company="Acme"))
store.upsert_role(posting("2", company="Other"))
assert {r["source_id"] for r in client.get("/api/roles").json()} == {"1", "2"}
assert client.post("/api/companies/acme/affinity", json={"affinity": -1}).status_code == 200
assert {r["source_id"] for r in client.get("/api/roles").json()} == {"2"}
assert {r["source_id"] for r in
client.get("/api/roles", params={"show_muted": "true"}).json()} == {"1", "2"}
def test_muted_is_excluded_before_the_limit_not_after(
client: TestClient, store: Store) -> None:
"""A regression case: filtering a muted company out of an already
`LIMIT`-ed page can leave nothing to show, if that company happens to be
the newest thing in the database — exactly what a company with hundreds
of roles, all freshly (re-)pulled at once, produces."""
clock = Clock()
store.clock = clock
store.add_company("Acme", key="acme", affinity=-1)
store.upsert_role(posting("other", company="Other"))
clock.tick()
for i in range(3):
store.upsert_role(posting(f"a{i}", company="Acme"))
clock.tick()
res = client.get("/api/roles", params={"limit": 1})
assert [r["source_id"] for r in res.json()] == ["other"]
# --------------------------------------------------------------- companies
def test_companies_lists_board_and_open_role_count(
client: TestClient, store: Store) -> None:
sub = store.add_subscription("ats", "greenhouse:acme", company="Acme", board="greenhouse")
store.add_company("Acme", key="acme")
store.upsert_role(posting("1", company="Acme"), sub)
res = client.get("/api/companies")
assert res.status_code == 200
[row] = [c for c in res.json() if c["key"] == "acme"]
assert row == {"key": "acme", "name": "Acme", "board": "greenhouse",
"affinity": 0, "open_roles": 1}
def test_set_affinity_validates_and_updates(client: TestClient, store: Store) -> None:
store.add_company("Acme", key="acme")
res = client.post("/api/companies/acme/affinity", json={"affinity": 2})
assert res.status_code == 200
assert res.json()["affinity"] == 2
assert store.company("acme").affinity == 2 # type: ignore[union-attr]
assert client.post("/api/companies/acme/affinity", json={"affinity": 9}).status_code == 422
assert client.post("/api/companies/nope/affinity", json={"affinity": 1}).status_code == 404
# ----------------------------------------------------------- applications
def test_save_creates_an_application_with_a_saved_event(
client: TestClient, store: Store) -> None:
store.upsert_role(posting("1", company="Acme", place="Berlin"))
uid = posting("1").uid
res = client.post("/api/applications", json={"role_uid": uid, "status": "saved"})
assert res.status_code == 201
body = res.json()
assert body["role_uid"] == uid
assert body["status"] == "saved"
assert body["company_key"] == "acme"
assert body["next_action"] == "Read the posting and decide"
assert body["next_date"] is not None
events = store.application_events(body["id"])
assert [e.status for e in events] == ["saved"]
# Saving the same role again returns the existing row rather than a
# second one.
again = client.post("/api/applications", json={"role_uid": uid, "status": "saved"})
assert again.json()["id"] == body["id"]
listed = client.get("/api/applications").json()
assert [a["id"] for a in listed] == [body["id"]]
assert listed[0]["role_title"] == "Senior Backend Engineer"
def test_save_an_unknown_role_is_refused(client: TestClient) -> None:
res = client.post("/api/applications", json={"role_uid": "nope", "status": "saved"})
assert res.status_code == 404
def test_set_status_validates_and_writes_an_event(
client: TestClient, store: Store) -> None:
store.upsert_role(posting("1", company="Acme"))
uid = posting("1").uid
saved = client.post("/api/applications", json={"role_uid": uid}).json()
res = client.post(f"/api/applications/{saved['id']}/status", json={"status": "applied"})
assert res.status_code == 200
assert res.json()["status"] == "applied"
assert [e.status for e in store.application_events(saved["id"])] == ["saved", "applied"]
assert client.post(f"/api/applications/{saved['id']}/status",
json={"status": "ghosted"}).status_code == 422
assert client.post("/api/applications/nope/status",
json={"status": "applied"}).status_code == 404
# -------------------------------------------------------------------- tabs
def test_every_tab_renders_with_the_whole_nav(client: TestClient) -> None:
assert [t.label for t in TABS] == ["Roles", "Applications", "Agents", "Companies",
"Sources", "Jobs", "Schedules", "Messages", "Account"]
for tab in TABS:
res = client.get(tab.path)
assert res.status_code == 200, f"{tab.path} answered {res.status_code}"
assert "roledesk</title>" in res.text
for other in TABS:
assert f">{other.label}</a>" in res.text
def test_each_roledesk_tab_is_a_shell_for_roles_js(client: TestClient) -> None:
for path, container in [("/", 'id="roles-list"'),
("/applications", 'id="applications-list"'),
("/agents", 'id="agents-list"'),
("/companies", 'id="companies-list"')]:
page = client.get(path).text
assert container in page and "/static/roles.js" in page
# toasts.js before app.js before the page's own script: `api()` needs
# `window.toast`, and roles.js needs `api()`.
assert page.index("toasts.js") < page.index("app.js") < page.index("roles.js")
assert "ROLEDESK_STATUSES" in client.get("/applications").text
assert client.get("/static/roles.js").status_code == 200
def test_the_sources_tab_is_a_shell_for_sources_js(client: TestClient) -> None:
page = client.get("/sources").text
assert 'id="searches-list"' in page and 'id="boards-list"' in page
assert page.index("app.js") < page.index("sources.js")
assert 'value="1" selected>Region Hovedstaden' in page # from plugins.search
assert client.get("/static/sources.js").status_code == 200
def test_the_modules_bring_their_own_elements(client: TestClient) -> None:
assert "<desk-jobs>" in client.get("/jobs").text
assert "<desk-schedules>" in client.get("/schedules").text
assert "<auth-account>" in client.get("/account").text
def test_pull_is_declared_every_six_hours(client: TestClient) -> None:
rows = {r["name"]: r for r in client.get("/api/schedules").json()}
assert rows["pull"]["kind"] == "pull"
assert rows["pull"]["cadence"] == "every 6h"
assert rows["pull"]["enabled"] is True and rows["pull"]["unknown"] is False
def test_the_jobs_tab_offers_pull_once_and_no_batch(client: TestClient) -> None:
"""A subset rather than the list: `pipeline/tests` registers kinds of its
own into the same global `JOBS` when the whole suite runs."""
kinds = [k["kind"] for k in client.get("/api/jobs/kinds").json()]
assert {"embed", "extract", "pull", "score"} <= set(kinds)
assert kinds.count("pull") == 1
assert not {"pull_batch", "extract_batch", "advance"} & set(kinds)
def test_an_error_is_one_sentence(client: TestClient) -> None:
"""`api()` toasts `detail` as it is, so a 422 is a sentence, not a list."""
res = client.post("/api/agents", json={"name": "Bad",
"gates": [{"field": "salary", "values": [1]}]})
assert res.status_code == 422
assert "gates.0.field" in res.json()["detail"]
missing = client.get("/nothing-here")
assert missing.status_code == 404 and "text/html" in missing.headers["content-type"]
def test_health_is_open_and_reads_the_store(client: TestClient) -> None:
assert client.get("/health").json() == {"ok": True, "open_roles": 0}
def test_a_locked_app_shuts_every_tab_and_the_api(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("APP_PASSWORD", "open-sesame-please")
config = Config(server=ServerConfig(host="127.0.0.1", port=0),
database=tmp_path / "locked.db", auth=AuthConfig(enabled="always"))
with TestClient(create_app(config), follow_redirects=False) as locked:
for tab in TABS:
assert locked.get(tab.path).status_code == 303
assert locked.get("/api/roles").status_code == 401
assert locked.get("/health").status_code == 200
signed_in = locked.post("/login", json={"password": "open-sesame-please"})
assert signed_in.status_code == 200
assert locked.get("/api/roles").status_code == 200
# ------------------------------------------------------------------ agents
def test_agents_are_created_updated_listed_and_deleted(client: TestClient) -> None:
body = {"name": "Berlin", "intent": "python backend",
"gates": [{"field": "place", "values": ["Berlin"], "mode": "require"}]}
created = client.post("/api/agents", json=body)
assert created.status_code == 200
agent = created.json()
assert agent["weights"] == {"fit": 0.6, "recency": 0.2, "affinity": 0.2}
assert agent["gates"][0]["weight"] == 1.0
updated = client.post("/api/agents", json={**body, "id": agent["id"], "enabled": False,
"weights": {"fit": 1, "recency": 0,
"affinity": 0}})
assert updated.json()["enabled"] is False and updated.json()["weights"]["fit"] == 1
assert [a["name"] for a in client.get("/api/agents").json()] == ["Berlin"]
assert client.post("/api/agents", json=body).status_code == 409
assert client.delete(f"/api/agents/{agent['id']}").status_code == 204
assert client.get("/api/agents").json() == []
assert client.delete(f"/api/agents/{agent['id']}").status_code == 404
def test_a_gate_on_an_unknown_field_is_refused(client: TestClient) -> None:
body = {"name": "Bad", "gates": [{"field": "salary", "values": [1]}]}
assert client.post("/api/agents", json=body).status_code == 422
def test_roles_by_agent_are_ordered_by_score_and_hide_the_gated(
client: TestClient, store: Store) -> None:
for sid in ("low", "high", "gated"):
store.upsert_role(posting(sid))
uids = {r.source_id: r.uid for r in store.roles()}
agent = store.save_agent("A")
store.replace_scores(agent.id, [(uids["low"], 0.2, ""), (uids["high"], 0.8, ""),
(uids["gated"], 0.0, "place unknown")])
shown = client.get(f"/api/roles?agent={agent.id}").json()
assert [r["source_id"] for r in shown] == ["high", "low"]
assert shown[0]["score"] == 0.8
everything = client.get(f"/api/roles?agent={agent.id}&gated=1").json()
assert everything[-1]["gated_reason"] == "place unknown"
assert client.get("/api/roles").json()[0]["score"] is None
assert client.get("/api/roles?agent=999").status_code == 404
# ----------------------------------------------------------------- sources
def _fake_search(monkeypatch: pytest.MonkeyPatch, rows: int) -> None:
import plugins.search as search
def run(target: str, params: dict[str, object],
keys: dict[str, object] | None = None) -> tuple[list[dict[str, object]], bool]:
return [{"title": f"Engineer {n}", "company": "Acme", "place": "København",
"url": f"https://x.example/{n}"} for n in range(rows)], True
monkeypatch.setattr(search, "run_search", run)
def test_sources_lists_searches_and_boards_with_their_countries(
client: TestClient, store: Store) -> None:
board = store.add_subscription("ats", "greenhouse:acme", label="Acme", company="Acme",
board="greenhouse")
store.upsert_role(posting("1", company="Acme", place="Copenhagen"), board)
store.upsert_role(posting("2", company="Acme", place="Boston, MA"), board)
store.upsert_role(posting("3", company="Acme", place="Aarhus"), board)
store.add_subscription("search", "jobindex:cph", label="Copenhagen", board="jobindex",
params={"q": "backend", "area": 1})
res = client.get("/api/sources").json()
[row] = res["boards"]
assert (row["label"], row["on"], row["open_roles"]) == ("Acme", True, 3)
assert row["countries"] == [["DK", 2], ["US", 1]]
assert [s["label"] for s in res["searches"]] == ["Copenhagen"]
assert res["searches"][0]["params"] == {"q": "backend", "area": 1}
def test_switching_a_board_off_closes_its_roles_and_on_keeps_them_closed_until_a_pull(
client: TestClient, store: Store) -> None:
board = store.add_subscription("ats", "greenhouse:acme", label="Acme", company="Acme",
board="greenhouse")
store.upsert_role(posting("1", company="Acme"), board)
off = client.post(f"/api/sources/{board.id}/switch", json={"on": False}).json()
assert off["closed"] == 1 and off["source"]["on"] is False
assert store.subscriptions(source="ats", fetchable=True) == []
assert store.roles() == []
on = client.post(f"/api/sources/{board.id}/switch", json={"on": True}).json()
assert on["closed"] == 0 and on["source"]["on"] is True
assert client.post("/api/sources/999/switch", json={"on": True}).status_code == 404
def test_a_search_is_tried_saved_updated_and_removed(
client: TestClient, store: Store, monkeypatch: pytest.MonkeyPatch) -> None:
_fake_search(monkeypatch, 3)
body = {"provider": "jobindex", "name": "Copenhagen backend", "q": "backend", "area": 1}
tried = client.post("/api/searches/try", json=body).json()
assert tried["found"] == 3 and tried["complete"] is True
assert tried["sample"][0] == {"title": "Engineer 0", "company": "Acme",
"place": "København", "url": "https://x.example/0"}
assert store.subscriptions(source="search") == []
saved = client.post("/api/searches", json=body).json()
assert saved["source"]["target"] == "jobindex:copenhagen-backend"
assert saved["source"]["params"] == {"q": "backend", "area": 1}
updated = client.post("/api/searches", json={**body, "q": "python", "pages": 3}).json()
assert updated["source"]["id"] == saved["source"]["id"]
assert updated["source"]["params"] == {"q": "python", "area": 1, "pages": 3}
sub_id = saved["source"]["id"]
assert client.delete(f"/api/searches/{sub_id}").json() == {"closed": 0}
assert client.get("/api/sources").json()["searches"] == []
again = client.post("/api/searches", json=body).json() # the same row, back on
assert again["source"]["id"] == sub_id and again["source"]["on"] is True
def test_a_search_that_finds_nothing_or_is_malformed_is_refused(
client: TestClient, store: Store, monkeypatch: pytest.MonkeyPatch) -> None:
_fake_search(monkeypatch, 0)
res = client.post("/api/searches", json={"provider": "jobindex", "name": "X", "q": "x"})
assert res.status_code == 422 and "found nothing" in res.json()["detail"]
res = client.post("/api/searches", json={"provider": "indeed", "name": "X", "q": "x"})
assert res.status_code == 422
res = client.post("/api/searches/try", json={"provider": "jobindex", "q": " "})
assert res.status_code == 422 and "query" in res.json()["detail"]
assert store.subscriptions(source="search") == []
def test_a_board_is_followed_only_if_it_answers(
client: TestClient, store: Store, monkeypatch: pytest.MonkeyPatch) -> None:
import plugins.ats as ats
monkeypatch.setattr(ats, "fetch_board", lambda target: [{"source_id": "1"}])
res = client.post("/api/boards", json={"board": "ashby:acme", "name": "Acme"})
assert res.status_code == 201
assert res.json()["found"] == 1 and res.json()["source"]["target"] == "ashby:acme"
assert store.company("acme") is not None
again = client.post("/api/boards", json={"board": "ashby:acme", "name": "Acme"})
assert again.status_code == 422 and "already followed" in again.json()["detail"]
bad = client.post("/api/boards", json={"board": "acme", "name": "Other"})
assert bad.status_code == 422 and "host:slug" in bad.json()["detail"]
def test_prune_previews_then_switches_off(client: TestClient, store: Store) -> None:
us = store.add_subscription("ats", "greenhouse:us", label="US", company="US",
board="greenhouse")
dk = store.add_subscription("ats", "greenhouse:dk", label="DK", company="DK",
board="greenhouse")
store.upsert_role(posting("1", company="US", place="Boston, MA"), us)
store.upsert_role(posting("2", company="DK", place="Copenhagen"), dk)
preview = client.get("/api/prune", params={"region": "DK,EU"}).json()
assert [b["label"] for b in preview["boards"]] == ["US"]
assert len(store.subscriptions(source="ats", fetchable=True)) == 2
done = client.post("/api/prune", json={"region": "DK,EU"}).json()
assert (done["pruned"], done["roles_closed"], done["boards_left"]) == (1, 1, 1)
assert client.get("/api/prune", params={"region": " "}).status_code == 422