Files
jobboard/tests/test_storage.py
T
WolfandClaude Fable 5.1 09c5dde113 Roles as a feed, a read page, votes that move the rank, unstar
The Roles tab is news's feed row: the title opens /roles/{uid}, company,
place and age under it, the badges, a one-line excerpt (summary, else the
description's opening), and ▲ ● ▼ ★ on the right, under the text at 640px.
The company affinity control leaves the row. A passed role and a hidden
company's are dimmed and stay. The filter bar is one row: order, search and
a Filters <details> holding the rest, with a judged select and "Show hidden
companies". The list loads 60 and appends on an IntersectionObserver
sentinel; back from a read page restores the filters, rows and scroll.

GET /api/roles takes offset, defaults to 60 and answers {items, total}.
judged= is a WHERE on roles.vote. Under a ranking the served score and the
order are the stored score moved by the vote (x0.5 pass, x1.2 like, capped
at 1), so a vote shows at once without a rescore. POST and DELETE
/api/roles/{uid}/vote set and clear it; pressing the pressed stance clears.

★ saves; pressed again it calls DELETE /api/applications/{id}, which drops
the application while it is still saved and answers 409 after. save_role no
longer writes the placeholder next step.

The read page (role.html, role.js) is news's reader: a bar with back,
▲ ● ▼ ★ and ↗, the company with its affinity control, place, badges, salary,
summary, the text (fetched posting, else description) and the link out.
It offers Fetch the posting for a teaser and Summarise without a summary,
against the /text and /summarise routes B4 adds. The vote and star buttons
are judge.js, shared by the feed and the reader.

Applications: titles open the read page, the Next column is gone, a Saved
column instead, and the lede says what the page is for.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-25 21:51:48 +02:00

370 lines
16 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""The store: schema, role upserts, closure, companies, subscriptions, the tracker."""
from __future__ import annotations
import sqlite3
from collections.abc import Iterator
from datetime import UTC, datetime, timedelta
from pathlib import Path
import pytest
from pydantic import ValidationError
from desk.models import Item
from app.models import Application, company_key, place_key, title_key
from app.storage import LATEST, Store
class Clock:
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)
@pytest.fixture
def clock() -> Clock:
return Clock()
@pytest.fixture
def store(tmp_path: Path, clock: Clock) -> Iterator[Store]:
s = Store(tmp_path / "roledesk.db")
s.clock = clock
yield s
def posting(source_id: str = "123", **raw: object) -> Item:
item = Item(source_id=source_id, location=f"https://boards.example/acme/{source_id}",
title="Senior Backend Engineer (m/w/d)", body="We build things.",
published_at=datetime(2026, 9, 20, tzinfo=UTC), raw=dict(raw))
item.source = "ats"
return item
# ------------------------------------------------------------------ schema
def test_schema_creates_on_an_empty_file(tmp_path: Path) -> None:
path = tmp_path / "new.db"
store = Store(path)
with sqlite3.connect(path) as conn:
tables = {r[0] for r in conn.execute(
"SELECT name FROM sqlite_master WHERE type='table'")}
assert conn.execute("PRAGMA user_version").fetchone()[0] == LATEST
assert conn.execute("PRAGMA journal_mode").fetchone()[0] == "wal"
indexes = {r[0] for r in conn.execute(
"SELECT name FROM sqlite_master WHERE type='index'")}
assert {"roles", "companies", "subscriptions", "applications",
"application_events", "agents", "scores", "state"} <= tables
assert "idx_roles_cluster" in indexes
assert store.migrations_applied == []
# A second open finds it current and applies nothing.
assert Store(path).migrations_applied == []
def test_a_newer_file_is_refused(tmp_path: Path) -> None:
path = tmp_path / "future.db"
Store(path)
with sqlite3.connect(path) as conn:
conn.execute(f"PRAGMA user_version = {LATEST + 1}")
with pytest.raises(RuntimeError, match=r"Upgrade roledesk"):
Store(path)
def _columns(path: Path, table: str) -> list[tuple[str, str, int, str]]:
with sqlite3.connect(path) as conn:
return [(r[1], r[2], r[3], r[4]) for r in conn.execute(f"PRAGMA table_info({table})")]
def test_a_v1_file_migrates_to_the_shape_a_new_file_has(tmp_path: Path) -> None:
fresh, old = tmp_path / "fresh.db", tmp_path / "old.db"
Store(fresh)
Store(old)
with sqlite3.connect(old) as conn:
for column in ("permit", "languages", "extract_tries", "vote", "voted_at",
"summary", "summarised_at", "article_text", "article_at"):
conn.execute(f"ALTER TABLE roles DROP COLUMN {column}")
for column in ("intent_key", "intent_vec"):
conn.execute(f"ALTER TABLE agents DROP COLUMN {column}")
conn.execute("DROP TABLE vectors")
conn.execute("PRAGMA user_version = 1")
assert Store(old).migrations_applied == list(range(2, LATEST + 1))
# ALTER appends, so the order differs; every read is by column name.
for table in ("roles", "agents", "vectors"):
assert sorted(_columns(old, table)) == sorted(_columns(fresh, table))
def test_state_is_a_mapping(store: Store) -> None:
store.state["ats:last"] = "2026-09-23"
assert store.state["ats:last"] == "2026-09-23"
assert dict(store.state) == {"ats:last": "2026-09-23"}
del store.state["ats:last"]
assert "ats:last" not in store.state
# ------------------------------------------------------------------- keys
def test_keys() -> None:
assert title_key("Senior Backend Engineer (m/w/d)") == "senior backend engineer"
assert title_key("Data Scientist (f/m/x) – Berlin") == "data scientist berlin" # noqa: RUF001
assert title_key("Product Designer m/w/d") == "product designer"
assert title_key("Engineer (all genders)") == "engineer"
assert place_key("Zürich, Switzerland") == "zurich switzerland"
assert company_key("Trade Republic Bank GmbH") == "trade-republic-bank"
assert company_key("Celonis SE") == company_key("celonis") == "celonis"
# ------------------------------------------------------------------- roles
def test_upsert_twice_keeps_first_seen_and_bumps_last_seen(
store: Store, clock: Clock) -> None:
assert store.upsert_role(posting(company="Acme GmbH", place="Berlin")) is True
first = store.role(posting().uid)
assert first is not None
clock.tick()
assert store.upsert_role(posting(company="Acme GmbH", place="Berlin")) is False
again = store.role(posting().uid)
assert again is not None
assert again.first_seen == first.first_seen == first.created_at
assert again.last_seen > first.last_seen
assert (again.company_key, again.title_key, again.place_key) == \
("acme", "senior backend engineer", "berlin")
def test_upsert_unpacks_raw_and_keeps_filled_columns(store: Store) -> None:
store.upsert_role(posting(place="Berlin", remote=True, salary_min="80000",
salary_max=95000, currency="EUR", department="Eng"))
role = store.role(posting().uid)
assert role is not None
assert (role.remote, role.salary_min, role.salary_max, role.currency) == \
("remote", 80000, 95000, "EUR")
assert role.raw["department"] == "Eng"
assert role.description == "We build things."
assert role.original_url.endswith("/123")
# A later fetch saying less does not erase what was known.
store.upsert_role(posting())
role = store.role(posting().uid)
assert role is not None
assert (role.place, role.remote, role.salary_min) == ("Berlin", "remote", 80000)
def test_company_falls_back_to_the_subscription(store: Store) -> None:
sub = store.add_subscription("ats", "greenhouse:acme", company="Acme", board="Greenhouse")
store.upsert_role(posting(), sub)
role = store.role(posting().uid)
assert role is not None
assert (role.company, role.company_key, role.subscription_id) == ("Acme", "acme", sub.id)
def test_roles_newest_first_and_filtered(store: Store, clock: Clock) -> None:
store.upsert_role(posting("1", company="Acme", place="Berlin"))
clock.tick()
store.upsert_role(posting("2", company="Acme", place="Munich"))
clock.tick()
store.upsert_role(posting("3", company="Other", place="Berlin"))
assert [r.source_id for r in store.roles()] == ["3", "2", "1"]
assert [r.source_id for r in store.roles(company="ACME")] == ["2", "1"]
assert [r.source_id for r in store.roles(place="berlin")] == ["3", "1"]
assert [r.source_id for r in store.roles(limit=1)] == ["3"]
def test_roles_filters_q_function_remote_and_days(store: Store, clock: Clock) -> None:
store.upsert_role(posting("1", company="Acme", place="Berlin",
function="engineering", remote=True))
clock.tick(hours=48)
store.upsert_role(posting("2", company="Acme", place="Munich",
function="sales"))
assert [r.source_id for r in store.roles(q="senior engineer")] == ["2", "1"]
assert [r.source_id for r in store.roles(q="backend nonsense")] == []
assert [r.source_id for r in store.roles(function="engineering")] == ["1"]
assert [r.source_id for r in store.roles(remote="remote")] == ["1"]
assert [r.source_id for r in store.roles(company="ac")] == ["2", "1"]
assert [r.source_id for r in store.roles(place="berlin")] == ["1"]
assert [r.source_id for r in store.roles(days=1)] == ["2"]
assert [r.source_id for r in store.roles(days=30)] == ["2", "1"]
def test_roles_hide_muted_excludes_before_the_limit(store: Store, clock: Clock) -> None:
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()
# Acme's roles are the three newest, so a plain limit=1 shows only Acme;
# hide_muted has to reach past all three to find "other" rather than
# just dropping Acme's rows out of an already-limited page.
assert [r.source_id for r in store.roles(limit=1)] == ["a2"]
assert [r.source_id for r in store.roles(limit=1, hide_muted=True)] == ["other"]
assert {r.source_id for r in store.roles(hide_muted=True)} == {"other"}
assert {r.source_id for r in store.roles()} == {"a0", "a1", "a2", "other"}
def test_roles_page_by_offset_and_count_the_same_filter(
store: Store, clock: Clock) -> None:
for sid in ("1", "2", "3", "4"):
store.upsert_role(posting(sid, company="Acme" if sid != "4" else "Other"))
clock.tick()
assert [r.source_id for r in store.roles(limit=2, offset=1)] == ["3", "2"]
assert [r.source_id for r in store.roles(limit=2, offset=3)] == ["1"]
assert store.count_roles() == 4
assert store.count_roles(company="acme") == 3
store.add_company("Other", key="other", affinity=-1)
assert store.count_roles(hide_muted=True) == 3
def test_a_vote_is_stamped_cleared_and_filtered(store: Store, clock: Clock) -> None:
for sid in ("up", "down", "fine", "none"):
store.upsert_role(posting(sid))
uid = {r.source_id: r.uid for r in store.roles()}
role = store.set_vote(uid["up"], 1)
assert (role.vote, role.voted_at) == (1, clock().isoformat(timespec="seconds"))
store.set_vote(uid["down"], -1)
store.set_vote(uid["fine"], 0)
assert [r.source_id for r in store.roles(judged="liked")] == ["up"]
assert [r.source_id for r in store.roles(judged="passed")] == ["down"]
assert [r.source_id for r in store.roles(judged="unjudged")] == ["none"]
assert store.count_roles(judged="unjudged") == 1
with pytest.raises(ValueError, match="judged"):
store.roles(judged="maybe")
cleared = store.set_vote(uid["up"], None)
assert (cleared.vote, cleared.voted_at) == (None, None)
with pytest.raises(ValueError):
store.set_vote(uid["up"], 2)
with pytest.raises(ValueError):
store.set_vote(uid["up"], True)
with pytest.raises(KeyError):
store.set_vote("nope", 1)
def test_a_vote_moves_the_served_score_and_the_order(store: Store) -> None:
for sid in ("a", "b", "c"):
store.upsert_role(posting(sid))
uid = {r.source_id: r.uid for r in store.roles()}
agent = store.save_agent("A")
store.replace_scores(agent.id, [(uid["a"], 0.9, ""), (uid["b"], 0.5, ""),
(uid["c"], 0.4, "")])
store.set_vote(uid["a"], -1) # 0.45
store.set_vote(uid["c"], 1) # 0.48
ranked = [(r.source_id, round(r.score or 0, 3)) for r in store.roles(agent=agent.id)]
assert ranked == [("b", 0.5), ("c", 0.48), ("a", 0.45)]
assert store.scores(agent.id)[uid["a"]][0] == 0.9 # the stored score is kept
store.set_vote(uid["a"], 1)
assert store.roles(agent=agent.id, limit=1)[0].score == 1.0
def test_mark_closed_closes_what_the_board_no_longer_lists(store: Store) -> None:
sub = store.add_subscription("ats", "greenhouse:acme")
other = store.add_subscription("ats", "greenhouse:other")
for source_id in ("1", "2", "3"):
store.upsert_role(posting(source_id), sub)
store.upsert_role(posting("9"), other)
assert store.mark_closed("ats", ["1", "3"], sub.id) == 1
assert {r.source_id for r in store.roles()} == {"1", "3", "9"}
assert {r.source_id for r in store.roles(open_only=False)} == {"1", "2", "3", "9"}
# Listed again: open again.
store.upsert_role(posting("2"), sub)
assert {r.source_id for r in store.roles()} == {"1", "2", "3", "9"}
def test_an_item_without_a_source_is_refused(store: Store) -> None:
item = posting()
item.source = ""
with pytest.raises(ValueError, match="no source"):
store.upsert_role(item)
# --------------------------------------------------------------- companies
def test_companies_crud(store: Store) -> None:
acme = store.add_company("Acme GmbH", domain="acme.example")
assert acme.key == "acme" and acme.affinity == 0 and acme.status == "researching"
with pytest.raises(ValueError, match="already exists"):
store.add_company("Acme")
updated = store.update_company("acme", affinity=2, status="contacted")
assert (updated.affinity, updated.status) == (2, "contacted")
with pytest.raises(ValueError, match="affinity"):
store.update_company("acme", affinity=5)
with pytest.raises(ValueError, match="not a company field"):
store.update_company("acme", created_at="x")
assert [c.key for c in store.companies()] == ["acme"]
assert store.remove_company("acme") is True
assert store.company("acme") is None
def test_open_role_counts_and_company_boards(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", place="Berlin"), sub)
store.upsert_role(posting("2", company="Acme", place="Munich"), sub)
store.mark_closed("ats", ["1"], sub.id)
assert store.open_role_counts() == {"acme": 1}
assert store.company_boards() == {"acme": "greenhouse"}
# ----------------------------------------------------------- subscriptions
def test_subscriptions_crud(store: Store) -> None:
sub = store.add_subscription("ats", "greenhouse:acme", label="Acme",
company="Acme", board="Greenhouse", params={"q": 1})
assert (sub.company, sub.board, sub.params, sub.fetch) == \
("Acme", "Greenhouse", {"q": 1}, 1)
with pytest.raises(ValueError):
store.add_subscription("ats", "greenhouse:acme")
assert store.subscription_for("ats", "Acme") == sub
store.update_subscription(sub.id, fetch=False)
assert store.subscriptions(fetchable=True) == []
assert [s.id for s in store.subscriptions(source="ats")] == [sub.id]
gone = store.unsubscribe(sub.id)
assert (gone.subscribed, gone.fetch, gone.show) == (0, 0, 0)
# ------------------------------------------------------------ applications
def test_a_status_change_writes_an_event(store: Store, clock: Clock) -> None:
saved = store.save_application(Application(company_key="acme", role_title="Engineer"))
assert saved.id and saved.status == "saved"
clock.tick()
store.set_application_status(saved.id, "applied")
clock.tick()
store.save_application(saved.model_copy(update={"status": "applied", "notes": "x"}))
clock.tick()
store.set_application_status(saved.id, "screen")
events = store.application_events(saved.id)
assert [e.status for e in events] == ["saved", "applied", "screen"]
assert events[0].at < events[1].at < events[2].at
assert [a.notes for a in store.applications()] == ["x"]
def test_an_invalid_status_is_refused(store: Store) -> None:
saved = store.save_application(Application(role_title="Engineer"))
with pytest.raises(ValueError, match="not an application status"):
store.set_application_status(saved.id, "ghosted")
with pytest.raises(ValidationError):
Application(status="ghosted")
with pytest.raises(sqlite3.IntegrityError), store.transaction() as conn:
conn.execute("UPDATE applications SET status='ghosted' WHERE id=?", (saved.id,))
assert [e.status for e in store.application_events(saved.id)] == ["saved"]
def test_events_are_append_only(store: Store) -> None:
saved = store.save_application(Application(role_title="Engineer"))
with pytest.raises(sqlite3.IntegrityError, match="append-only"), \
store.transaction() as conn:
conn.execute("UPDATE application_events SET status='offer'")
assert store.application_events(saved.id)[0].status == "saved"
def test_an_application_may_point_at_a_role(store: Store) -> None:
store.upsert_role(posting())
saved = store.save_application(Application(role_uid=posting().uid, status="applied"))
assert saved.role_uid == posting().uid
assert [e.status for e in store.application_events(saved.id)] == ["applied"]