380 lines
18 KiB
Python
380 lines
18 KiB
Python
"""#2464 cluster E — domrf_kn_objects snapshot dedup regression tests.
|
|
|
|
domrf_kn_objects retains MULTIPLE historical rows per obj_id (one per
|
|
snapshot_date, UNIQUE(obj_id, snapshot_date), no retention). Prod measurement:
|
|
4090 rows / 482 distinct obj_id for site_status='Строящиеся' (8.49x inflation).
|
|
|
|
Three read-side queries counted/returned every retained snapshot instead of the
|
|
latest one per obj_id:
|
|
- _active_competitors_count (via its _q closure)
|
|
- developer_portfolio
|
|
- _competitors_two_dim (its `active` CTE)
|
|
|
|
All fixed with the established repo dedup pattern: DISTINCT ON (obj_id) ...
|
|
ORDER BY obj_id, snapshot_date DESC NULLS LAST (sibling: _L3_FUTURE_SQL #1212 in
|
|
app/services/site_finder/supply_layers.py, cmp_rows/latest_obj CTE in
|
|
analytics_queries.recommend_mix).
|
|
|
|
VOLATILE-FILTER PLACEMENT (authoritative prod measurement, coordinator
|
|
2026-07-08 — per-obj_id variance across snapshots): dev_id=0, region_cd=0
|
|
(STABLE) vs district_name=1, obj_class=29, site_status=11 (VOLATILE). Volatile
|
|
predicates MUST be applied to the true-latest row (outer/downstream WHERE), NOT
|
|
pre-filtered inside the DISTINCT ON CTE — else DISTINCT ON returns "the latest
|
|
snapshot that still MATCHED the filter", not the object's true latest snapshot
|
|
(a ЖК that sold out / changed class / moved districts would be miscounted by a
|
|
stale snapshot). Only the stable region_cd stays inside the CTE as the dedup
|
|
partition-scope. dev_id (developer_portfolio) is likewise stable → kept in-CTE.
|
|
|
|
Mock-based — mirrors the SQL-shape assertion convention used in
|
|
tests/services/site_finder/test_supply_layers.py (TestLayer2Hidden.
|
|
test_sql_dedups_latest_snapshot) since there's no SQLite stand-in for
|
|
Postgres-only `DISTINCT ON` syntax and no throwaway-schema DML fixture in this
|
|
repo's integration-test conventions (tests/integration/conftest.py is
|
|
EXPLAIN-only / read-only against a real tunnel DB — safe for plan-checks, not
|
|
for INSERT fixtures). A second class (`TestDedupAlgorithmSpec`) hand-replicates
|
|
the exact dedup+filter semantics the SQL implements in pure Python and asserts
|
|
the two behaviors the epic calls out explicitly: multi-snapshot obj_id counted
|
|
once, and a sold-out object with only an OLD 'Строящиеся' snapshot excluded.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
from unittest.mock import MagicMock
|
|
|
|
from app.services.analytics_queries import _active_competitors_count, developer_portfolio
|
|
|
|
# ── shared helpers (mirrors test_supply_layers.py _mock_db/_executed_sql) ─────
|
|
|
|
|
|
def _mock_scalar_db(value: int) -> MagicMock:
|
|
"""Session stand-in: every db.execute(...).scalar() returns `value`."""
|
|
db = MagicMock()
|
|
db.execute.return_value.scalar.return_value = value
|
|
return db
|
|
|
|
|
|
def _mock_mapping_db(rows: list[dict[str, Any]]) -> MagicMock:
|
|
db = MagicMock()
|
|
db.execute.return_value.mappings.return_value.all.return_value = rows
|
|
return db
|
|
|
|
|
|
def _executed_sql(db: MagicMock, call_index: int = 0) -> str:
|
|
args, _kwargs = db.execute.call_args_list[call_index]
|
|
return str(args[0])
|
|
|
|
|
|
def _executed_params(db: MagicMock, call_index: int = 0) -> dict:
|
|
args, _kwargs = db.execute.call_args_list[call_index]
|
|
return args[1]
|
|
|
|
|
|
def _split_latest_cte(sql: str) -> tuple[str, str]:
|
|
"""Split whitespace-normalized SQL into (CTE body, outer body).
|
|
|
|
CTE body = `WITH latest AS ( ... )` up to the `)` that closes the CTE,
|
|
which is the first `)` after the ORDER BY feeding DISTINCT ON. Outer body =
|
|
everything after. Lets tests assert WHICH side a predicate lives on.
|
|
"""
|
|
norm = " ".join(sql.split())
|
|
cte_open = norm.index("WITH latest AS (")
|
|
order_by_idx = norm.index("ORDER BY obj_id, snapshot_date DESC NULLS LAST")
|
|
cte_close = norm.index(")", order_by_idx)
|
|
return norm[cte_open:cte_close], norm[cte_close:]
|
|
|
|
|
|
# ── _active_competitors_count SQL shape ────────────────────────────────────
|
|
|
|
|
|
class TestActiveCompetitorsCountSqlShape:
|
|
def test_dedups_via_distinct_on_obj_id_latest_snapshot(self) -> None:
|
|
# n never reaches the >=2 early-return threshold with scalar()==0, so
|
|
# all 3 cascade tiers execute — call_index 0 is tier1 (district+class).
|
|
db = _mock_scalar_db(0)
|
|
_active_competitors_count(
|
|
db, region_code=66, district_name="Ленинский", target_class="Комфорт"
|
|
)
|
|
sql = _executed_sql(db, 0)
|
|
norm = " ".join(sql.split())
|
|
assert "DISTINCT ON (obj_id)" in norm
|
|
assert "ORDER BY obj_id, snapshot_date DESC NULLS LAST" in norm
|
|
|
|
def test_site_status_filter_is_volatile_applied_after_distinct_on(self) -> None:
|
|
# Regression guard for the exact bug shape #2464 warns about: a
|
|
# sold-out object whose ONLY 'Строящиеся' row is an old snapshot must
|
|
# not be counted. That requires site_status to be filtered on the
|
|
# OUTER (post-DISTINCT-ON) query, never inside the `latest` CTE's
|
|
# WHERE — else DISTINCT ON would pick "the latest snapshot that still
|
|
# matched site_status='Строящиеся'" instead of the object's true
|
|
# latest snapshot. (Prod per-obj_id variance: site_status=11.)
|
|
db = _mock_scalar_db(0)
|
|
_active_competitors_count(
|
|
db, region_code=66, district_name="Ленинский", target_class="Комфорт"
|
|
)
|
|
cte_body, outer_body = _split_latest_cte(_executed_sql(db, 0))
|
|
# site_status legitimately appears in the CTE's SELECT list (it's the
|
|
# column DISTINCT ON needs to expose) -- what must NOT appear is a
|
|
# filter predicate on it inside the CTE's WHERE.
|
|
assert (
|
|
"site_status = 'Строящиеся'" not in cte_body
|
|
), f"site_status must not pre-filter the DISTINCT ON CTE (volatile field):\n{cte_body}"
|
|
assert "site_status = 'Строящиеся'" in outer_body
|
|
|
|
def test_district_and_class_are_volatile_applied_after_distinct_on(self) -> None:
|
|
# Companion to the site_status guard: authoritative prod measurement
|
|
# (coordinator 2026-07-08) — per-obj_id variance across snapshots is
|
|
# district_name=1 and obj_class=29 (NON-zero → VOLATILE), unlike
|
|
# dev_id/region_cd (0 → stable). So district_name/obj_class predicates
|
|
# must ALSO be applied on the true-latest row (outer WHERE), never
|
|
# pre-filtered inside the DISTINCT ON CTE — else a ЖК that changed
|
|
# class/district gets counted by a stale snapshot. Tier-1
|
|
# (district+class) is call_index 0 when target_class is given.
|
|
db = _mock_scalar_db(0)
|
|
_active_competitors_count(
|
|
db, region_code=66, district_name="Ленинский", target_class="Комфорт"
|
|
)
|
|
cte_body, outer_body = _split_latest_cte(_executed_sql(db, 0))
|
|
# CTE WHERE must scope on ONLY the stable region_cd — no volatile predicate.
|
|
assert (
|
|
"district_name = :dn" not in cte_body
|
|
), f"district_name (volatile) must not pre-filter the DISTINCT ON CTE:\n{cte_body}"
|
|
assert (
|
|
"COALESCE(obj_class, obj_class_fallback) = :cls" not in cte_body
|
|
), f"obj_class (volatile) must not pre-filter the DISTINCT ON CTE:\n{cte_body}"
|
|
# Both live in the outer WHERE, applied to the deduped true-latest row.
|
|
assert "district_name = :dn" in outer_body
|
|
assert "COALESCE(obj_class, obj_class_fallback) = :cls" in outer_body
|
|
|
|
def test_cte_where_scopes_only_stable_region_cd(self) -> None:
|
|
# Belt-and-suspenders: the DISTINCT ON CTE's WHERE partition-scope is
|
|
# exactly `region_cd = :rc` and nothing else (all volatile predicates
|
|
# relocated). Guards against a future re-introduction of a volatile
|
|
# pre-filter that would silently pick a stale-but-matching snapshot.
|
|
db = _mock_scalar_db(0)
|
|
_active_competitors_count(
|
|
db, region_code=66, district_name="Ленинский", target_class="Комфорт"
|
|
)
|
|
cte_body, _outer = _split_latest_cte(_executed_sql(db, 0))
|
|
# extract the CTE's WHERE clause (between WHERE and the feeding ORDER BY,
|
|
# which _split_latest_cte leaves at the tail of the CTE body).
|
|
where_start = cte_body.index("WHERE ") + len("WHERE ")
|
|
where_end = cte_body.index("ORDER BY", where_start)
|
|
where_clause = cte_body[where_start:where_end].strip()
|
|
assert (
|
|
where_clause == "region_cd = :rc"
|
|
), f"CTE WHERE must scope on ONLY stable region_cd, got: {where_clause!r}"
|
|
|
|
def test_no_double_colon_cast(self) -> None:
|
|
import re
|
|
|
|
db = _mock_scalar_db(0)
|
|
_active_competitors_count(db, region_code=66, district_name="Ленинский", target_class=None)
|
|
sql = _executed_sql(db, 0)
|
|
assert re.search(r":[a-z_]+::[a-z]", sql) is None
|
|
|
|
def test_cascade_still_stops_early_when_tier_hits_threshold(self) -> None:
|
|
# Sanity: fallback cascade logic (n>=2 -> stop) is untouched by the dedup fix.
|
|
db = _mock_scalar_db(5)
|
|
n, scope = _active_competitors_count(
|
|
db, region_code=66, district_name="Ленинский", target_class="Комфорт"
|
|
)
|
|
assert n == 5
|
|
assert scope == "district+class"
|
|
assert db.execute.call_count == 1
|
|
|
|
|
|
# ── developer_portfolio SQL shape ──────────────────────────────────────────
|
|
|
|
|
|
class TestDeveloperPortfolioSqlShape:
|
|
def test_dedups_via_distinct_on_obj_id_latest_snapshot(self) -> None:
|
|
db = _mock_mapping_db([])
|
|
developer_portfolio(db, "6208_0")
|
|
sql = _executed_sql(db, 0)
|
|
norm = " ".join(sql.split())
|
|
assert "DISTINCT ON (obj_id)" in norm
|
|
assert "ORDER BY obj_id, snapshot_date DESC NULLS LAST" in norm
|
|
|
|
def test_preserves_final_ready_dt_ordering(self) -> None:
|
|
# DISTINCT ON's own ORDER BY must start with (obj_id, snapshot_date) —
|
|
# the caller-facing ready_dt ordering has to live in the OUTER SELECT.
|
|
db = _mock_mapping_db([])
|
|
developer_portfolio(db, "6208_0")
|
|
sql = _executed_sql(db, 0)
|
|
norm = " ".join(sql.split())
|
|
assert norm.rstrip().endswith("ORDER BY ready_dt DESC NULLS LAST")
|
|
|
|
def test_dev_id_filter_unchanged(self) -> None:
|
|
db = _mock_mapping_db([])
|
|
developer_portfolio(db, "6208_0")
|
|
params = _executed_params(db, 0)
|
|
assert params == {"dev": "6208_0"}
|
|
|
|
def test_returned_columns_unchanged(self) -> None:
|
|
# Fix must not add/drop columns from the caller-facing shape.
|
|
rows = [
|
|
{
|
|
"obj_id": 1,
|
|
"comm_name": "ЖК Тест",
|
|
"addr": "ул. Тест, 1",
|
|
"region_cd": 66,
|
|
"flat_count": 100,
|
|
"square_living": 5000.0,
|
|
"ready_dt": None,
|
|
"obj_class": "Комфорт",
|
|
"escrow": True,
|
|
"problem_flag": None,
|
|
"latitude": 56.8,
|
|
"longitude": 60.6,
|
|
"is_ekb": True,
|
|
}
|
|
]
|
|
db = _mock_mapping_db(rows)
|
|
out = developer_portfolio(db, "6208_0")
|
|
assert len(out) == 1
|
|
assert set(out[0].keys()) == {
|
|
"obj_id",
|
|
"comm_name",
|
|
"addr",
|
|
"region_cd",
|
|
"flat_count",
|
|
"square_living",
|
|
"ready_dt",
|
|
"obj_class",
|
|
"escrow",
|
|
"problem_flag",
|
|
"lat",
|
|
"lon",
|
|
"is_ekb",
|
|
}
|
|
|
|
|
|
# ── _competitors_two_dim `active`/`latest` CTE shape ───────────────────────
|
|
|
|
|
|
def _mock_two_dim_db(radius_n: int, district_only_n: int) -> MagicMock:
|
|
"""Session stand-in for _competitors_two_dim: call 0 = centroid lookup
|
|
(returns a non-null WKT so the main query runs), call 1 = the radius/
|
|
district aggregate. radius_n/district_only_n chosen so total_weighted >= 1
|
|
keeps execution off the single-dim fallback path (which would add calls)."""
|
|
db = MagicMock()
|
|
centroid_res = MagicMock()
|
|
centroid_res.mappings.return_value.first.return_value = {"centroid_wkt": "POINT(60.6 56.8)"}
|
|
main_res = MagicMock()
|
|
main_res.mappings.return_value.first.return_value = {
|
|
"radius_n": radius_n,
|
|
"district_only_n": district_only_n,
|
|
}
|
|
db.execute.side_effect = [centroid_res, main_res]
|
|
return db
|
|
|
|
|
|
class TestCompetitorsTwoDimActiveCte:
|
|
"""#2464 sibling: _competitors_two_dim's `active` CTE had site_status /
|
|
district_name / obj_class ALL inside its DISTINCT ON — same latest-matching-
|
|
not-latest bug. Fix dedups to true-latest per obj_id first (region_cd-only
|
|
CTE scope), then applies the volatile predicates."""
|
|
|
|
def _main_sql(self, db: MagicMock) -> str:
|
|
# call_index 1 is the radius/district aggregate (0 is the centroid lookup).
|
|
return " ".join(_executed_sql(db, 1).split())
|
|
|
|
def test_dedups_via_distinct_on_before_volatile_filters(self) -> None:
|
|
from app.services.analytics_queries import _competitors_two_dim
|
|
|
|
db = _mock_two_dim_db(radius_n=3, district_only_n=0)
|
|
_competitors_two_dim(db, region_code=66, district_name="Ленинский", target_class="Комфорт")
|
|
sql = self._main_sql(db)
|
|
assert "DISTINCT ON (obj_id)" in sql
|
|
assert "ORDER BY obj_id, snapshot_date DESC NULLS LAST" in sql
|
|
|
|
def test_volatile_filters_are_post_distinct_on(self) -> None:
|
|
from app.services.analytics_queries import _competitors_two_dim
|
|
|
|
db = _mock_two_dim_db(radius_n=3, district_only_n=0)
|
|
_competitors_two_dim(db, region_code=66, district_name="Ленинский", target_class="Комфорт")
|
|
sql = self._main_sql(db)
|
|
# Split the DISTINCT ON CTE (`latest`) from everything downstream. Its
|
|
# WHERE must scope on ONLY stable region_cd; site_status/district_name/
|
|
# obj_class predicates live in the downstream `active` CTE.
|
|
latest_open = sql.index("WITH latest AS (")
|
|
order_by_idx = sql.index("ORDER BY obj_id, snapshot_date DESC NULLS LAST")
|
|
latest_close = sql.index(")", order_by_idx)
|
|
latest_body = sql[latest_open:latest_close]
|
|
downstream = sql[latest_close:]
|
|
|
|
assert "site_status = 'Строящиеся'" not in latest_body
|
|
assert "district_name = :dn" not in latest_body
|
|
assert "COALESCE(obj_class, obj_class_fallback) = :cls" not in latest_body
|
|
|
|
assert "site_status = 'Строящиеся'" in downstream
|
|
assert "district_name = :dn" in downstream
|
|
assert "COALESCE(obj_class, obj_class_fallback) = :cls" in downstream
|
|
|
|
def test_output_shape_preserved(self) -> None:
|
|
from app.services.analytics_queries import _competitors_two_dim
|
|
|
|
db = _mock_two_dim_db(radius_n=3, district_only_n=2)
|
|
radius_n, district_only_n, total_weighted, scope = _competitors_two_dim(
|
|
db, region_code=66, district_name="Ленинский", target_class="Комфорт"
|
|
)
|
|
assert radius_n == 3
|
|
assert district_only_n == 2
|
|
# 3*1.0 + 2*0.6 = 4.2
|
|
assert total_weighted == 4.2
|
|
assert scope == "district_2d"
|
|
|
|
|
|
# ── Pure-Python spec replica: exact dedup + volatile-filter algorithm ─────
|
|
#
|
|
# MagicMock can't execute real SQL (and DISTINCT ON has no SQLite equivalent),
|
|
# so this class locks in the ALGORITHM the SQL is required to implement:
|
|
# "take the row with MAX(snapshot_date) per obj_id, THEN filter on that row's
|
|
# site_status" — as opposed to the buggy "filter rows on site_status, then
|
|
# take MAX(snapshot_date) among survivors". It's a spec/regression guard, not
|
|
# a live-DB execution test (see module docstring for why).
|
|
|
|
|
|
def _latest_snapshot_active_count(rows: list[dict[str, Any]]) -> int:
|
|
"""Reference implementation of what the fixed `_q` SQL computes."""
|
|
latest_by_obj: dict[int, dict[str, Any]] = {}
|
|
for row in rows:
|
|
obj_id = row["obj_id"]
|
|
cur = latest_by_obj.get(obj_id)
|
|
if cur is None or (row["snapshot_date"] or "") > (cur["snapshot_date"] or ""):
|
|
latest_by_obj[obj_id] = row
|
|
return sum(1 for r in latest_by_obj.values() if r["site_status"] == "Строящиеся")
|
|
|
|
|
|
class TestDedupAlgorithmSpec:
|
|
def test_multi_snapshot_same_obj_id_counted_once(self) -> None:
|
|
rows = [
|
|
{"obj_id": 1, "snapshot_date": "2026-04-27", "site_status": "Строящиеся"},
|
|
{"obj_id": 1, "snapshot_date": "2026-05-25", "site_status": "Строящиеся"},
|
|
{"obj_id": 1, "snapshot_date": "2026-06-28", "site_status": "Строящиеся"},
|
|
]
|
|
assert _latest_snapshot_active_count(rows) == 1
|
|
|
|
def test_sold_out_object_with_old_active_snapshot_not_counted(self) -> None:
|
|
# obj_id=2's LATEST snapshot says "Реализован" (sold out) even though
|
|
# older snapshots said "Строящиеся" — must NOT count as active.
|
|
rows = [
|
|
{"obj_id": 2, "snapshot_date": "2026-04-27", "site_status": "Строящиеся"},
|
|
{"obj_id": 2, "snapshot_date": "2026-05-25", "site_status": "Строящиеся"},
|
|
{"obj_id": 2, "snapshot_date": "2026-06-28", "site_status": "Реализован"},
|
|
]
|
|
assert _latest_snapshot_active_count(rows) == 0
|
|
|
|
def test_mixed_objects_only_latest_active_ones_counted(self) -> None:
|
|
rows = [
|
|
# obj 1: still active across all 3 snapshots -> counts once.
|
|
{"obj_id": 1, "snapshot_date": "2026-04-27", "site_status": "Строящиеся"},
|
|
{"obj_id": 1, "snapshot_date": "2026-06-28", "site_status": "Строящиеся"},
|
|
# obj 2: sold out on the latest snapshot -> excluded.
|
|
{"obj_id": 2, "snapshot_date": "2026-04-27", "site_status": "Строящиеся"},
|
|
{"obj_id": 2, "snapshot_date": "2026-06-28", "site_status": "Реализован"},
|
|
# obj 3: single snapshot, active -> counts once.
|
|
{"obj_id": 3, "snapshot_date": "2026-06-28", "site_status": "Строящиеся"},
|
|
]
|
|
assert _latest_snapshot_active_count(rows) == 2
|