From 06eb929eaf246c24fb334d7ca569491ee85c61ed Mon Sep 17 00:00:00 2001 From: Wolf Date: Wed, 30 Sep 2026 11:07:07 +0200 Subject: [PATCH] Readers oracle to workday and the providers hand on the host's words; their word tables move to app/prep/hosts Co-Authored-By: Claude Opus 5.5 --- app/prep/hosts/oracle.py | 5 +++ app/prep/hosts/personio.py | 11 +++++ app/prep/hosts/phenom.py | 5 +++ app/prep/hosts/pinpoint.py | 12 ++++++ app/prep/hosts/recruitee.py | 15 +++++++ app/prep/hosts/rippling.py | 8 ++++ app/prep/hosts/smartrecruiters.py | 11 +++++ app/prep/hosts/teamtailor.py | 7 ++++ app/prep/hosts/workable.py | 8 ++++ app/prep/hosts/workday.py | 10 +++++ plugins/readers/adzuna.py | 3 +- plugins/readers/jobindex.py | 7 +--- plugins/readers/oracle.py | 26 ++++-------- plugins/readers/personio.py | 39 +++++------------- plugins/readers/phenom.py | 7 ++-- plugins/readers/pinpoint.py | 30 ++------------ plugins/readers/platsbanken.py | 10 ++--- plugins/readers/recruitee.py | 51 ++++-------------------- plugins/readers/rippling.py | 22 ++-------- plugins/readers/smartrecruiters.py | 30 ++++---------- plugins/readers/successfactors.py | 22 ++-------- plugins/readers/teamtailor.py | 8 +--- plugins/readers/workable.py | 31 +++++--------- plugins/readers/workday.py | 48 +++++++++------------- tests/test_ats.py | 13 +++--- tests/test_ats_oracle.py | 10 ++--- tests/test_ats_personio.py | 24 +++-------- tests/test_ats_phenom.py | 2 +- tests/test_ats_pinpoint.py | 7 +--- tests/test_ats_recruitee.py | 34 +++++----------- tests/test_ats_rippling.py | 24 +++++------ tests/test_ats_smartrecruiters.py | 28 +++---------- tests/test_ats_successfactors.py | 16 ++------ tests/test_ats_workable.py | 14 ++----- tests/test_ats_workday.py | 21 +++++----- tests/test_prep_hosts_oracle.py | 12 ++++++ tests/test_prep_hosts_personio.py | 22 ++++++++++ tests/test_prep_hosts_phenom.py | 12 ++++++ tests/test_prep_hosts_pinpoint.py | 24 +++++++++++ tests/test_prep_hosts_recruitee.py | 27 +++++++++++++ tests/test_prep_hosts_rippling.py | 19 +++++++++ tests/test_prep_hosts_smartrecruiters.py | 22 ++++++++++ tests/test_prep_hosts_teamtailor.py | 14 +++++++ tests/test_prep_hosts_workable.py | 18 +++++++++ tests/test_prep_hosts_workday.py | 21 ++++++++++ tests/test_readers_adzuna.py | 2 +- tests/test_readers_platsbanken.py | 4 +- tests/test_readers_shared.py | 32 +++++++++++++++ 48 files changed, 460 insertions(+), 388 deletions(-) create mode 100644 app/prep/hosts/oracle.py create mode 100644 app/prep/hosts/personio.py create mode 100644 app/prep/hosts/phenom.py create mode 100644 app/prep/hosts/pinpoint.py create mode 100644 app/prep/hosts/recruitee.py create mode 100644 app/prep/hosts/rippling.py create mode 100644 app/prep/hosts/smartrecruiters.py create mode 100644 app/prep/hosts/teamtailor.py create mode 100644 app/prep/hosts/workable.py create mode 100644 app/prep/hosts/workday.py create mode 100644 tests/test_prep_hosts_oracle.py create mode 100644 tests/test_prep_hosts_personio.py create mode 100644 tests/test_prep_hosts_phenom.py create mode 100644 tests/test_prep_hosts_pinpoint.py create mode 100644 tests/test_prep_hosts_recruitee.py create mode 100644 tests/test_prep_hosts_rippling.py create mode 100644 tests/test_prep_hosts_smartrecruiters.py create mode 100644 tests/test_prep_hosts_teamtailor.py create mode 100644 tests/test_prep_hosts_workable.py create mode 100644 tests/test_prep_hosts_workday.py diff --git a/app/prep/hosts/oracle.py b/app/prep/hosts/oracle.py new file mode 100644 index 0000000..05ac9f4 --- /dev/null +++ b/app/prep/hosts/oracle.py @@ -0,0 +1,5 @@ +"""Oracle Recruiting Cloud's words, for prep.""" + +#: `WorkplaceTypeCode` -> `REMOTE`'s words. A role that states none has an +#: empty code, which stays unknown. +REMOTE = {"ora_remote": "remote", "ora_hybrid": "hybrid", "ora_on_site": "onsite"} diff --git a/app/prep/hosts/personio.py b/app/prep/hosts/personio.py new file mode 100644 index 0000000..62bb864 --- /dev/null +++ b/app/prep/hosts/personio.py @@ -0,0 +1,11 @@ +"""Personio's words, for prep.""" + +#: `seniority`. `experienced` is what most roles say and names no level. +SENIORITY = {"entry-level": "junior", "student": "intern", "executive": "exec", + "experienced": ""} + +#: `employment` is the feed's `employmentType`, or, for a `permanent` one +#: (which says nothing about the hours), its `schedule`. +EMPLOYMENT = {"temporary": "temporary", "freelance": "contract", "intern": "internship", + "working_student": "internship", "trainee": "internship", + "permanent": "", "full-time": "full_time", "part-time": "part_time"} diff --git a/app/prep/hosts/phenom.py b/app/prep/hosts/phenom.py new file mode 100644 index 0000000..01873c3 --- /dev/null +++ b/app/prep/hosts/phenom.py @@ -0,0 +1,5 @@ +"""Phenom's words, for prep.""" + +#: The words a page's `checkRemote` says (King's pages say "On-site"; no +#: other was seen). +REMOTE = {"remote": "remote", "hybrid": "hybrid", "on-site": "onsite", "onsite": "onsite"} diff --git a/app/prep/hosts/pinpoint.py b/app/prep/hosts/pinpoint.py new file mode 100644 index 0000000..44889a7 --- /dev/null +++ b/app/prep/hosts/pinpoint.py @@ -0,0 +1,12 @@ +"""Pinpoint's words, for prep.""" + +#: `workplace_type`. Anything else says nothing. +REMOTE = {"onsite": "onsite", "on_site": "onsite", "hybrid": "hybrid", "remote": "remote"} + +#: What `employment_type` (`permanent_full_time`, `fixed_term_full_time`) +#: says, matched by fragment: the first fragment found in the lowercased +#: word decides, so a contract type beats the hours. The fixtures hold two +#: whole words only, so this is not turned into a whole-word table. +MATCH = [("intern", "internship"), ("freelance", "contract"), ("contract", "contract"), + ("fixed_term", "temporary"), ("temporary", "temporary"), + ("part_time", "part_time"), ("full_time", "full_time")] diff --git a/app/prep/hosts/recruitee.py b/app/prep/hosts/recruitee.py new file mode 100644 index 0000000..d302831 --- /dev/null +++ b/app/prep/hosts/recruitee.py @@ -0,0 +1,15 @@ +"""Recruitee's words, for prep.""" + +#: `experience_code`. `experienced` names no level and is known, so it maps +#: to none. +SENIORITY = {"student_school": "intern", "entry_level": "junior", "mid_level": "mid", + "experienced": ""} + +#: The words of `employment_type_code` (`fulltime_permanent`), which is +#: lowercased and split at "_" and "-"; the first entry found among its words +#: decides, so a contract type beats the hours. The fixtures hold three whole +#: codes only, so this is a table of words, not whole codes. +MATCH = [("internship", "internship"), ("intern", "internship"), + ("freelance", "contract"), ("contract", "contract"), + ("temporary", "temporary"), ("fixed", "temporary"), + ("parttime", "part_time"), ("fulltime", "full_time")] diff --git a/app/prep/hosts/rippling.py b/app/prep/hosts/rippling.py new file mode 100644 index 0000000..6c42ff6 --- /dev/null +++ b/app/prep/hosts/rippling.py @@ -0,0 +1,8 @@ +"""Rippling's words, for prep.""" + +#: The words of `employmentType.label` (`SALARIED_FT`), which is split at +#: "_" and the first token found here decides. The fixtures hold one whole +#: label only, so this is a table of tokens (lowercased), not whole words. +MATCH = [("ft", "full_time"), ("pt", "part_time"), ("intern", "internship"), + ("internship", "internship"), ("contract", "contract"), ("contractor", "contract"), + ("temp", "temporary"), ("temporary", "temporary"), ("seasonal", "temporary")] diff --git a/app/prep/hosts/smartrecruiters.py b/app/prep/hosts/smartrecruiters.py new file mode 100644 index 0000000..0306623 --- /dev/null +++ b/app/prep/hosts/smartrecruiters.py @@ -0,0 +1,11 @@ +"""SmartRecruiters' words, for prep.""" + +#: `experienceLevel.id`. The three in the middle name no level ("associate" is +#: half of Bosch's roles) and are known, so they map to none. +SENIORITY = {"internship": "intern", "entry_level": "junior", "director": "director", + "executive": "exec", "associate": "", "mid_senior_level": "", + "not_applicable": ""} + +#: `typeOfEmployment.id`. +EMPLOYMENT = {"permanent": "", "intern": "internship", "temporary": "temporary", + "contract": "contract", "part_time": "part_time", "full_time": "full_time"} diff --git a/app/prep/hosts/teamtailor.py b/app/prep/hosts/teamtailor.py new file mode 100644 index 0000000..d28997e --- /dev/null +++ b/app/prep/hosts/teamtailor.py @@ -0,0 +1,7 @@ +"""Teamtailor's words, for prep.""" + +#: `remoteStatus`. `none` says nothing about where the role is worked and +#: `temporary` is remote for a spell only, so both are known and stay +#: unknown rather than become "onsite" or "remote". +REMOTE = {"fully": "remote", "hybrid": "hybrid", "onsite": "onsite", + "none": "", "temporary": ""} diff --git a/app/prep/hosts/workable.py b/app/prep/hosts/workable.py new file mode 100644 index 0000000..d18eccb --- /dev/null +++ b/app/prep/hosts/workable.py @@ -0,0 +1,8 @@ +"""Workable's words, for prep.""" + +#: `workplace`. +REMOTE = {"remote": "remote", "hybrid": "hybrid", "on_site": "onsite"} + +#: `type`. +EMPLOYMENT = {"full": "full_time", "part": "part_time", "contract": "contract", + "temporary": "temporary", "internship": "internship"} diff --git a/app/prep/hosts/workday.py b/app/prep/hosts/workday.py new file mode 100644 index 0000000..75e2adb --- /dev/null +++ b/app/prep/hosts/workday.py @@ -0,0 +1,10 @@ +"""Workday's words, for prep.""" + +#: `remoteType`. Only some tenants send it, and each words it its own way +#: (Zendesk's "Fully Flexible", Axis' "On-Site"); a word not listed, a bare +#: "No" among them, says nothing and stays unknown. +REMOTE = {"remote": "remote", "fully flexible": "remote", "hybrid": "hybrid", + "in office": "onsite", "on-site": "onsite", "onsite": "onsite"} + +#: `timeType`. +EMPLOYMENT = {"full time": "full_time", "part time": "part_time"} diff --git a/plugins/readers/adzuna.py b/plugins/readers/adzuna.py index afb0ba2..19780a5 100644 --- a/plugins/readers/adzuna.py +++ b/plugins/readers/adzuna.py @@ -24,7 +24,7 @@ from urllib.parse import urlencode from desk.sources import strip_html from ._contract import Ask, Fields, Filters, Key, Place, Reads -from ._shared import Get, Page, Row, is_web_url, only, parse_dt, remote_word +from ._shared import Get, Page, Row, is_web_url, only, parse_dt NAME = "adzuna" LABEL = "Adzuna" @@ -124,7 +124,6 @@ def rows(decoded: Any, slug: str) -> list[Row]: "places": places, "location": town, "country": country.upper(), - "remote": remote_word(title), "posted": parse_dt(job.get("created")), "teaser": _text(job.get("description") or ""), "salary_min": None if predicted else job.get("salary_min"), diff --git a/plugins/readers/jobindex.py b/plugins/readers/jobindex.py index 0dd6da9..c7bb7ce 100644 --- a/plugins/readers/jobindex.py +++ b/plugins/readers/jobindex.py @@ -28,7 +28,7 @@ from urllib.parse import urlencode from desk.sources import strip_html -from ._shared import Get, Page, Row, is_web_url, only, parse_dt, remote_word +from ._shared import Get, Page, Row, is_web_url, only, parse_dt, place from ._contract import Ask, Fields, Filters, Place, Reads NAME = "jobindex" @@ -131,9 +131,7 @@ def rows(decoded: Any, slug: str) -> list[Row]: company = full_title[len(title) + 2:].strip() area = _AREA.search(description) town = _text(area.group(1)) if area else decoded["area"] - remote = remote_word(f"{town} {title}") - places: list[Place] = [{"text": town, "remote": True if remote == "remote" else None}] \ - if town else [] + places: list[Place] = [place(town)] if town else [] out.append({ "source_id": item["id"], "title": title or full_title, @@ -142,7 +140,6 @@ def rows(decoded: Any, slug: str) -> list[Row]: "places": places, "location": town, "country": "DK", - "remote": remote, "posted": parse_dt(item["published"]), "teaser": " ".join(_text(p) for p in _PARAGRAPHS.findall(description)), }) diff --git a/plugins/readers/oracle.py b/plugins/readers/oracle.py index 9ac97eb..739a6c3 100644 --- a/plugins/readers/oracle.py +++ b/plugins/readers/oracle.py @@ -35,7 +35,7 @@ from desk.sources import strip_html from ._contract import Ask, Fields, Filters, Place, Reads from ._countries import NAMES, code_of -from ._shared import Get, Page, Row, add_place, country_if_single, only, parse_dt +from ._shared import Get, Page, Row, add_place, only, parse_dt NAME = "oracle" LABEL = "Oracle Recruiting Cloud" @@ -55,7 +55,7 @@ PATTERNS = ( READS = Reads( scope="board", listing="paged", page_size=200, text="detail", teaser=True, complete="stated", places="many", filters=Filters(country="ids", remote="one"), - fields=Fields(posted="trusted", remote="stated", country="stated"), + fields=Fields(posted="trusted", remote="stated"), robots=("read: robots.txt allows /hcmUI/CandidateExperience/en/sites//jobs " "(checked 2026-09-29)"), ) @@ -71,11 +71,6 @@ PAGE_SIZE = 200 _HOST = r"[a-z0-9-]+(?:\.[a-z0-9-]+)*\.oraclecloud\.(?:com|eu)" _SLUG = re.compile(rf"({_HOST})/([A-Za-z0-9_-]+)", re.IGNORECASE) -#: `WorkplaceTypeCode` -> `store._remote`'s words. A role that states none -#: has an empty code, which stays unknown. -_REMOTE = {"ora_remote": "remote", "ora_hybrid": "hybrid", "ora_on_site": "onsite"} - - def _parts(slug: str) -> tuple[str, str]: """`(host, site number)` of a slug that passed `slug_ok`.""" host, _, site = slug.partition("/") @@ -189,18 +184,14 @@ def rows(search: dict[str, Any], slug: str) -> list[Row]: # The id goes into a URL, and a listing is external content. if not title or not re.fullmatch(r"[A-Za-z0-9_-]+", role_id): continue - remote = _REMOTE.get(_text(role.get("WorkplaceTypeCode")).lower()) + remote = _text(role.get("WorkplaceTypeCode")) or None + at_office = (remote or "").lower() in ("ora_hybrid", "ora_on_site") places: list[Place] = [] - codes: set[str] = set() secondary = [s for s in role.get("secondaryLocations") or [] if isinstance(s, dict)] - for name, code in ((_text(role.get("PrimaryLocation")), - _text(role.get("PrimaryLocationCountry"))), - *((_text(s.get("Name")), _text(s.get("CountryCode"))) - for s in secondary)): - add_place(places, {"text": name, "remote": {"remote": True, "hybrid": False, - "onsite": False}.get(remote or "")}) - if code: - codes.add(code.upper()) + for name in (_text(role.get("PrimaryLocation")), + *(_text(s.get("Name")) for s in secondary)): + add_place(places, {"text": name, "remote": ( + True if (remote or "").lower() == "ora_remote" else False if at_office else None)}) out.append({ "source_id": role_id, "title": title, @@ -212,7 +203,6 @@ def rows(search: dict[str, Any], slug: str) -> list[Row]: or _text(role.get("Department")) or _text(role.get("Organization"))), "description": "", "teaser": _plain(role.get("ShortDescriptionStr")), - "country": country_if_single(codes), "remote": remote, "salary_text": "", # the resource states no pay }) diff --git a/plugins/readers/personio.py b/plugins/readers/personio.py index 6476768..8768f13 100644 --- a/plugins/readers/personio.py +++ b/plugins/readers/personio.py @@ -7,16 +7,13 @@ Personio. from __future__ import annotations -import logging import xml.etree.ElementTree as ET from collections.abc import Callable from desk.sources import strip_html from ._contract import Ask, Fields, Place, Reads -from ._shared import Row, add_place, label_slug_ok, num, only, parse_dt, pay_line, place, table_word, yearly_amount - -log = logging.getLogger(__name__) +from ._shared import Row, add_place, label_slug_ok, num, only, parse_dt, pay_line, place, yearly_amount NAME = "personio" LABEL = "Personio" @@ -30,19 +27,6 @@ READS = Reads( robots="api: no robots.txt check needed (public board API), 2026-09-30", ) -#: `seniority` -> the app's levels. `experienced` is what most roles say and -#: names no level, so it is known and maps to none; a word not listed is -#: logged at debug level so the table can grow. -_SENIORITY = {"entry-level": "junior", "student": "intern", "executive": "exec", - "experienced": ""} - -#: `employmentType` when it is not the usual permanent contract, to the app's -#: employment words; `permanent` says nothing about the hours, so `schedule` -#: decides then. -_CONTRACT = {"temporary": "temporary", "freelance": "contract", "intern": "internship", - "working_student": "internship", "trainee": "internship"} -_SCHEDULE = {"full-time": "full_time", "part-time": "part_time"} - #: Personio's `salaryInformation/type` spellings, to the plain period word #: `pay_line` wants ("yearly" -> "year"). Anything else is passed through. _PERIODS = {"yearly": "year", "monthly": "month", "hourly": "hour", @@ -85,18 +69,14 @@ def _salary_text(salary_info: ET.Element) -> str: salary_info.findtext("currencyCode"), period) -def _seniority(word: str) -> str | None: - return table_word(_SENIORITY, word, log, "seniority") - - def _employment(position: ET.Element) -> str | None: - contract = (position.findtext("employmentType") or "").strip().lower() - schedule = (position.findtext("schedule") or "").strip().lower() - if contract in _CONTRACT: - return _CONTRACT[contract] - if contract and contract != "permanent": - log.debug("personio: unknown employmentType %r", contract) - return _SCHEDULE.get(schedule) + """The host's word for the contract, or, for a `permanent` one (which says + nothing about the hours), the `schedule`.""" + contract = (position.findtext("employmentType") or "").strip() + schedule = (position.findtext("schedule") or "").strip() + if contract.lower() in ("", "permanent") and schedule: + return schedule + return contract or None def _places(position: ET.Element) -> list[Place]: @@ -148,8 +128,7 @@ def parse(body: bytes, slug: str) -> list[Row]: "posted": parse_dt(position.findtext("createdAt")), "department": (position.findtext("department") or "").strip(), "description": strip_html(description), - "remote": any(p["remote"] for p in places) or None, - "seniority": _seniority(position.findtext("seniority") or ""), + "seniority": (position.findtext("seniority") or "").strip() or None, "employment": _employment(position), "salary_text": salary_text, "salary_min": salary_min, diff --git a/plugins/readers/phenom.py b/plugins/readers/phenom.py index 1c62876..a08f717 100644 --- a/plugins/readers/phenom.py +++ b/plugins/readers/phenom.py @@ -188,10 +188,9 @@ def rows(search: dict[str, Any], slug: str) -> list[Row]: _JSON_LD = re.compile(r"]+application/ld\+json[^>]*>(.*?)", re.S | re.I) -#: Where a page assigns its state, and the words its `checkRemote` says that -#: `store._remote` reads (King's pages say "On-site"; no other was seen). +#: Where a page assigns its state. Its `checkRemote` says "On-site" on King's +#: pages; no other word was seen. _STATE = "phApp.ddo = " -_REMOTE = {"remote": "remote", "hybrid": "hybrid", "on-site": "onsite", "onsite": "onsite"} def _job_posting(body: str) -> dict[str, Any]: @@ -243,6 +242,6 @@ def detail(get: Get, slug: str, row: Row) -> dict[str, Any]: raise ValueError("no description on the role's page") if posted := parse_dt(posting.get("datePosted")): out["posted"] = posted - if remote := _REMOTE.get(_text(job.get("checkRemote")).lower()): + if remote := _text(job.get("checkRemote")): out["remote"] = remote return out diff --git a/plugins/readers/pinpoint.py b/plugins/readers/pinpoint.py index 15cf6e3..f59fef9 100644 --- a/plugins/readers/pinpoint.py +++ b/plugins/readers/pinpoint.py @@ -18,7 +18,6 @@ from __future__ import annotations import html import json -import logging from collections.abc import Callable from typing import Any @@ -27,8 +26,6 @@ from desk.sources import strip_html from ._contract import Ask, Fields, Reads from ._shared import Row, is_web_url, label_slug_ok, num, only, pay_line, yearly_amount -log = logging.getLogger(__name__) - NAME = "pinpoint" LABEL = "Pinpoint" PATTERNS = (r"https?://([a-z0-9-]+)\.pinpointhq\.com",) @@ -39,9 +36,6 @@ READS = Reads( robots="read: robots.txt allows / (checked 2026-09-29)", ) -#: `workplace_type` -> `store._remote`'s words. Anything else says nothing. -_REMOTE = {"onsite": "onsite", "on_site": "onsite", "hybrid": "hybrid", "remote": "remote"} - #: `compensation_frequency` -> the multiplier that makes a figure yearly. The #: spellings are a guess, since no board read so far states pay; a frequency #: not listed leaves the yearly columns empty, and `salary_text` still says it. @@ -51,12 +45,6 @@ _YEARLY = {"annually": 1, "annual": 1, "yearly": 1, "year": 1, "monthly": 12, "m _PERIOD = {"annually": "year", "annual": "year", "yearly": "year", "monthly": "month", "weekly": "week", "daily": "day", "hourly": "hour"} -#: What `employment_type` (`permanent_full_time`, `fixed_term_full_time`) says, -#: the first fragment found deciding, so a contract type beats the hours. -_EMPLOYMENT = (("intern", "internship"), ("freelance", "contract"), ("contract", "contract"), - ("fixed_term", "temporary"), ("temporary", "temporary"), - ("part_time", "part_time"), ("full_time", "full_time")) - #: The sections of a posting's text, in the order the page shows them: the #: description, then these fields, each with its own heading in `_header`. _SECTIONS = ("key_responsibilities", "skills_knowledge_expertise", "benefits") @@ -112,16 +100,6 @@ def _place(location: dict[str, Any]) -> str: return ", ".join(parts) -def _employment(code: str) -> str | None: - code = code.strip().lower() - for fragment, value in _EMPLOYMENT: - if fragment in code: - return value - if code: - log.debug("pinpoint: unknown employment_type %r", code) - return None - - def _pay(j: dict[str, Any]) -> tuple[int | None, int | None, str, str]: """`(salary_min, salary_max, currency, salary_text)` of a posting whose pay is shown (`compensation_visible`); the free-text `compensation` is the @@ -154,21 +132,21 @@ def parse(body: bytes, slug: str) -> list[Row]: continue job = j.get("job") or {} low, high, currency, salary_text = _pay(j) - workplace = str(j.get("workplace_type") or "").strip().lower() + workplace = str(j.get("workplace_type") or "").strip() place = _place(j.get("location") or {}) out.append({ "source_id": source_id, "title": title, "places": [{"text": place, "remote": {"remote": True, "onsite": False, - "on_site": False, "hybrid": False}.get(workplace)}] + "on_site": False, "hybrid": False}.get(workplace.lower())}] if place else [], "location": place, "url": url, "posted": None, # only the posting's own page has a date "department": str((job.get("department") or {}).get("name") or "").strip(), "description": _text(j), - "remote": _REMOTE.get(workplace), - "employment": _employment(str(j.get("employment_type") or "")), + "remote": workplace or None, + "employment": str(j.get("employment_type") or "").strip() or None, "salary_text": salary_text, "salary_min": low, "salary_max": high, diff --git a/plugins/readers/platsbanken.py b/plugins/readers/platsbanken.py index 48fd6ff..c876266 100644 --- a/plugins/readers/platsbanken.py +++ b/plugins/readers/platsbanken.py @@ -7,8 +7,8 @@ Checked live on 2026-09-29 and 2026-09-30, moved here from `plugins/search.py`. above 2000 is refused, so a search reads 2,100 results at most. It states `total`. A hit has the whole ad's text, so the list has the full text. An ad may name several workplaces: `workplace_addresses` holds one entry each, and -every one is a place of the role. `workplace_model` is mostly empty, so -`remote` comes from the headline and the model together. +every one is a place of the role. `workplace_model` is mostly empty; its +label is passed on as `remote`, in the host's words. """ from __future__ import annotations @@ -22,7 +22,7 @@ from urllib.parse import urlencode from desk.sources import strip_html from ._contract import Ask, Fields, Filters, Place, Reads -from ._shared import Get, Page, Row, is_web_url, only, parse_dt, remote_word +from ._shared import Get, Page, Row, is_web_url, only, parse_dt NAME = "platsbanken" LABEL = "Platsbanken" @@ -113,7 +113,7 @@ def rows(decoded: Any, slug: str) -> list[Row]: addresses = hit.get("workplace_addresses") or [hit.get("workplace_address") or {}] places = [place for address in addresses if isinstance(address, dict) if (place := _place(address))] - model = (hit.get("workplace_model") or {}).get("label") or "" + model = str((hit.get("workplace_model") or {}).get("label") or "").strip() out.append({ "source_id": str(hit.get("id") or ""), "title": title, @@ -122,7 +122,7 @@ def rows(decoded: Any, slug: str) -> list[Row]: "places": places, "location": places[0]["text"] if places else "", "country": "SE", - "remote": remote_word(f"{title} {model}"), + "remote": model or None, "posted": parse_dt(hit.get("publication_date")), "description": _text((hit.get("description") or {}).get("text") or ""), }) diff --git a/plugins/readers/recruitee.py b/plugins/readers/recruitee.py index e494d4c..36f1aab 100644 --- a/plugins/readers/recruitee.py +++ b/plugins/readers/recruitee.py @@ -8,16 +8,13 @@ Recruitee. from __future__ import annotations import json -import logging from collections.abc import Callable from typing import Any from desk.sources import strip_html from ._contract import Ask, Fields, Place, Reads -from ._shared import Row, add_place, country_if_single, is_web_url, label_slug_ok, num, only, parse_dt, pay_line, table_word, yearly_amount - -log = logging.getLogger(__name__) +from ._shared import Row, add_place, is_web_url, label_slug_ok, num, only, parse_dt, pay_line, yearly_amount NAME = "recruitee" LABEL = "Recruitee" @@ -27,23 +24,11 @@ PATTERNS = (r"https?://([a-z0-9-]+)\.recruitee\.com",) READS = Reads( scope="board", listing="whole", text="listing", complete="whole", places="many", - fields=Fields(pay="figures", posted="trusted", remote="stated", country="stated", + fields=Fields(pay="figures", posted="trusted", remote="stated", seniority="stated", employment="stated"), robots="api: no robots.txt check needed (public board API), 2026-09-30", ) -#: `experience_code` -> the app's levels. `experienced` names no level and is -#: known, so it maps to none; a word not listed is logged at debug level. -_SENIORITY = {"student_school": "intern", "entry_level": "junior", "mid_level": "mid", - "experienced": ""} - -#: The words of `employment_type_code` (`fulltime_permanent`), the first that -#: is found deciding, so a contract type beats the hours. -_EMPLOYMENT = (("internship", "internship"), ("intern", "internship"), - ("freelance", "contract"), ("contract", "contract"), - ("temporary", "temporary"), ("fixed", "temporary"), - ("parttime", "part_time"), ("fulltime", "full_time")) - #: What the board writes as a place for a role that is worked anywhere. _NO_PLACE = ("remote job",) @@ -82,28 +67,13 @@ def _salary_text(salary: dict[str, Any]) -> str: salary.get("currency"), period) -def _seniority(code: str) -> str | None: - return table_word(_SENIORITY, code, log, "experience_code") - - -def _employment(code: str) -> str | None: - words = set(code.strip().lower().replace("-", "_").split("_")) - for word, value in _EMPLOYMENT: - if word in words: - return value - if code.strip(): - log.debug("recruitee: unknown employment_type_code %r", code) - return None - - -def _places(offer: dict[str, Any]) -> tuple[list[Place], set[str]]: - """Every place of an offer and the countries' codes among them. `locations` +def _places(offer: dict[str, Any]) -> list[Place]: + """Every place of an offer. `locations` lists them (city, state, country), `location` is the first as one line and is the fallback for an offer that lists none. The board writes "Remote job" where an offer has no place: that is not one, and a remote offer with no other place has the place "Remote".""" found: list[Place] = [] - codes: set[str] = set() def add(text: str) -> None: text = text.strip() @@ -119,15 +89,11 @@ def _places(offer: dict[str, Any]) -> tuple[list[Place], set[str]]: if part and part not in parts: parts.append(part) add(", ".join(parts)) - if code := str(loc.get("country_code") or "").strip().upper(): - codes.add(code) if not found: add(str(offer.get("location") or offer.get("city") or "")) - if code := str(offer.get("country_code") or "").strip().upper(): - codes.add(code) if not found and offer.get("remote"): found.append({"text": "Remote", "remote": True}) - return found, codes + return found def parse(body: bytes, slug: str) -> list[Row]: @@ -145,7 +111,7 @@ def parse(body: bytes, slug: str) -> list[Row]: salary_min, salary_max, currency = yearly_amount( salary.get("min"), salary.get("max"), salary.get("currency"), salary.get("period"), {"year": 1, "month": 12}) - places, codes = _places(j) + places = _places(j) rows.append({ "source_id": str(j.get("id") or ""), "title": title, @@ -160,8 +126,7 @@ def parse(body: bytes, slug: str) -> list[Row]: "salary_min": salary_min, "salary_max": salary_max, "currency": currency, - "country": country_if_single(codes), - "seniority": _seniority(str(j.get("experience_code") or "")), - "employment": _employment(str(j.get("employment_type_code") or "")), + "seniority": str(j.get("experience_code") or "").strip() or None, + "employment": str(j.get("employment_type_code") or "").strip() or None, }) return rows diff --git a/plugins/readers/rippling.py b/plugins/readers/rippling.py index 866e603..1e98e4d 100644 --- a/plugins/readers/rippling.py +++ b/plugins/readers/rippling.py @@ -12,7 +12,6 @@ from __future__ import annotations import html import json -import logging import re from collections.abc import Callable from typing import Any @@ -22,8 +21,6 @@ from desk.sources import strip_html from ._contract import Ask, Fields, Place, Reads from ._shared import Get, Row, add_place, parse_dt, yearly_amount -log = logging.getLogger(__name__) - NAME = "rippling" LABEL = "Rippling" KEEP_CASE = True @@ -46,11 +43,6 @@ _SITE = "ats.rippling.com" #: whole; it is also what discovery's patterns take. _SLUG = re.compile(r"[A-Za-z0-9][A-Za-z0-9_-]*") -#: The words of `employmentType.label` (`SALARIED_FT`), split at "_". -_EMPLOYMENT = {"FT": "full_time", "PT": "part_time", "INTERN": "internship", - "INTERNSHIP": "internship", "CONTRACT": "contract", "CONTRACTOR": "contract", - "TEMP": "temporary", "TEMPORARY": "temporary", "SEASONAL": "temporary"} - #: A role's id in the board's own links. _UUID = re.compile(r"[0-9A-Za-z-]{8,64}") @@ -86,8 +78,7 @@ def parse(body: bytes, slug: str) -> list[Row]: role and place, so a role in three cities is three entries with one `uuid` (Rippling's own board: 638 entries, 326 roles); the rows merge them, the places kept as a list and joined with "; " for `location`. The entry has no description, date - or pay: `detail` reads them. `remote` is True only when every place is a - "Remote (...)" one, since a label says nothing else about the work.""" + or pay: `detail` reads them.""" data = json.loads(body) if not isinstance(data, list): raise ValueError("not a Rippling board: the answer is not a list") @@ -114,19 +105,12 @@ def parse(body: bytes, slug: str) -> list[Row]: for job_id, row in roles.items(): row["places"] = places[job_id] row["location"] = "; ".join(p["text"] for p in places[job_id]) - row["remote"] = True if places[job_id] and all( - p["remote"] for p in places[job_id]) else None return list(roles.values()) def _employment(kind: Any) -> str | None: - label = str((kind or {}).get("label") or "").strip().upper() if isinstance(kind, dict) else "" - for word in label.split("_"): - if word in _EMPLOYMENT: - return _EMPLOYMENT[word] - if label: - log.debug("rippling: unknown employmentType %r", label) - return None + """The host's `employmentType.label` (`SALARIED_FT`), as given.""" + return (str(kind.get("label") or "").strip() or None) if isinstance(kind, dict) else None def detail(get: Get, slug: str, row: Row) -> dict[str, Any]: diff --git a/plugins/readers/smartrecruiters.py b/plugins/readers/smartrecruiters.py index 152bb7f..efc56a3 100644 --- a/plugins/readers/smartrecruiters.py +++ b/plugins/readers/smartrecruiters.py @@ -13,15 +13,12 @@ ignores a remote parameter, so remote is not filtered. from __future__ import annotations import json -import logging import re from collections.abc import Callable from typing import Any from ._contract import Ask, Fields, Filters, Place, Reads -from ._shared import Get, Page, Row, only, parse_dt, path_slug_ok, table_word - -log = logging.getLogger(__name__) +from ._shared import Get, Page, Row, only, parse_dt, path_slug_ok NAME = "smartrecruiters" LABEL = "SmartRecruiters" @@ -41,17 +38,6 @@ READS = Reads( _API = "api.smartrecruiters.com" -#: `experienceLevel.id` -> the app's levels. The three in the middle name no -#: level ("associate" is half of Bosch's roles) and are known, so they map to -#: none; an id not listed is logged at debug level. -_SENIORITY = {"internship": "intern", "entry_level": "junior", "director": "director", - "executive": "exec", "associate": "", "mid_senior_level": "", - "not_applicable": ""} - -#: `typeOfEmployment.id` -> the app's employment words. -_EMPLOYMENT = {"permanent": "", "intern": "internship", "temporary": "temporary", - "contract": "contract", "part_time": "part_time", "full_time": "full_time"} - #: The page size asked for, which is also the most the host serves per page. PAGE_SIZE = 100 @@ -94,10 +80,9 @@ def parse(body: bytes, slug: str) -> list[Row]: return rows(json.loads(body), slug) -def _word(job: dict[str, Any], key: str, table: dict[str, str]) -> str | None: - """The `id` of the object `job[key]` looked up in `table`; none for a word - the table maps to none, and a word it does not know is logged.""" - return table_word(table, (job.get(key) or {}).get("id"), log, key) +def _word(job: dict[str, Any], key: str) -> str | None: + """The `id` of the object `job[key]`, as given.""" + return str((job.get(key) or {}).get("id") or "").strip() or None def rows(data: dict[str, Any], slug: str) -> list[Row]: @@ -122,7 +107,6 @@ def rows(data: dict[str, Any], slug: str) -> list[Row]: loc_text = ", ".join(part.strip() for part in (loc_text or "").split(",") if part.strip()) place: Place = {"text": loc_text, "remote": location.get("remote")} - country = str(location.get("country") or "").strip().upper() out.append({ "source_id": job_id, "title": title, @@ -134,8 +118,8 @@ def rows(data: dict[str, Any], slug: str) -> list[Row]: "description": "", "remote": location.get("remote"), "salary_text": "", # SmartRecruiters' list endpoint states no pay at all - "country": country if len(country) == 2 else None, - "seniority": _word(j, "experienceLevel", _SENIORITY), - "employment": _word(j, "typeOfEmployment", _EMPLOYMENT), + "country": str(location.get("country") or "").strip() or None, + "seniority": _word(j, "experienceLevel"), + "employment": _word(j, "typeOfEmployment"), }) return out diff --git a/plugins/readers/successfactors.py b/plugins/readers/successfactors.py index 96d5858..9747575 100644 --- a/plugins/readers/successfactors.py +++ b/plugins/readers/successfactors.py @@ -59,7 +59,7 @@ from desk.sources import strip_html from ._contract import Ask, Fields, Filters, Place, Reads from ._countries import NAMES -from ._shared import Get, Page, Row, add_place, country_if_single, is_web_url, only, parse_dt +from ._shared import Get, Page, Row, add_place, is_web_url, only, parse_dt NAME = "successfactors" LABEL = "SuccessFactors" @@ -86,7 +86,7 @@ KEEP_CASE = True READS = Reads( scope="board", listing="paged", text="detail", complete="stated", places="many", filters=Filters(country="one"), - fields=Fields(posted="trusted", country="stated"), + fields=Fields(posted="trusted"), robots="read: robots.txt allows /search/ and /job/ (checked 2026-09-29)", ) @@ -342,19 +342,6 @@ def _posted(value: str) -> datetime | None: return parse_dt(value) -def _country_code(meta: dict[str, str]) -> str: - """The address's country as an ISO code: `addressCountry`, or the code that - `_place` reads in a `streetAddress`; '' for neither.""" - code = meta.get("addressCountry", "").strip().upper() - if len(code) == 2: - return code - parts = [part.strip() for part in meta.get("streetAddress", "").split(",")] - for i in range(len(parts) - 1, 0, -1): - if len(parts) - i <= 2 and parts[i] in _COUNTRIES: - return parts[i] - return "" - - def _location(meta: dict[str, str]) -> str: """The address as "City, Country". Vestas and Demant state `addressLocality` and `addressCountry` (a code), the other sites one @@ -373,7 +360,7 @@ def detail(get: Get, slug: str, row: Row) -> dict[str, Any]: """A role's own page: `description` from the block marked `itemprop="description"`, which Novo Nordisk's pages have without the microdata around it, and, from a page that has the `JobPosting` microdata, - `posted` (`datePosted`) and every place with the country's code. A page that + `posted` (`datePosted`) and every place. A page that is not a role's (the site answers 200 for a closed one with its search) has no description block and gives an empty answer.""" text = get(row["url"]).decode("utf-8", "replace") @@ -396,9 +383,6 @@ def detail(get: Get, slug: str, row: Row) -> dict[str, Any]: if places: out["places"] = places out["location"] = "; ".join(p["text"] for p in places) - codes = {_country_code(address) for address in addresses} - if code := country_if_single(codes): - out["country"] = code return out diff --git a/plugins/readers/teamtailor.py b/plugins/readers/teamtailor.py index 075e7e5..937d1f8 100644 --- a/plugins/readers/teamtailor.py +++ b/plugins/readers/teamtailor.py @@ -51,12 +51,6 @@ _HOST = re.compile(r"[a-z0-9-]+(\.[a-z0-9-]+)*") #: Teamtailor's own namespace in the feed, the `tt:` of `tt:locations`. _TT = "{https://teamtailor.com/locations}" -#: Teamtailor's `remoteStatus` -> `store._remote`'s words. `none` says nothing -#: about where the role is worked and `temporary` is remote for a spell only, -#: so both stay unknown rather than become "onsite" or "remote". -_REMOTE = {"fully": "remote", "hybrid": "hybrid", "onsite": "onsite"} - - def site(slug: str) -> str: """The host a career site is served from: `acme` is acme.teamtailor.com, and a slug with a dot is a site on the company's own domain, @@ -141,7 +135,7 @@ def rows(items: list[ET.Element], slug: str) -> list[Row]: "department": ((item.findtext(f"{_TT}department") or "").strip() or (item.findtext(f"{_TT}role") or "").strip()), "description": html.unescape(strip_html(item.findtext("description") or "")), - "remote": _REMOTE.get(status), + "remote": status or None, "salary_text": "", # Teamtailor's feed states no pay at all }) return out diff --git a/plugins/readers/workable.py b/plugins/readers/workable.py index 99597ed..4ed795c 100644 --- a/plugins/readers/workable.py +++ b/plugins/readers/workable.py @@ -8,14 +8,11 @@ board with roles was seen; jobhunt-hq did not read Workable. from __future__ import annotations import json -import logging from collections.abc import Callable from typing import Any from ._contract import Ask, Fields, Place, Reads -from ._shared import Get, Page, Row, add_place, country_if_single, only, parse_dt, path_slug_ok, table_word - -log = logging.getLogger(__name__) +from ._shared import Get, Page, Row, add_place, only, parse_dt, path_slug_ok NAME = "workable" LABEL = "Workable" @@ -28,17 +25,12 @@ PATTERNS = ( READS = Reads( scope="board", listing="paged", page_size=10, text="none", complete="stated", places="many", - fields=Fields(posted="trusted", remote="stated", country="stated", employment="stated"), + fields=Fields(posted="trusted", remote="stated", employment="stated"), robots="api: no robots.txt check needed (public board API), 2026-09-30", ) _API = "apply.workable.com" -#: `type` -> the app's employment words; a type not listed is logged at debug -#: level so the table can grow. -_EMPLOYMENT = {"full": "full_time", "part": "part_time", "contract": "contract", - "temporary": "temporary", "internship": "internship"} - # No probe: Workable's API sits behind a rate limit that a run of guesses # trips, and a Workable site links its board plainly anyway. @@ -67,13 +59,12 @@ def parse(body: bytes, slug: str) -> list[Row]: return rows(json.loads(body), slug) -def _places(job: dict[str, Any], remote: bool) -> tuple[list[Place], set[str]]: - """Every place of a role and the countries' codes among them. `locations` +def _places(job: dict[str, Any], remote: bool) -> list[Place]: + """Every place of a role. `locations` lists them (city, region, country; `hidden` ones are stated too), and `location` is the first alone, the fallback for a role that lists none. A place is remote when the role is.""" found: list[Place] = [] - codes: set[str] = set() listed = [loc for loc in job.get("locations") or [] if isinstance(loc, dict)] for loc in listed or [job.get("location") or {}]: parts: list[str] = [] @@ -83,9 +74,7 @@ def _places(job: dict[str, Any], remote: bool) -> tuple[list[Place], set[str]]: parts.append(part) text = ", ".join(parts) add_place(found, {"text": text, "remote": remote}) - if code := str(loc.get("countryCode") or "").strip().upper(): - codes.add(code) - return found, codes + return found def rows(data: dict[str, Any], slug: str) -> list[Row]: @@ -104,8 +93,9 @@ def rows(data: dict[str, Any], slug: str) -> list[Row]: shortcode = (j.get("shortcode") or "").strip() if not title or not shortcode: continue - remote = bool(j.get("remote")) or j.get("workplace") == "remote" - places, codes = _places(j, remote) + workplace = str(j.get("workplace") or "").strip() + remote = bool(j.get("remote")) or workplace == "remote" + places = _places(j, remote) dept = j.get("department") or "" if isinstance(dept, list): dept = ", ".join(d for d in dept if d) @@ -118,9 +108,8 @@ def rows(data: dict[str, Any], slug: str) -> list[Row]: "posted": parse_dt(j.get("published")), "department": dept.strip(), "description": "", - "remote": remote, + "remote": workplace or j.get("remote"), "salary_text": "", # Workable's list endpoint states no pay at all - "country": country_if_single(codes), - "employment": table_word(_EMPLOYMENT, j.get("type"), log, "type"), + "employment": str(j.get("type") or "").strip() or None, }) return out diff --git a/plugins/readers/workday.py b/plugins/readers/workday.py index a2e6ec6..73b08f9 100644 --- a/plugins/readers/workday.py +++ b/plugins/readers/workday.py @@ -29,7 +29,6 @@ from __future__ import annotations import html import json -import logging import re from collections.abc import Callable from datetime import UTC, datetime, timedelta @@ -39,9 +38,7 @@ from desk.sources import strip_html from ._contract import Ask, Fields, Filters, Place, Reads from ._countries import code_of -from ._shared import Get, Page, Row, add_place, only, parse_dt, table_word - -log = logging.getLogger(__name__) +from ._shared import Get, Page, Row, add_place, only, parse_dt NAME = "workday" LABEL = "Workday" @@ -50,7 +47,7 @@ KEEP_CASE = True READS = Reads( scope="board", listing="paged", page_size=20, ceiling=2000, text="detail", complete="stated", places="many", filters=Filters(country="ids", remote="ids"), - fields=Fields(posted="trusted", remote="stated", country="stated", employment="stated"), + fields=Fields(posted="trusted", remote="stated", employment="stated"), robots="read: robots.txt allows // (checked 2026-09-29)", ) @@ -167,7 +164,7 @@ def facets(get: Get, slug: str) -> dict[str, dict[str, str]]: """The tenant's host ids, read off one page of one role: `country` maps an ISO code to `=` in the facet whose values are countries (most of them, `_COUNTRY_SHARE`; the one with most countries - when two are), and `remote` maps each facet value that `_REMOTE` reads as + when two are), and `remote` maps each facet value that `_REMOTE_FACET` names as remote ("Remote", "Fully Flexible"), in whatever facet, to its id. A tenant with neither states no such dimension, and the runner then does not filter on it.""" @@ -184,7 +181,7 @@ def facets(get: Get, slug: str) -> dict[str, dict[str, str]]: country = found for v in values: word = " ".join(str(v.get("descriptor") or "").split()) - if v.get("id") and _remote(word) == "remote": + if v.get("id") and word.lower() in _REMOTE_FACET: remote[word.lower()] = f"{name}={v['id']}" out: dict[str, dict[str, str]] = {} if country: @@ -216,11 +213,14 @@ def _today() -> datetime: return datetime.now(UTC).replace(hour=0, minute=0, second=0, microsecond=0) -#: `remoteType` -> `store._remote`'s words. Only some tenants send it, and -#: each words it its own way (Zendesk's "Fully Flexible", Axis' "On-Site"); a -#: word not listed, a bare "No" among them, says nothing and stays unknown. -_REMOTE = {"remote": "remote", "fully flexible": "remote", "hybrid": "hybrid", - "in office": "onsite", "on-site": "onsite", "onsite": "onsite"} +#: The `remoteType` words a facet names that mean remote, which the `remote` +#: filter looks for; the row keeps the host's word whatever it is (only some +#: tenants send it, each in its own way: Zendesk's "Fully Flexible", Axis' +#: "On-Site"). +_REMOTE_FACET = ("remote", "fully flexible") + +#: The words that put a role's places in an office, for their `remote` flag. +_OFFICE = ("hybrid", "in office", "on-site", "onsite") def _requisition(posting: dict[str, Any], path: str) -> str: @@ -234,12 +234,10 @@ def _requisition(posting: dict[str, Any], path: str) -> str: def _remote(value: Any) -> str | None: - return _REMOTE.get(str(value or "").strip().lower()) + """The host's `remoteType`, as given.""" + return str(value or "").strip() or None -#: `timeType` -> the app's employment words. -_EMPLOYMENT = {"full time": "full_time", "part time": "part_time"} - #: What `locationsText` says of a role at several places: "2 Locations". The #: places arrive with the role's own read. _COUNT = re.compile(r"\d+ locations?", re.I) @@ -259,8 +257,9 @@ def _place(text: Any, remote: str | None) -> Place | None: if len(parts) > 1 and "," not in text and all(parts) \ and not parts[0].lower().startswith(("remote", "hybrid", "on-site", "onsite")): text = ", ".join(reversed(parts)) - return {"text": text, "remote": {"remote": True, "hybrid": False, "onsite": False}.get( - remote or "")} + word = (remote or "").lower() + return {"text": text, "remote": True if word in _REMOTE_FACET + else False if word in _OFFICE else None} def rows(decoded: dict[str, Any], slug: str) -> list[Row]: @@ -318,9 +317,7 @@ def detail(get: Get, slug: str, row: Row) -> dict[str, Any]: if places := _places(posting, remote): out["places"] = places out["location"] = "; ".join(p["text"] for p in places) - if len(places) == 1 and (code := _country_code(posting)): - out["country"] = code - if employment := table_word(_EMPLOYMENT, posting.get("timeType"), log, "timeType"): + if employment := str(posting.get("timeType") or "").strip(): out["employment"] = employment if posted := parse_dt(posting.get("startDate")): out["posted"] = posted @@ -329,15 +326,6 @@ def detail(get: Get, slug: str, row: Row) -> dict[str, Any]: return out -def _country_code(posting: dict[str, Any]) -> str | None: - """The role's country as an ISO code, from the requisition's location. The - code belongs to the main location only, so it is used for a role with one - place.""" - country = (posting.get("jobRequisitionLocation") or {}).get("country") or {} - code = str(country.get("alpha2Code") or "").strip().upper() - return code if len(code) == 2 else None - - def _places(posting: dict[str, Any], remote: str | None) -> list[Place]: """The main location and the additional ones, each once, which replace the listing's "2 Locations". A single location that does not name its country diff --git a/tests/test_ats.py b/tests/test_ats.py index 3f855fe..74d5b1a 100644 --- a/tests/test_ats.py +++ b/tests/test_ats.py @@ -132,10 +132,10 @@ def test_workable_builds_the_job_url_and_reads_location_and_remote() -> None: assert [r["source_id"] for r in rows] == ["6125026", "6125041"] assert rows[0]["url"] == "https://apply.workable.com/huggingface/j/DB4D7C0EC8/" assert rows[0]["location"] == "France" - assert rows[0]["remote"] is True + assert rows[0]["remote"] == "remote" assert rows[0]["department"] == "Product" assert rows[1]["location"] == "Berlin, Germany" - assert rows[1]["remote"] is False + assert rows[1]["remote"] == "hybrid" assert rows[0]["description"] == "" # the list endpoint carries no text assert rows[0]["salary_text"] == "" # Workable's list endpoint states no pay at all @@ -173,8 +173,9 @@ def test_personio_builds_the_job_url_and_reads_cdata_description() -> None: assert [r["source_id"] for r in rows] == ["6001", "6002", "6003"] assert rows[0]["url"] == "https://acme.jobs.personio.de/job/6001" assert rows[0]["description"] == "Grow our pipeline." - assert rows[0]["remote"] is True # "Remote - Germany" - assert rows[1]["remote"] is None # "Munich" + assert rows[0]["places"][0]["remote"] is True # "Remote - Germany" + assert rows[1]["places"][0]["remote"] is None # "Munich" + assert "remote" not in rows[0] # the feed states none def test_personio_reads_salary_information_when_present() -> None: @@ -291,9 +292,9 @@ def test_teamtailor_joins_the_distinct_locations_for_country_of() -> None: assert country_of(rows[0]["location"]) == "SE" -def test_teamtailor_maps_remote_status_and_falls_back_to_role_for_department() -> None: +def test_teamtailor_hands_on_remote_status_and_falls_back_to_role_for_department() -> None: rows = ats._parse_teamtailor(TEAMTAILOR, "kry") - assert [r["remote"] for r in rows] == ["hybrid", "remote", None] # none says nothing + assert [r["remote"] for r in rows] == ["hybrid", "fully", "none"] # prep maps them assert rows[1]["title"] == "Läkare" # trimmed assert rows[1]["department"] == "Software Development" assert ats.classify(rows[1]["department"], "Sales Lead") == "sales" diff --git a/tests/test_ats_oracle.py b/tests/test_ats_oracle.py index e5b4123..4442319 100644 --- a/tests/test_ats_oracle.py +++ b/tests/test_ats_oracle.py @@ -59,19 +59,19 @@ def test_the_locations_are_the_primary_and_the_secondary_ones() -> None: assert rows[2]["location"] == "India" -def test_every_place_is_kept_with_its_work_mode_and_the_countrys_code() -> None: +def test_every_place_is_kept_with_its_work_mode() -> None: rows = _rows() assert [p["text"] for p in rows[1]["places"]] == [ "Malaysia", "Philippines", "Indonesia", "Thailand"] assert [p["remote"] for p in rows[0]["places"]] == [False, False] # hybrid assert [p["remote"] for p in rows[4]["places"]] == [True] # remote assert [p["remote"] for p in rows[3]["places"]] == [None] # states none - # One country when the places share one, none over several. - assert [r["country"] for r in rows] == [None, None, "IN", "DE", "US"] + assert all("country" not in r for r in rows) # prep derives it from the places -def test_remote_follows_the_workplace_type_code() -> None: - assert [r["remote"] for r in _rows()] == ["hybrid", "hybrid", "onsite", None, "remote"] +def test_remote_is_the_workplace_type_code_as_given() -> None: + assert [r["remote"] for r in _rows()] == [ + "ORA_HYBRID", "ORA_HYBRID", "ORA_ON_SITE", None, "ORA_REMOTE"] def test_a_department_is_taken_where_a_tenant_fills_one() -> None: diff --git a/tests/test_ats_personio.py b/tests/test_ats_personio.py index cb644b7..e84f35c 100644 --- a/tests/test_ats_personio.py +++ b/tests/test_ats_personio.py @@ -3,17 +3,14 @@ No network: the fixtures are saved feeds.""" from __future__ import annotations -import logging import sys from pathlib import Path -import pytest ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) -from app.models import SENIORITIES # noqa: E402 from plugins.readers import Ask, personio # noqa: E402 FIXTURES = ROOT / "tests" / "fixtures" / "ats" @@ -37,23 +34,12 @@ def test_additional_offices_are_places_of_the_role_each_once() -> None: assert [p["text"] for p in first["places"]] == ["Remote - Germany", "Berlin", "Hamburg"] assert [p["remote"] for p in first["places"]] == [True, None, None] assert first["location"] == "Remote - Germany; Berlin; Hamburg" - assert first["remote"] is True # one of the places is remote + assert "remote" not in first # the feed states none assert _rows()[1]["places"] == [{"text": "Munich", "remote": None}] - assert _rows()[1]["remote"] is None -def test_the_stated_level_and_employment_are_mapped() -> None: +def test_the_stated_level_and_employment_are_the_hosts_words() -> None: rows = _rows() - assert [r["seniority"] for r in rows] == ["junior", "exec", "intern"] - # permanent + full-time; permanent + full-time; working student wins over part-time - assert [r["employment"] for r in rows] == ["full_time", "full_time", "internship"] - - -def test_the_table_speaks_the_apps_vocabulary_and_a_new_word_is_logged( - caplog: pytest.LogCaptureFixture) -> None: - assert {v for v in personio._SENIORITY.values() if v} <= set(SENIORITIES) - with caplog.at_level(logging.DEBUG, logger=personio.__name__): - assert personio._seniority("wizard") is None - assert personio._seniority("experienced") is None # known, names no level - assert personio._seniority("") is None - assert [r.getMessage() for r in caplog.records] == ["personio: unknown seniority 'wizard'"] + assert [r["seniority"] for r in rows] == ["entry-level", "executive", "student"] + # permanent + full-time gives the schedule; a working student is the contract's word + assert [r["employment"] for r in rows] == ["full-time", "full-time", "working_student"] diff --git a/tests/test_ats_phenom.py b/tests/test_ats_phenom.py index 0decca2..0cd40c8 100644 --- a/tests/test_ats_phenom.py +++ b/tests/test_ats_phenom.py @@ -226,7 +226,7 @@ def test_detail_falls_back_to_the_page_state_where_there_is_no_job_posting() -> got = phenom.detail(_get_of("phenom-detail-3.html", []), SLUG, row) assert got["description"].startswith("Craft: Games Design & Production Job Description:") assert "<" not in got["description"] and "&" not in got["description"] - assert got["remote"] == "onsite" + assert got["remote"] == "On-site" assert "posted" not in got and set(got) <= set(ats.DETAIL_FIELDS) diff --git a/tests/test_ats_pinpoint.py b/tests/test_ats_pinpoint.py index bffc5cb..e091caf 100644 --- a/tests/test_ats_pinpoint.py +++ b/tests/test_ats_pinpoint.py @@ -161,9 +161,6 @@ def test_a_role_has_its_one_place_with_the_work_mode_of_the_role() -> None: assert rows[0]["location"] == "Bucharest" -def test_employment_is_read_from_the_type_and_an_unknown_one_is_left() -> None: +def test_employment_is_the_hosts_type_as_given() -> None: rows = pinpoint.parse((FIXTURES / "pinpoint.json").read_bytes(), "xeneta") - assert [r["employment"] for r in rows] == ["full_time", "temporary"] - assert pinpoint._employment("permanent_part_time") == "part_time" - assert pinpoint._employment("internship") == "internship" - assert pinpoint._employment("something_new") is None + assert [r["employment"] for r in rows] == ["permanent_full_time", "fixed_term_full_time"] diff --git a/tests/test_ats_recruitee.py b/tests/test_ats_recruitee.py index 33f031e..cb20ea8 100644 --- a/tests/test_ats_recruitee.py +++ b/tests/test_ats_recruitee.py @@ -4,17 +4,14 @@ bunq's board, read on 2026-09-30.""" from __future__ import annotations -import logging import sys from pathlib import Path -import pytest ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) -from app.models import SENIORITIES # noqa: E402 from plugins.readers import Ask, recruitee # noqa: E402 FIXTURES = ROOT / "tests" / "fixtures" / "ats" @@ -27,19 +24,18 @@ def _rows() -> list[dict]: def test_the_declaration_says_what_the_feed_gives() -> None: reads = recruitee.READS assert (reads.listing, reads.places, reads.text) == ("whole", "many", "listing") - assert reads.fields.posted == "trusted" and reads.fields.country == "stated" + assert reads.fields.posted == "trusted" and reads.fields.country == "none" assert reads.robots.startswith("api: no robots.txt check needed") assert recruitee.feed_url("acme", Ask()) == "https://acme.recruitee.com/api/offers/" -def test_every_location_is_a_place_and_the_country_is_stated_when_they_share_one() -> None: +def test_every_location_is_a_place_and_no_country_is_stated() -> None: first, _remote, berlin = _rows() assert [p["text"] for p in first["places"]] == [ "Amsterdam, Noord-Holland, Netherlands", "Sofia, Bulgaria"] assert first["location"] == "Amsterdam, Noord-Holland, Netherlands; Sofia, Bulgaria" - assert first["country"] is None # NL and BG + assert "country" not in first # prep derives it from the places assert berlin["places"] == [{"text": "Berlin, Germany", "remote": None}] - assert berlin["country"] == "DE" def test_remote_job_is_not_a_place() -> None: @@ -48,28 +44,16 @@ def test_remote_job_is_not_a_place() -> None: assert remote["location"] == "Remote" offer = {"id": 1, "title": "T", "careers_url": "https://a.example/o/t", "location": "Remote job", "remote": False} - assert recruitee._places(offer) == ([], set()) + assert recruitee._places(offer) == [] def test_an_offer_without_a_locations_list_falls_back_to_its_location() -> None: offer = {"location": "Lisbon, Portugal", "country_code": "pt"} - assert recruitee._places(offer) == ([{"text": "Lisbon, Portugal", "remote": None}], {"PT"}) + assert recruitee._places(offer) == [{"text": "Lisbon, Portugal", "remote": None}] -def test_the_stated_level_and_employment_are_mapped() -> None: +def test_the_stated_level_and_employment_are_the_hosts_codes() -> None: rows = _rows() - assert [r["seniority"] for r in rows] == [None, "junior", "intern"] - assert [r["employment"] for r in rows] == ["full_time", "part_time", "internship"] - assert recruitee._employment("fulltime_fixed_term") == "temporary" - assert recruitee._employment("freelance") == "contract" - - -def test_the_table_speaks_the_apps_vocabulary_and_a_new_word_is_logged( - caplog: pytest.LogCaptureFixture) -> None: - assert {v for v in recruitee._SENIORITY.values() if v} <= set(SENIORITIES) - with caplog.at_level(logging.DEBUG, logger=recruitee.__name__): - assert recruitee._seniority("senior_level") is None - assert recruitee._employment("odd_job") is None - assert [r.getMessage() for r in caplog.records] == [ - "recruitee: unknown experience_code 'senior_level'", - "recruitee: unknown employment_type_code 'odd_job'"] + assert [r["seniority"] for r in rows] == ["experienced", "entry_level", "student_school"] + assert [r["employment"] for r in rows] == [ + "fulltime_permanent", "parttime_permanent", "internship"] diff --git a/tests/test_ats_rippling.py b/tests/test_ats_rippling.py index 74da897..0f10598 100644 --- a/tests/test_ats_rippling.py +++ b/tests/test_ats_rippling.py @@ -41,21 +41,18 @@ def test_rows_merge_one_entry_per_place_into_one_role() -> None: assert first["description"] == "" and first["salary_text"] == "" and first["posted"] is None -def test_remote_is_true_only_when_every_place_is_a_remote_one() -> None: +def test_a_remote_place_is_flagged_and_the_role_states_no_remote() -> None: by_id = {r["source_id"][:8]: r for r in rippling.parse(BOARD, "rippling")} - assert by_id["46b4af52"]["remote"] is True and by_id["19ae5b34"]["remote"] is True - assert by_id["75ad50c6"]["remote"] is None # an office label says nothing either way - mixed = json.dumps([ - {"uuid": "abcdefgh-1", "name": "A", "workLocation": {"label": "Remote (Germany)"}}, - {"uuid": "abcdefgh-1", "name": "A", "workLocation": {"label": "Berlin"}}]).encode() - assert rippling.parse(mixed, "x")[0]["remote"] is None + assert [p["remote"] for p in by_id["46b4af52"]["places"]] == [True] + assert [p["remote"] for p in by_id["75ad50c6"]["places"]] == [None] # an office label + assert all("remote" not in r for r in by_id.values()) # prep derives it from the places def test_prisma_board_reads_two_roles() -> None: rows = rippling.parse(PRISMA, "prisma-careers") - assert [(r["title"], r["department"], r["location"], r["remote"]) for r in rows] == [ - ("General Applications: Engineering", "Engineering", "Remote (Germany)", True), - ("General Applications: Product", "Product", "Remote (Germany)", True)] + assert [(r["title"], r["department"], r["location"]) for r in rows] == [ + ("General Applications: Engineering", "Engineering", "Remote (Germany)"), + ("General Applications: Product", "Product", "Remote (Germany)")] def test_an_empty_board_is_no_roles_and_an_error_answer_is_not_a_board() -> None: @@ -92,7 +89,7 @@ def test_detail_reads_description_places_date_and_a_single_yearly_range() -> Non assert "<" not in found["description"] assert found["location"] == "San Francisco, CA; Seattle, WA; New York, NY" assert [p["text"] for p in found["places"]] == ["San Francisco, CA", "Seattle, WA", "New York, NY"] - assert found["employment"] == "full_time" # employmentType.label SALARIED_FT + assert found["employment"] == "SALARIED_FT" # employmentType.label assert found["posted"] is not None and found["posted"].isoformat() == \ "2025-04-07T12:29:19.348000-07:00" assert (found["salary_min"], found["salary_max"], found["currency"]) == (216000, 378000, "USD") @@ -203,13 +200,12 @@ def test_discovery_finds_the_board_slug() -> None: ("rippling", "prisma-careers"), ("rippling", "Acme"), ("rippling", "beta")] -def test_a_role_at_several_places_keeps_each_once_and_is_remote_only_if_all_are() -> None: +def test_a_role_at_several_places_keeps_each_once() -> None: rows = {r["source_id"]: r for r in rippling.parse(BOARD, "rippling")} director = rows[DIRECTOR] assert [p["text"] for p in director["places"]] == [ "San Francisco, CA", "Seattle, WA", "New York, NY"] assert director["location"] == "San Francisco, CA; Seattle, WA; New York, NY" - assert director["remote"] is None remote = next(r for r in rows.values() if r["places"] == [ {"text": "Remote (United States)", "remote": True}]) - assert remote["remote"] is True + assert remote["places"][0]["remote"] is True diff --git a/tests/test_ats_smartrecruiters.py b/tests/test_ats_smartrecruiters.py index aa616c7..e2db36e 100644 --- a/tests/test_ats_smartrecruiters.py +++ b/tests/test_ats_smartrecruiters.py @@ -4,17 +4,14 @@ No network: the shapes are those of Bosch's board, read on 2026-09-30.""" from __future__ import annotations import json -import logging import sys from pathlib import Path -import pytest ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) -from app.models import SENIORITIES # noqa: E402 from plugins.readers import Ask, smartrecruiters # noqa: E402 FIXTURES = ROOT / "tests" / "fixtures" / "ats" @@ -54,38 +51,23 @@ def test_page_reads_by_offset_and_takes_the_ask() -> None: def test_the_place_is_one_clean_line_with_its_remote_flag_and_country() -> None: [row] = _rows(_posting()) assert row["places"] == [{"text": "Hatvan, Hungary", "remote": False}] # ", ," gone - assert row["location"] == "Hatvan, Hungary" and row["country"] == "HU" + assert row["location"] == "Hatvan, Hungary" and row["country"] == "hu" [remote] = _rows(_posting(location={"remote": True, "fullLocation": "Remote", "country": ""})) assert remote["places"] == [{"text": "Remote", "remote": True}] and remote["country"] is None [none] = _rows(_posting(location={})) assert none["places"] == [] and none["location"] == "" -def test_the_stated_level_and_employment_are_mapped() -> None: +def test_the_stated_level_and_employment_are_the_hosts_words() -> None: [row] = _rows(_posting(experienceLevel={"id": "internship", "label": "Internship"}, typeOfEmployment={"id": "intern", "label": "Intern"})) - assert (row["seniority"], row["employment"]) == ("intern", "internship") - levels = {"entry_level": "junior", "director": "director", "executive": "exec", - "associate": None, "mid_senior_level": None, "not_applicable": None} - for word, want in levels.items(): - [row] = _rows(_posting(experienceLevel={"id": word})) - assert row["seniority"] == want, word - [row] = _rows(_posting(typeOfEmployment={"id": "permanent"})) - assert row["employment"] is None + assert (row["seniority"], row["employment"]) == ("internship", "intern") + [row] = _rows(_posting(experienceLevel={"id": "mid_senior_level"})) + assert row["seniority"] == "mid_senior_level" [row] = _rows(_posting()) assert row["seniority"] is None and row["employment"] is None -def test_the_table_speaks_the_apps_vocabulary_and_a_new_word_is_logged( - caplog: pytest.LogCaptureFixture) -> None: - assert {v for v in smartrecruiters._SENIORITY.values() if v} <= set(SENIORITIES) - with caplog.at_level(logging.DEBUG, logger=smartrecruiters.__name__): - [row] = _rows(_posting(experienceLevel={"id": "guru"})) - assert row["seniority"] is None - assert [r.getMessage() for r in caplog.records] == [ - "smartrecruiters: unknown experienceLevel 'guru'"] - - def test_the_saved_page_still_reads() -> None: data = json.loads((FIXTURES / "smartrecruiters.json").read_bytes()) assert [r["location"] for r in smartrecruiters.rows(data, "Acme")] == ["Berlin, Germany", diff --git a/tests/test_ats_successfactors.py b/tests/test_ats_successfactors.py index 044b62d..ea237b7 100644 --- a/tests/test_ats_successfactors.py +++ b/tests/test_ats_successfactors.py @@ -315,7 +315,7 @@ def _detail(name: str, url: str = "https://careers.vestas.com/job/x/1431772533/" return successfactors.detail(get, "careers.vestas.com", {"url": url}) # type: ignore[arg-type] -def test_detail_reads_the_description_the_date_and_the_country_code_of_an_address() -> None: +def test_detail_reads_the_description_the_date_and_the_places_of_an_address() -> None: got = _detail("successfactors-job.html") assert got["description"].startswith("Senior Management | Full-Time | Commercial Are you") assert "<" not in got["description"] @@ -324,7 +324,7 @@ def test_detail_reads_the_description_the_date_and_the_country_code_of_an_addres # The locality and the country's name; the region is cut to "Seou" by the site. assert got["location"] == "Seoul, South Korea" assert got["places"] == [{"text": "Seoul, South Korea", "remote": None}] - assert got["country"] == "KR" + assert "country" not in got # prep derives it from the places def test_detail_keeps_every_address_of_a_role_at_several_places() -> None: @@ -333,15 +333,6 @@ def test_detail_keeps_every_address_of_a_role_at_several_places() -> None: assert [p["text"] for p in got["places"]] == [ "Seoul, South Korea", "Busan, South Korea", "Aarhus, Denmark"] assert got["location"] == "Seoul, South Korea; Busan, South Korea; Aarhus, Denmark" - assert "country" not in got # KR and DK: no single country for the role - - -def test_detail_states_the_country_when_every_address_is_in_it() -> None: - text = _read("successfactors-places-detail.html").replace( - 'content="Aarhus, DK, 8200"', 'content="Daegu, KR, 41200"') - got = successfactors.detail(lambda url, **kw: text.encode(), "careers.vestas.com", - {"url": "https://careers.vestas.com/job/x/1/"}) - assert got["country"] == "KR" def test_the_listing_place_is_the_roles_only_place_until_its_page_is_read() -> None: @@ -351,11 +342,10 @@ def test_the_listing_place_is_the_roles_only_place_until_its_page_is_read() -> N for r in rows) -def test_detail_reads_the_country_from_a_street_address() -> None: +def test_detail_reads_the_place_from_a_street_address() -> None: """Systematic and most other sites give one `streetAddress`, "City, CC, zip".""" got = _detail("successfactors-job-street.html") assert got["location"] == "Bern, Switzerland" - assert got["country"] == "CH" assert got["posted"] == datetime(2026, 9, 28, 2, tzinfo=UTC) assert got["description"].startswith("Senior Solution Engineer Defence") diff --git a/tests/test_ats_workable.py b/tests/test_ats_workable.py index db5291f..674e8a5 100644 --- a/tests/test_ats_workable.py +++ b/tests/test_ats_workable.py @@ -5,11 +5,9 @@ No network: the fixture has the shape of Hugging Face's board, read on from __future__ import annotations import json -import logging import sys from pathlib import Path -import pytest ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: @@ -49,21 +47,15 @@ def test_every_location_of_a_role_is_a_place_once() -> None: assert [p["text"] for p in first["places"]] == ["Berlin, Germany", "Munich, Bavaria, Germany", "Paris, France"] assert first["location"] == "Berlin, Germany; Munich, Bavaria, Germany; Paris, France" - assert first["country"] is None # DE and FR + assert "country" not in first # prep derives it from the places assert [p["remote"] for p in first["places"]] == [False] * 3 assert remote["places"] == [{"text": "France", "remote": True}] - assert remote["country"] == "FR" # A list-less answer (the older shape) still gives its one place. assert oslo["places"] == [{"text": "Oslo, Norway", "remote": False}] - assert oslo["country"] == "NO" -def test_the_stated_hours_are_mapped_and_an_unknown_type_is_logged( - caplog: pytest.LogCaptureFixture) -> None: - with caplog.at_level(logging.DEBUG, logger=workable.__name__): - rows = _rows() - assert [r["employment"] for r in rows] == ["full_time", "part_time", None] - assert [r.getMessage() for r in caplog.records] == ["workable: unknown type 'volunteer'"] +def test_the_stated_hours_are_the_hosts_word() -> None: + assert [r["employment"] for r in _rows()] == ["full", "part", "volunteer"] def test_the_shape_of_a_real_list_answer_is_read() -> None: diff --git a/tests/test_ats_workday.py b/tests/test_ats_workday.py index dadb2b3..164d175 100644 --- a/tests/test_ats_workday.py +++ b/tests/test_ats_workday.py @@ -54,8 +54,8 @@ def test_rows_read_the_listing_of_a_tenant_that_sends_remote_type() -> None: "Associate-Solutions-Architect_R35358") assert first["posted"] == TODAY assert first["description"] == "" and first["department"] == "" and first["salary_text"] == "" - # "Fully Flexible" is Zendesk's word for remote. - assert [r["remote"] for r in rows] == ["remote", "onsite", "hybrid", "remote", "hybrid"] + # The host's own words, "Fully Flexible" among them; prep maps them. + assert [r["remote"] for r in rows] == ["Fully Flexible", "In Office", "Hybrid", "Fully Flexible", "Hybrid"] def test_rows_of_a_tenant_without_remote_type_leave_remote_unknown() -> None: @@ -80,7 +80,7 @@ def test_rows_of_a_site_called_jobs_state_the_requisition_id_and_no_date_past_30 assert rows[1]["places"] == [{"text": "Remote US TX", "remote": True}] assert rows[2]["url"].startswith("https://redhat.wd5.myworkdayjobs.com/jobs/job/") assert rows[3]["posted"] is None # "Posted 30+ Days Ago" says only that it is older - assert [r["remote"] for r in rows] == ["onsite", "remote", "remote", "hybrid"] + assert [r["remote"] for r in rows] == ["Onsite", "Remote", "Remote", "Hybrid"] @pytest.mark.parametrize(("text", "expected"), [ @@ -275,13 +275,12 @@ def test_detail_reads_the_description_date_remote_and_place_of_the_role() -> Non SLUG, row) assert asked == [f"https://{HOST}/wday/cxs/zendesk/zendesk" "/job/Remote-Mexico-City-Mexico/Associate-Solutions-Architect_R35358"] - assert set(got) == {"description", "location", "places", "posted", "remote", "country", - "employment"} + assert set(got) == {"description", "location", "places", "posted", "remote", "employment"} assert got["posted"] == datetime(2026, 9, 29, tzinfo=UTC) - assert got["remote"] == "remote" + assert got["remote"] == "Fully Flexible" assert got["location"] == "Remote, Mexico City, Mexico" assert got["places"] == [{"text": "Remote, Mexico City, Mexico", "remote": True}] - assert (got["country"], got["employment"]) == ("MX", "full_time") + assert got["employment"] == "Full time" and "country" not in got assert got["description"].startswith("Job Description") or len(got["description"]) > 200 assert "<" not in got["description"] and " " not in got["description"] assert " " not in got["description"] @@ -296,7 +295,7 @@ def test_detail_names_every_location_of_a_role_listed_as_several() -> None: "/job/Remote-Italy/Telco-Cloud-Consultant_R-059566-2"] assert got["location"] == "Remote Italy; Remote Spain" assert [p["text"] for p in got["places"]] == ["Remote Italy", "Remote Spain"] - assert "country" not in got # the code belongs to the main location alone + assert "country" not in got def _detail(**info: Any) -> bytes: @@ -337,9 +336,9 @@ def test_a_country_dash_city_place_is_turned_round() -> None: assert workday._place("12 Locations", None) is None -def test_detail_takes_no_word_for_remote_it_does_not_know() -> None: +def test_detail_hands_on_a_word_for_remote_it_does_not_know() -> None: row = workday.rows(_load("workday.json"), SLUG)[0] - assert "remote" not in workday.detail(_get_of(_detail(remoteType="No"), []), SLUG, row) + assert workday.detail(_get_of(_detail(remoteType="No"), []), SLUG, row)["remote"] == "No" def test_detail_refuses_a_row_that_is_not_a_role_of_the_board() -> None: @@ -383,7 +382,7 @@ def test_detail_is_read_through_the_getter_ats_binds( monkeypatch.setattr(ats, "_get", fake_get) row = workday.rows(_load("workday.json"), SLUG)[0] got = workday.detail(ats._getter(object(), "workday", SLUG), SLUG, row) # type: ignore[arg-type] - assert got["remote"] == "remote" + assert got["remote"] == "Fully Flexible" assert seen[0][:2] == ("workday", SLUG) diff --git a/tests/test_prep_hosts_oracle.py b/tests/test_prep_hosts_oracle.py new file mode 100644 index 0000000..e49b28c --- /dev/null +++ b/tests/test_prep_hosts_oracle.py @@ -0,0 +1,12 @@ +"""Oracle's word tables for prep: the host's codes, and what they mean.""" + +from __future__ import annotations + +import importlib + +oracle = importlib.import_module("app.prep.hosts.oracle") + + +def test_workplace_type_codes_read() -> None: + assert oracle.REMOTE == {"ora_remote": "remote", "ora_hybrid": "hybrid", + "ora_on_site": "onsite"} diff --git a/tests/test_prep_hosts_personio.py b/tests/test_prep_hosts_personio.py new file mode 100644 index 0000000..1ae6157 --- /dev/null +++ b/tests/test_prep_hosts_personio.py @@ -0,0 +1,22 @@ +"""Personio's word tables for prep: the feed's own words, and what they mean.""" + +from __future__ import annotations + +import importlib + +personio = importlib.import_module("app.prep.hosts.personio") + + +def test_seniority_words_read() -> None: + seniority = personio.SENIORITY + assert [seniority[w] for w in ("entry-level", "executive", "student")] == [ + "junior", "exec", "intern"] + assert seniority["experienced"] == "" # known, names no level + assert "wizard" not in seniority + + +def test_employment_words_read_from_the_contract_or_the_schedule() -> None: + employment = personio.EMPLOYMENT + assert employment["working_student"] == "internship" and employment["freelance"] == "contract" + assert employment["permanent"] == "" + assert employment["full-time"] == "full_time" and employment["part-time"] == "part_time" diff --git a/tests/test_prep_hosts_phenom.py b/tests/test_prep_hosts_phenom.py new file mode 100644 index 0000000..38e84f2 --- /dev/null +++ b/tests/test_prep_hosts_phenom.py @@ -0,0 +1,12 @@ +"""Phenom's word table for prep: the words a page's `checkRemote` says.""" + +from __future__ import annotations + +import importlib + +phenom = importlib.import_module("app.prep.hosts.phenom") + + +def test_check_remote_words_read() -> None: + assert phenom.REMOTE["on-site"] == "onsite" # King's pages + assert phenom.REMOTE["remote"] == "remote" and phenom.REMOTE["hybrid"] == "hybrid" diff --git a/tests/test_prep_hosts_pinpoint.py b/tests/test_prep_hosts_pinpoint.py new file mode 100644 index 0000000..26d0727 --- /dev/null +++ b/tests/test_prep_hosts_pinpoint.py @@ -0,0 +1,24 @@ +"""Pinpoint's word tables for prep: `workplace_type` and `employment_type`.""" + +from __future__ import annotations + +import importlib + +pinpoint = importlib.import_module("app.prep.hosts.pinpoint") + + +def _match(code: str) -> str | None: + """The first entry of `MATCH` found in the lowercased code.""" + code = code.strip().lower() + return next((value for fragment, value in pinpoint.MATCH if fragment in code), None) + + +def test_workplace_types_read() -> None: + assert pinpoint.REMOTE == {"onsite": "onsite", "on_site": "onsite", "hybrid": "hybrid", + "remote": "remote"} + + +def test_employment_types_read_by_their_fragments() -> None: + assert [_match(w) for w in ("permanent_full_time", "fixed_term_full_time", + "permanent_part_time", "internship", "something_new")] == [ + "full_time", "temporary", "part_time", "internship", None] diff --git a/tests/test_prep_hosts_recruitee.py b/tests/test_prep_hosts_recruitee.py new file mode 100644 index 0000000..3d4072e --- /dev/null +++ b/tests/test_prep_hosts_recruitee.py @@ -0,0 +1,27 @@ +"""Recruitee's word tables for prep: the host's codes, and what they mean.""" + +from __future__ import annotations + +import importlib + +recruitee = importlib.import_module("app.prep.hosts.recruitee") + + +def _match(word: str) -> str | None: + """The first entry of `MATCH` found among the words of a code.""" + words = set(word.strip().lower().replace("-", "_").split("_")) + return next((value for fragment, value in recruitee.MATCH if fragment in words), None) + + +def test_experience_codes_read() -> None: + seniority = recruitee.SENIORITY + assert [seniority[w] for w in ("student_school", "entry_level", "mid_level")] == [ + "intern", "junior", "mid"] + assert seniority["experienced"] == "" + assert "senior_level" not in seniority + + +def test_employment_type_codes_read_by_their_words() -> None: + assert [_match(w) for w in ("fulltime_permanent", "parttime_permanent", "internship", + "fulltime_fixed_term", "freelance", "odd_job")] == [ + "full_time", "part_time", "internship", "temporary", "contract", None] diff --git a/tests/test_prep_hosts_rippling.py b/tests/test_prep_hosts_rippling.py new file mode 100644 index 0000000..756dd67 --- /dev/null +++ b/tests/test_prep_hosts_rippling.py @@ -0,0 +1,19 @@ +"""Rippling's word table for prep: the words of `employmentType.label`.""" + +from __future__ import annotations + +import importlib + +rippling = importlib.import_module("app.prep.hosts.rippling") + + +def _match(label: str) -> str | None: + """The first entry of `MATCH` found among the "_"-separated words of a label.""" + words = set(label.strip().lower().split("_")) + return next((value for token, value in rippling.MATCH if token in words), None) + + +def test_employment_labels_read_by_their_words() -> None: + assert [_match(w) for w in ("SALARIED_FT", "HOURLY_PT", "INTERN", "CONTRACTOR", + "SEASONAL", "ODD")] == [ + "full_time", "part_time", "internship", "contract", "temporary", None] diff --git a/tests/test_prep_hosts_smartrecruiters.py b/tests/test_prep_hosts_smartrecruiters.py new file mode 100644 index 0000000..8390c0d --- /dev/null +++ b/tests/test_prep_hosts_smartrecruiters.py @@ -0,0 +1,22 @@ +"""SmartRecruiters' word tables for prep: the host's ids, and what they mean.""" + +from __future__ import annotations + +import importlib + +smartrecruiters = importlib.import_module("app.prep.hosts.smartrecruiters") + + +def test_experience_levels_read() -> None: + seniority = smartrecruiters.SENIORITY + assert [seniority[w] for w in ("internship", "entry_level", "director", "executive")] == [ + "intern", "junior", "director", "exec"] + # Known, and naming no level. + assert [seniority[w] for w in ("associate", "mid_senior_level", "not_applicable")] == [""] * 3 + assert "guru" not in seniority + + +def test_employment_types_read() -> None: + employment = smartrecruiters.EMPLOYMENT + assert employment["intern"] == "internship" and employment["permanent"] == "" + assert employment["full_time"] == "full_time" and employment["part_time"] == "part_time" diff --git a/tests/test_prep_hosts_teamtailor.py b/tests/test_prep_hosts_teamtailor.py new file mode 100644 index 0000000..2856866 --- /dev/null +++ b/tests/test_prep_hosts_teamtailor.py @@ -0,0 +1,14 @@ +"""Teamtailor's word table for prep: the feed's `remoteStatus`.""" + +from __future__ import annotations + +import importlib + +teamtailor = importlib.import_module("app.prep.hosts.teamtailor") + + +def test_remote_status_words_read() -> None: + remote = teamtailor.REMOTE + assert [remote[w] for w in ("fully", "hybrid", "onsite")] == ["remote", "hybrid", "onsite"] + # Known, and saying nothing about where the role is worked. + assert remote["none"] == "" and remote["temporary"] == "" diff --git a/tests/test_prep_hosts_workable.py b/tests/test_prep_hosts_workable.py new file mode 100644 index 0000000..268bdf0 --- /dev/null +++ b/tests/test_prep_hosts_workable.py @@ -0,0 +1,18 @@ +"""Workable's word tables for prep: the host's own words, lowercased, and what they mean.""" + +from __future__ import annotations + +import importlib + +workable = importlib.import_module("app.prep.hosts.workable") + + +def test_workplace_words_read() -> None: + assert workable.REMOTE == {"remote": "remote", "hybrid": "hybrid", "on_site": "onsite"} + + +def test_type_words_read() -> None: + assert workable.EMPLOYMENT == {"full": "full_time", "part": "part_time", + "contract": "contract", "temporary": "temporary", + "internship": "internship"} + assert "volunteer" not in workable.EMPLOYMENT # an unknown word is prep's to report diff --git a/tests/test_prep_hosts_workday.py b/tests/test_prep_hosts_workday.py new file mode 100644 index 0000000..a23d698 --- /dev/null +++ b/tests/test_prep_hosts_workday.py @@ -0,0 +1,21 @@ +"""Workday's word tables for prep: the host's own words, lowercased, and what they mean.""" + +from __future__ import annotations + +import importlib + + +workday = importlib.import_module("app.prep.hosts.workday") + + +def test_remote_type_words_of_the_tenants_read() -> None: + remote = workday.REMOTE + # Zendesk's "Fully Flexible", Axis' "On-Site", Red Hat's "Onsite". + assert [remote[w] for w in ("remote", "fully flexible", "hybrid", "in office", + "on-site", "onsite")] == [ + "remote", "remote", "hybrid", "onsite", "onsite", "onsite"] + assert "no" not in remote # a bare "No" says nothing + + +def test_time_type_words_read() -> None: + assert workday.EMPLOYMENT == {"full time": "full_time", "part time": "part_time"} diff --git a/tests/test_readers_adzuna.py b/tests/test_readers_adzuna.py index ef378c5..a50a036 100644 --- a/tests/test_readers_adzuna.py +++ b/tests/test_readers_adzuna.py @@ -46,7 +46,7 @@ def test_it_strips_highlights_keeps_the_excerpt_as_teaser_and_drops_predicted_pa assert "description" not in first assert first["company"] == "Acme GmbH" assert first["places"] == [{"text": "Berlin, Deutschland", "remote": None}] - assert first["country"] == "DE" and first["remote"] == "remote" + assert first["country"] == "DE" and "remote" not in first assert (first["salary_min"], first["salary_max"], first["currency"]) == (70000, 90000, "EUR") assert (predicted["salary_min"], predicted["currency"]) == (None, None) diff --git a/tests/test_readers_platsbanken.py b/tests/test_readers_platsbanken.py index 4adc47b..88d5a37 100644 --- a/tests/test_readers_platsbanken.py +++ b/tests/test_readers_platsbanken.py @@ -61,12 +61,12 @@ def test_it_reads_title_company_date_and_the_full_text() -> None: first, _no_town, remote = platsbanken.rows(decoded, "") assert first["title"] == "Postdoctoral Researcher" assert first["company"] == "European Spallation Source Eric" - assert first["country"] == "SE" and first["remote"] is None + assert first["country"] == "SE" and first["remote"] == "Arbete på plats" assert first["url"] == "https://arbetsformedlingen.se/platsbanken/annonser/31457942" assert first["posted"].date().isoformat() == "2026-09-09" assert first["description"].startswith("The European Spallation Source") assert "teaser" not in first - assert (remote["remote"], remote["company"], remote["posted"]) == ("remote", "", None) + assert (remote["remote"], remote["company"], remote["posted"]) == (None, "", None) def test_it_sends_the_region_the_offset_and_no_region_for_all_of_sweden() -> None: diff --git a/tests/test_readers_shared.py b/tests/test_readers_shared.py index 91b3474..e03529f 100644 --- a/tests/test_readers_shared.py +++ b/tests/test_readers_shared.py @@ -2,6 +2,7 @@ from __future__ import annotations +import importlib import logging import sys from pathlib import Path @@ -24,6 +25,16 @@ from plugins.readers._shared import ( # noqa: E402 #: The module-level names a reader keeps its employment words in. _TABLES = ("_EMPLOYMENT", "_CONTRACT", "_SCHEDULE") +#: The hosts whose word tables are prep's, in `app/prep/hosts/.py`. +_PREP_HOSTS = ("oracle", "personio", "phenom", "pinpoint", "recruitee", "rippling", + "smartrecruiters", "teamtailor", "workable", "workday") + + +def _prep_table(name: str, table_name: str): + """A word table of `app.prep.hosts.`, or None where it has none.""" + module = importlib.import_module(f"app.prep.hosts.{name}") + return getattr(module, table_name, None) + def test_every_employment_table_maps_into_the_shared_vocabulary() -> None: found = 0 @@ -36,9 +47,30 @@ def test_every_employment_table_maps_into_the_shared_vocabulary() -> None: values = table.values() if isinstance(table, dict) else [v for _k, v in table] # "" is a known word that names no employment ("permanent"). assert set(values) <= {*EMPLOYMENTS, ""}, (name, table_name) + for name in _PREP_HOSTS: + for table_name in ("EMPLOYMENT", "MATCH"): + table = _prep_table(name, table_name) + if table is None: + continue + values = table.values() if isinstance(table, dict) else [v for _k, v in table] + found += 1 + assert set(values) <= {*EMPLOYMENTS, ""}, (name, table_name) assert found >= 15 +def test_the_prep_tables_of_the_hosts_speak_the_apps_vocabulary() -> None: + from app.models import SENIORITIES + for name in _PREP_HOSTS: + seniority = _prep_table(name, "SENIORITY") + if seniority is not None: + assert set(seniority.values()) <= {*SENIORITIES, ""}, name + remote = _prep_table(name, "REMOTE") + if remote is not None: + assert set(remote.values()) <= {"remote", "hybrid", "onsite", ""}, name + for table in (seniority, remote, _prep_table(name, "EMPLOYMENT")): + assert table is None or all(k == k.lower() for k in table), name + + def test_the_vocabulary_is_the_documented_one() -> None: assert EMPLOYMENTS == ("full_time", "part_time", "contract", "temporary", "internship", "freelance")