Storage: roles, companies, subscriptions, applications, agents

roledesk/storage/schema.py creates the tables at v1 with WAL and the
versioned-migration machinery from newsdesk; store.py adds upsert_role
(unpacks raw into gate columns, first_seen on insert, last_seen every
time), roles(), mark_closed, companies and subscriptions CRUD, and
save_application writing an append-only application_events row on every
status entered. Key helpers company_key, title_key, place_key live in
models.py. docs/decisions.md records the key decisions.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
WolfandClaude Opus 5.5 committed 2026-09-23 11:03:51 +02:00
1 parent 36dbcbb29e
commit ac5eca874a
5 files changed
+949 -7

No files matched your search

+248
View File
@@ -0,0 +1,248 @@
"""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 roledesk.models import Application, company_key, place_key, title_key
from roledesk.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 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_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
# ----------------------------------------------------------- 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"]