329 lines
13 KiB
Python
329 lines
13 KiB
Python
"""Per-field priority resolution tests."""
|
|
|
|
from datetime import datetime
|
|
|
|
from app.services.matching.conflict_resolution import (
|
|
HOUSE_FIELD_PRIORITY,
|
|
LISTING_FIELD_PRIORITY,
|
|
resolve_house_field,
|
|
resolve_listing_field,
|
|
)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Pre-existing tests (preserved)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_house_year_built_prefers_cian_bti() -> None:
|
|
out = resolve_house_field(
|
|
"year_built",
|
|
{"avito_houses_catalog": 2020, "cian_bti": 2021, "cian_serp": 2022},
|
|
)
|
|
assert out == 2021
|
|
|
|
|
|
def test_house_unknown_field_first_non_null() -> None:
|
|
assert resolve_house_field("totally_unknown", {"x": None, "y": 5}) == 5
|
|
|
|
|
|
def test_listing_owners_count_avito_domoteka_only() -> None:
|
|
out = resolve_listing_field("owners_count", {"avito_domoteka": 2, "cian_serp": 99})
|
|
assert out == 2
|
|
|
|
|
|
def test_listing_photo_urls_union() -> None:
|
|
out = resolve_listing_field(
|
|
"photo_urls",
|
|
{"avito": ["a.jpg", "b.jpg"], "cian": ["b.jpg", "c.jpg"]},
|
|
)
|
|
assert set(out) == {"a.jpg", "b.jpg", "c.jpg"}
|
|
|
|
|
|
def test_listing_kadastr_first_non_null() -> None:
|
|
out = resolve_listing_field("kadastr_num", {"avito": None, "cian": "66:1:1:1"})
|
|
assert out == "66:1:1:1"
|
|
|
|
|
|
def test_house_priority_dict_has_year_built() -> None:
|
|
assert "cian_bti" in HOUSE_FIELD_PRIORITY["year_built"]
|
|
|
|
|
|
def test_listing_priority_dict_has_owners() -> None:
|
|
assert "avito_domoteka" in LISTING_FIELD_PRIORITY["owners_count"]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Yandex house priority tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestYandexHousePriority:
|
|
def test_house_lat_yandex_realty_nb_when_cian_missing(self) -> None:
|
|
out = resolve_house_field("lat", {"yandex_realty_nb": 56.85})
|
|
assert out == 56.85
|
|
|
|
def test_house_lat_cian_preferred_over_yandex(self) -> None:
|
|
out = resolve_house_field("lat", {"cian_serp": 56.83, "yandex_realty_nb": 56.85})
|
|
assert out == 56.83
|
|
|
|
def test_house_year_built_yandex_valuation_picked(self) -> None:
|
|
out = resolve_house_field("year_built", {"yandex_valuation": 1981})
|
|
assert out == 1981
|
|
|
|
def test_house_year_built_cian_bti_preferred(self) -> None:
|
|
out = resolve_house_field("year_built", {"cian_bti": 1980, "yandex_valuation": 1981})
|
|
assert out == 1980
|
|
|
|
def test_house_text_reviews_count_yandex_only(self) -> None:
|
|
out = resolve_house_field("text_reviews_count", {"yandex_realty_nb": 353})
|
|
assert out == 353
|
|
|
|
def test_house_corpus_count_yandex_only(self) -> None:
|
|
out = resolve_house_field("corpus_count", {"yandex_realty_nb": 3})
|
|
assert out == 3
|
|
|
|
def test_house_commission_year_cian_serp_preferred(self) -> None:
|
|
out = resolve_house_field("commission_year", {"cian_serp": 2022, "yandex_realty_nb": 2023})
|
|
assert out == 2022
|
|
|
|
def test_house_commission_month_yandex_only(self) -> None:
|
|
out = resolve_house_field("commission_month", {"yandex_realty_nb": "июнь"})
|
|
assert out == "июнь"
|
|
|
|
def test_house_developer_name_cian_preferred(self) -> None:
|
|
out = resolve_house_field(
|
|
"developer_name",
|
|
{"cian": "PRINZIP", "yandex_realty_nb": "PRINZIP недвижимость"},
|
|
)
|
|
assert out == "PRINZIP"
|
|
|
|
def test_house_has_lift_cian_bti_preferred_over_yandex_valuation(self) -> None:
|
|
out = resolve_house_field("has_lift", {"cian_bti": True, "yandex_valuation": True})
|
|
assert out is True
|
|
|
|
def test_house_ceiling_height_cian_detail_preferred(self) -> None:
|
|
out = resolve_house_field("ceiling_height", {"cian_detail": 2.7, "yandex_valuation": 2.5})
|
|
assert out == 2.7
|
|
|
|
def test_house_has_panorama_yandex_valuation_only(self) -> None:
|
|
out = resolve_house_field("has_panorama", {"yandex_valuation": True})
|
|
assert out is True
|
|
|
|
def test_house_yandex_total_listings_yandex_valuation_only(self) -> None:
|
|
out = resolve_house_field("yandex_total_listings", {"yandex_valuation": 42})
|
|
assert out == 42
|
|
|
|
def test_house_house_class_yandex_realty_nb_fallback(self) -> None:
|
|
out = resolve_house_field("house_class", {"yandex_realty_nb": "бизнес"})
|
|
assert out == "бизнес"
|
|
|
|
def test_house_house_class_avito_preferred_over_yandex(self) -> None:
|
|
out = resolve_house_field(
|
|
"house_class",
|
|
{"avito_houses_catalog": "комфорт", "yandex_realty_nb": "бизнес"},
|
|
)
|
|
assert out == "комфорт"
|
|
|
|
def test_house_total_area_ha_yandex_only(self) -> None:
|
|
out = resolve_house_field("total_area_ha", {"yandex_realty_nb": 12.5})
|
|
assert out == 12.5
|
|
|
|
def test_house_has_lift_yandex_valuation_fallback_when_cian_missing(self) -> None:
|
|
out = resolve_house_field("has_lift", {"yandex_valuation": False})
|
|
assert out is False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Yandex listing priority tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestYandexListingPriority:
|
|
def test_listing_description_cian_preferred_over_yandex_detail(self) -> None:
|
|
out = resolve_listing_field(
|
|
"description",
|
|
{"cian_serp": "cian text", "yandex_detail": "yandex text"},
|
|
)
|
|
assert out == "cian text"
|
|
|
|
def test_listing_house_type_yandex_detail_used_when_cian_avito_missing(self) -> None:
|
|
out = resolve_listing_field("house_type", {"yandex_detail": "brick"})
|
|
assert out == "brick"
|
|
|
|
def test_listing_agency_name_yandex_only(self) -> None:
|
|
out = resolve_listing_field("agency_name", {"yandex_detail": "Агентство «Диал»"})
|
|
assert out == "Агентство «Диал»"
|
|
|
|
def test_listing_agency_founded_year_yandex_only(self) -> None:
|
|
out = resolve_listing_field("agency_founded_year", {"yandex_detail": 2005})
|
|
assert out == 2005
|
|
|
|
def test_listing_agency_objects_count_yandex_only(self) -> None:
|
|
out = resolve_listing_field("agency_objects_count", {"yandex_detail": 120})
|
|
assert out == 120
|
|
|
|
def test_listing_views_total_yandex_only(self) -> None:
|
|
out = resolve_listing_field("views_total_yandex", {"yandex_detail": 874})
|
|
assert out == 874
|
|
|
|
def test_listing_publish_date_relative_yandex_only(self) -> None:
|
|
out = resolve_listing_field("publish_date_relative", {"yandex_detail": "3 дня назад"})
|
|
assert out == "3 дня назад"
|
|
|
|
def test_listing_agency_name_none_when_no_yandex(self) -> None:
|
|
out = resolve_listing_field("agency_name", {"cian_serp": None})
|
|
assert out is None
|
|
|
|
def test_listing_description_avito_detail_preferred_over_yandex(self) -> None:
|
|
out = resolve_listing_field(
|
|
"description",
|
|
{"avito_detail": "avito desc", "yandex_detail": "yandex desc"},
|
|
)
|
|
assert out == "avito desc"
|
|
|
|
def test_listing_house_type_cian_preferred_over_yandex_detail(self) -> None:
|
|
out = resolve_listing_field(
|
|
"house_type",
|
|
{"cian_serp": "панель", "yandex_detail": "кирпич"},
|
|
)
|
|
assert out == "панель"
|
|
|
|
def test_listing_yandex_detail_keys_registered(self) -> None:
|
|
"""Ensure all Yandex-unique listing keys are in priority dict."""
|
|
yandex_keys = [
|
|
"agency_name",
|
|
"agency_founded_year",
|
|
"agency_objects_count",
|
|
"views_total_yandex",
|
|
"publish_date_relative",
|
|
]
|
|
for key in yandex_keys:
|
|
assert key in LISTING_FIELD_PRIORITY, f"{key!r} missing from LISTING_FIELD_PRIORITY"
|
|
rule = LISTING_FIELD_PRIORITY[key]
|
|
assert rule == ["yandex_detail"], f"{key!r} rule mismatch: {rule!r}"
|
|
|
|
def test_house_yandex_keys_registered(self) -> None:
|
|
"""Ensure all Yandex-unique house keys are in priority dict."""
|
|
yandex_keys = [
|
|
"text_reviews_count",
|
|
"corpus_count",
|
|
"total_area_ha",
|
|
"commission_month",
|
|
"has_panorama",
|
|
"yandex_total_listings",
|
|
]
|
|
for key in yandex_keys:
|
|
assert key in HOUSE_FIELD_PRIORITY, f"{key!r} missing from HOUSE_FIELD_PRIORITY"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Freshness-based conflict resolution (#1539) — last_seen_at wins, deterministic
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestFreshnessResolution:
|
|
"""first_non_null / fallback must prefer the freshest source, not dict order."""
|
|
|
|
def test_first_non_null_fresher_source_wins(self) -> None:
|
|
# kadastr_num uses the 'first_non_null' rule.
|
|
candidates = {"avito": "66:1:1:OLD", "cian": "66:1:1:NEW"}
|
|
timestamps = {
|
|
"avito": datetime(2026, 1, 1),
|
|
"cian": datetime(2026, 6, 1), # fresher
|
|
}
|
|
out = resolve_listing_field("kadastr_num", candidates, timestamps)
|
|
assert out == "66:1:1:NEW"
|
|
|
|
def test_first_non_null_fresher_source_wins_regardless_of_order(self) -> None:
|
|
# Same data, opposite insertion order — result must not flip.
|
|
candidates = {"cian": "66:1:1:NEW", "avito": "66:1:1:OLD"}
|
|
timestamps = {
|
|
"avito": datetime(2026, 1, 1),
|
|
"cian": datetime(2026, 6, 1),
|
|
}
|
|
out = resolve_listing_field("kadastr_num", candidates, timestamps)
|
|
assert out == "66:1:1:NEW"
|
|
|
|
def test_freshness_picks_avito_when_avito_is_newer(self) -> None:
|
|
candidates = {"avito": "AVITO", "cian": "CIAN"}
|
|
timestamps = {
|
|
"avito": datetime(2026, 6, 1), # fresher
|
|
"cian": datetime(2026, 1, 1),
|
|
}
|
|
out = resolve_listing_field("kadastr_num", candidates, timestamps)
|
|
assert out == "AVITO"
|
|
|
|
def test_null_only_returns_none(self) -> None:
|
|
out = resolve_listing_field(
|
|
"kadastr_num",
|
|
{"avito": None, "cian": None},
|
|
{"avito": datetime(2026, 6, 1), "cian": datetime(2026, 1, 1)},
|
|
)
|
|
assert out is None
|
|
|
|
def test_null_source_skipped_even_if_fresher(self) -> None:
|
|
# cian is fresher but null → avito's non-null value wins.
|
|
candidates = {"avito": "VALUE", "cian": None}
|
|
timestamps = {
|
|
"avito": datetime(2026, 1, 1),
|
|
"cian": datetime(2026, 6, 1),
|
|
}
|
|
out = resolve_listing_field("kadastr_num", candidates, timestamps)
|
|
assert out == "VALUE"
|
|
|
|
def test_tie_breaks_by_source_name_deterministic(self) -> None:
|
|
# Equal timestamps → lexicographically smallest source name wins.
|
|
ts = datetime(2026, 6, 1)
|
|
out1 = resolve_listing_field(
|
|
"kadastr_num",
|
|
{"avito": "A", "cian": "C"},
|
|
{"avito": ts, "cian": ts},
|
|
)
|
|
out2 = resolve_listing_field(
|
|
"kadastr_num",
|
|
{"cian": "C", "avito": "A"},
|
|
{"cian": ts, "avito": ts},
|
|
)
|
|
assert out1 == "A" # "avito" < "cian"
|
|
assert out1 == out2 # order-independent
|
|
|
|
def test_no_timestamps_falls_back_deterministically(self) -> None:
|
|
# Without timestamps, fallback is deterministic by sorted source name.
|
|
out1 = resolve_listing_field("kadastr_num", {"avito": "A", "cian": "C"})
|
|
out2 = resolve_listing_field("kadastr_num", {"cian": "C", "avito": "A"})
|
|
assert out1 == "A"
|
|
assert out1 == out2
|
|
|
|
def test_partial_timestamps_timed_source_preferred(self) -> None:
|
|
# Only one source carries a timestamp → it is treated as the freshest.
|
|
candidates = {"avito": "A", "cian": "C"}
|
|
timestamps = {"cian": datetime(2026, 6, 1)} # avito has none
|
|
out = resolve_listing_field("kadastr_num", candidates, timestamps)
|
|
assert out == "C"
|
|
|
|
def test_house_unknown_field_freshness(self) -> None:
|
|
# Unknown house field also uses freshness fallback.
|
|
candidates = {"src_a": 1, "src_b": 2}
|
|
timestamps = {"src_a": datetime(2026, 1, 1), "src_b": datetime(2026, 6, 1)}
|
|
assert resolve_house_field("totally_unknown", candidates, timestamps) == 2
|
|
|
|
def test_priority_list_fallback_uses_freshness(self) -> None:
|
|
# No ranked source present for 'lat' → freshest non-null wins.
|
|
candidates = {"unranked_old": 56.80, "unranked_new": 56.90}
|
|
timestamps = {
|
|
"unranked_old": datetime(2026, 1, 1),
|
|
"unranked_new": datetime(2026, 6, 1),
|
|
}
|
|
out = resolve_house_field("lat", candidates, timestamps)
|
|
assert out == 56.90
|
|
|
|
def test_priority_list_ranking_beats_freshness(self) -> None:
|
|
# Explicit ranking is authoritative: cian_serp ranked above yandex even if
|
|
# yandex is fresher.
|
|
candidates = {"cian_serp": 56.83, "yandex_realty_nb": 56.85}
|
|
timestamps = {
|
|
"cian_serp": datetime(2026, 1, 1),
|
|
"yandex_realty_nb": datetime(2026, 6, 1), # fresher but lower-ranked
|
|
}
|
|
out = resolve_house_field("lat", candidates, timestamps)
|
|
assert out == 56.83
|