diff --git a/app/jobs/discover.py b/app/jobs/discover.py index c118418..2e35765 100644 --- a/app/jobs/discover.py +++ b/app/jobs/discover.py @@ -10,6 +10,10 @@ read; any other host is recorded as `ats`, with its slug where the URL carries one, so the company is kept as one the app cannot read yet rather than dropped. +A Teamtailor site on the company's own domain names no slug: the page only +loads Teamtailor's CDN. The board there is the site's own host, and it is +taken only once that host answers `/jobs.rss` with a Teamtailor feed. + Only when no page names a host at all are the hosts with a cheap per-slug endpoint (`_PROBES`) probed with the company's own slug, because a site that draws its jobs from an iframe or a script leaves no link to find. A page that @@ -50,7 +54,7 @@ MAX_PAGES = 6 #: The hosts the `ats` plugin parses; a match on one of these is a `board`. READABLE = ("greenhouse", "lever", "ashby", "workable", "smartrecruiters", - "recruitee", "personio") + "recruitee", "personio", "teamtailor") #: host -> pattern over a URL. Group 1, where there is one, is the slug the #: host names the company by; a host with no group is recognised but its @@ -70,12 +74,14 @@ HOSTS: tuple[tuple[str, re.Pattern[str]], ...] = tuple( ("smartrecruiters", r"(?:jobs|careers|api)\.smartrecruiters\.com/(?:v1/companies/)?([A-Za-z0-9_-]+)"), ("recruitee", r"https?://([a-z0-9-]+)\.recruitee\.com"), ("personio", r"https?://([a-z0-9-]+)\.jobs\.personio\.(?:de|com)"), + ("teamtailor", r"https?://([a-z0-9-]+)\.teamtailor\.com"), + # No slug: a career site on the company's own domain, which only loads + # Teamtailor's CDN. `_discover` reads its board off the page's host. + ("teamtailor", r"cdn\.teamtailor\.com|teamtailor-cdn|teamtailor\.com/assets"), # Not readable. The slug, where the URL has one, is kept for the day # a parser exists. ("workday", r"https?://([a-z0-9-]+)\.wd\d+\.myworkdayjobs\.com"), ("successfactors", r"(?:career|jobs|performancemanager)\d*\.successfactors\.(?:eu|com)|\.sapsf\.(?:eu|com)"), - ("teamtailor", r"https?://([a-z0-9-]+)\.teamtailor\.com"), - ("teamtailor", r"cdn\.teamtailor\.com|teamtailor-cdn|teamtailor\.com/assets"), ("icims", r"https?://([a-z0-9-]+)\.icims\.com"), ("taleo", r"\.taleo\.net"), ("jobvite", r"jobs\.jobvite\.com/([a-z0-9-]+)"), @@ -97,6 +103,10 @@ HOSTS: tuple[tuple[str, re.Pattern[str]], ...] = tuple( ("hibob", r"https?://([a-z0-9-]+)\.hibob\.com"), )) +#: What a Teamtailor feed carries and a page that only looks like one does not: +#: the namespace of `tt:locations`, declared on `` even when no role is open. +TEAMTAILOR_FEED = "https://teamtailor.com/locations" + #: Paths a careers page usually lives at, tried after the home page's own #: links so the site's word for it wins over a guess. CAREERS_PATHS = ("/careers", "/careers/", "/jobs", "/en/careers", "/company/careers", @@ -117,9 +127,10 @@ _TAGS = re.compile(r"<[^>]+>") #: Words a pattern's slug group can catch that name no board: the hosts' #: own path segments, the analytics subdomain Recruitee sites embed, and -#: the CDN Teamtailor sites load from (cdn.teamtailor.com). +#: the CDN and the admin app Teamtailor sites load from (cdn.teamtailor.com, +#: app.teamtailor.com). _NOT_SLUGS = frozenset({"embed", "boards", "v1", "api", "www", "jobs", "careers", "apply", - "careers-analytics", "cdn"}) + "careers-analytics", "cdn", "app"}) Found = tuple[str, str, str] # (host, slug, the URL that named it) @@ -236,6 +247,7 @@ _PROBES = { "smartrecruiters": "https://api.smartrecruiters.com/v1/companies/{slug}/postings?limit=1", "recruitee": "https://{slug}.recruitee.com/api/offers/", "personio": "https://{slug}.jobs.personio.de/xml", + "teamtailor": "https://{slug}.teamtailor.com/jobs.rss", } @@ -260,6 +272,8 @@ def probe(client: httpx.Client, host: str, slug: str) -> bool: return b'"offers":[' in body and b'"offers":[]' not in body if host == "personio": return b"" in body + if host == "teamtailor": + return b"" in body return True @@ -305,6 +319,7 @@ def _discover(name: str, site: str, client: httpx.Client, fetch: Fetch, home_url, home = fetch(client, f"https://{site}/") unreadable: Discovery | None = None careers_page = "" + own_sites: list[tuple[str, str]] = [] # (host, page) that loaded Teamtailor's CDN def first_readable(found: list[Found], page: str) -> Discovery | None: """The first readable board on a page. Otherwise the first host named @@ -312,6 +327,9 @@ def _discover(name: str, site: str, client: httpx.Client, fetch: Fetch, may name teamtailor by its CDN before it links acme.teamtailor.com.""" nonlocal unreadable for host, slug, url in found: + site_host = httpx.URL(page).host if page else "" + if host == "teamtailor" and not slug and site_host and (site_host, page) not in own_sites: + own_sites.append((site_host, page)) if host in READABLE and slug: return Discovery(board=f"{host}:{slug}", ats=host, ats_slug=slug, careers_url=page, evidence=url) @@ -347,6 +365,14 @@ def _discover(name: str, site: str, client: httpx.Client, fetch: Fetch, if hit := first_readable(boards_in(text), final): return hit queue[:0] = [link for link in careers_links(text, final)[:2] if link not in seen] + # A page loaded Teamtailor's CDN and linked no *.teamtailor.com: the site + # itself is the board, if it serves the feed. + for site_host, page in own_sites: + feed = f"https://{site_host}/jobs.rss" + _final, text = fetch(client, feed) + if TEAMTAILOR_FEED in text: + return Discovery(board=f"teamtailor:{site_host}", ats="teamtailor", + ats_slug=site_host, careers_url=page, evidence=feed) # A page named a host the app cannot read: that is the answer, and a # probe could only add another tenant's board of the same name. if unreadable is not None: diff --git a/plugins/ats.py b/plugins/ats.py index 1c6acb0..ba6b618 100644 --- a/plugins/ats.py +++ b/plugins/ats.py @@ -1,7 +1,8 @@ -"""ATS boards: Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Personio. +"""ATS boards: Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Personio, +Teamtailor. Every one of these hosts is a company's own careers page speaking public, -unauthenticated JSON (Personio: XML) — first-party, no scraping, and a role +unauthenticated JSON (Personio, Teamtailor: XML) — first-party, no scraping, and a role that drops off the board is *closed*, which is the cheapest staleness check there is. @@ -12,18 +13,25 @@ The field map and the redirect allow-list are ported from Recruitee and Personio are new: jobhunt-hq only read Greenhouse, Lever and Ashby, so those four are written from one real board of each host, fetched while this file was written (2026-09-23; Workable on 2026-09-28, when the -first board with roles was seen), rather than from the Go source. +first board with roles was seen), rather than from the Go source. Teamtailor +is the same, written from live feeds on 2026-09-29. The body cap is not a straight port — see `MAX_BYTES` below. A target is `host:slug`, e.g. `greenhouse:databricks`, `ashby:deepl`, -`lever:acme`. Every board is fetched independently; one that fails or times +`lever:acme`, `teamtailor:acme`. Every board is fetched independently; one that fails or times out is logged, recorded as failing under `ats:failing:` (see `ATSSource.fetch`), and skipped, and the rest continue. -Workable and SmartRecruiters page their list and state a total; every other -host answers with the whole board at once. A paged board counts as complete -only when it read as many distinct roles as the total says (see `_paged`). +A Teamtailor slug is the `acme` of acme.teamtailor.com, or, for a career site +on the company's own domain, that whole host name: `teamtailor:careers.acme.com` +(see `_teamtailor_site`). + +Workable and SmartRecruiters page their list and state a total; Teamtailor +pages by offset and states none; every other host answers with the whole board +at once. A board with a total counts as complete only when it read as many +distinct roles as the total says, one without when it read up to an empty page +(see `_paged`). """ from __future__ import annotations @@ -36,6 +44,7 @@ import time import xml.etree.ElementTree as ET from collections.abc import Callable, Iterator from datetime import UTC, datetime +from email.utils import parsedate_to_datetime from typing import Any import httpx @@ -76,7 +85,8 @@ TIMEOUTS = httpx.Timeout(10.0, read=30.0) DEADLINE = 60.0 #: host -> (feed URL template, careers URL template). `{slug}` is filled in; -#: recruitee and personio put the slug in the hostname instead of the path. +#: recruitee and personio put the slug in the hostname instead of the path, +#: and teamtailor's `{site}` is the whole host (see `_teamtailor_site`). _BOARDS: dict[str, tuple[str, str]] = { "greenhouse": ("https://boards-api.greenhouse.io/v1/boards/{slug}/jobs" "?content=true&pay_transparency=true", @@ -94,6 +104,7 @@ _BOARDS: dict[str, tuple[str, str]] = { "https://{slug}.recruitee.com"), "personio": ("https://{slug}.jobs.personio.de/xml", "https://{slug}.jobs.personio.de"), + "teamtailor": ("https://{site}/jobs.rss", "https://{site}/jobs"), } #: host -> the name the host gives itself: the hosts this plugin reads, in @@ -102,13 +113,14 @@ _BOARDS: dict[str, tuple[str, str]] = { HOSTS: dict[str, str] = { "greenhouse": "Greenhouse", "lever": "Lever", "ashby": "Ashby", "workable": "Workable", "smartrecruiters": "SmartRecruiters", - "recruitee": "Recruitee", "personio": "Personio", + "recruitee": "Recruitee", "personio": "Personio", "teamtailor": "Teamtailor", } assert set(HOSTS) == set(_BOARDS) #: The hosts a request or a redirect may land on for a given board host — a -#: fixed API host for five of them, and the company's own subdomain for the -#: two that put the slug in the hostname. Anything else is refused, at the +#: fixed API host for five of them, the company's own subdomain for the two +#: that put the slug in the hostname, and the one site a Teamtailor slug names. +#: Anything else is refused, at the #: first hop and at every redirect: a feed is external content, and a board #: row must never be able to point this fetch at an internal address. def _allowed_host(host: str, slug: str) -> Callable[[str], bool]: @@ -128,9 +140,31 @@ def _allowed_host(host: str, slug: str) -> Callable[[str], bool]: if host == "personio": want = f"{slug}.jobs.personio.de" return lambda h: h == want + if host == "teamtailor": + want = _teamtailor_site(slug) + return lambda h: h == want return lambda h: False +#: The host a Teamtailor 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, `careers.acme.com`, taken whole (the feed path is the same on both). +#: Only a DNS name with a letter in its last label is one, so an address +#: (`127.0.0.1`, `[::1]`) or a single word never names a host the fetch could be +#: pointed at; `_get` still refuses every host but this one, redirects included. +_TEAMTAILOR_HOST = re.compile(r"^[a-z0-9-]+(\.[a-z0-9-]+)*$") + + +def _teamtailor_site(slug: str) -> str: + slug = slug.strip().lower() + return slug if "." in slug else f"{slug}.teamtailor.com" + + +def _teamtailor_slug_ok(slug: str) -> bool: + site = _teamtailor_site(slug) + return bool(_TEAMTAILOR_HOST.match(site)) and not site.rsplit(".", 1)[-1].isdigit() + + def _is_web_url(url: str) -> bool: """A trimmed http(s) URL, or refuse — a feed is external content and a `javascript:` or `data:` link must never reach an href. Port of @@ -200,8 +234,8 @@ def _get(client: httpx.Client, url: str, host: str, slug: str, *, def _parse_dt(value: Any) -> datetime | None: """An aware datetime from whatever a board sends: ISO-8601 with an - offset, `Z`, a bare date, epoch milliseconds, or "YYYY-MM-DD HH:MM:SS - UTC". None for anything else, which `Item` reads as "now".""" + offset, `Z`, a bare date, epoch milliseconds, "YYYY-MM-DD HH:MM:SS UTC", + or an RSS date ("Tue, 29 Sep 2026 13:36:59 +0200"). None for anything else, which `Item` reads as "now".""" if value is None: return None if isinstance(value, int | float): @@ -217,7 +251,11 @@ def _parse_dt(value: Any) -> datetime | None: except ValueError: match = re.match(r"^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})", text) if not match: - return None + try: + parsed = parsedate_to_datetime(text) + except (TypeError, ValueError): + return None + return parsed if parsed.utcoffset() is not None else parsed.replace(tzinfo=UTC) parsed = datetime.fromisoformat(f"{match.group(1)}T{match.group(2)}+00:00") return parsed if parsed.utcoffset() is not None else parsed.replace(tzinfo=UTC) @@ -234,7 +272,7 @@ Row = dict[str, Any] # (integers) and `currency` (ISO 4217) — the columns `upsert_role` unpacks # `raw` into, per docs/decisions.md's "raw is transport, columns are # storage". Only Ashby, Greenhouse, Lever, Recruitee and Personio give -# structured pay on their list endpoint; Workable and SmartRecruiters do not +# structured pay on their list endpoint; Workable, SmartRecruiters and Teamtailor do not # (checked live, 2026-09-29), so their parsers are untouched and `row.get` # below reads a plain '' or None for them. @@ -684,8 +722,67 @@ def _parse_personio(body: bytes, slug: str) -> list[Row]: return rows +#: 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". +_TEAMTAILOR_REMOTE = {"fully": "remote", "hybrid": "hybrid", "onsite": "onsite"} + + +def _parse_teamtailor(body: bytes, slug: str) -> list[Row]: + return _teamtailor_rows(_teamtailor_items(body), slug) + + +def _teamtailor_items(body: bytes) -> list[ET.Element]: + """`{site}/jobs.rss` -> `...`, the feed every Teamtailor + career site serves (checked live on a dozen sites, 2026-09-29). A missing + `channel` is a page that is not a feed, and raises.""" + channel = ET.fromstring(body).find("channel") + if channel is None: + raise ValueError("not a Teamtailor feed: no channel") + return channel.findall("item") + + +def _teamtailor_rows(items: list[ET.Element], slug: str) -> list[Row]: + """One page of items. The item has the title, the job URL (on the site's + own domain), a `guid` uuid, `pubDate`, the HTML `description` in full, + `remoteStatus` (fully, hybrid, onsite, none or temporary), and, in the + `tt:` namespace, `locations` (a list: `city` and `country` each, `name` free + text), `department` and `role`, either of which may be empty. `place` joins + the distinct locations with "; ", which `country_of` reads a location at a + time. No pay is stated anywhere in the feed.""" + rows = [] + for item in items: + title = (item.findtext("title") or "").strip() + url = (item.findtext("link") or "").strip() + if not title or not _is_web_url(url): + continue + places: list[str] = [] + for loc in item.findall(f"{_TT}locations/{_TT}location"): + city = (loc.findtext(f"{_TT}city") or loc.findtext(f"{_TT}name") or "").strip() + country = (loc.findtext(f"{_TT}country") or "").strip() + place = city if country == city else ", ".join(p for p in (city, country) if p) + if place and place not in places: + places.append(place) + rows.append({ + "source_id": (item.findtext("guid") or url).strip(), + "title": title, + "location": "; ".join(places), + "url": url, + "posted": _parse_dt(item.findtext("pubDate")), + "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": _TEAMTAILOR_REMOTE.get((item.findtext("remoteStatus") or "").strip()), + "salary_text": "", # Teamtailor's feed states no pay at all + }) + return rows + + #: host -> parser. Every one takes the raw response body, plus the slug for -#: the two hosts whose feed does not carry the URL or the company itself. +#: the hosts whose feed does not carry the URL or the company itself. _PARSERS: dict[str, Callable[..., list[Row]]] = { "greenhouse": lambda body, slug: _parse_greenhouse(body), "lever": lambda body, slug: _parse_lever(body), @@ -694,6 +791,7 @@ _PARSERS: dict[str, Callable[..., list[Row]]] = { "smartrecruiters": _parse_smartrecruiters, "recruitee": lambda body, slug: _parse_recruitee(body), "personio": _parse_personio, + "teamtailor": _parse_teamtailor, } @@ -825,11 +923,13 @@ def classify(department: str, title: str) -> str: def is_known_target(target: str) -> bool: - """`host:slug`, with `host` one of `_BOARDS` and a non-empty slug. What + """`host:slug`, with `host` one of `_BOARDS` and a non-empty slug (for + Teamtailor one that names a host, see `_teamtailor_slug_ok`). What the target validator refuses: `app companies add` and the pull job both call this before touching the network.""" host, sep, slug = target.partition(":") - return bool(sep) and host in _BOARDS and bool(slug.strip()) + return (bool(sep) and host in _BOARDS and bool(slug.strip()) + and (host != "teamtailor" or _teamtailor_slug_ok(slug))) def careers_url(target: str) -> str: @@ -838,12 +938,12 @@ def careers_url(target: str) -> str: host, _, slug = target.partition(":") if host not in _BOARDS: return "" - return _BOARDS[host][1].format(slug=slug) + return _BOARDS[host][1].format(slug=slug, site=_teamtailor_site(slug)) #: Pages read from one paged board at most, and the pause between two of -#: them. Workable answers ten roles a page and SmartRecruiters a hundred, so -#: the cap is 1,000 and 10,000 roles; the pause keeps Workable, which answers +#: them. Workable answers ten roles a page, SmartRecruiters a hundred and +#: Teamtailor fifty, so the cap is 1,000, 10,000 and 5,000 roles; the pause keeps Workable, which answers #: a burst with 429, from seeing one. MAX_PAGES = 100 PAGE_DELAY = 0.5 @@ -851,9 +951,17 @@ PAGE_DELAY = 0.5 #: SmartRecruiters' page size, which is also the most it serves per page. SMARTRECRUITERS_PAGE = 100 +#: Teamtailor's page size, asked for as `per_page`. A feed with neither +#: parameter answers with every role (73 of 73 at Shine, 2026-09-29), but says +#: nowhere that it is the whole list, so this reads by page to an empty one; +#: `per_page=200` was answered in full too, and the cursor advances by what a +#: page returned, so a smaller cap on the host's side would not skip a role. +TEAMTAILOR_PAGE = 50 + #: A paged host's one page: `(client, slug, cursor)` -> the decoded page, its -#: raw results, the total it states, and the cursor of the next page (None -#: after the last). The first call gets cursor None. +#: raw results, the total it states (None for a host that states none), and the +#: cursor of the next page (None after the last). The first call gets cursor +#: None. Page = tuple[dict[str, Any], list[dict[str, Any]], Any, Any] @@ -873,19 +981,32 @@ def _smartrecruiters_page(client: httpx.Client, slug: str, cursor: Any) -> Page: return data, content, data.get("totalFound"), offset + len(content) if content else None +def _teamtailor_page(client: httpx.Client, slug: str, cursor: Any) -> Page: + offset = int(cursor or 0) + url = (_BOARDS["teamtailor"][0].format(site=_teamtailor_site(slug)) + + f"?per_page={TEAMTAILOR_PAGE}&offset={offset}") + items = _teamtailor_items(_get(client, url, "teamtailor", slug)) + results = [{"id": item.findtext("guid") or item.findtext("link") or ""} for item in items] + return items, results, None, offset + len(items) if items else None + + #: host -> (one page, that page's rows) for the hosts that page. _PAGED: dict[str, tuple[Callable[[httpx.Client, str, Any], Page], Callable[[dict[str, Any], str], list[Row]]]] = { "workable": (_workable_page, _workable_rows), "smartrecruiters": (_smartrecruiters_page, _smartrecruiters_rows), + "teamtailor": (_teamtailor_page, _teamtailor_rows), } def _paged(client: httpx.Client, target: str) -> tuple[list[Row], bool]: - """Every page of a Workable or SmartRecruiters board, `PAGE_DELAY` apart, - until the host has no next page, the stated total is reached, or - `MAX_PAGES`. Returns the rows and whether the board is complete: as many - distinct results read as the host's stated total. Counted on the raw + """Every page of a Workable, SmartRecruiters or Teamtailor board, + `PAGE_DELAY` apart, until the host has no next page, the stated total is + reached, or `MAX_PAGES`. Returns the rows and whether the board is + complete: as many distinct results read as the host's stated total, or, + for a host that states none (Teamtailor), the read ended on an empty page + (a page with nothing new in it ends the read short of that, incomplete, + so an offset the host ignores cannot loop). Counted on the raw results, so a row the parser drops does not make a board incomplete, and on distinct ids, so a page that shifted under an offset and repeated a role does not make it complete. @@ -909,14 +1030,17 @@ def _paged(client: httpx.Client, target: str) -> tuple[list[Row], bool]: log.warning("ats: %s: 429 on page %d; kept %d of %s, not complete", target, page + 1, len(seen), total) return list(rows.values()), False + before = len(seen) seen |= {str(r.get("id") or r.get("shortcode") or "") for r in results} for row in rows_of(data, slug): rows.setdefault(row["source_id"], row) - if cursor is None or (isinstance(total, int) and len(seen) >= total): + if (cursor is None or (isinstance(total, int) and len(seen) >= total) + or (total is None and len(seen) == before)): break - complete = isinstance(total, int) and len(seen) == total + complete = len(seen) == total if isinstance(total, int) else total is None and cursor is None if not complete: - log.warning("ats: %s: read %d of %s stated; not complete", target, len(seen), total) + log.warning("ats: %s: read %d of %s stated; not complete", target, len(seen), + "an unstated total" if total is None else total) return list(rows.values()), complete @@ -972,7 +1096,7 @@ def failure_reason(exc: BaseException) -> str: class ATSSource(Source): name = "ats" description = "Company job boards: Greenhouse, Lever, Ashby, Workable, " \ - "SmartRecruiters, Recruitee, Personio." + "SmartRecruiters, Recruitee, Personio, Teamtailor." #: The raw entries under `sources.ats.boards` are `{"url": target, "label": #: company}` — `url` carries the `host:slug` target and `label` the #: company name, which is how `Source.targets()`'s generic dict reading diff --git a/tests/test_ats.py b/tests/test_ats.py index 2574d56..84adb4b 100644 --- a/tests/test_ats.py +++ b/tests/test_ats.py @@ -6,6 +6,7 @@ from __future__ import annotations import json import sys +from datetime import UTC, datetime from pathlib import Path from collections.abc import Callable, Iterator from typing import Any @@ -194,6 +195,120 @@ def test_personio_salary_text_states_a_monthly_rate_with_no_currency() -> None: (None, None, "") +# Trimmed from live feeds of 2026-09-29 (career.kry.se, careers.tobii.com): the +# `tt:` namespace, an item with several locations, one whose city is a country, +# an empty department with a role, and one whose link is not a web URL. +TEAMTAILOR = """ + + + Kry + Job openings + https://career.kry.se/jobs + + Software Engineer + <h1>About the role</h1><p>Build &amp; run care.</p> + Wed, 23 Sep 2026 12:59:53 +0200 + https://career.kry.se/jobs/8440833-software-engineer + hybrid + 39ac1fca-a904-4905-b780-18c599e99b07 + Kry + + + Sverige + SverigeSweden + + + Stockholm, SverigeTorsgatan 21 + 113 21StockholmSweden + + + Stockholm, SverigeTorsgatan 21 + 113 21StockholmSweden + + + Engineering + + + + Läkare + <p>Träffa patienter.</p> + Fri, 31 Jul 2026 14:51:42 +0200 + https://career.kry.se/jobs/8156121-lakare + fully + 9787a509-ff84-400a-ad68-84e22c4cf2fb + + + SwedenKarlsrovägen 2D + 182 53DanderydSweden + + + + Software Development + + + Sales Lead + + https://career.kry.se/jobs/8156122-sales-lead + none + 0a0a0a0a-ff84-400a-ad68-84e22c4cf2fb + + Sales + + + + Elsewhere + javascript:alert(1) + bad + + + +""".encode() + + +def test_teamtailor_reads_the_rss_feed_with_its_own_namespace() -> None: + rows = ats._parse_teamtailor(TEAMTAILOR, "kry") + # the javascript: link is refused like on the other hosts + assert [r["source_id"] for r in rows] == [ + "39ac1fca-a904-4905-b780-18c599e99b07", "9787a509-ff84-400a-ad68-84e22c4cf2fb", + "0a0a0a0a-ff84-400a-ad68-84e22c4cf2fb"] + first = rows[0] + assert first["url"] == "https://career.kry.se/jobs/8440833-software-engineer" + assert first["department"] == "Engineering" + assert first["description"] == "About the role Build & run care." + assert first["posted"] == datetime(2026, 9, 23, 10, 59, 53, tzinfo=UTC) + assert first["salary_text"] == "" + + +def test_teamtailor_joins_the_distinct_locations_for_country_of() -> None: + from app.models import country_of + + rows = ats._parse_teamtailor(TEAMTAILOR, "kry") + # "Sverige" (a city that is a country) once, Stockholm's twin once + assert rows[0]["location"] == "Sverige, Sweden; Stockholm, Sweden" + assert rows[1]["location"] == "Danderyd, Sweden" + assert rows[2]["location"] == "" + assert country_of(rows[0]["location"]) == "SE" + + +def test_teamtailor_maps_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 rows[1]["title"] == "Läkare" # trimmed + assert rows[1]["department"] == "Software Development" + assert ats.classify(rows[1]["department"], "Sales Lead") == "sales" + + +def test_teamtailor_refuses_a_page_that_is_not_a_feed() -> None: + with pytest.raises(ValueError): + ats._parse_teamtailor(b"", "kry") + + +def test_parse_dt_reads_an_rss_date_and_still_refuses_junk() -> None: + assert ats._parse_dt("Tue, 29 Sep 2026 13:36:59 +0200") == \ + datetime(2026, 9, 29, 11, 36, 59, tzinfo=UTC) + assert ats._parse_dt("last tuesday") is None + + # ------------------------------------------------------------ salary math def test_yearly_amount_converts_a_monthly_range_by_12() -> None: @@ -264,14 +379,19 @@ def test_classify_understands_a_modest_set_of_other_languages() -> None: # ------------------------------------------------------------- allow-list -def test_is_known_target_accepts_the_seven_hosts_and_refuses_others() -> None: +def test_is_known_target_accepts_the_eight_hosts_and_refuses_others() -> None: for host in ("greenhouse", "lever", "ashby", "workable", "smartrecruiters", - "recruitee", "personio"): + "recruitee", "personio", "teamtailor"): assert ats.is_known_target(f"{host}:acme") assert not ats.is_known_target("linkedin:acme") assert not ats.is_known_target("workday:acme") assert not ats.is_known_target("greenhouse:") assert not ats.is_known_target("nohostnoseparator") + # a Teamtailor slug names a host: its own subdomain, or a whole domain + assert ats.is_known_target("teamtailor:careers.acme.com") + assert not ats.is_known_target("teamtailor:127.0.0.1") + assert not ats.is_known_target("teamtailor:acme.com/x") + assert not ats.is_known_target("teamtailor:acme com") def test_allowed_host_refuses_a_foreign_host_per_board() -> None: @@ -286,11 +406,20 @@ def test_allowed_host_refuses_a_foreign_host_per_board() -> None: assert allow_recruitee("acme.recruitee.com") assert not allow_recruitee("other.recruitee.com") + # teamtailor: the subdomain of a plain slug, the whole host of a dotted one + assert ats._allowed_host("teamtailor", "acme")("acme.teamtailor.com") + assert not ats._allowed_host("teamtailor", "acme")("other.teamtailor.com") + own = ats._allowed_host("teamtailor", "Careers.Acme.com") + assert own("careers.acme.com") + assert not own("acme.com") and not own("careers.acme.com.evil.example") + def test_careers_url_is_filled_per_host_and_empty_for_unknown() -> None: assert ats.careers_url("greenhouse:acme") == "https://job-boards.greenhouse.io/acme" assert ats.careers_url("ashby:acme") == "https://jobs.ashbyhq.com/acme" assert ats.careers_url("recruitee:acme") == "https://acme.recruitee.com" + assert ats.careers_url("teamtailor:acme") == "https://acme.teamtailor.com/jobs" + assert ats.careers_url("teamtailor:careers.acme.com") == "https://careers.acme.com/jobs" assert ats.careers_url("workday:acme") == "" @@ -517,6 +646,107 @@ def test_a_429_on_the_first_page_is_a_failure( ats._fetch_rows(object(), "workable:exotec") # type: ignore[arg-type] +def _feed(guids: list[str]) -> bytes: + """A Teamtailor feed of `guids`, one role each.""" + items = "".join( + f"Role {g}https://careers.acme.com/jobs/{g}" + f"{g}" for g in guids) + return ('' + f"{items}").encode() + + +def _teamtailor_web(monkeypatch: pytest.MonkeyPatch, guids: list[str], + page: int = 2) -> list[str]: + """`_get` answering from `guids` by `offset` and `per_page`, as a + Teamtailor site does, returning the URLs it was asked.""" + urls: list[str] = [] + + def fake_get(client, url, host, slug, *, method="GET", payload=None): + urls.append(url) + query = dict(httpx.URL(url).params) + start, size = int(query["offset"]), min(int(query["per_page"]), page) + return _feed(guids[start:start + size]) + + monkeypatch.setattr(ats, "_get", fake_get) + return urls + + +def test_teamtailor_pages_by_offset_and_is_complete_on_an_empty_page( + monkeypatch: pytest.MonkeyPatch, no_delay: None) -> None: + """The host caps a page below what was asked; the offset advances by what + came back, and the read ends on the empty page after the last role.""" + urls = _teamtailor_web(monkeypatch, ["a", "b", "c", "d", "e"]) + rows, complete = ats._fetch_rows(object(), "teamtailor:careers.acme.com") # type: ignore[arg-type] + + base = "https://careers.acme.com/jobs.rss?per_page=50" + assert urls == [f"{base}&offset=0", f"{base}&offset=2", f"{base}&offset=4", + f"{base}&offset=5"] + assert [r["source_id"] for r in rows] == ["a", "b", "c", "d", "e"] + assert complete + + +def test_a_teamtailor_slug_without_a_dot_is_a_teamtailor_subdomain( + monkeypatch: pytest.MonkeyPatch, no_delay: None) -> None: + urls = _teamtailor_web(monkeypatch, ["a"]) + ats._fetch_rows(object(), "teamtailor:acme") # type: ignore[arg-type] + assert urls[0].startswith("https://acme.teamtailor.com/jobs.rss?") + + +def test_a_board_with_no_roles_is_complete_at_zero( + monkeypatch: pytest.MonkeyPatch, no_delay: None) -> None: + _teamtailor_web(monkeypatch, []) + assert ats._fetch_rows(object(), "teamtailor:acme") == ([], True) # type: ignore[arg-type] + + +def test_a_teamtailor_host_that_ignores_the_offset_is_incomplete( + monkeypatch: pytest.MonkeyPatch, no_delay: None) -> None: + """The same page again: nothing new, so the read stops rather than loops.""" + calls: list[str] = [] + + def fake_get(client, url, host, slug, *, method="GET", payload=None): + calls.append(url) + return _feed(["a", "b"]) + + monkeypatch.setattr(ats, "_get", fake_get) + rows, complete = ats._fetch_rows(object(), "teamtailor:acme") # type: ignore[arg-type] + assert (len(calls), len(rows), complete) == (2, 2, False) + + +def test_the_page_cap_leaves_a_teamtailor_board_incomplete( + monkeypatch: pytest.MonkeyPatch, no_delay: None) -> None: + _teamtailor_web(monkeypatch, [str(n) for n in range(10)]) + monkeypatch.setattr(ats, "MAX_PAGES", 2) + rows, complete = ats._fetch_rows(object(), "teamtailor:acme") # type: ignore[arg-type] + assert (len(rows), complete) == (4, False) + + +def test_a_teamtailor_429_after_the_first_page_is_incomplete( + monkeypatch: pytest.MonkeyPatch, no_delay: None) -> None: + def fake_get(client, url, host, slug, *, method="GET", payload=None): + if "offset=0" not in url: + raise _status(429) + return _feed(["a", "b"]) + + monkeypatch.setattr(ats, "_get", fake_get) + rows, complete = ats._fetch_rows(object(), "teamtailor:acme") # type: ignore[arg-type] + assert ([r["source_id"] for r in rows], complete) == (["a", "b"], False) + + +def test_teamtailor_is_read_through_the_streamed_get_and_a_redirect_elsewhere_is_refused( + no_delay: None) -> None: + def handler(request: httpx.Request) -> httpx.Response: + if request.url.host == "moved.acme.com": + return httpx.Response(302, headers={"location": "https://evil.example/jobs.rss"}) + assert request.url.path == "/jobs.rss" + return httpx.Response(200, content=_feed(["a"] if request.url.params["offset"] == "0" else [])) + + with _client(handler) as client: + rows, complete = ats._fetch_rows(client, "teamtailor:careers.acme.com") + assert ([r["source_id"] for r in rows], complete) == (["a"], True) + with pytest.raises(ats._Refused): + ats._fetch_rows(client, "teamtailor:moved.acme.com") + + # -------------------------------------------------------- failing boards def _source(monkeypatch: pytest.MonkeyPatch, answer: object) -> ats.ATSSource: diff --git a/tests/test_discover.py b/tests/test_discover.py index 58fe9c9..5c1b581 100644 --- a/tests/test_discover.py +++ b/tests/test_discover.py @@ -160,7 +160,7 @@ def test_a_readable_board_on_a_later_page_still_beats_an_unreadable_host() -> No assert site.probed == [] -def test_an_unreadable_hosts_slug_is_kept_when_a_later_link_names_it() -> None: +def test_a_teamtailor_link_is_a_board_even_after_the_cdn_named_it_first() -> None: """The CDN names teamtailor before any link does; the slug comes from the first link that carries one, the acme of acme.teamtailor.com.""" site = Site({ @@ -168,9 +168,49 @@ def test_an_unreadable_hosts_slug_is_kept_when_a_later_link_names_it() -> None: "https://acme.com/careers": 'Jobs', }) found = run(site) - assert (found.ats, found.ats_slug, found.board) == ("teamtailor", "acme-jobs", "") + assert (found.ats, found.ats_slug, found.board) == ("teamtailor", "acme-jobs", + "teamtailor:acme-jobs") + assert found.readable assert found.evidence == "https://acme-jobs.teamtailor.com" - assert found.careers_url == "https://acme.com/" + assert found.careers_url == "https://acme.com/careers" + + +def test_a_teamtailor_site_on_its_own_domain_is_read_off_its_host() -> None: + """Only the CDN is named, so the site's host is the slug, once that host + serves the feed.""" + site = Site({ + "https://acme.com/": 'Careers', + "https://careers.acme.com/": '', + "https://careers.acme.com/jobs.rss": + '', + }) + found = run(site) + assert found == Discovery(board="teamtailor:careers.acme.com", ats="teamtailor", + ats_slug="careers.acme.com", + careers_url="https://careers.acme.com/", + evidence="https://careers.acme.com/jobs.rss") + assert site.probed == [] + + +def test_a_page_that_only_loads_the_cdn_is_not_a_board_without_the_feed() -> None: + site = Site({"https://acme.com/": ''}) + found = run(site) + assert (found.ats, found.ats_slug, found.board) == ("teamtailor", "", "") + assert not found.readable + assert "https://acme.com/jobs.rss" in site.fetched + + +def test_the_admin_app_and_cdn_hosts_are_no_teamtailor_slug() -> None: + page = 'a' + assert [(h, s) for h, s, _ in boards_in(page)] == [("teamtailor", "")] + + +def test_a_teamtailor_board_is_found_by_its_slug_probe() -> None: + site = Site({"https://acme.com/": "

a script draws the jobs

"}, + boards={("teamtailor", "acme")}) + found = run(site) + assert found.board == "teamtailor:acme" + assert found.evidence == "https://acme.teamtailor.com/jobs.rss" def test_slug_probes_find_a_board_the_pages_never_link() -> None: