"""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
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.storage import Store
from app.web import MOVED, SETTINGS, 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 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:
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)
store.add_company("Other", key="other") # known only from a search: no board
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",
"subscription_id": sub.id, "on": True, "affinity": 0, "open_roles": 1}
[other] = [c for c in res.json() if c["key"] == "other"]
assert (other["board"], other["subscription_id"], other["on"]) == ("", None, None)
def test_set_affinity_validates_updates_and_enqueues_a_score(
client: TestClient, store: Store, queue: Any) -> 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 queue.jobs.last("score", states=("queued", "running", "done")) is not None
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_page_renders_with_the_whole_nav(client: TestClient) -> None:
assert [t.label for t in TABS] == ["Roles", "Applications"]
assert [t.label for t in SETTINGS] == ["Ranking", "Searches", "Companies", "Pulls",
"Messages", "Account"]
assert all(t.path.startswith("/settings/") for t in SETTINGS)
for tab in (*TABS, *SETTINGS):
res = client.get(tab.path)
assert res.status_code == 200, f"{tab.path} answered {res.status_code}"
assert "roledesk" in res.text
for other in TABS:
assert f">{other.label}" in res.text
assert 'href="/settings" class="icon' in res.text
assert '' in res.text
def test_the_cog_and_one_sub_tab_are_current_on_a_settings_page(client: TestClient) -> None:
page = client.get("/settings/pulls").text
assert 'class="icon active"' in page
for tab in SETTINGS:
assert f">{tab.label}" in page
assert page.count('aria-current="page"') == 1
current = page.index('aria-current="page"')
assert page.rindex('href="', 0, current) == page.index('href="/settings/pulls"')
assert 'class="icon active"' not in client.get("/").text
def test_settings_is_ranking(client: TestClient) -> None:
res = client.get("/settings", follow_redirects=False)
assert res.status_code == 302 and res.headers["location"] == "/settings/ranking"
@pytest.mark.parametrize(("old", "new"), sorted(MOVED.items()))
def test_an_old_tab_moves_permanently_and_keeps_its_query(
client: TestClient, old: str, new: str) -> None:
res = client.get(old, follow_redirects=False)
assert res.status_code == 301 and res.headers["location"] == new
res = client.get(f"{old}?agent=3&q=a+b", follow_redirects=False)
assert res.status_code == 301 and res.headers["location"] == f"{new}?agent=3&q=a+b"
assert client.get(old).status_code == 200
def test_each_page_loads_only_its_own_script(client: TestClient) -> None:
scripts = {"roles.js", "applications.js", "ranking.js", "companies.js", "sources.js",
"jobs.js", "messages.js"}
for path, container, script in [
("/", 'id="roles-list"', "roles.js"),
("/applications", 'id="applications-list"', "applications.js"),
("/settings/ranking", 'id="ranking-form"', "ranking.js"),
("/settings/searches", 'id="searches-list"', "sources.js"),
("/settings/companies", 'id="companies-list"', "companies.js"),
("/settings/pulls", 'id="kinds"', "jobs.js"),
("/settings/messages", 'id="notices"', "messages.js")]:
page = client.get(path).text
assert container in page, path
assert [s for s in scripts if f"/static/{s}" in page] == [script], path
# toasts.js before app.js before the page's own script: `api()` needs
# `window.toast`, and every page script needs `api()` and the helpers.
assert page.index("toasts.js") < page.index("app.js") < page.index(f"/static/{script}")
assert client.get(f"/static/{script}").status_code == 200
assert "ROLEDESK_STATUSES" in client.get("/applications").text
def test_the_ranking_page_edits_one_ranking(client: TestClient) -> None:
page = client.get("/settings/ranking").text
assert 'id="a-intent"' in page and " None:
page = client.get("/settings/searches").text
assert 'id="searches-list"' in page
assert 'value="1" selected>Region Hovedstaden' in page # from plugins.search
# Boards and the prune tool moved to Companies; a search has no board.
assert 'id="boards-list"' not in page and 'id="prune-form"' not in page
assert 'id="pull-now"' not in page # moved to Pulls
def test_the_companies_page_offers_the_follow_form_and_the_prune_tool(
client: TestClient) -> None:
page = client.get("/settings/companies").text
assert 'id="companies-list"' in page
assert 'id="b-host"' in page and 'id="b-slug"' in page and 'id="b-name"' in page
assert '