Files
jobboard/tests/test_limits.py
T

239 lines
9.5 KiB
Python

"""The limit words of a board (`app/jobs/limits.py`) and what the Companies
and Sources pages carry of them."""
from __future__ import annotations
import html
import json
import re
import types
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.jobs import limits, reach
from app.main import create_app
from app.storage import Store
from desk.models import Item
from plugins.readers import Fields, Filters, Reads
from prepped import upsert
TARGET = "fake:acme"
def fake(**over: Any) -> types.ModuleType:
"""A reader that declares `READS`, the only thing `words` looks at."""
reads: dict[str, Any] = {
"scope": "board", "listing": "whole", "text": "listing", "complete": "whole",
"places": "one", "robots": "read: test",
"fields": Fields(pay="figures", posted="trusted"),
"filters": Filters(country="one", remote="one")}
reads.update(over)
module = types.ModuleType("fake")
module.READS = Reads(**reads) # type: ignore[attr-defined]
return module
def state(**keys: str) -> dict[str, str]:
"""`ats:<key>:fake:acme` for each keyword, with the markers of a complete
read unless given."""
kept = {"ok": "run", "complete": "1"} | keys
return {f"ats:{k}:{TARGET}": v for k, v in kept.items()}
def words(module: types.ModuleType, kept: dict[str, str], size: int | None = 500,
**kw: Any) -> list[str]:
return limits.words(module, kept, TARGET, None, size, **kw)
def test_a_quiet_board_has_no_words() -> None:
assert words(fake(), state()) == []
@pytest.mark.parametrize("keys, word", [
({"failing": json.dumps({"since": "2026-09-01", "reason": "x"})}, "failing"),
({"complete": ""}, "read incomplete"),
({"swept": "1"}, "swept"),
({"sweep": "{}"}, "swept"),
({"filtered": "1"}, "filtered by reach"),
({"remote_unasked": "1"}, "remote not asked"),
({"narrowed": "1"}, "narrowed by terms"),
])
def test_the_words_of_the_state(keys: dict[str, str], word: str) -> None:
found = words(fake(), state(**keys))
assert word in found
assert set(found) <= {word, "read incomplete"}
def test_a_board_never_read_is_not_incomplete() -> None:
"""No `ok` marker is a board not read yet, which no word says."""
assert words(fake(), {}) == []
def test_a_missing_or_empty_remote_unasked_is_not_set() -> None:
assert "remote not asked" not in words(fake(), state())
assert "remote not asked" not in words(fake(), state(remote_unasked=""))
def test_the_line_says_nothing_asked() -> None:
assert words(fake(), state(), line="site lists none of DK, SE: nothing asked") == [
"nothing asked"]
assert words(fake(), state(), line="follows agents: DK · all roles") == []
def test_size_and_ceiling() -> None:
paged = fake(listing="paged", page_size=20, ceiling=2000, complete="end")
assert words(paged, state(), 0) == ["size 0", "read whole"]
assert words(paged, state(), 1999) == []
assert words(paged, state(), 2000) == ["over the ceiling"]
assert words(paged, state(), None) == []
assert words(fake(), state(), 5000) == [] # no ceiling declared
@pytest.mark.parametrize("text, word", [("detail", "text per role"), ("none", "no text"),
("excerpt", "excerpt only")])
def test_where_the_text_is(text: str, word: str) -> None:
assert words(fake(text=text), state()) == [word]
def test_what_the_host_states() -> None:
assert words(fake(fields=Fields(pay="none", posted="listed")), state()) == [
"no pay", "date not trusted"]
assert words(fake(fields=Fields(pay="line", posted="none")), state()) == [
"date not trusted"]
def test_roles_without_text_and_text_reads_that_failed() -> None:
kept = state(detailfailed=json.dumps(["1", "2", "3"]))
assert words(fake(), kept, counts=limits.Texts(9, 4)) == [
"without text: 4", "text failed: 3"]
assert words(fake(), state(), counts=limits.Texts(9, 0)) == []
@pytest.mark.parametrize(("dropped", "found"), [
("3", ["3 listings dropped: no title or link"]),
("1", ["1 listing dropped: no title or link"]),
("", []), ("x", [])])
def test_the_listings_the_last_read_dropped_are_named(dropped: str, found: list[str]) -> None:
"""The rows the runner dropped (`_runner.valid`), after "read incomplete"."""
assert words(fake(), state(dropped=dropped)) == found
assert words(fake(), state(dropped=dropped, complete=""))[1:] == found
def test_a_board_is_read_whole_under_the_bar_or_when_its_host_cannot_filter() -> None:
assert words(fake(), state(), reach.SMALL - 1) == ["read whole"]
assert words(fake(), state(), reach.SMALL) == []
assert words(fake(filters=Filters()), state(), 5000) == ["read whole"]
def test_the_words_come_in_the_order_of_the_vocabulary() -> None:
found = words(fake(text="none", fields=Fields()),
state(complete="", filtered="1", narrowed="1", remote_unasked="1"), 0,
counts=limits.Texts(2, 2), line="nothing asked")
assert found == ["read incomplete", "filtered by reach", "remote not asked",
"narrowed by terms", "nothing asked", "size 0", "no text", "no pay",
"date not trusted", "without text: 2", "read whole"]
phrases = [w.partition(":")[0] for w in found]
assert phrases == sorted(phrases, key=list(limits.WORDS).index)
def test_a_search_reader_reads_its_own_keys() -> None:
module = fake(scope="search", complete="never", listing="paged", page_size=20)
assert words(module, {f"search:failing:{TARGET}": "{}"}, None) == ["failing"]
assert "failing" not in words(module, state(failing="{}"), None)
def test_a_module_that_declares_nothing_gets_the_words_of_its_state() -> None:
assert words(types.ModuleType("old"), state(filtered="1"), 0) == [
"filtered by reach", "size 0"]
def test_the_filter_offers_every_word_with_its_meaning() -> None:
"""The template repeats `WORDS`, since no view hands it over; they must agree."""
text = (Path(__file__).parent.parent / "app/templates/settings/sources.html").read_text()
group = re.search(r'<optgroup label="Limits">(.*?)</optgroup>', text, re.S)
assert group
options = [(html.unescape(v), html.unescape(t)) for v, t in re.findall(
r'<option value="([^"]+)" title="([^"]*)">[^<]+</option>', group.group(1))]
assert options == list(limits.WORDS.items())
# ---------------------------------------------------------- the two endpoints
@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:
return app.state.store
@pytest.fixture
def client(app: FastAPI) -> Iterator[TestClient]:
with TestClient(app) as c:
yield c
def role(source: str, source_id: str, body: str) -> Item:
item = Item(source_id=source_id, location=f"https://x.example/{source_id}",
title="Senior Backend Engineer", body=body,
published_at=datetime(2026, 9, 20, tzinfo=UTC), raw={"company": "Acme"})
item.source = source
return item
def test_companies_carry_their_limits_and_the_boards_own_open_roles(
client: TestClient, store: Store) -> None:
board = store.add_subscription("ats", "lever:acme", company="Acme", board="lever")
search = store.add_subscription("search", "jobindex:cph", label="cph", board="jobindex")
store.add_company("Acme", key="acme", ats="lever")
upsert(store, role("ats", "1", "Build things."), board)
upsert(store, role("ats", "2", ""), board)
upsert(store, role("search", "s1", "Teaser"), search)
store.state["ats:ok:lever:acme"] = "run"
store.state["ats:complete:lever:acme"] = ""
store.state["ats:size:lever:acme"] = "12"
[row] = client.get("/api/companies").json()
assert (row["open_roles"], row["board_open"]) == (3, 2)
# Lever states pay and a trusted date, gives its text in the list and cannot filter.
assert row["limits"] == ["read incomplete", "without text: 1", "read whole"]
def test_a_board_that_dropped_listings_says_so_on_its_row(
client: TestClient, store: Store) -> None:
store.add_subscription("ats", "lever:acme", company="Acme", board="lever")
store.add_company("Acme", key="acme", ats="lever")
store.state["ats:ok:lever:acme"] = "run"
store.state["ats:complete:lever:acme"] = "1"
store.state["ats:dropped:lever:acme"] = "3"
[row] = client.get("/api/companies").json()
assert row["limits"][0] == "3 listings dropped: no title or link"
def test_a_company_without_a_board_has_no_limits(client: TestClient, store: Store) -> None:
store.add_company("Novo", key="novo", ats="taleo")
[row] = client.get("/api/companies").json()
assert (row["limits"], row["board_open"]) == ([], None)
def test_the_readers_carry_what_they_declare_of_their_limits(client: TestClient) -> None:
found = {r["name"]: r for r in client.get("/api/readers").json()}
workday = found["workday"]
assert (workday["complete"], workday["page_size"], workday["ceiling"]) == (
"stated", 20, 2000)
assert workday["teaser"] is False and workday["empty"] == "trusted"
assert workday["fields"]["pay"] == "none"
assert set(workday["fields"]) == {"pay", "posted", "remote", "country", "seniority",
"employment"}
assert found["oracle"]["teaser"] is True