Provider names, the CLI's choices and the dupes rule's search hosts now come from readers.PROVIDERS, and the regions, work modes and remote words from the modules' REGIONS, MODES and REMOTE, read with getattr so main works before and after the readers merge. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
662 lines
31 KiB
Python
662 lines
31 KiB
Python
"""A company's board, set by hand, by discovery or by the seed: `set_board`
|
|
and the three ways in that go through it."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import sys
|
|
from datetime import UTC, datetime
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import pytest
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
if str(ROOT) not in sys.path:
|
|
sys.path.insert(0, str(ROOT))
|
|
|
|
import plugins.ats as ats # noqa: E402
|
|
from desk.models import Item # noqa: E402
|
|
from app.cli import main # noqa: E402
|
|
from app.jobs import sources # noqa: E402
|
|
from app.jobs.discover import Discovery # noqa: E402
|
|
from app.storage import Store # noqa: E402
|
|
|
|
|
|
@pytest.fixture
|
|
def store(tmp_path: Path) -> Store:
|
|
return Store(tmp_path / "t.db")
|
|
|
|
|
|
class Boards:
|
|
"""A fake `board_size`: `listed` maps a target to how many roles it
|
|
lists; any other target does not answer. Remembers what was sized."""
|
|
|
|
def __init__(self, **listed: int) -> None:
|
|
self.listed = {k.replace("_", ":", 1): v for k, v in listed.items()}
|
|
self.fetched: list[str] = []
|
|
|
|
def __call__(self, target: str, **kwargs: Any) -> int:
|
|
self.fetched.append(target)
|
|
if target not in self.listed:
|
|
raise OSError("connection refused")
|
|
return self.listed[target]
|
|
|
|
|
|
@pytest.fixture
|
|
def boards(monkeypatch: pytest.MonkeyPatch) -> Boards:
|
|
fake = Boards(greenhouse_acme=3, ashby_acme=2, lever_quiet=0, lever_acme=1)
|
|
monkeypatch.setattr(ats, "board_size", fake)
|
|
return fake
|
|
|
|
|
|
def posting(source_id: str) -> Item:
|
|
item = Item(source_id=source_id, location=f"https://boards.example/acme/{source_id}",
|
|
title="Backend Engineer", body="",
|
|
published_at=datetime(2026, 9, 20, tzinfo=UTC), raw={})
|
|
item.source = "ats"
|
|
return item
|
|
|
|
|
|
# --------------------------------------------------------------- set_board
|
|
|
|
def test_set_board_creates_a_company_with_its_board(store: Store, boards: Boards) -> None:
|
|
sub, roles, closed = sources.set_board(store, "acme", "greenhouse:acme", name="Acme",
|
|
domain="acme.example")
|
|
assert (sub.target, roles, closed) == ("greenhouse:acme", 3, 0)
|
|
acme = store.company("acme")
|
|
assert acme is not None
|
|
assert (acme.name, acme.ats, acme.ats_slug, acme.domain, acme.careers_url) == (
|
|
"Acme", "greenhouse", "acme", "acme.example", "https://job-boards.greenhouse.io/acme")
|
|
|
|
|
|
def test_set_board_attaches_a_board_to_a_row_without_one(store: Store, boards: Boards) -> None:
|
|
store.add_company("Acme", domain="acme.example", ats="teamtailor", ats_slug="acme",
|
|
careers_url="https://acme.example/careers", notes="met them")
|
|
sub, roles, closed = sources.set_board(store, "acme", "ashby:acme", domain="other.example")
|
|
assert (sub.target, sub.company, roles, closed) == ("ashby:acme", "Acme", 2, 0)
|
|
acme = store.company("acme")
|
|
assert acme is not None
|
|
# The board's host and slug replace what discovery found; the rest of the
|
|
# row, domain included, is not overwritten.
|
|
assert (acme.ats, acme.ats_slug, acme.domain, acme.notes, acme.careers_url) == (
|
|
"ashby", "acme", "acme.example", "met them", "https://acme.example/careers")
|
|
|
|
|
|
def test_set_board_clears_the_reason_a_company_was_read_by_hand(
|
|
store: Store, boards: Boards) -> None:
|
|
store.add_company("Acme", careers_url="https://acme.example/careers", hand_reason="unread")
|
|
sources.set_board(store, "acme", "ashby:acme")
|
|
acme = store.company("acme")
|
|
assert acme is not None
|
|
# The link a person set stays; the reason goes with the board's arrival.
|
|
assert (acme.hand_reason, acme.careers_url) == ("", "https://acme.example/careers")
|
|
|
|
|
|
def test_set_board_replaces_a_board_and_closes_its_open_roles(
|
|
store: Store, boards: Boards) -> None:
|
|
old, _, _ = sources.set_board(store, "acme", "greenhouse:acme", name="Acme")
|
|
store.upsert_role(posting("1"), old)
|
|
store.upsert_role(posting("2"), old)
|
|
|
|
new, roles, closed = sources.set_board(store, "acme", "lever:acme")
|
|
|
|
assert (new.id, new.target, roles, closed) == (old.id, "lever:acme", 1, 2)
|
|
assert store.roles() == []
|
|
acme = store.company("acme")
|
|
assert acme is not None
|
|
# careers_url was the old board's page, so it follows the board.
|
|
assert (acme.ats, acme.careers_url) == ("lever", "https://jobs.lever.co/acme")
|
|
|
|
|
|
def test_a_board_listing_nothing_is_kept(store: Store, boards: Boards) -> None:
|
|
sub, roles, _ = sources.set_board(store, "", "lever:quiet", name="Quiet")
|
|
assert (sub.target, roles) == ("lever:quiet", 0)
|
|
assert store.company("quiet") is not None
|
|
|
|
|
|
def test_a_board_that_does_not_answer_or_is_unknown_is_refused(
|
|
store: Store, boards: Boards) -> None:
|
|
with pytest.raises(ValueError, match="did not answer"):
|
|
sources.set_board(store, "", "greenhouse:gone", name="Gone")
|
|
with pytest.raises(ValueError, match="host:slug"):
|
|
sources.set_board(store, "", "taleo:gone", name="Gone")
|
|
with pytest.raises(ValueError, match="needs a name"):
|
|
sources.set_board(store, "nobody", "greenhouse:acme")
|
|
with pytest.raises(ValueError, match="is not the company"):
|
|
sources.set_board(store, "acme", "greenhouse:acme", name="Other")
|
|
assert store.companies() == [] and store.subscriptions() == []
|
|
assert boards.fetched == ["greenhouse:gone"] # the others refused before it
|
|
|
|
|
|
def test_a_board_another_company_has_leaves_nothing_written(
|
|
store: Store, boards: Boards) -> None:
|
|
sources.set_board(store, "", "greenhouse:acme", name="Acme")
|
|
with pytest.raises(ValueError, match="already has"):
|
|
sources.add_board(store, "greenhouse:acme", "Beta")
|
|
assert store.company("beta") is None
|
|
|
|
|
|
def test_detach_board_closes_its_roles_and_keeps_the_row(store: Store, boards: Boards) -> None:
|
|
sub, _, _ = sources.set_board(store, "", "greenhouse:acme", name="Acme")
|
|
store.upsert_role(posting("1"), sub)
|
|
assert sources.detach_board(store, "acme") == 1
|
|
acme = store.company("acme")
|
|
assert acme is not None and (acme.ats, acme.ats_slug) == ("greenhouse", "acme")
|
|
assert store.company_boards() == {}
|
|
with pytest.raises(ValueError, match="no board"):
|
|
sources.detach_board(store, "acme")
|
|
with pytest.raises(KeyError):
|
|
sources.detach_board(store, "nope")
|
|
|
|
|
|
# ----------------------------------------------------------- add_discovered
|
|
|
|
def test_add_discovered_sets_or_replaces_the_board_of_an_existing_company(
|
|
store: Store, boards: Boards) -> None:
|
|
store.add_company("Acme", ats="teamtailor")
|
|
key, roles = sources.add_discovered(store, "Acme", "acme.example",
|
|
Discovery(board="greenhouse:acme", ats="greenhouse"))
|
|
assert (key, roles) == ("acme", 3)
|
|
key, roles = sources.add_discovered(store, "Acme", "acme.example",
|
|
Discovery(board="ashby:acme", ats="ashby"))
|
|
assert roles == 2
|
|
assert store.company_subscription("acme").target == "ashby:acme" # type: ignore[union-attr]
|
|
assert store.company("acme").domain == "acme.example" # type: ignore[union-attr]
|
|
|
|
|
|
def test_add_discovered_records_an_unreadable_host_with_its_slug(
|
|
store: Store, boards: Boards) -> None:
|
|
found = Discovery(ats="teamtailor", ats_slug="acme",
|
|
careers_url="https://acme.example/careers")
|
|
assert sources.add_discovered(store, "Acme", "acme.example", found) == ("acme", 0)
|
|
store.update_company("acme", notes="keep")
|
|
newer = Discovery(ats="taleo", ats_slug="acme-inc",
|
|
careers_url="https://acme.example/jobs")
|
|
assert sources.add_discovered(store, "Acme", "acme.example", newer) == ("acme", 0)
|
|
acme = store.company("acme")
|
|
assert acme is not None
|
|
# The host and slug follow what discovery found last; the link, once
|
|
# there, is kept, since a person may have typed it.
|
|
assert (acme.ats, acme.ats_slug, acme.careers_url, acme.notes) == (
|
|
"taleo", "acme-inc", "https://acme.example/careers", "keep")
|
|
|
|
|
|
def test_add_discovered_fills_a_link_only_where_there_is_none(
|
|
store: Store, boards: Boards) -> None:
|
|
store.add_company("Acme", ats="teamtailor")
|
|
found = Discovery(ats="taleo", ats_slug="acme", careers_url="https://acme.example/jobs")
|
|
sources.add_discovered(store, "Acme", "acme.example", found)
|
|
assert store.company("acme").careers_url == "https://acme.example/jobs" # type: ignore[union-attr]
|
|
|
|
store.update_company("acme", careers_url="https://typed.example/by-hand")
|
|
sources.add_discovered(store, "Acme", "acme.example", found)
|
|
assert store.company("acme").careers_url == "https://typed.example/by-hand" # type: ignore[union-attr]
|
|
|
|
|
|
def test_add_discovered_keeps_a_board_when_nothing_readable_was_found(
|
|
store: Store, boards: Boards) -> None:
|
|
sources.set_board(store, "", "greenhouse:acme", name="Acme")
|
|
with pytest.raises(ValueError, match="nothing changed"):
|
|
sources.add_discovered(store, "Acme", "acme.example", Discovery(ats="taleo"))
|
|
acme = store.company("acme")
|
|
assert acme is not None and acme.ats == "greenhouse"
|
|
|
|
|
|
# --------------------------------------------------------------- the seed
|
|
|
|
def _seed(tmp_path: Path, *entries: dict[str, str]) -> Path:
|
|
path = tmp_path / "companies.json"
|
|
path.write_text(json.dumps({"companies": list(entries)}))
|
|
return path
|
|
|
|
|
|
def test_a_seed_rerun_attaches_a_board_the_seed_gained(
|
|
store: Store, boards: Boards, tmp_path: Path) -> None:
|
|
first = _seed(tmp_path,
|
|
{"name": "Acme", "domain": "acme.example", "ats": "teamtailor",
|
|
"careers_url": "https://acme.example/careers"},
|
|
{"name": "Beta", "board": "lever:beta"})
|
|
assert sources.seed_companies(store, first) == {
|
|
"added": 2, "boards": 1, "skipped": 0, "total": 2, "problems": []}
|
|
agent = store.save_agent("A")
|
|
store.set_affinity(agent.id, "acme", 2)
|
|
store.update_company("acme", notes="met them", status="contacted")
|
|
|
|
# The next seed found Acme's board, and names a new board for Beta.
|
|
later = _seed(tmp_path,
|
|
{"name": "Acme", "domain": "acme.example", "board": "ashby:acme"},
|
|
{"name": "Beta", "board": "lever:beta-new"})
|
|
assert sources.seed_companies(store, later) == {
|
|
"added": 0, "boards": 1, "skipped": 1, "total": 2, "problems": []}
|
|
|
|
assert store.company_subscription("acme").target == "ashby:acme" # type: ignore[union-attr]
|
|
acme = store.company("acme", agent.id)
|
|
assert acme is not None
|
|
assert (acme.affinity, acme.notes, acme.status, acme.ats) == (
|
|
2, "met them", "contacted", "ashby")
|
|
# A board a row already has is never replaced by the seed.
|
|
assert store.company_subscription("beta").target == "lever:beta" # type: ignore[union-attr]
|
|
# The seed's boards are not fetched: they were read when it was written.
|
|
assert boards.fetched == []
|
|
|
|
|
|
def test_a_seed_rerun_leaves_a_detached_board_detached(
|
|
store: Store, boards: Boards, tmp_path: Path) -> None:
|
|
seed = _seed(tmp_path, {"name": "Acme", "board": "greenhouse:acme"})
|
|
sources.seed_companies(store, seed)
|
|
sources.detach_board(store, "acme")
|
|
assert sources.seed_companies(store, seed)["skipped"] == 1
|
|
assert store.company_boards() == {}
|
|
|
|
|
|
def test_a_seed_board_that_clashes_still_lands_the_company(
|
|
store: Store, boards: Boards, tmp_path: Path) -> None:
|
|
seed = _seed(tmp_path, {"name": "Acme", "board": "greenhouse:acme"},
|
|
{"name": "Acme Two", "board": "greenhouse:acme", "country": "DK"})
|
|
result = sources.seed_companies(store, seed)
|
|
assert (result["added"], result["boards"]) == (2, 1)
|
|
[problem] = result["problems"]
|
|
assert problem.startswith("acme-two: another board already has 'greenhouse:acme'")
|
|
two = store.company("acme-two")
|
|
assert two is not None
|
|
assert (two.ats, two.ats_slug, two.country) == ("greenhouse", "acme", "DK")
|
|
assert store.company_subscription("acme-two") is None
|
|
|
|
|
|
def test_a_seed_rerun_fills_an_empty_link_and_reason_and_never_overwrites_one(
|
|
store: Store, boards: Boards, tmp_path: Path) -> None:
|
|
store.add_company("Bare", key="bare")
|
|
store.add_company("Typed", key="typed", careers_url="https://typed.example/by-hand",
|
|
hand_reason="blocked", notes="mine")
|
|
seed = _seed(tmp_path,
|
|
{"name": "Bare", "careers_url": "https://bare.example/jobs",
|
|
"hand_reason": "unread"},
|
|
{"name": "Typed", "careers_url": "https://seed.example/jobs",
|
|
"hand_reason": "robots"},
|
|
{"name": "Fresh", "careers_url": "https://fresh.example/jobs",
|
|
"hand_reason": "key"})
|
|
|
|
result = sources.seed_companies(store, seed)
|
|
|
|
assert (result["added"], result["skipped"], result["problems"]) == (1, 2, [])
|
|
got = {k: (c.careers_url, c.hand_reason, c.notes) for k in ("bare", "typed", "fresh")
|
|
if (c := store.company(k)) is not None}
|
|
assert got == {
|
|
"bare": ("https://bare.example/jobs", "unread", ""),
|
|
"typed": ("https://typed.example/by-hand", "blocked", "mine"),
|
|
"fresh": ("https://fresh.example/jobs", "key", "")}
|
|
# Run again, nothing moves.
|
|
assert sources.seed_companies(store, seed)["added"] == 0
|
|
assert store.company("bare").hand_reason == "unread" # type: ignore[union-attr]
|
|
|
|
|
|
def test_a_seed_reason_outside_the_vocabulary_is_a_problem_not_a_row_value(
|
|
store: Store, boards: Boards, tmp_path: Path) -> None:
|
|
result = sources.seed_companies(
|
|
store, _seed(tmp_path, {"name": "Odd", "hand_reason": "lazy"}))
|
|
assert result["problems"] == ["odd: 'lazy' is not a hand_reason; kept without it"]
|
|
assert store.company("odd").hand_reason == "" # type: ignore[union-attr]
|
|
|
|
|
|
def test_a_seed_link_reaches_a_row_whose_board_clashes(
|
|
store: Store, boards: Boards, tmp_path: Path) -> None:
|
|
sources.set_board(store, "acme", "greenhouse:acme", name="Acme")
|
|
store.add_company("Twin", key="twin")
|
|
result = sources.seed_companies(store, _seed(
|
|
tmp_path, {"name": "Twin", "board": "greenhouse:acme",
|
|
"careers_url": "https://twin.example/jobs"}))
|
|
assert len(result["problems"]) == 1
|
|
assert store.company("twin").careers_url == "https://twin.example/jobs" # type: ignore[union-attr]
|
|
|
|
|
|
# ------------------------------------------------------------- by hand
|
|
|
|
def test_a_company_added_by_hand_has_no_board_and_a_checked_link(store: Store) -> None:
|
|
company = sources.add_by_hand(store, "Revolut Ltd", careers_url=" https://r.example/jobs ",
|
|
notes="login wall")
|
|
assert (company.key, company.hand_reason, company.careers_url, company.notes) == (
|
|
"revolut", "added", "https://r.example/jobs", "login wall")
|
|
assert store.company_subscription("revolut") is None
|
|
with pytest.raises(sources.Conflict, match="on the list already"):
|
|
sources.add_by_hand(store, "REVOLUT")
|
|
for link in ("javascript:alert(1)", "r.example/jobs", "https://", "ftp://r.example"):
|
|
with pytest.raises(ValueError, match="http"):
|
|
sources.add_by_hand(store, "Other", careers_url=link)
|
|
with pytest.raises(ValueError, match="hand_reason"):
|
|
sources.add_by_hand(store, "Other", hand_reason="lazy")
|
|
with pytest.raises(ValueError, match="needs a name"):
|
|
sources.add_by_hand(store, " ")
|
|
assert [c.key for c in store.companies()] == ["revolut"]
|
|
|
|
|
|
def test_edit_company_changes_what_it_is_given_and_renames_only_without_a_board(
|
|
store: Store, boards: Boards) -> None:
|
|
sources.add_by_hand(store, "Acme", notes="old")
|
|
edited = sources.edit_company(store, "acme", name="Acme GmbH", hand_reason="gone")
|
|
assert (edited.key, edited.name, edited.notes, edited.hand_reason) == (
|
|
"acme", "Acme GmbH", "old", "gone")
|
|
with pytest.raises(ValueError, match="needs a name"):
|
|
sources.edit_company(store, "acme", name=" ")
|
|
with pytest.raises(ValueError, match="not a field"):
|
|
sources.edit_company(store, "acme", ats="lever")
|
|
with pytest.raises(KeyError):
|
|
sources.edit_company(store, "nobody", notes="x")
|
|
|
|
sources.set_board(store, "acme", "greenhouse:acme")
|
|
with pytest.raises(sources.Conflict, match="detach"):
|
|
sources.edit_company(store, "acme", name="Acme Labs")
|
|
# The name it has, and any other field, are no rename.
|
|
assert sources.edit_company(store, "acme", name="Acme GmbH", notes="new").notes == "new"
|
|
sources.detach_board(store, "acme")
|
|
with pytest.raises(sources.Conflict):
|
|
sources.edit_company(store, "acme", name="Acme Labs")
|
|
|
|
|
|
def test_remove_company_refuses_a_board_shown_and_open_roles(
|
|
store: Store, boards: Boards) -> None:
|
|
agent = store.save_agent("A")
|
|
sources.add_by_hand(store, "Hand")
|
|
store.set_affinity(agent.id, "hand", 2)
|
|
sources.remove_company(store, "hand")
|
|
assert store.company("hand") is None
|
|
assert store.company("hand", agent.id) is None
|
|
with pytest.raises(KeyError):
|
|
sources.remove_company(store, "hand")
|
|
|
|
sub, _found, _closed = sources.set_board(store, "acme", "greenhouse:acme", name="Acme")
|
|
with pytest.raises(sources.Conflict, match="detach the board"):
|
|
sources.remove_company(store, "acme")
|
|
store.upsert_role(posting("1"), sub)
|
|
sources.detach_board(store, "acme") # closes the role: no board, none open
|
|
sources.remove_company(store, "acme")
|
|
assert store.company("acme") is None
|
|
# The detached subscription stays and is found again by a company of that name.
|
|
assert store.company_subscription("acme") is not None
|
|
|
|
store.add_company("Open", key="open")
|
|
other = store.add_subscription("search", "jobindex:x", label="x", board="jobindex")
|
|
item = posting("2")
|
|
item.raw = {"company": "Open"}
|
|
store.upsert_role(item, other)
|
|
with pytest.raises(ValueError, match="open roles"):
|
|
sources.remove_company(store, "open")
|
|
|
|
|
|
def test_by_hand_lists_the_unboarded_never_opened_first(
|
|
store: Store, boards: Boards) -> None:
|
|
sources.add_by_hand(store, "Zeta")
|
|
sources.add_by_hand(store, "Beta")
|
|
sources.add_by_hand(store, "Old")
|
|
sources.add_by_hand(store, "Recent")
|
|
store.update_company("old", careers_opened_at="2026-08-01T00:00:00+00:00")
|
|
store.update_company("recent", careers_opened_at="2026-09-20T00:00:00+00:00")
|
|
sources.set_board(store, "read", "greenhouse:acme", name="Read") # a board: not listed
|
|
store.add_company("Pleo", key="pleo", ats="teamtailor") # unread, no reason: listed
|
|
store.add_company("Quiet", key="quiet") # from a search only
|
|
sources.set_board(store, "gone", "ashby:acme", name="Gone")
|
|
sources.detach_board(store, "gone") # detached: listed
|
|
|
|
assert [c.key for c in sources.by_hand(store)] == [
|
|
"beta", "gone", "pleo", "zeta", "old", "recent"]
|
|
|
|
|
|
# -------------------------------------------------------------------- CLI
|
|
|
|
def _cli(tmp_path: Path, *argv: str) -> int:
|
|
config = tmp_path / "config.yaml"
|
|
if not config.exists():
|
|
config.write_text(f"database: {tmp_path / 't.db'}\n")
|
|
return main(["-c", str(config), "companies", *argv])
|
|
|
|
|
|
def test_cli_set_board_attaches_and_replaces(
|
|
store: Store, boards: Boards, tmp_path: Path,
|
|
capsys: pytest.CaptureFixture[str]) -> None:
|
|
store.add_company("Acme", ats="teamtailor")
|
|
assert _cli(tmp_path, "set-board", "acme", "greenhouse:acme") == 0
|
|
assert json.loads(capsys.readouterr().out) == {
|
|
"key": "acme", "board": "greenhouse:acme", "roles": 3, "closed": 0}
|
|
assert _cli(tmp_path, "set-board", "acme", "lever:acme") == 0
|
|
assert json.loads(capsys.readouterr().out)["board"] == "lever:acme"
|
|
assert _cli(tmp_path, "set-board", "nobody", "lever:acme") == 1
|
|
assert "no company 'nobody'" in capsys.readouterr().err
|
|
assert _cli(tmp_path, "detach", "acme") == 0
|
|
assert json.loads(capsys.readouterr().out) == {"key": "acme", "closed": 0}
|
|
|
|
|
|
def test_cli_discover_add_updates_an_existing_company(
|
|
store: Store, boards: Boards, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
|
|
capsys: pytest.CaptureFixture[str]) -> None:
|
|
from app.jobs import discover
|
|
|
|
store.add_company("Acme", ats="teamtailor")
|
|
monkeypatch.setattr(discover, "discover",
|
|
lambda name, domain: Discovery(board="ashby:acme", ats="ashby",
|
|
ats_slug="acme"))
|
|
assert _cli(tmp_path, "discover", "Acme", "acme.example", "--add") == 0
|
|
out = json.loads(capsys.readouterr().out)
|
|
assert (out["key"], out["board"], out["roles"]) == ("acme", "ashby:acme", 2)
|
|
assert store.company_subscription("acme").target == "ashby:acme" # type: ignore[union-attr]
|
|
|
|
|
|
def test_cli_seed_prints_counts_and_problems(
|
|
store: Store, boards: Boards, tmp_path: Path,
|
|
capsys: pytest.CaptureFixture[str]) -> None:
|
|
seed = _seed(tmp_path, {"name": "Odd", "board": "nosuch:odd"})
|
|
assert _cli(tmp_path, "seed", "--path", str(seed)) == 0
|
|
captured = capsys.readouterr()
|
|
assert json.loads(captured.out) == {"added": 1, "boards": 0, "skipped": 0, "total": 1}
|
|
assert "companies seed: odd: 'nosuch:odd' is not a known board" in captured.err
|
|
|
|
|
|
def test_cli_add_with_one_name_lists_a_company_by_hand_and_with_two_follows_a_board(
|
|
store: Store, boards: Boards, tmp_path: Path,
|
|
capsys: pytest.CaptureFixture[str]) -> None:
|
|
assert _cli(tmp_path, "add", "Revolut", "--careers-url", "https://r.example/jobs",
|
|
"--note", "login wall") == 0
|
|
assert json.loads(capsys.readouterr().out) == {"key": "revolut", "hand_reason": "added"}
|
|
revolut = store.company("revolut")
|
|
assert revolut is not None
|
|
assert (revolut.careers_url, revolut.notes, revolut.hand_reason) == (
|
|
"https://r.example/jobs", "login wall", "added")
|
|
assert _cli(tmp_path, "add", "Meta", "--reason", "blocked") == 0
|
|
assert store.company("meta").hand_reason == "blocked" # type: ignore[union-attr]
|
|
capsys.readouterr()
|
|
|
|
assert _cli(tmp_path, "add", "Revolut") == 1
|
|
assert "on the list already" in capsys.readouterr().err
|
|
assert _cli(tmp_path, "add", "Odd", "--careers-url", "javascript:alert(1)") == 1
|
|
assert "http" in capsys.readouterr().err
|
|
with pytest.raises(SystemExit): # argparse refuses the reason
|
|
_cli(tmp_path, "add", "Odd", "--reason", "lazy")
|
|
capsys.readouterr()
|
|
assert store.company("odd") is None
|
|
|
|
# Two words are the board and the company, as before.
|
|
assert _cli(tmp_path, "add", "greenhouse:acme", "Acme") == 0
|
|
assert json.loads(capsys.readouterr().out) == {
|
|
"key": "acme", "board": "greenhouse:acme", "roles": 3}
|
|
|
|
|
|
def test_cli_edit_checked_and_remove_a_company_by_hand(
|
|
store: Store, boards: Boards, tmp_path: Path,
|
|
capsys: pytest.CaptureFixture[str]) -> None:
|
|
store.add_company("Acme", key="acme", notes="keep", hand_reason="unread")
|
|
assert _cli(tmp_path, "edit", "acme", "--careers-url", "https://acme.example/jobs",
|
|
"--reason", "robots") == 0
|
|
assert json.loads(capsys.readouterr().out) == {
|
|
"key": "acme", "name": "Acme", "careers_url": "https://acme.example/jobs",
|
|
"notes": "keep", "hand_reason": "robots"}
|
|
assert _cli(tmp_path, "edit", "acme", "--note", "") == 0
|
|
assert store.company("acme").notes == "" # type: ignore[union-attr]
|
|
assert _cli(tmp_path, "edit", "acme", "--careers-url", "ftp://x") == 1
|
|
assert "http" in capsys.readouterr().err
|
|
assert _cli(tmp_path, "edit", "nobody", "--note", "x") == 1
|
|
assert "no company 'nobody'" in capsys.readouterr().err
|
|
|
|
assert _cli(tmp_path, "checked", "acme") == 0
|
|
stamp = json.loads(capsys.readouterr().out)["careers_opened_at"]
|
|
assert stamp and store.company("acme").careers_opened_at == stamp # type: ignore[union-attr]
|
|
assert _cli(tmp_path, "checked", "nobody") == 1
|
|
capsys.readouterr()
|
|
|
|
sources.set_board(store, "read", "greenhouse:acme", name="Read")
|
|
assert _cli(tmp_path, "remove", "read") == 1
|
|
assert "detach the board first" in capsys.readouterr().err
|
|
assert _cli(tmp_path, "remove", "acme") == 0
|
|
assert store.company("acme") is None
|
|
assert _cli(tmp_path, "remove", "acme") == 1
|
|
|
|
|
|
def test_cli_by_hand_prints_never_opened_first_then_the_oldest_and_the_watch_rating(
|
|
store: Store, boards: Boards, tmp_path: Path,
|
|
capsys: pytest.CaptureFixture[str]) -> None:
|
|
store.add_company("Recent", careers_url="https://recent.example/jobs",
|
|
hand_reason="gone")
|
|
store.add_company("Old", hand_reason="robots")
|
|
store.add_company("Never", careers_url="https://never.example/jobs", hand_reason="added")
|
|
store.update_company("recent", careers_opened_at="2026-09-20T08:00:00+00:00", watch=0)
|
|
store.update_company("old", careers_opened_at="2026-08-01T08:00:00+00:00", watch=1)
|
|
sources.set_board(store, "read", "greenhouse:acme", name="Read")
|
|
|
|
assert _cli(tmp_path, "by-hand") == 0
|
|
lines = capsys.readouterr().out.splitlines()
|
|
assert [ln.split()[0] for ln in lines[:-1]] == ["Never", "Old", "Recent"]
|
|
assert lines[0].split() == ["Never", "added", "-", "never", "https://never.example/jobs"]
|
|
assert lines[1].split() == ["Old", "robots", "yes", "2026-08-01"]
|
|
assert lines[2].split() == ["Recent", "gone", "no", "2026-09-20",
|
|
"https://recent.example/jobs"]
|
|
assert lines[-1] == "3 by hand"
|
|
|
|
|
|
def test_replacing_or_detaching_a_board_forgets_that_it_was_failing(
|
|
store: Store, boards: Boards) -> None:
|
|
from app.jobs.pull import FAILING, failing_boards
|
|
|
|
sources.set_board(store, "acme", "greenhouse:acme", name="Acme")
|
|
store.state[FAILING + "greenhouse:acme"] = '{"since": "2026-09-01T00:00:00+00:00", "reason": "404 Not Found"}'
|
|
assert "greenhouse:acme" in failing_boards(store)
|
|
|
|
sources.set_board(store, "acme", "ashby:acme")
|
|
assert failing_boards(store) == {}
|
|
|
|
store.state[FAILING + "ashby:acme"] = '{"since": "2026-09-01T00:00:00+00:00", "reason": "timeout"}'
|
|
sources.detach_board(store, "acme")
|
|
assert failing_boards(store) == {}
|
|
|
|
|
|
def test_replacing_or_detaching_a_board_forgets_its_robots_and_detail_records(
|
|
store: Store, boards: Boards) -> None:
|
|
kept = ("ats:robots:", "ats:detailed:", "ats:detailfailed:")
|
|
sources.set_board(store, "acme", "greenhouse:acme", name="Acme")
|
|
for key in kept:
|
|
store.state[key + "greenhouse:acme"] = "[]"
|
|
store.state["ats:robots:lever:other"] = "{}"
|
|
|
|
sources.set_board(store, "acme", "ashby:acme")
|
|
assert not any(key + "greenhouse:acme" in store.state for key in kept)
|
|
assert "ats:robots:lever:other" in store.state
|
|
|
|
for key in kept:
|
|
store.state[key + "ashby:acme"] = "[]"
|
|
sources.detach_board(store, "acme")
|
|
assert not any(key + "ashby:acme" in store.state for key in kept)
|
|
|
|
|
|
def test_search_params_keeps_only_what_the_provider_reads() -> None:
|
|
assert sources.search_params("jobindex", " python ", area=1, region="CaRE_1nn_cSU") == {
|
|
"q": "python", "area": 1}
|
|
assert sources.search_params("platsbanken", "data", area=1, country="de") == {
|
|
"q": "data", "region": ""}
|
|
assert sources.search_params("platsbanken", "data", region=" CaRE_1nn_cSU ", pages=3) == {
|
|
"q": "data", "region": "CaRE_1nn_cSU", "pages": 3}
|
|
|
|
|
|
def test_the_providers_and_their_params_follow_the_reader_declarations() -> None:
|
|
from plugins import readers
|
|
|
|
assert tuple(readers.PROVIDERS)[:3] == ("jobindex", "adzuna", "platsbanken")
|
|
assert sources.search_params("adzuna", " backend ", country=" DE ", where=" Berlin ",
|
|
area=1, region="x", pages=2) == {
|
|
"q": "backend", "country": "de", "where": "Berlin", "pages": 2}
|
|
with pytest.raises(ValueError, match="country"):
|
|
sources.search_params("adzuna", "backend", country="dk")
|
|
|
|
|
|
def test_search_params_refuses_a_region_that_is_no_swedish_lan() -> None:
|
|
with pytest.raises(ValueError, match="region"):
|
|
sources.search_params("platsbanken", "data", region="zYpL_aGk_QY8") # Midland
|
|
with pytest.raises(ValueError, match="provider"):
|
|
sources.search_params("indeed", "data")
|
|
|
|
|
|
def test_search_params_of_the_three_newer_providers_follow_their_declarations(
|
|
search_stubs: dict[str, Any]) -> None:
|
|
assert sources.search_params("freehire", " head of data ", country=" DK,se ",
|
|
remote="remote", area=1, region="x", pages=2) == {
|
|
"q": "head of data", "country": "dk,se", "remote": "remote", "pages": 2}
|
|
assert sources.search_params("jobnet", "data", region="Midtjylland", country="dk",
|
|
remote="remote") == {"q": "data", "region": "Midtjylland"}
|
|
assert sources.search_params("jobbank", "data", region="2", remote="helt") == {
|
|
"q": "data", "region": "2", "remote": "helt"}
|
|
with pytest.raises(ValueError, match="region"):
|
|
sources.search_params("jobnet", "data", region="Fyn")
|
|
with pytest.raises(ValueError, match="remote"):
|
|
sources.search_params("freehire", "data", remote="helt")
|
|
|
|
|
|
def test_the_provider_error_lists_the_loaded_readers(search_stubs: dict[str, Any]) -> None:
|
|
with pytest.raises(ValueError, match=r"freehire.*jobnet.*jobbank"):
|
|
sources.search_params("indeed", "data")
|
|
|
|
|
|
def test_a_provider_table_is_empty_for_a_reader_that_is_not_loaded(
|
|
search_stubs: dict[str, Any], monkeypatch: pytest.MonkeyPatch) -> None:
|
|
from plugins import readers
|
|
|
|
assert sources.provider_table("jobbank", "REMOTE") == {
|
|
"helt": "Fully remote", "delvist": "Partly remote"}
|
|
assert sources.provider_table("freehire", "REGIONS") == {} # it declares none
|
|
monkeypatch.delitem(readers.PROVIDERS, "jobbank")
|
|
assert sources.provider_table("jobbank", "REGIONS") == {}
|
|
assert sources.provider_table("nobody", "MODES") == {}
|
|
|
|
|
|
def test_cli_searches_add_takes_the_newer_providers_and_their_flags(
|
|
search_stubs: dict[str, Any], store: Store, tmp_path: Path,
|
|
monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
|
|
monkeypatch.setattr(sources, "try_search", lambda config, provider, name, params: (
|
|
[{"title": "Data lead", "company": "Acme", "place": "København",
|
|
"url": "https://x.example/1"}], True))
|
|
config = tmp_path / "config.yaml"
|
|
config.write_text(f"database: {store.path}\n")
|
|
|
|
def add(*argv: str) -> int:
|
|
return main(["-c", str(config), "searches", "add", *argv])
|
|
|
|
assert add("freehire", "Head of data", "--q", "head of data", "--country", "DK,SE",
|
|
"--remote", "hybrid") == 0
|
|
assert add("jobnet", "Data science", "--q", "data science", "--region",
|
|
"HovedstadenOgBornholm") == 0
|
|
assert add("jobbank", "Data director", "--q", "data director", "--region", "2",
|
|
"--remote", "delvist") == 0
|
|
capsys.readouterr()
|
|
saved = {s.board: s.params for s in store.subscriptions(source="search")}
|
|
assert saved == {
|
|
"freehire": {"q": "head of data", "country": "dk,se", "remote": "hybrid"},
|
|
"jobnet": {"q": "data science", "region": "HovedstadenOgBornholm"},
|
|
"jobbank": {"q": "data director", "region": "2", "remote": "delvist"}}
|
|
assert add("jobnet", "Bad", "--q", "x", "--region", "Fyn") == 1
|
|
assert "region" in capsys.readouterr().err
|
|
|
|
|
|
def test_cli_searches_add_help_names_the_regions_and_work_modes(
|
|
search_stubs: dict[str, Any], capsys: pytest.CaptureFixture[str]) -> None:
|
|
with pytest.raises(SystemExit):
|
|
main(["searches", "add", "-h"])
|
|
text = " ".join(capsys.readouterr().out.split())
|
|
assert "freehire" in text and "jobnet" in text and "jobbank" in text
|
|
assert "HovedstadenOgBornholm" in text and "2 Storkøbenhavn" in text
|
|
assert "hybrid Hybrid" in text and "helt Fully remote" in text
|