155 lines
6.4 KiB
Python
155 lines
6.4 KiB
Python
"""
|
|
Unit tests for the Elasticsearch query builder.
|
|
|
|
``build_query`` is a pure function, so the ranking and filtering rules can be
|
|
asserted without a running cluster - the fastest possible feedback loop for the
|
|
part of the system that is easiest to get subtly wrong.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from apps.search.backends.elastic import build_query
|
|
from apps.search.types import SORT_EXPERIENCE_DESC, SORT_NAME, SearchRequest
|
|
|
|
FACET_NAMES = ("skills", "job_title_role", "seniority", "country", "industry", "company")
|
|
|
|
|
|
def _bool(request: SearchRequest) -> dict:
|
|
return build_query(request)["query"]["bool"]
|
|
|
|
|
|
def _post_filters(request: SearchRequest) -> list[dict]:
|
|
body = build_query(request)
|
|
return body.get("post_filter", {}).get("bool", {}).get("filter", [])
|
|
|
|
|
|
def test_empty_query_matches_everything() -> None:
|
|
body = build_query(SearchRequest())
|
|
assert body["query"]["bool"]["must"] == [{"match_all": {}}]
|
|
assert "post_filter" not in body
|
|
|
|
|
|
def test_keyword_query_uses_fuzzy_multi_match_and_phrase_boost() -> None:
|
|
clause = _bool(SearchRequest(q="python developer"))
|
|
multi_match = clause["must"][0]["multi_match"]
|
|
assert multi_match["query"] == "python developer"
|
|
assert multi_match["fuzziness"] == "AUTO"
|
|
assert any(field.startswith("full_name^") for field in multi_match["fields"])
|
|
# The phrase clause only boosts; it must never be required.
|
|
assert clause["should"][0]["multi_match"]["type"] == "phrase"
|
|
|
|
|
|
def test_filters_do_not_narrow_the_scored_query() -> None:
|
|
"""
|
|
Filters must live in ``post_filter``, never in ``query.bool`` - that is
|
|
what lets a facet's own aggregation stay unaffected by its own selection.
|
|
See ``test_a_facets_own_selection_does_not_narrow_its_own_aggregation``
|
|
for the behaviour this enables.
|
|
"""
|
|
clause = _bool(
|
|
SearchRequest(skills=("python", "django"), countries=("germany",), seniority=("senior",))
|
|
)
|
|
assert clause["must"] == [{"match_all": {}}]
|
|
assert "filter" not in clause
|
|
|
|
|
|
def test_filters_are_terms_clauses_in_the_post_filter() -> None:
|
|
filters = _post_filters(
|
|
SearchRequest(skills=("python", "django"), countries=("germany",), seniority=("senior",))
|
|
)
|
|
assert {"terms": {"skills.keyword": ["python", "django"]}} in filters
|
|
assert {"terms": {"location_country": ["germany"]}} in filters
|
|
assert {"terms": {"seniority_levels": ["senior"]}} in filters
|
|
|
|
|
|
def test_experience_range_is_translated_to_a_range_filter() -> None:
|
|
filters = _post_filters(SearchRequest(min_experience=5, max_experience=10))
|
|
assert {"range": {"years_experience": {"gte": 5, "lte": 10}}} in filters
|
|
|
|
open_ended = _post_filters(SearchRequest(min_experience=5))
|
|
assert {"range": {"years_experience": {"gte": 5}}} in open_ended
|
|
|
|
|
|
def test_pagination_maps_to_from_and_size() -> None:
|
|
body = build_query(SearchRequest(page=3, page_size=25))
|
|
assert body["from"] == 50
|
|
assert body["size"] == 25
|
|
assert body["track_total_hits"] is True
|
|
|
|
|
|
def test_sort_options() -> None:
|
|
assert build_query(SearchRequest(sort=SORT_NAME))["sort"][0] == {"full_name.keyword": "asc"}
|
|
assert build_query(SearchRequest(sort=SORT_EXPERIENCE_DESC))["sort"][0] == {
|
|
"years_experience": {"order": "desc", "missing": "_last"}
|
|
}
|
|
assert build_query(SearchRequest())["sort"][0] == "_score"
|
|
|
|
|
|
def test_highlight_only_requested_with_a_keyword() -> None:
|
|
assert "highlight" not in build_query(SearchRequest())
|
|
assert "highlight" in build_query(SearchRequest(q="python"))
|
|
|
|
|
|
def test_facets_can_be_switched_off() -> None:
|
|
assert "aggs" in build_query(SearchRequest())
|
|
assert "aggs" not in build_query(SearchRequest(include_facets=False))
|
|
|
|
|
|
# -- Multi-select faceting ---------------------------------------------------
|
|
#
|
|
# The bug this section pins down: ticking one value in a facet (e.g. "senior"
|
|
# under Seniority) must not make the other values in *that same facet*
|
|
# disappear. Elasticsearch has no built-in notion of "OR within a facet,
|
|
# ignore this facet's own filter" - it has to be built by hand as one `filter`
|
|
# aggregation per facet, scoped by every *other* active filter. These tests
|
|
# exist so a future refactor of ``build_query``/``_build_aggregations`` cannot
|
|
# silently regress back to the single-facet-collapses-to-one-value bug.
|
|
|
|
|
|
def test_a_facets_own_selection_does_not_narrow_its_own_aggregation() -> None:
|
|
aggs = build_query(SearchRequest(roles=("engineering",)))["aggs"]
|
|
# `job_title_role` is the facet driven by `roles` - its own filter must be
|
|
# absent from its own aggregation, so unrelated role buckets still appear.
|
|
assert aggs["job_title_role"] == {
|
|
"terms": {"field": "job_title_role", "size": 25, "order": {"_count": "desc"}}
|
|
}
|
|
|
|
|
|
def test_a_facets_selection_does_narrow_every_other_facet() -> None:
|
|
aggs = build_query(SearchRequest(roles=("engineering",)))["aggs"]
|
|
for facet in ("skills", "seniority", "country", "industry", "company"):
|
|
wrapper = aggs[facet]
|
|
assert wrapper["filter"] == {
|
|
"bool": {"filter": [{"terms": {"job_title_role": ["engineering"]}}]}
|
|
}
|
|
# The terms aggregation itself is nested one level deeper, under its
|
|
# own name, once it is wrapped in the scoping `filter` aggregation.
|
|
assert facet in wrapper["aggs"]
|
|
|
|
|
|
def test_two_active_facets_each_exclude_only_their_own_filter() -> None:
|
|
aggs = build_query(SearchRequest(roles=("engineering",), countries=("germany",)))["aggs"]
|
|
|
|
role_filters = aggs["job_title_role"]["filter"]["bool"]["filter"]
|
|
assert role_filters == [{"terms": {"location_country": ["germany"]}}]
|
|
|
|
country_filters = aggs["country"]["filter"]["bool"]["filter"]
|
|
assert country_filters == [{"terms": {"job_title_role": ["engineering"]}}]
|
|
|
|
# A facet with no selection of its own is scoped by both.
|
|
skills_filters = aggs["skills"]["filter"]["bool"]["filter"]
|
|
assert {"terms": {"job_title_role": ["engineering"]}} in skills_filters
|
|
assert {"terms": {"location_country": ["germany"]}} in skills_filters
|
|
|
|
|
|
def test_experience_range_scopes_every_facet_and_is_never_excluded() -> None:
|
|
"""The years-of-experience range has no facet of its own, so it always
|
|
applies - including to a facet that shares no other active filter."""
|
|
aggs = build_query(SearchRequest(min_experience=5))["aggs"]
|
|
for facet in FACET_NAMES:
|
|
wrapper = aggs[facet]
|
|
assert wrapper["filter"]["bool"]["filter"] == [
|
|
{"range": {"years_experience": {"gte": 5}}}
|
|
]
|
|
|