From 2a0f7fe0c393ad597096d61e65bc1674717ac0db Mon Sep 17 00:00:00 2001 From: Wolf Date: Wed, 30 Sep 2026 16:00:06 +0200 Subject: [PATCH] Test the remote area with the live boards' place texts Co-Authored-By: Claude Opus 5.5 --- tests/test_remote.py | 533 +++++++++++++++++++++++++++++++++++++++++++ tests/test_web.py | 2 +- 2 files changed, 534 insertions(+), 1 deletion(-) create mode 100644 tests/test_remote.py diff --git a/tests/test_remote.py b/tests/test_remote.py new file mode 100644 index 0000000..32ba4a6 --- /dev/null +++ b/tests/test_remote.py @@ -0,0 +1,533 @@ +"""Where a remote role may be worked from: the `remote:` tokens, a remote +role's area in prep, the chips and gates that read it, the model's answer and +migration 27. The place texts are the live boards' (docs/plan-remote.md).""" + +from __future__ import annotations + +import json +import sqlite3 +from collections.abc import Iterator +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +import pytest + +from desk.models import Item +from app import places, prep +from app.jobs import extract, reach +from app.models import Agent, Gate +from app.places import Gazetteer, label, known, parse, seed, suggest +from app.prep import words +from app.storage import Store + +#: The require gate on country of the owner's agent: the EU, the EEA, the +#: UK, Switzerland and `EU`. +EUROPE = ["AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IE", + "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE", "IS", + "LI", "NO", "GB", "CH", "EU"] + + +def gazetteer() -> Gazetteer: + """The seeded gazetteer, as a fresh file holds it.""" + seeds, includes = seed() + ids = {(s.kind, s.key): n for n, s in enumerate(seeds, 1)} + return Gazetteer([(ids[(s.kind, s.key)], s.kind, s.key, s.name, + ids[s.parent] if s.parent else None) for s in seeds], + [(a, ids[(s.kind, s.key)]) for s in seeds for a in s.aliases], + [(ids[w], ids[p]) for w, p in includes]) + + +GAZ = gazetteer() + + +def names(ids: Any) -> list[str]: + return [GAZ.places[p].name for p in ids] + + +# ------------------------------------------------------------------ tokens + +@pytest.mark.parametrize(("token", "shown", "text"), [ + ("remote:country:DK", "Remote · Denmark", "remote:country:DK"), + ("remote:country:dk", "Remote · Denmark", "remote:country:DK"), + ("remote:country:EU", "Remote · Europe", "remote:country:EU"), + ("remote:region:oresund", "Remote · Øresund", "remote:region:oresund"), + ("remote:place:berlin", "Remote · Berlin", "remote:place:berlin"), + ("remote:anywhere", "Remote · anywhere", "remote:anywhere"), + ("remote:worldwide", "Remote · anywhere", "remote:anywhere"), + ("remote:any", "Remote", "remote:any"), +]) +def test_a_remote_token_reads_its_place_token(token: str, shown: str, text: str) -> None: + assert label(token) == shown + assert str(parse(token)) == text + assert known(token) + + +def test_a_remote_token_of_nothing_is_not_known() -> None: + for token in ("remote:", "remote:country:ZZ", "remote:region:atlantis", + "remote:remote:country:DK"): + assert not known(token), token + + +def test_a_remote_token_is_answered_by_the_areas_only() -> None: + assert places.match_sql("remote:country:DK") == ("0", []) + assert not places.matches("remote denmark", "DK", "remote:country:DK") + + +@pytest.mark.parametrize(("text", "expected"), [ + ("Sweden (Remote)", ["Sweden"]), # Grafana + ("Remote - US", ["United States"]), + ("Home Based - EMEA", ["Europe"]), + ("Home Based - Worldwide", ["Anywhere"]), # Canonical + ("Remote, Global", ["Anywhere"]), + ("Distributed, Global", ["Anywhere"]), + ("Cardiff, London or Remote (UK)", ["United Kingdom"]), + ("Anywhere in France, Belgium, Spain", ["France", "Belgium", "Spain"]), + ("Remote", []), + ("Global HQ, Berlin", []), + ("Berlin", []), + ("Hybrid, Berlin", []), +]) +def test_the_parts_that_say_remote_name_the_area(text: str, expected: list[str]) -> None: + assert names(GAZ.remote_places(text)) == expected + + +def test_anywhere_is_no_place_of_a_role() -> None: + assert GAZ.resolve("Worldwide") == () and GAZ.resolve("Anywhere") == () + assert names(GAZ.resolve("Global HQ, Berlin")) == ["Berlin"] + assert GAZ.under((GAZ.anywhere,)) == {GAZ.anywhere} + + +def test_denmarks_overlap_is_what_lies_in_it_what_it_lies_in_and_anywhere() -> None: + denmark = GAZ.by_key[("country", "DK")] + found = GAZ.overlap((denmark,)) + for key in (("continent", "europe"), ("region", "oresund"), ("region", "hovedstaden"), + ("city", "copenhagen"), places.ANYWHERE): + assert GAZ.by_key[key] in found, key + for key in (("country", "US"), ("country", "SE"), ("region", "skane")): + assert GAZ.by_key[key] not in found, key + + +def test_a_remote_line_is_no_town() -> None: + lines = [("USA (Remote)", "US", 70), ("Remote US", "US", 60), ("Germany (Remote)", "DE", 61), + ("Remote Germany", "DE", 14), ("Remote - Berlin", "DE", 3), ("Berlin", "DE", 80)] + for q in ("usa", "remote", "germ", "berl"): + assert [s.label for s in suggest(q, lines) if s.kind == "place"] \ + == (["Berlin"] if q == "berl" else []), q + assert places.towns("USA (Remote)") == frozenset() + + +# ---------------------------------------------------------------- the words + +def test_remote_sensing_in_a_title_is_no_remote_work() -> None: + for title in ("Senior Sea Ice Scientist with Experience on Remote Sensing", + "Remote Control Engineer", "Remote-controlled Systems Lead", + "Remote Monitoring Specialist"): + assert words.remote("jobindex", None, (), "København Ø", title=title) == "", title + assert words.remote("jobindex", None, (), "Aarhus", title="Developer - Remote") == "remote" + + +# ------------------------------------------------------------------ the area + +@pytest.fixture +def store(tmp_path: Path) -> Iterator[Store]: + yield Store(tmp_path / "roledesk.db") + + +def posting(source_id: str, place: str = "", *, board: str = "greenhouse", + **raw: Any) -> Item: + item = Item(source_id=f"{board}:{source_id}", location=f"https://boards.example/{source_id}", + title="Backend Engineer", body="", published_at=datetime(2026, 9, 20, tzinfo=UTC), + raw={"board": board, "company": "Acme"} | ({"place": place} if place else {}) + | raw) + item.source = "ats" + return item + + +def add(store: Store, source_id: str, place: str = "", **raw: Any) -> str: + item = posting(source_id, place, **raw) + store.upsert_role(item) + return item.uid + + +#: One role per case of the plan, by what it stands for. +LINES: dict[str, tuple[str, dict[str, Any]]] = { + "grafana": ("Sweden (Remote)", {}), + "canonical": ("Home Based - EMEA; Home Based - Worldwide", {}), + "databricks": ("Denmark", {"remote": True}), + "airtame": ("København, Hovedstaden, Denmark; Remote", {}), + "europe": ("Remote - Europe", {}), + "germany": ("Germany (Remote)", {}), + "us": ("Remote US", {}), + "plain": ("Remote", {}), + "berlin": ("Global HQ, Berlin", {"remote": True}), + "hybrid": ("Hybrid, Copenhagen", {}), + "office": ("Copenhagen", {}), +} + + +@pytest.fixture +def roles(store: Store) -> dict[str, str]: + found = {key: add(store, key, line, **raw) for key, (line, raw) in LINES.items()} + prep.run(store, dupes=False) + return found + + +def area(store: Store, uid: str) -> tuple[str, str]: + role = store.role(uid) + assert role is not None + return role.remote, role.remote_where + + +def test_each_remote_role_gets_the_area_its_places_say(store: Store, + roles: dict[str, str]) -> None: + assert {key: area(store, uid) for key, uid in roles.items()} == { + "grafana": ("remote", "Sweden"), + "canonical": ("remote", "anywhere"), # EMEA and worldwide is worldwide + "databricks": ("remote", "Denmark"), # the host's flag and the place + "airtame": ("remote", "Denmark"), # an office town, read as its country + "europe": ("remote", "Europe"), + "germany": ("remote", "Germany"), + "us": ("remote", "United States"), + "plain": ("remote", ""), # remote, area not stated + "berlin": ("remote", "Germany"), + "hybrid": ("hybrid", ""), + "office": ("", ""), + } + role = store.role(roles["berlin"]) + assert role is not None and [p.name for p in role.places] == ["Berlin"] + + +def test_the_rows_carry_the_area(store: Store, roles: dict[str, str]) -> None: + rows = {r.uid: r.remote_where for r in store.roles_page(limit=100)} + assert rows[roles["canonical"]] == "anywhere" and rows[roles["plain"]] == "" + listed = {r.uid: r.remote_where for r in store.roles(limit=100, by_score=False)} + assert listed == rows + + +def test_many_places_read_as_their_countries(store: Store) -> None: + uid = add(store, "komma", "Bayern (Remote); Hessen (Remote); Sachsen (Remote); " + "Saarland (Remote); Dänemark (Remote)") + prep.run(store, dupes=False) + assert area(store, uid) == ("remote", "Germany, Denmark") + + +def uids(store: Store, *tokens: str, agent: int | None = None) -> set[str]: + return {r.uid for r in store.roles(limit=1000, places=list(tokens), agent=agent, + by_score=False)} + + +def pick(roles: dict[str, str], *keys: str) -> set[str]: + return {roles[k] for k in keys} + + +def test_remote_denmark_is_every_remote_role_open_to_someone_in_denmark( + store: Store, roles: dict[str, str]) -> None: + assert uids(store, "remote:country:DK") == pick( + roles, "canonical", "databricks", "airtame", "europe") + assert uids(store, "remote:region:hovedstaden") == uids(store, "remote:country:DK") + + +def test_remote_europe_is_every_remote_role_in_europe(store: Store, + roles: dict[str, str]) -> None: + assert uids(store, "remote:country:EU") == pick( + roles, "grafana", "canonical", "databricks", "airtame", "europe", "germany", "berlin") + assert uids(store, "remote:country:SE") == pick( + roles, "grafana", "canonical", "europe") # Sweden, anywhere, Europe + + +def test_remote_anywhere_is_only_anywhere(store: Store, roles: dict[str, str]) -> None: + assert uids(store, "remote:anywhere") == pick(roles, "canonical") + assert uids(store, "remote:country:US") == pick(roles, "canonical", "us") + + +def test_remote_chips_or_with_the_place_chips(store: Store, roles: dict[str, str]) -> None: + assert uids(store, "remote:anywhere", "place:copenhagen") == pick( + roles, "canonical", "airtame", "hybrid", "office") + + +def test_remote_any_keeps_the_agents_scope(store: Store, roles: dict[str, str]) -> None: + remote = pick(roles, "grafana", "canonical", "databricks", "airtame", "europe", "germany", + "us", "plain", "berlin") + assert uids(store, "remote:any") == remote + agent = store.save_agent("Europe", "python backend", [ + Gate(field="country", values=EUROPE, mode="require")]) + assert uids(store, "remote:any", agent=agent.id) == remote - pick(roles, "us") + wide = store.save_agent("Anywhere", "python backend", [ + Gate(field="country", values=["DK", "SE"], mode="any")]) + assert uids(store, "remote:any", agent=wide.id) == remote + + +def states(store: Store, *gates: Gate) -> dict[str, list[int]]: + agent = store.save_agent(f"gates {len(store.agents())}", "python backend", list(gates)) + return {c.uid: c.gates for c in store.score_candidates(agent.id, list(gates))} + + +def test_remote_from_is_met_as_the_chip_is_and_empty_without_an_area( + store: Store, roles: dict[str, str]) -> None: + found = states(store, Gate(field="remote_from", values=["country:DK"], mode="any"), + Gate(field="remote_from", values=["anywhere"], mode="any")) + by_key = {key: found[uid] for key, uid in roles.items()} + assert by_key == { + "grafana": [0, 0], "canonical": [1, 1], "databricks": [1, 0], "airtame": [1, 0], + "europe": [1, 0], "germany": [0, 0], "us": [0, 0], + "plain": [-1, -1], # remote, area not stated: neither + "berlin": [0, 0], + "hybrid": [0, 0], # evidence: not remote + "office": [-1, -1], # remote unknown + } + + +def test_a_require_gate_on_europe_reads_a_remote_role_through_its_area( + store: Store, roles: dict[str, str]) -> None: + found = states(store, Gate(field="country", values=EUROPE, mode="require")) + by_key = {key: found[uid][0] for key, uid in roles.items()} + assert by_key["canonical"] == 1 # Home Based - Worldwide + assert by_key["germany"] == 1 + assert by_key["europe"] == 1 + assert by_key["plain"] == -1 # "Remote" alone: kept, extract reads it + assert by_key["us"] == 0 # Remote US + assert by_key["office"] == 1 and by_key["hybrid"] == 1 + + +def test_anywhere_aliased_by_hand_is_no_place_for_the_country_gate(store: Store) -> None: + uid = add(store, "ww", "Hybrid, Worldwide") + anywhere = store.gazetteer().anywhere + assert anywhere is not None + store.add_place_alias("Worldwide", anywhere) + prep.run(store, dupes=False) + assert [p.name for p in store.role_places(uid)] == ["Anywhere"] + assert area(store, uid) == ("hybrid", "") + found = states(store, Gate(field="country", values=EUROPE, mode="require")) + assert found[uid] == [-1] + + +def test_the_owners_agent_keeps_remote_roles_open_to_europe_and_drops_remote_us( + store: Store, roles: dict[str, str]) -> None: + from app.jobs.score import failed_gates + + gates = [Gate(field="country", values=EUROPE, mode="require"), + Gate(field="country", values=["DK", "SE"], mode="any"), + Gate(field="remote", values=["remote"], mode="any")] + agent = store.save_agent("Owner", "python backend", gates) + kept = {c.uid for c in store.score_candidates(agent.id, gates) if not failed_gates(c, gates)} + assert pick(roles, "canonical", "germany", "europe", "plain") <= kept + assert roles["us"] not in kept + + +# ------------------------------------------------------------ the model's say + +def test_the_models_remote_wins_and_its_names_are_the_area(store: Store) -> None: + # Black Forest Labs: Ashby says OnSite, the text offers remote work with + # an office week a month. + uid = add(store, "bfl", "Freiburg, Germany", board="ashby", remote="OnSite") + prep.run(store, dupes=False) + assert area(store, uid) == ("onsite", "") + + store.set_extracted(uid, {"remote": "remote", "remote_where": []}) + prep.run_roles(store, [uid]) + assert area(store, uid) == ("remote", "Germany") + + store.set_extracted(uid, {"remote": "remote", "remote_where": ["Europe"]}) + prep.run_roles(store, [uid]) + assert area(store, uid) == ("remote", "Europe") + # A later pull leaves the model's answer standing. + store.upsert_role(posting("bfl", "Freiburg, Germany", board="ashby", remote="OnSite")) + prep.run(store, dupes=False) + assert area(store, uid) == ("remote", "Europe") + + +def test_set_extracted_writes_the_remote_answer_outright(store: Store) -> None: + uid = add(store, "1", "Berlin") + prep.run(store, dupes=False) + store.set_extracted(uid, {"remote": "remote", "remote_where": ["anywhere"]}) + row = store._row("SELECT remote_model, remote_where_model, prep_due FROM roles WHERE uid=?", + (uid,)) + assert row is not None + assert (row["remote_model"], json.loads(row["remote_where_model"]), row["prep_due"]) == \ + ("remote", ["anywhere"], 1) + store.set_extracted(uid, {}) + row = store._row("SELECT remote_model, remote_where_model FROM roles WHERE uid=?", (uid,)) + assert row is not None and (row["remote_model"], row["remote_where_model"]) == ("", "[]") + + +@pytest.fixture +def config(tmp_path: Path) -> Any: + from app.config import Config + + return Config(database=str(tmp_path / "roledesk.db"), extract={"enabled": True}) + + +def test_extract_reads_the_area_once_more_and_maps_the_role_before_the_rescore( + store: Store, config: Any, monkeypatch: pytest.MonkeyPatch) -> None: + from desk import modeltask + from desk.tools import agent as desk_agent + + uid = add(store, "1", "Freiburg, Germany", board="ashby", remote="OnSite") + prep.run(store, dupes=False) + agent = store.save_agent("Backend", "python backend") + store.replace_scores(agent.id, [(uid, 1.0, "")]) + with store.transaction() as conn: + conn.execute("UPDATE roles SET extracted_at = '2026-09-22T00:00:00+00:00', " + "seniority_model = 'senior' WHERE uid = ?", (uid,)) + assert [r.uid for r in store.extract_waiting(10)] == [uid] # never asked where + + def reply(settings: Any, **kwargs: Any) -> desk_agent.Reply: + [one] = kwargs["question"]["roles"] + return desk_agent.Reply(data={"roles": [{ + "uid": one["uid"], "place": "", "country": "", "remote": "remote", + "remote_where": ["Denmark", "Sweden"], "seniority": "senior", "salary_min": None, + "salary_max": None, "currency": "", "function": "", "permit": "", + "languages_required": []}]}, backend="api") + + monkeypatch.setattr(desk_agent, "backend", lambda settings: "api") + monkeypatch.setattr(desk_agent, "ask_json", reply) + modeltask.run(extract.TASK, config, store) + + assert area(store, uid) == ("remote", "Denmark, Sweden") + assert store.extract_waiting(10) == [] + + +def test_the_prompt_asks_where_a_remote_hire_may_live() -> None: + props = extract.SCHEMA["properties"]["roles"]["items"] + assert "remote_where" in props["required"] + assert props["properties"]["remote_where"]["type"] == "array" + assert "office week" in extract.SYSTEM and "remote_where" in extract.SYSTEM + got = extract.fields({"remote": "remote", "remote_where": [" Europe ", "", "Europe", 3]}) + assert (got["remote"], got["remote_where"]) == ("remote", ["Europe", "3"]) + + +# ------------------------------------------------------------- suggestions + +def test_remote_is_suggested_after_remote_any_and_before_the_regions( + store: Store, roles: dict[str, str]) -> None: + gaz = store.gazetteer() + areas = store.open_remote_areas() + + def shown(q: str) -> list[tuple[str, str, str, int]]: + return [(s.kind, s.token, s.label, s.count) + for s in suggest(q, store.open_places(), 20, remote=areas, gaz=gaz, + remote_any=lambda: 9)] + + found = shown("remote") + assert found[0] == ("remote", "remote:any", "Remote", 9) + tokens = [t for _, t, _, _ in found] + assert "remote:country:EU" in tokens and "remote:country:US" in tokens + assert "remote:anywhere" not in tokens + assert all(kind == "remote" for kind, _, _, _ in found) + assert ("remote", "remote:country:EU", "Remote · Europe", 7) in found + + found = shown("denm") + assert found[:2] == [("country", "country:DK", "Denmark", 4), + ("remote", "remote:country:DK", "Remote · Denmark", 4)] + assert shown("remote den")[:2] == [("remote", "remote:any", "Remote", 9), + ("remote", "remote:country:DK", "Remote · Denmark", 4)] + assert shown("re") == [t for t in shown("re") if t[1] != "remote:any"] + + +def test_a_suggested_remote_token_finds_the_roles_it_counted( + store: Store, roles: dict[str, str]) -> None: + gaz = store.gazetteer() + for s in suggest("remote", store.open_places(), 50, remote=store.open_remote_areas(), + gaz=gaz): + assert label(s.token) == s.label + assert len(uids(store, s.token)) == s.count, s.token + + +def test_the_api_suggests_labels_and_filters_the_remote_tokens(tmp_path: Path) -> None: + from fastapi.testclient import TestClient + + from app.config import Config, ServerConfig + from app.main import create_app + + app = create_app(Config(server=ServerConfig(host="127.0.0.1", port=0), + database=tmp_path / "roledesk.db")) + store: Store = app.state.store + for key in ("europe", "us", "plain"): + line, raw = LINES[key] + add(store, key, line, **raw) + prep.run(store, dupes=False) + agent = store.save_agent("Europe", "python backend", [ + Gate(field="country", values=EUROPE, mode="require")]) + with TestClient(app) as client: + found = client.get("/api/suggest/places", params={"q": "remote"}).json() + assert found[0] == {"token": "remote:any", "label": "Remote", "kind": "remote", + "count": 2} + assert {"token": "remote:country:EU", "label": "Remote · Europe", "kind": "remote", + "count": 1} in found + other = client.get("/api/suggest/places", params={"q": "remote", "agent": agent.id}) + assert other.json()[0]["count"] == 2 + labels = client.get("/api/places/labels", params=[ + ("tokens", "remote:country:DK"), ("tokens", "remote:anywhere"), + ("tokens", "remote:country:ZZ")]).json() + assert labels == [{"token": "remote:country:DK", "label": "Remote · Denmark"}, + {"token": "remote:anywhere", "label": "Remote · anywhere"}] + rows = client.get("/api/roles", params={"places": "remote:country:DK"}).json() + assert [r["remote_where"] for r in rows["items"]] == ["Europe"] + assert client.get("/api/roles", params={"places": "remote:country:ZZ"}).status_code \ + == 422 + + +# ------------------------------------------------------------------ reach + +def test_remote_from_is_remote_reach_and_never_widens_the_require_reach() -> None: + gaz = GAZ + near = Gate(field="remote_from", values=["country:DK"], mode="any") + assert reach.gate_reach(near, gaz) == reach.Reach(remote=True) + owner = Agent(id=2, name="Owner", created_at="2026-09-30", gates=[ + Gate(field="country", values=EUROPE, mode="require"), + Gate(field="country", values=["DK", "SE"], mode="any"), near, + Gate(field="remote_from", values=["country:DK"], mode="require")]) + assert reach.any_reach(owner, gaz) == reach.Reach(frozenset({"DK", "SE"}), remote=True) + wide = reach.require_reach(owner, gaz) + assert not wide.everywhere and not wide.remote and "DE" in wide.countries + + +# --------------------------------------------------------------- migration + +def test_migration_27_keeps_an_older_readers_remote_as_the_hosts_word(tmp_path: Path) -> None: + path = tmp_path / "old.db" + store = Store(path) + board = add(store, "board", "Ireland") + search = Item(source_id="jobindex:1", location="https://jobindex.example/1", + title="Scientist with Experience on Remote Sensing", + body="", published_at=datetime(2026, 9, 20, tzinfo=UTC), + raw={"provider": "jobindex", "place": "København Ø", "remote": None}) + search.source = "search" + store.upsert_role(search) + with sqlite3.connect(path) as conn: + conn.execute("UPDATE roles SET remote = 'remote', remote_host = '' WHERE uid = ?", + (board,)) + conn.execute("UPDATE roles SET remote = 'remote', remote_host = 'remote' " + "WHERE uid = ?", (search.uid,)) + conn.execute("DROP INDEX idx_role_remote_place") + conn.execute("DROP TABLE role_remote") + conn.execute("ALTER TABLE roles DROP COLUMN remote_model") + conn.execute("ALTER TABLE roles DROP COLUMN remote_where_model") + conn.execute("DELETE FROM places WHERE kind = 'continent' AND key = 'world'") + conn.execute("PRAGMA user_version = 26") + + migrated = Store(path) + + assert migrated.migrations_applied == [27] + assert migrated.gazetteer().anywhere is not None + row = migrated._row("SELECT remote_host, remote_model, remote_where_model FROM roles " + "WHERE uid = ?", (board,)) + assert row is not None and tuple(row) == ("remote", "", None) + prep.run(migrated, dupes=False) + assert area(migrated, board) == ("remote", "Ireland") + assert area(migrated, search.uid) == ("", "") + with sqlite3.connect(path) as conn: + conn.execute("PRAGMA user_version = 26") + assert Store(path).migrations_applied == [27] + + +def test_a_role_waits_for_extract_until_it_was_asked_where(store: Store) -> None: + uid = add(store, "1", "Berlin") + prep.run(store, dupes=False) + with store.transaction() as conn: + conn.execute("UPDATE roles SET extracted_at = '2026-09-22', seniority_model = 'mid' " + "WHERE uid = ?", (uid,)) + assert [r.uid for r in store.extract_waiting(5, [uid])] == [uid] + store.set_extracted(uid, {"seniority": "mid"}) + assert store.extract_waiting(5, [uid]) == [] diff --git a/tests/test_web.py b/tests/test_web.py index 5864863..f78a01b 100644 --- a/tests/test_web.py +++ b/tests/test_web.py @@ -1226,7 +1226,7 @@ def test_list_roles_serves_the_row_projection_and_not_the_big_columns( "uid", "company_key", "company", "title", "place", "country", "remote", "function", "seniority", "salary_min", "salary_max", "currency", "salary_text", "salary_state", "original_url", "posting_url", "posted_at", "score", "gated_reason", "prompt", "vote", - "voted_at", "read_at", "tags", "excerpt", "copies", + "voted_at", "read_at", "tags", "excerpt", "copies", "remote_where", } assert row["uid"] == uid assert row["company"] == "Acme" and row["place"] == "Berlin, Germany"