`app.jobs.sources.set_board` attaches a board to an existing company,
replaces the one it has (closing the old board's open roles) or creates
the company, with row and subscription changed in one transaction by
`Store.set_company_board`. A board that lists zero roles is kept. `add`,
`discover --add`, the seed importer (moved out of app/cli.py) and the new
`POST|DELETE /api/companies/{key}/board` all go through it; a seed re-run
attaches a board to a row that never had one. A company's subscription is
rewritten in place, and detaching hides it.
`companies.ats_slug` (migration 9) keeps the slug of a host the app
cannot read yet, and discovery returns such a host before probing slugs.
The Companies rows get Set board / Change, the host select is rendered
from `plugins.ats.HOSTS`, and a row with nothing found reads "board not
found" and is in the "Not readable yet" filter.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
864 lines
39 KiB
Python
864 lines
39 KiB
Python
"""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, Limits, 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 == []
|
||
assert LATEST == 9
|
||
# 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", "summary", "summarised_at",
|
||
"article_text", "article_at", "read_at"):
|
||
conn.execute(f"ALTER TABLE roles DROP COLUMN {column}")
|
||
for column in ("intent_key", "intent_vec", "limits"): # v3, v8
|
||
conn.execute(f"ALTER TABLE agents DROP COLUMN {column}")
|
||
# v1 had affinity on the company; the vote columns v4 added and v6
|
||
# drops again are not in a fresh file, so there is nothing to put back.
|
||
conn.execute("ALTER TABLE companies ADD COLUMN affinity INTEGER NOT NULL DEFAULT 0")
|
||
for column in ("ats", "country", "city", "ats_slug"): # v7, v9
|
||
conn.execute(f"ALTER TABLE companies DROP COLUMN {column}")
|
||
for table in ("vectors", "role_tags", "agent_companies", "role_votes"):
|
||
conn.execute(f"DROP TABLE {table}")
|
||
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", "companies", "role_tags",
|
||
"agent_companies", "role_votes"):
|
||
assert sorted(_columns(old, table)) == sorted(_columns(fresh, table))
|
||
|
||
|
||
def test_a_v8_file_gains_ats_slug_and_keeps_its_companies(tmp_path: Path) -> None:
|
||
path = tmp_path / "v8.db"
|
||
Store(path).add_company("Acme", ats="teamtailor", country="DK")
|
||
with sqlite3.connect(path) as conn:
|
||
conn.execute("ALTER TABLE companies DROP COLUMN ats_slug")
|
||
conn.execute("PRAGMA user_version = 8")
|
||
|
||
migrated = Store(path)
|
||
|
||
assert migrated.migrations_applied == [9]
|
||
acme = migrated.company("acme")
|
||
assert acme is not None
|
||
assert (acme.ats, acme.country, acme.ats_slug) == ("teamtailor", "DK", "")
|
||
|
||
|
||
def _downgrade_to_v4(path: Path) -> None:
|
||
"""A fresh file put back to the v4 shape: votes on the role, affinity on
|
||
the company, no read state, no tags, no per-agent tables."""
|
||
with sqlite3.connect(path) as conn:
|
||
conn.execute("ALTER TABLE roles DROP COLUMN read_at")
|
||
conn.execute("DROP TABLE role_tags")
|
||
conn.execute("ALTER TABLE roles ADD COLUMN vote INTEGER CHECK (vote IN (-1, 0, 1))")
|
||
conn.execute("ALTER TABLE roles ADD COLUMN voted_at TEXT")
|
||
conn.execute("ALTER TABLE companies ADD COLUMN affinity INTEGER NOT NULL DEFAULT 0")
|
||
for column in ("ats", "country", "city", "ats_slug"): # v7, v9
|
||
conn.execute(f"ALTER TABLE companies DROP COLUMN {column}")
|
||
conn.execute("ALTER TABLE agents DROP COLUMN limits") # v8
|
||
conn.execute("DROP TABLE agent_companies")
|
||
conn.execute("DROP TABLE role_votes")
|
||
conn.execute("PRAGMA user_version = 4")
|
||
|
||
|
||
def test_v6_moves_the_votes_and_affinities_to_the_default_agent(tmp_path: Path) -> None:
|
||
path = tmp_path / "v4.db"
|
||
store = Store(path)
|
||
store.upsert_role(posting("liked"))
|
||
store.upsert_role(posting("passed"))
|
||
store.upsert_role(posting("none"))
|
||
store.add_company("Acme", key="acme")
|
||
store.add_company("Other", key="other")
|
||
# The disabled agent has the lower id; the enabled one is the default.
|
||
second = store.save_agent("Second", enabled=False)
|
||
first = store.save_agent("First")
|
||
assert first.id > second.id and store.default_agent().id == first.id
|
||
_downgrade_to_v4(path)
|
||
with sqlite3.connect(path) as conn:
|
||
conn.execute("UPDATE roles SET vote = 1, voted_at = 'then' WHERE uid = ?",
|
||
(posting("liked").uid,))
|
||
conn.execute("UPDATE roles SET vote = -1 WHERE uid = ?", (posting("passed").uid,))
|
||
conn.execute("UPDATE companies SET affinity = -1 WHERE key = 'acme'")
|
||
|
||
migrated = Store(path)
|
||
|
||
assert migrated.migrations_applied == list(range(5, LATEST + 1))
|
||
assert [a.name for a in migrated.agents()] == ["First", "Second"] # none added
|
||
assert migrated.votes(first.id) == {posting("liked").uid: 1, posting("passed").uid: -1}
|
||
assert migrated.votes(second.id) == {}
|
||
liked = migrated.role(posting("liked").uid, first.id)
|
||
assert liked is not None and liked.voted_at == "then"
|
||
passed = migrated.role(posting("passed").uid, first.id)
|
||
assert passed is not None and passed.voted_at # stamped when v4 had none
|
||
assert [c.affinity for c in migrated.companies(first.id)] == [-1, 0]
|
||
assert [c.affinity for c in migrated.companies(second.id)] == [0, 0]
|
||
with sqlite3.connect(path) as conn:
|
||
columns = {r[1] for r in conn.execute("PRAGMA table_info(roles)")}
|
||
assert not {"vote", "voted_at"} & columns
|
||
assert "affinity" not in {r[1] for r in conn.execute("PRAGMA table_info(companies)")}
|
||
|
||
|
||
def test_v6_makes_an_agent_when_there_is_something_to_move_and_none_to_take_it(
|
||
tmp_path: Path) -> None:
|
||
path = tmp_path / "v4.db"
|
||
store = Store(path)
|
||
store.upsert_role(posting("liked"))
|
||
store.add_company("Acme", key="acme")
|
||
_downgrade_to_v4(path)
|
||
with sqlite3.connect(path) as conn:
|
||
conn.execute("UPDATE companies SET affinity = 2 WHERE key = 'acme'")
|
||
|
||
migrated = Store(path)
|
||
|
||
[agent] = migrated.agents()
|
||
assert (agent.name, agent.enabled, agent.gates) == ("My ranking", True, [])
|
||
assert agent.created_at.endswith("+00:00")
|
||
assert migrated.default_agent() == agent
|
||
assert migrated.company("acme", agent.id).affinity == 2 # type: ignore[union-attr]
|
||
|
||
|
||
def test_v6_makes_no_agent_when_there_is_nothing_to_move(tmp_path: Path) -> None:
|
||
path = tmp_path / "v4.db"
|
||
store = Store(path)
|
||
store.upsert_role(posting("plain"))
|
||
store.add_company("Acme", key="acme")
|
||
_downgrade_to_v4(path)
|
||
|
||
assert Store(path).migrations_applied == list(range(5, LATEST + 1))
|
||
assert Store(path).agents() == []
|
||
|
||
|
||
def test_a_v4_file_migrates_read_state_and_tags(tmp_path: Path) -> None:
|
||
fresh, old = tmp_path / "fresh.db", tmp_path / "old.db"
|
||
Store(fresh)
|
||
Store(old)
|
||
_downgrade_to_v4(old)
|
||
|
||
assert Store(old).migrations_applied == list(range(5, LATEST + 1))
|
||
assert sorted(_columns(old, "roles")) == sorted(_columns(fresh, "roles"))
|
||
with sqlite3.connect(old) as conn:
|
||
tables = {r[0] for r in conn.execute(
|
||
"SELECT name FROM sqlite_master WHERE type='table'")}
|
||
assert "role_tags" in tables
|
||
|
||
|
||
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:
|
||
agent = store.save_agent("A")
|
||
store.add_company("Acme", key="acme")
|
||
store.set_affinity(agent.id, "acme", -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.
|
||
listing = {"agent": agent.id, "by_score": False}
|
||
assert [r.source_id for r in store.roles(limit=1, **listing)] == ["a2"]
|
||
assert [r.source_id for r in store.roles(limit=1, hide_muted=True, **listing)] == ["other"]
|
||
assert {r.source_id for r in store.roles(hide_muted=True, **listing)} == {"other"}
|
||
assert {r.source_id for r in store.roles(**listing)} == {"a0", "a1", "a2", "other"}
|
||
# Hidden is per agent: another agent, or no agent, hides nothing.
|
||
other = store.save_agent("B")
|
||
assert store.count_roles(hide_muted=True, agent=other.id, by_score=False) == 4
|
||
assert store.count_roles(hide_muted=True) == 4
|
||
|
||
|
||
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
|
||
agent = store.save_agent("A")
|
||
store.add_company("Other", key="other")
|
||
store.set_affinity(agent.id, "other", -1)
|
||
assert store.count_roles(hide_muted=True, agent=agent.id, by_score=False) == 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()}
|
||
agent = store.save_agent("A")
|
||
role = store.set_vote(agent.id, uid["up"], 1)
|
||
assert (role.vote, role.voted_at) == (1, clock().isoformat(timespec="seconds"))
|
||
store.set_vote(agent.id, uid["down"], -1)
|
||
store.set_vote(agent.id, uid["fine"], 0)
|
||
assert store.votes(agent.id) == {uid["up"]: 1, uid["down"]: -1, uid["fine"]: 0}
|
||
|
||
def listed(judged: str) -> list[str]:
|
||
return [r.source_id for r in store.roles(agent=agent.id, by_score=False,
|
||
judged=judged)]
|
||
|
||
assert listed("liked") == ["up"]
|
||
assert listed("passed") == ["down"]
|
||
assert listed("unjudged") == ["none"]
|
||
assert store.count_roles(agent=agent.id, by_score=False, judged="unjudged") == 1
|
||
with pytest.raises(ValueError, match="judged"):
|
||
store.roles(judged="maybe")
|
||
|
||
clock.tick()
|
||
changed = store.set_vote(agent.id, uid["up"], -1)
|
||
assert (changed.vote, changed.voted_at) == (-1, clock().isoformat(timespec="seconds"))
|
||
cleared = store.set_vote(agent.id, uid["up"], None)
|
||
assert (cleared.vote, cleared.voted_at) == (None, None)
|
||
assert store.set_vote(agent.id, uid["up"], None).vote is None # clearing twice is fine
|
||
with pytest.raises(ValueError):
|
||
store.set_vote(agent.id, uid["up"], 2)
|
||
with pytest.raises(ValueError):
|
||
store.set_vote(agent.id, uid["up"], True)
|
||
with pytest.raises(KeyError):
|
||
store.set_vote(agent.id, "nope", 1)
|
||
with pytest.raises(KeyError):
|
||
store.set_vote(999, uid["up"], 1)
|
||
|
||
|
||
def test_votes_are_per_agent(store: Store) -> None:
|
||
store.upsert_role(posting("1"))
|
||
uid = posting("1").uid
|
||
one = store.save_agent("One")
|
||
two = store.save_agent("Two")
|
||
store.set_vote(one.id, uid, 1)
|
||
|
||
assert store.role(uid, one.id).vote == 1 # type: ignore[union-attr]
|
||
assert store.role(uid, two.id).vote is None # type: ignore[union-attr]
|
||
assert store.role(uid).vote is None # type: ignore[union-attr]
|
||
assert store.votes(two.id) == {}
|
||
assert [r.vote for r in store.roles(agent=two.id, by_score=False)] == [None]
|
||
assert [r.vote for r in store.roles()] == [None]
|
||
assert [r.source_id for r in store.roles(agent=two.id, by_score=False, judged="liked")] == []
|
||
assert [r.source_id for r in store.roles(judged="liked")] == []
|
||
assert [r.source_id for r in store.roles(judged="unjudged")] == ["1"]
|
||
|
||
store.set_vote(two.id, uid, -1)
|
||
assert store.role(uid, one.id).vote == 1 # type: ignore[union-attr]
|
||
assert store.role(uid, two.id).vote == -1 # type: ignore[union-attr]
|
||
|
||
# Deleting the agent takes its votes with it and leaves the other's.
|
||
store.delete_agent(two.id)
|
||
assert store.votes(one.id) == {uid: 1}
|
||
with store.transaction() as conn:
|
||
assert conn.execute("SELECT COUNT(*) FROM role_votes").fetchone()[0] == 1
|
||
|
||
|
||
def test_roles_with_an_agent_but_not_by_score_are_newest_first_with_votes(
|
||
store: Store, clock: Clock) -> None:
|
||
for sid in ("1", "2", "3"):
|
||
store.upsert_role(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 = store.roles(agent=agent.id, by_score=False)
|
||
assert [r.source_id for r in newest] == ["3", "2", "1"]
|
||
assert [r.score for r in newest] == [None, None, None]
|
||
assert [r.vote for r in newest] == [None, None, 1]
|
||
assert store.count_roles(agent=agent.id, by_score=False) == 3
|
||
assert [r.source_id for r in store.roles(agent=agent.id)] == ["1", "2"]
|
||
|
||
|
||
def test_read_state_is_set_cleared_and_a_vote_marks_read(
|
||
store: Store, clock: Clock) -> None:
|
||
store.upsert_role(posting("1"))
|
||
uid = posting("1").uid
|
||
role = store.role(uid)
|
||
assert role is not None and role.read_at is None
|
||
|
||
read = store.set_read(uid)
|
||
assert read.read_at == clock().isoformat(timespec="seconds")
|
||
clock.tick()
|
||
again = store.set_read(uid)
|
||
assert again.read_at == read.read_at, "reading twice keeps the first stamp"
|
||
|
||
cleared = store.set_read(uid, False)
|
||
assert cleared.read_at is None
|
||
|
||
agent = store.save_agent("A")
|
||
voted = store.set_vote(agent.id, uid, 1)
|
||
assert voted.read_at is not None, "voting is reading"
|
||
stamp = voted.read_at
|
||
unvoted = store.set_vote(agent.id, uid, None)
|
||
assert unvoted.read_at == stamp, "clearing a vote is not un-reading"
|
||
|
||
with pytest.raises(KeyError):
|
||
store.set_read("nope")
|
||
|
||
|
||
def test_roles_include_read_excludes_a_read_role_before_the_limit(store: Store) -> None:
|
||
store.upsert_role(posting("1"))
|
||
store.upsert_role(posting("2"))
|
||
uid = {r.source_id: r.uid for r in store.roles()}
|
||
store.set_read(uid["1"])
|
||
|
||
assert {r.source_id for r in store.roles()} == {"1", "2"}
|
||
assert {r.source_id for r in store.roles(include_read=False)} == {"2"}
|
||
assert store.count_roles(include_read=False) == 1
|
||
|
||
|
||
def test_set_tags_normalises_dedupes_and_caps(store: Store) -> None:
|
||
store.upsert_role(posting("1"))
|
||
uid = posting("1").uid
|
||
long_tag = "x" * 50
|
||
|
||
tags = store.set_tags(uid, [" Backend Engineer ", "python", "PYTHON", "", " ",
|
||
long_tag, *[f"t{i}" for i in range(15)]])
|
||
|
||
assert tags == sorted(tags)
|
||
assert len(tags) == 12 # capped at _MAX_TAGS
|
||
assert len(set(tags)) == 12 # no repeats
|
||
assert all(len(t) <= 40 for t in tags) # cut to _MAX_TAG_LEN
|
||
assert "backend engineer" in tags and "python" in tags
|
||
role = store.role(uid)
|
||
assert role is not None and role.tags == tags # loaded sorted, with the role
|
||
|
||
with pytest.raises(KeyError):
|
||
store.set_tags("nope", ["x"])
|
||
|
||
|
||
def test_roles_filters_by_tags_any_and_all(store: Store) -> None:
|
||
store.upsert_role(posting("1"))
|
||
store.upsert_role(posting("2"))
|
||
store.upsert_role(posting("3"))
|
||
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"])
|
||
store.set_tags(uid["3"], ["go"])
|
||
|
||
assert {r.source_id for r in store.roles(tags=["python"])} == {"1", "2"}
|
||
assert {r.source_id for r in store.roles(tags=["python", "go"])} == {"1", "2", "3"}
|
||
assert {r.source_id for r in
|
||
store.roles(tags=["python", "backend"], tag_mode="all")} == {"1"}
|
||
assert store.count_roles(tags=["python"]) == 2
|
||
assert store.count_roles(tags=["python", "backend"], tag_mode="all") == 1
|
||
with pytest.raises(ValueError, match="tag_mode"):
|
||
store.roles(tags=["python"], tag_mode="maybe")
|
||
|
||
|
||
def test_tag_counts_orders_by_count_then_tag_and_respects_muted(store: Store) -> None:
|
||
store.add_company("Hidden", key="hidden")
|
||
agent = store.save_agent("A")
|
||
store.set_affinity(agent.id, "hidden", -1)
|
||
store.upsert_role(posting("1", company="Acme"))
|
||
store.upsert_role(posting("2", company="Acme"))
|
||
store.upsert_role(posting("3", company="Hidden"))
|
||
uid = {r.source_id: r.uid for r in store.roles(hide_muted=False)}
|
||
store.set_tags(uid["1"], ["python", "backend"])
|
||
store.set_tags(uid["2"], ["python"])
|
||
store.set_tags(uid["3"], ["python", "backend"])
|
||
store.set_read(uid["1"])
|
||
|
||
assert store.tag_counts(agent.id) == [("python", 2, 1), ("backend", 1, 0)]
|
||
assert store.tag_counts(agent.id, show_muted=True) == [("python", 3, 2), ("backend", 2, 1)]
|
||
assert store.tag_counts() == [("python", 3, 2), ("backend", 2, 1)] # no agent, nothing hidden
|
||
|
||
|
||
def test_scores_for_an_agent_deleted_mid_run_are_dropped_not_an_error(store: Store) -> None:
|
||
store.upsert_role(posting("a"))
|
||
uid = store.roles()[0].uid
|
||
agent = store.save_agent("A")
|
||
store.delete_agent(agent.id)
|
||
assert store.replace_scores(agent.id, [(uid, 0.9, "")]) == 0
|
||
assert store.scores(agent.id) == {}
|
||
|
||
|
||
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")
|
||
other = store.save_agent("B")
|
||
store.replace_scores(agent.id, [(uid["a"], 0.9, ""), (uid["b"], 0.5, ""),
|
||
(uid["c"], 0.4, "")])
|
||
store.replace_scores(other.id, [(uid["a"], 0.9, ""), (uid["b"], 0.5, ""),
|
||
(uid["c"], 0.4, "")])
|
||
store.set_vote(agent.id, uid["a"], -1) # 0.45
|
||
store.set_vote(agent.id, 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(agent.id, uid["a"], 1)
|
||
assert store.roles(agent=agent.id, limit=1)[0].score == 1.0
|
||
# The other agent's ranking is untouched by these votes.
|
||
assert [(r.source_id, r.score) for r in store.roles(agent=other.id)] == \
|
||
[("a", 0.9), ("b", 0.5), ("c", 0.4)]
|
||
|
||
|
||
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", status="contacted")
|
||
assert updated.status == "contacted"
|
||
with pytest.raises(ValueError, match="not a company field"):
|
||
store.update_company("acme", affinity=2)
|
||
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_affinity_is_per_agent(store: Store) -> None:
|
||
store.add_company("Acme", key="acme")
|
||
store.add_company("Other", key="other")
|
||
one = store.save_agent("One")
|
||
two = store.save_agent("Two")
|
||
|
||
assert store.set_affinity(one.id, "acme", 2).affinity == 2
|
||
assert store.company("acme", one.id).affinity == 2 # type: ignore[union-attr]
|
||
assert store.company("acme", two.id).affinity == 0 # type: ignore[union-attr]
|
||
assert store.company("acme").affinity == 0 # type: ignore[union-attr]
|
||
assert [(c.key, c.affinity) for c in store.companies(one.id)] == [("acme", 2), ("other", 0)]
|
||
assert [c.affinity for c in store.companies(two.id)] == [0, 0]
|
||
assert [c.affinity for c in store.companies()] == [0, 0]
|
||
|
||
store.set_affinity(two.id, "acme", -1)
|
||
assert store.company("acme", one.id).affinity == 2 # type: ignore[union-attr]
|
||
assert store.company("acme", two.id).affinity == -1 # type: ignore[union-attr]
|
||
|
||
# 0 deletes the row rather than keeping a neutral one.
|
||
assert store.set_affinity(one.id, "acme", 0).affinity == 0
|
||
with store.transaction() as conn:
|
||
rows = conn.execute("SELECT agent_id, company_key FROM agent_companies").fetchall()
|
||
assert [tuple(r) for r in rows] == [(two.id, "acme")]
|
||
|
||
with pytest.raises(ValueError, match="affinity"):
|
||
store.set_affinity(one.id, "acme", 5)
|
||
with pytest.raises(ValueError, match="affinity"):
|
||
store.set_affinity(one.id, "acme", True) # type: ignore[arg-type]
|
||
with pytest.raises(KeyError):
|
||
store.set_affinity(one.id, "nope", 1)
|
||
with pytest.raises(KeyError):
|
||
store.set_affinity(999, "acme", 1)
|
||
|
||
store.delete_agent(two.id)
|
||
with store.transaction() as conn:
|
||
assert conn.execute("SELECT COUNT(*) FROM agent_companies").fetchone()[0] == 0
|
||
|
||
|
||
def test_the_default_agent_is_the_lowest_enabled_id(store: Store) -> None:
|
||
assert store.default_agent() is None
|
||
off = store.save_agent("Off", enabled=False)
|
||
assert store.default_agent() == off
|
||
on = store.save_agent("On")
|
||
assert store.default_agent() == on
|
||
later = store.save_agent("Later")
|
||
assert store.default_agent() == on
|
||
store.delete_agent(on.id)
|
||
assert store.default_agent() == later
|
||
|
||
|
||
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"}
|
||
|
||
|
||
def test_set_company_board_creates_the_row_and_its_board_together(store: Store) -> None:
|
||
company, sub, closed = store.set_company_board(
|
||
"acme", "greenhouse:acme", host="greenhouse", name="Acme",
|
||
fields={"ats": "greenhouse", "ats_slug": "acme", "country": "DK"})
|
||
assert (company.name, company.ats, company.ats_slug, company.country) == (
|
||
"Acme", "greenhouse", "acme", "DK")
|
||
assert sub is not None and closed == 0
|
||
assert (sub.target, sub.label, sub.company, sub.board, sub.show) == (
|
||
"greenhouse:acme", "Acme", "Acme", "greenhouse", 1)
|
||
assert store.company_subscription("acme") == sub
|
||
assert store.company_boards() == {"acme": "greenhouse"}
|
||
|
||
|
||
def test_a_board_clash_leaves_no_company_row(store: Store) -> None:
|
||
"""The subscription insert fails on UNIQUE (source, target), and the
|
||
company row written a statement earlier goes with it."""
|
||
store.set_company_board("acme", "greenhouse:acme", host="greenhouse", name="Acme")
|
||
with pytest.raises(ValueError, match="already has 'greenhouse:acme'"):
|
||
store.set_company_board("beta", "greenhouse:acme", host="greenhouse", name="Beta")
|
||
assert store.company("beta") is None
|
||
assert [s.company for s in store.subscriptions(source="ats")] == ["Acme"]
|
||
|
||
|
||
def test_a_clash_on_replace_leaves_the_old_board_and_its_roles(store: Store) -> None:
|
||
store.set_company_board("acme", "greenhouse:acme", host="greenhouse", name="Acme")
|
||
_, beta, _ = store.set_company_board("beta", "lever:beta", host="lever", name="Beta")
|
||
assert beta is not None
|
||
store.upsert_role(posting("1", company="Beta"), beta)
|
||
with pytest.raises(ValueError):
|
||
store.set_company_board("beta", "greenhouse:acme", host="greenhouse",
|
||
fields={"ats": "greenhouse"})
|
||
assert store.company_subscription("beta") == beta
|
||
assert store.company("beta").ats == "" # type: ignore[union-attr]
|
||
assert [r.source_id for r in store.roles()] == ["1"] # still open
|
||
|
||
|
||
def test_replacing_a_board_rewrites_it_in_place_and_closes_the_old_roles(
|
||
store: Store) -> None:
|
||
_, old, _ = store.set_company_board("acme", "greenhouse:acme", host="greenhouse",
|
||
name="Acme")
|
||
assert old is not None
|
||
store.update_subscription(old.id, fetch=False, target_id="gh-1")
|
||
store.upsert_role(posting("1", company="Acme"), old)
|
||
store.upsert_role(posting("2", company="Acme"), old)
|
||
|
||
company, new, closed = store.set_company_board("acme", "ashby:acme", host="ashby",
|
||
fields={"ats": "ashby"})
|
||
assert closed == 2 and store.roles() == []
|
||
assert new is not None and new.id == old.id
|
||
assert (new.target, new.board, new.target_id, new.fetch, new.subscribed) == (
|
||
"ashby:acme", "ashby", "", 1, 1)
|
||
assert company.ats == "ashby"
|
||
# The same board again closes nothing.
|
||
store.upsert_role(posting("3", company="Acme"), new)
|
||
assert store.set_company_board("acme", "ashby:acme", host="ashby")[2] == 0
|
||
assert [r.source_id for r in store.roles()] == ["3"]
|
||
|
||
|
||
def test_detaching_a_board_hides_it_closes_its_roles_and_keeps_the_row(
|
||
store: Store) -> None:
|
||
_, sub, _ = store.set_company_board("acme", "greenhouse:acme", host="greenhouse",
|
||
name="Acme")
|
||
assert sub is not None
|
||
store.upsert_role(posting("1", company="Acme"), sub)
|
||
company, detached, closed = store.set_company_board("acme", "")
|
||
assert closed == 1 and company.key == "acme"
|
||
assert detached is not None
|
||
assert (detached.subscribed, detached.fetch, detached.show) == (0, 0, 0)
|
||
assert store.company_boards() == {}
|
||
# The next board reuses the row rather than clashing on its label.
|
||
_, again, _ = store.set_company_board("acme", "lever:acme", host="lever")
|
||
assert again is not None and again.id == sub.id and again.show == 1
|
||
with pytest.raises(KeyError):
|
||
store.set_company_board("nope", "")
|
||
|
||
|
||
# ----------------------------------------------------------- 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"]
|
||
|
||
|
||
# -------------------------------------------------- summary and posting text
|
||
|
||
def test_the_posting_text_is_stored_and_stamped(store: Store) -> None:
|
||
store.upsert_role(posting())
|
||
role = store.set_article_text(posting().uid, "The whole posting.")
|
||
assert role is not None
|
||
assert role.article_text == "The whole posting." and role.article_at == store.now()
|
||
assert store.set_article_text("nope", "x") is None
|
||
|
||
|
||
def test_a_summary_is_written_once(store: Store) -> None:
|
||
store.upsert_role(posting())
|
||
uid = posting().uid
|
||
assert store.set_summary(uid, "First.") is True
|
||
assert store.set_summary(uid, "Second.") is False
|
||
role = store.role(uid)
|
||
assert role is not None and role.summary == "First." and role.summarised_at
|
||
assert store.set_summary("nope", "x") is False
|
||
|
||
|
||
def test_a_summarys_tags_land_with_it_and_not_on_a_rejected_late_answer(
|
||
store: Store) -> None:
|
||
store.upsert_role(posting())
|
||
uid = posting().uid
|
||
assert store.set_summary(uid, "First.", ["Python", "backend"]) is True
|
||
role = store.role(uid)
|
||
assert role is not None and role.tags == ["backend", "python"]
|
||
|
||
# A second write is rejected (already summarised), and does not touch tags.
|
||
assert store.set_summary(uid, "Second.", ["go"]) is False
|
||
role = store.role(uid)
|
||
assert role is not None and role.tags == ["backend", "python"]
|
||
|
||
|
||
def test_summarise_waits_on_the_top_of_each_enabled_agent_by_its_own_limits(
|
||
store: Store) -> None:
|
||
"""Each agent contributes its own top, as deep and as low as its own
|
||
`limits` say; a closed role and a gated score are in nobody's top. A
|
||
hidden company needs no case: `score` writes no rows for it under the
|
||
agent that hid it. An agent saved before v8 has `limits` of '{}', which
|
||
reads as the defaults."""
|
||
for sid in "abcd":
|
||
store.upsert_role(posting(sid))
|
||
a, b, c, d = (posting(s).uid for s in "abcd")
|
||
with store.transaction() as conn:
|
||
conn.execute("UPDATE roles SET closed_at = ? WHERE uid = ?", (store.now(), d))
|
||
one = store.save_agent("One", limits=Limits(summarise_top=1, summarise_min=0))
|
||
two = store.save_agent("Two", limits=Limits(summarise_top=1, summarise_min=0))
|
||
store.replace_scores(one.id, [(d, 0.99, ""), (a, 0.9, ""), (b, 0.5, "")])
|
||
store.replace_scores(two.id, [(a, 0.95, "remote"), (c, 0.7, ""), (b, 0.8, "")])
|
||
|
||
assert {r.uid for r in store.summarise_waiting(10)} == {a, b}
|
||
|
||
# Two goes deeper: its second, c, joins; One's second, b, was in already.
|
||
store.save_agent("Two", agent_id=two.id, limits=Limits(summarise_top=2, summarise_min=0))
|
||
assert {r.uid for r in store.summarise_waiting(10)} == {a, b, c}
|
||
assert store.summarise_pending() == 3
|
||
assert [r.uid for r in store.summarise_waiting(10, uids=[d])] == [d]
|
||
# The floor is Two's own: c at 0.7 drops, One's b at 0.5 stays.
|
||
store.save_agent("Two", agent_id=two.id,
|
||
limits=Limits(summarise_top=2, summarise_min=0.75))
|
||
store.save_agent("One", agent_id=one.id, limits=Limits(summarise_top=2, summarise_min=0))
|
||
assert {r.uid for r in store.summarise_waiting(10)} == {a, b}
|
||
# '{}' is the defaults, 30 at 0.5: One's b at 0.5 stays, Two's c at 0.7 is back.
|
||
with store.transaction() as conn:
|
||
conn.execute("UPDATE agents SET limits = '{}'")
|
||
assert {r.uid for r in store.summarise_waiting(10)} == {a, b, c}
|
||
assert store.agents()[0].limits == Limits()
|