"""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 import json from collections.abc import Iterator from datetime import UTC, datetime, timedelta 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 LADDER, RUNGS from app.models import excerpt as models_excerpt from app.storage import Store from app.web import SETTINGS, TABS from app.web.api import _score_after_change from app.web.pages import SECTIONS from auth import AuthConfig from desk.models import Item from prepped import upsert 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 queue(app: FastAPI) -> Any: return app.state.queue @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: upsert(store, posting("1", company="Acme", place="Berlin", function="engineering")) upsert(store, posting("2", company="Acme", place="Munich", function="sales")) upsert(store, posting("3", company="Other", place="Berlin", function="engineering")) uid = {r.source_id: r.uid for r in store.roles()} res = client.get("/api/roles", params={"q": "engineer", "place": "Berlin"}) assert res.status_code == 200 assert {r["uid"] for r in res.json()["items"]} == {uid["1"], uid["3"]} res = client.get("/api/roles", params={"function": "sales"}) assert [r["uid"] for r in res.json()["items"]] == [uid["2"]] res = client.get("/api/roles", params={"company": "other"}) assert [r["uid"] for r in res.json()["items"]] == [uid["3"]] def test_list_roles_filters_by_company_keys_places_and_seniority( client: TestClient, store: Store) -> None: for sid, company, place, title in ( ("kbh", "Acme", "København K", "Senior Engineer"), ("malmo", "Acme", "Malmö", "Engineer"), ("billund", "Other", "Billund, Denmark", "Junior Engineer"), ("berlin", "Other", "Berlin", "Senior Engineer")): item = posting(sid, company=company, place=place) item.title = title upsert(store, item) uid = {r.source_id: r.uid for r in store.roles()} def shown(**params: Any) -> set[str]: res = client.get("/api/roles", params=params) assert res.status_code == 200, res.text assert res.json()["total"] == len(res.json()["items"]) return {sid for sid, u in uid.items() if u in {r["uid"] for r in res.json()["items"]}} assert shown(company_keys=["acme"]) == {"kbh", "malmo"} assert shown(company_keys=["acme", "other"]) == set(uid) assert shown(places=["country:DK"]) == {"kbh", "billund"} assert shown(places=["country:DK", "region:skane"]) == {"kbh", "billund", "malmo"} assert shown(places=["place:kobenhavn"]) == {"kbh"} assert shown(places=["Lund"]) == set() # not Billund assert shown(level_from="senior", level_to="senior") == {"kbh", "berlin", "malmo"} assert shown(level_from="senior", level_to="senior", seniority_unknown="false") == {"kbh", "berlin"} assert shown(level_from="junior", level_to="senior", seniority_unknown="false", company_keys=["other"]) == {"billund", "berlin"} res = client.get("/api/roles", params={"places": ["region:atlantis"]}) assert res.status_code == 422 and "region:atlantis" in res.json()["detail"] res = client.get("/api/roles", params={"level_from": "boss"}) assert res.status_code == 422 and "boss" in res.json()["detail"] res = client.get("/api/roles", params={"level_to": "boss"}) assert res.status_code == 422 and "level_to" in res.json()["detail"] res = client.get("/api/roles", params={"track": "both"}) assert res.status_code == 422 and "both" in res.json()["detail"] # The repeated `seniority` of the chip row is not a parameter any more. assert shown(seniority=["junior"]) == set(uid) def test_list_roles_filters_by_a_range_of_rungs_and_a_track( client: TestClient, store: Store) -> None: for sid, title in (("junior", "Junior Engineer"), ("senior", "Senior Engineer"), ("staff", "Staff Engineer"), ("manager", "Engineering Manager"), ("director", "Director of Engineering"), ("none", "Engineer")): item = posting(sid) item.title = title upsert(store, item) uid = {r.source_id: r.uid for r in store.roles()} def shown(**params: Any) -> set[str]: res = client.get("/api/roles", params=params) assert res.status_code == 200, res.text found = {r["uid"] for r in res.json()["items"]} return {sid for sid, u in uid.items() if u in found} everyone = set(uid) assert shown() == everyone # A range: a bound alone is open on the other side; no level passes. assert shown(level_from="staff") == {"staff", "manager", "director", "none"} assert shown(level_to="senior") == {"junior", "senior", "none"} assert shown(level_from="senior", level_to="staff", seniority_unknown="false") == {"senior", "staff", "manager"} # A track keeps its own side and the rungs under Staff, which have none. assert shown(track="ic", seniority_unknown="false") == {"junior", "senior", "staff"} assert shown(track="people", seniority_unknown="false") == { "junior", "senior", "manager", "director"} # Both together. assert shown(level_from="staff", track="people", seniority_unknown="false") == {"manager", "director"} assert shown(level_from="staff", track="ic", seniority_unknown="false") == {"staff"} # `seniority_unknown` alone changes nothing: no bound, no track, no filter. assert shown(seniority_unknown="false") == everyone def test_role_facets_count_each_facet_under_the_other_filters( client: TestClient, store: Store) -> None: for sid, title, raw in (("a", "Senior Engineer", {"salary_min": 70000}), ("b", "Senior Engineer", {}), ("c", "Engineer", {"salary_text": "EUR 50 per hour"})): item = posting(sid, **raw) item.title = title upsert(store, item) res = client.get("/api/roles/facets", params={"level_from": "senior", "level_to": "senior", "seniority_unknown": "false", "pay": "stated"}) assert res.status_code == 200 body = res.json() levels = {f["value"]: f["count"] for f in body["seniority"]} assert (levels["senior"], levels[""], levels["junior"]) == (1, 1, 0) # a and c pay assert body["pay"] == [{"value": "normalised", "count": 1}, # a and b are senior {"value": "stated", "count": 0}, {"value": "", "count": 1}] assert client.get("/api/roles/facets", params={"places": ["country:ZZ"]}).status_code == 422 assert client.get("/api/roles/facets", params={"track": "boss"}).status_code == 422 # A track counts the same levels; the facet leaves its own filter out. res = client.get("/api/roles/facets", params={"track": "people"}) assert res.status_code == 200 assert {f["value"]: f["count"] for f in res.json()["seniority"]}["senior"] == 2 def test_suggest_companies_folds_the_name_and_leaves_out_the_hidden( client: TestClient, store: Store) -> None: for sid, company in (("1", "Ørsted"), ("2", "Ørsted"), ("3", "Data Minds"), ("4", "Big Data Corp"), ("5", "Big Data Corp"), ("6", "Big Data Corp"), ("7", "Metadata Ltd"), ("8", "Hidden Data")): upsert(store, posting(sid, company=company)) agent = store.save_agent("A") store.set_affinity(agent.id, "hidden-data", -1) store.set_affinity(agent.id, "ørsted", 2) def suggest(q: str, **params: Any) -> list[dict[str, Any]]: res = client.get("/api/suggest/companies", params={"q": q, **params}) assert res.status_code == 200 return res.json() assert suggest("orsted") == [{"key": "ørsted", "name": "Ørsted", "count": 2, "affinity": 2}] # A word prefix, not a substring: Metadata is not found; by open roles. assert [c["name"] for c in suggest("data")] == ["Big Data Corp", "Data Minds"] assert [c["name"] for c in suggest("big da")] == ["Big Data Corp"] assert [c["name"] for c in suggest("data", limit=1)] == ["Big Data Corp"] assert suggest("") == [] # Another agent hid nothing. other = store.save_agent("B") assert "Hidden Data" in [c["name"] for c in suggest("data", agent=other.id)] def test_suggest_places_and_read_labels_back(client: TestClient, store: Store) -> None: for sid, place in (("1", "Malmö"), ("2", "Malmö"), ("3", "Lund"), ("4", "København K"), ("5", "Kolding")): upsert(store, posting(sid, place=place)) res = client.get("/api/suggest/places", params={"q": "ska"}) assert res.status_code == 200 assert res.json()[0] == {"token": "region:skane", "label": "Skåne", "kind": "region", "count": 3} tokens = [s["token"] for s in client.get("/api/suggest/places", params={"q": "kob"}).json()] assert "place:kobenhavn" in tokens assert client.get("/api/suggest/places", params={"q": ""}).json() == [] res = client.get("/api/places/labels", params={"tokens": ["country:DK", "region:skane", "place:malmo", "region:atlantis"]}) assert res.json() == [{"token": "country:DK", "label": "Denmark"}, {"token": "region:skane", "label": "Skåne"}, {"token": "place:malmo", "label": "Malmö"}] def test_list_roles_exposes_and_filters_by_pay(client: TestClient, store: Store) -> None: """`salary_text` and `salary_state` (app/models.py) are on every role the API serves, and `pay` (`Store.PAY`) filters the feed by it, in SQL before `limit` like the other filters.""" upsert(store, posting("normalised", salary_min=70000, salary_max=90000, currency="EUR", salary_text="EUR 70,000 to 90,000 per year")) upsert(store, posting("stated", salary_text="USD 45 to 60 per hour")) upsert(store, posting("none")) uid = {r.source_id: r.uid for r in store.roles()} items = {r["uid"]: r for r in client.get("/api/roles").json()["items"]} assert items[uid["normalised"]]["salary_text"] == "EUR 70,000 to 90,000 per year" assert items[uid["normalised"]]["salary_state"] == "normalised" assert items[uid["stated"]]["salary_state"] == "stated" assert items[uid["none"]]["salary_state"] == "" res = client.get("/api/roles", params={"pay": "stated"}) assert {r["uid"] for r in res.json()["items"]} == {uid["normalised"], uid["stated"]} res = client.get("/api/roles", params={"pay": "normalised"}) assert [r["uid"] for r in res.json()["items"]] == [uid["normalised"]] res = client.get("/api/roles", params={"pay": "stated_only"}) assert [r["uid"] for r in res.json()["items"]] == [uid["stated"]] assert client.get("/api/roles", params={"pay": "bogus"}).status_code == 422 def test_list_roles_limit_is_bounded(client: TestClient, store: Store) -> None: for i in range(3): upsert(store, posting(str(i))) assert len(client.get("/api/roles", params={"limit": 1}).json()["items"]) == 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") upsert(store, posting("1", company="Acme")) upsert(store, posting("2", company="Other")) agent = store.save_agent("A") other = store.save_agent("B") uid = {r.source_id: r.uid for r in store.roles()} def shown(**params: Any) -> set[str]: return {r["uid"] for r in client.get("/api/roles", params=params).json()["items"]} assert shown() == {uid["1"], uid["2"]} # No agent in the body: the default agent's, which is also who a list # without `agent` hides for. assert client.post("/api/companies/acme/affinity", json={"affinity": -1}).status_code == 200 assert shown() == {uid["2"]} assert shown(show_muted="true") == {uid["1"], uid["2"]} assert shown(agent=agent.id, order="newest") == {uid["2"]} # Hidden is per agent: the other agent still sees Acme. assert shown(agent=other.id, order="newest") == {uid["1"], uid["2"]} assert [c["affinity"] for c in client.get("/api/companies").json()] == [-1] assert [c["affinity"] for c in client.get("/api/companies", params={"agent": other.id}).json()] == [0] 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") store.set_affinity(store.save_agent("A").id, "acme", -1) upsert(store, posting("other", company="Other")) clock.tick() for i in range(3): upsert(store, posting(f"a{i}", company="Acme")) clock.tick() uid = {r.source_id: r.uid for r in store.roles()} res = client.get("/api/roles", params={"limit": 1}) assert [r["uid"] for r in res.json()["items"]] == [uid["other"]] assert res.json()["total"] == 1 def test_list_roles_pages_by_offset_and_counts_the_total( client: TestClient, store: Store) -> None: clock = Clock() store.clock = clock for i in range(5): upsert(store, posting(str(i))) clock.tick() uid = {r.source_id: r.uid for r in store.roles()} first = client.get("/api/roles", params={"limit": 2}).json() assert [r["uid"] for r in first["items"]] == [uid["4"], uid["3"]] assert first["total"] == 5 rest = client.get("/api/roles", params={"limit": 2, "offset": 4}).json() assert [r["uid"] for r in rest["items"]] == [uid["0"]] and rest["total"] == 5 assert client.get("/api/roles", params={"offset": 9}).json() == {"items": [], "total": 5} assert client.get("/api/roles", params={"offset": -1}).status_code == 422 assert len(client.get("/api/roles").json()["items"]) == 5 # default 60 def test_a_vote_is_set_cleared_and_filtered_on(client: TestClient, store: Store) -> None: for sid in ("liked", "passed", "fine", "open"): upsert(store, posting(sid)) uid = {r.source_id: r.uid for r in store.roles()} agent = store.save_agent("A") store.replace_scores(agent.id, [(u, 0.5, "") for u in uid.values()]) # No `agent` in the body: the default agent's vote. res = client.post(f"/api/roles/{uid['liked']}/vote", json={"value": 1}) assert res.status_code == 200 assert res.json()["vote"] == 1 and res.json()["voted_at"] is not None assert store.votes(agent.id) == {uid["liked"]: 1} client.post(f"/api/roles/{uid['passed']}/vote", json={"value": -1, "agent": agent.id}) client.post(f"/api/roles/{uid['fine']}/vote", json={"value": 0}) def judged(value: str, **params: Any) -> set[str]: page = client.get("/api/roles", params={"judged": value, **params}).json() return {r["uid"] for r in page["items"]} assert judged("liked") == {uid["liked"]} assert judged("passed") == {uid["passed"]} assert judged("unjudged") == {uid["open"]} assert judged("") == {uid["liked"], uid["passed"], uid["fine"], uid["open"]} # a pass is not hidden assert judged("liked", agent=agent.id, order="newest") == {uid["liked"]} assert client.get("/api/roles", params={"judged": "maybe"}).status_code == 422 assert client.get(f"/api/roles/{uid['liked']}").json()["vote"] == 1 assert client.get(f"/api/roles/{uid['liked']}", params={"agent": agent.id}).json()["vote"] == 1 cleared = client.delete(f"/api/roles/{uid['liked']}/vote") assert cleared.status_code == 200 assert cleared.json()["vote"] is None and cleared.json()["voted_at"] is None assert judged("unjudged") == {uid["open"], uid["liked"]} cleared = client.delete(f"/api/roles/{uid['passed']}/vote", params={"agent": agent.id}) assert cleared.status_code == 200 and cleared.json()["vote"] is None assert client.post(f"/api/roles/{uid['open']}/vote", json={"value": 2}).status_code == 422 assert client.post("/api/roles/nope/vote", json={"value": 1}).status_code == 404 assert client.delete("/api/roles/nope/vote").status_code == 404 assert client.post(f"/api/roles/{uid['open']}/vote", json={"value": 1, "agent": 999}).status_code == 404 assert client.delete(f"/api/roles/{uid['open']}/vote", params={"agent": 999}).status_code == 404 def test_votes_are_per_agent_over_the_api(client: TestClient, store: Store) -> None: upsert(store, posting("1")) uid = posting("1").uid one = store.save_agent("One") two = store.save_agent("Two") for agent in (one, two): store.replace_scores(agent.id, [(uid, 0.5, "")]) assert client.post(f"/api/roles/{uid}/vote", json={"value": 1, "agent": one.id}).json()["vote"] == 1 assert client.post(f"/api/roles/{uid}/vote", json={"value": -1, "agent": two.id}).json()["vote"] == -1 assert client.get(f"/api/roles/{uid}", params={"agent": one.id}).json()["vote"] == 1 assert client.get(f"/api/roles/{uid}", params={"agent": two.id}).json()["vote"] == -1 assert client.get(f"/api/roles/{uid}").json()["vote"] == 1 # the default's assert client.get(f"/api/roles/{uid}", params={"agent": 999}).status_code == 404 def listed(**params: Any) -> list[int | None]: return [r["vote"] for r in client.get("/api/roles", params=params).json()["items"]] assert listed(agent=one.id, order="newest") == [1] assert listed(agent=two.id, order="newest") == [-1] assert listed() == [1] def test_a_vote_or_an_affinity_needs_an_agent_to_belong_to( client: TestClient, store: Store) -> None: """Nothing to vote as: a 422 with a sentence, not a vote that lands nowhere. Reading is fine, everything is simply unjudged and neutral.""" upsert(store, posting("1")) store.add_company("Acme", key="acme") uid = posting("1").uid res = client.post(f"/api/roles/{uid}/vote", json={"value": 1}) assert res.status_code == 422 and "Settings" in res.json()["detail"] assert client.delete(f"/api/roles/{uid}/vote").status_code == 422 assert client.post("/api/companies/acme/affinity", json={"affinity": 1}).status_code == 422 assert client.get(f"/api/roles/{uid}").json()["vote"] is None assert client.get("/api/roles").json()["items"][0]["vote"] is None assert client.get("/api/companies").json()[0]["affinity"] == 0 def test_roles_with_an_agent_can_be_ordered_newest_and_keep_the_votes( client: TestClient, store: Store) -> None: clock = Clock() store.clock = clock for sid in ("1", "2", "3"): upsert(store, posting(sid)) clock.tick() uid = {r.source_id: r.uid for r in store.roles()} agent = store.save_agent("A") store.replace_scores(agent.id, [(uid["1"], 0.9, ""), (uid["2"], 0.1, "")]) # 3 unscored store.set_vote(agent.id, uid["1"], 1) # Newest keeps to the agent's fetch gate: only what it scored and passed. page = client.get("/api/roles", params={"agent": agent.id, "order": "newest"}).json() assert [r["uid"] for r in page["items"]] == [uid["2"], uid["1"]] assert [r["score"] for r in page["items"]] == [None, None] assert [r["vote"] for r in page["items"]] == [None, 1] assert page["total"] == 2 # Without an agent named, newest is every open role. page = client.get("/api/roles", params={"order": "newest"}).json() assert [r["uid"] for r in page["items"]] == [uid["3"], uid["2"], uid["1"]] scored = client.get("/api/roles", params={"agent": agent.id, "order": "score"}).json() assert [r["uid"] for r in scored["items"]] == [uid["1"], uid["2"]] assert client.get("/api/roles", params={"agent": agent.id, "order": "best"}).status_code == 422 def test_a_vote_moves_a_role_in_the_ranking_at_once( client: TestClient, store: Store) -> None: for sid in ("a", "b", "c"): upsert(store, posting(sid)) uid = {r.source_id: r.uid for r in store.roles()} label = {v: k for k, v in uid.items()} agent = store.save_agent("A") store.replace_scores(agent.id, [(uid["a"], 0.9, ""), (uid["b"], 0.6, ""), (uid["c"], 0.55, "")]) def ranked() -> list[tuple[str, float]]: page = client.get("/api/roles", params={"agent": agent.id}).json() return [(label[r["uid"]], round(r["score"], 3)) for r in page["items"]] assert ranked() == [("a", 0.9), ("b", 0.6), ("c", 0.55)] client.post(f"/api/roles/{uid['a']}/vote", json={"value": -1}) client.post(f"/api/roles/{uid['c']}/vote", json={"value": 1}) assert ranked() == [("c", 0.66), ("b", 0.6), ("a", 0.45)] client.post(f"/api/roles/{uid['b']}/vote", json={"value": 0}) client.post(f"/api/roles/{uid['a']}/vote", json={"value": 1}) assert ranked() == [("a", 1.0), ("c", 0.66), ("b", 0.6)] # capped at 1 def test_read_state_is_set_and_cleared_over_the_api(client: TestClient, store: Store) -> None: upsert(store, posting("1")) uid = posting("1").uid res = client.post(f"/api/roles/{uid}/read") assert res.status_code == 200 assert res.json()["read_at"] is not None res = client.delete(f"/api/roles/{uid}/read") assert res.status_code == 200 assert res.json()["read_at"] is None assert client.post("/api/roles/nope/read").status_code == 404 assert client.delete("/api/roles/nope/read").status_code == 404 def test_list_roles_filters_by_include_read(client: TestClient, store: Store) -> None: upsert(store, posting("1")) upsert(store, posting("2")) ids = {r.source_id: r.uid for r in store.roles()} uid = posting("1").uid client.post(f"/api/roles/{uid}/read") all_ = client.get("/api/roles").json() assert {r["uid"] for r in all_["items"]} == {ids["1"], ids["2"]} unread = client.get("/api/roles", params={"include_read": "false"}).json() assert {r["uid"] for r in unread["items"]} == {ids["2"]} assert unread["total"] == 1 def test_list_roles_filters_by_tags_any_and_all(client: TestClient, store: Store) -> None: upsert(store, posting("1")) upsert(store, posting("2")) uid = {r.source_id: r.uid for r in store.roles()} store.set_tags(uid["1"], ["python", "backend"]) store.set_tags(uid["2"], ["python", "frontend"]) res = client.get("/api/roles", params={"tags": ["python"]}) assert {r["uid"] for r in res.json()["items"]} == {uid["1"], uid["2"]} both = client.get("/api/roles", params={"tags": ["python", "backend"], "tag_mode": "all"}) assert {r["uid"] for r in both.json()["items"]} == {uid["1"]} [item] = both.json()["items"] assert item["tags"] == ["backend", "python"] def test_filters_lists_tag_counts_and_respects_show_muted( client: TestClient, store: Store) -> None: store.add_company("Hidden", key="hidden") agent = store.save_agent("A") # the default agent, whose hidden companies count store.set_affinity(agent.id, "hidden", -1) upsert(store, posting("1", company="Acme")) upsert(store, posting("2", company="Hidden")) uid = {r.source_id: r.uid for r in store.roles(hide_muted=False)} store.set_tags(uid["1"], ["python"]) store.set_tags(uid["2"], ["python"]) res = client.get("/api/filters") assert res.status_code == 200 assert res.json() == {"tags": [{"tag": "python", "count": 1, "unread": 1}]} muted = client.get("/api/filters", params={"show_muted": "true"}) assert muted.json() == {"tags": [{"tag": "python", "count": 2, "unread": 2}]} def test_one_role_and_its_read_page(client: TestClient, store: Store) -> None: upsert(store, posting("1", company="Acme", place="Berlin")) uid = posting("1").uid res = client.get(f"/api/roles/{uid}") assert res.status_code == 200 body = res.json() assert (body["uid"], body["company"], body["description"]) == (uid, "Acme", "Build things.") assert body["vote"] is None and body["summary"] == "" and body["article_text"] == "" assert client.get("/api/roles/nope").status_code == 404 page = client.get(f"/roles/{uid}") assert page.status_code == 200 assert '' in page.text and "/static/roles.js" in page.text missing = client.get("/roles/nope") assert missing.status_code == 404 and "text/html" in missing.headers["content-type"] def test_the_roles_page_offers_the_judged_filter_and_hidden_companies( client: TestClient) -> None: page = client.get("/").text assert 'id="f-judged"' in page and "