vignette/apps/api/app/test_admin_health_maintenance.py
Yun Chan aeddaa6972
Some checks failed
API contract / OpenAPI type drift (push) Failing after 6m2s
운영 안정화와 화면 회귀 검증을 반영
2026-10-20 16:33:48 +09:00

370 lines
15 KiB
Python

"""Admin health sample retention/rollup tests."""
from __future__ import annotations
import unittest
import unittest.mock
from .services import admin_health_maintenance as maintenance
_VALID_ROLLUP_DELETE_POLICY = {
"policy_name": "p_admin_health_daily_rollup_delete",
"command": "d",
"permissive": True,
"rls_enabled": True,
"qual": "(app.current_role_name() = 'admin'::text)",
}
class _Acquire:
def __init__(self, conn):
self.conn = conn
self.exit_error = None
async def __aenter__(self):
return self.conn
async def __aexit__(self, exc_type, exc, tb):
self.exit_error = exc
return None
class AdminHealthMaintenanceTest(unittest.IsolatedAsyncioTestCase):
async def test_dry_run_counts_rollup_and_prunable_events_without_mutation(self) -> None:
class Conn:
def __init__(self):
self.fetch_calls = []
async def fetchrow(self, query, *args, **kwargs):
self.fetch_calls.append((query, args))
if len(self.fetch_calls) == 1:
return {"event_count": 12, "bucket_count": 3}
if len(self.fetch_calls) == 2:
return {"event_count": 4}
return {"rollup_count": 2}
async def fetch(self, *args, **kwargs):
raise AssertionError("dry-run must not upsert rollups")
async def execute(self, *args, **kwargs):
raise AssertionError("dry-run must not delete raw events")
conn = Conn()
with unittest.mock.patch.object(maintenance, "acquire", return_value=_Acquire(conn)):
result = await maintenance.maintain_admin_health_events(
rollup_days=2,
apply=False,
)
self.assertFalse(result.applied)
self.assertEqual(result.rollup_event_count, 12)
self.assertEqual(result.rollup_bucket_count, 3)
self.assertEqual(result.prunable_event_count, 4)
self.assertEqual(result.prunable_rollup_count, 2)
self.assertEqual(result.rollup_retention_days, 365)
self.assertEqual(result.upserted_rollups, 0)
self.assertEqual(result.deleted_events, 0)
self.assertEqual(result.deleted_rollups, 0)
self.assertEqual(conn.fetch_calls[0][1], (2,))
self.assertEqual(result.retention_days, 90)
self.assertEqual(conn.fetch_calls[1][1], (90,))
self.assertEqual(conn.fetch_calls[2][1], (365,))
self.assertIn("observed_at::date < current_date - $1::int", conn.fetch_calls[0][0])
self.assertIn("rollup_date < current_date - $1::int", conn.fetch_calls[2][0])
async def test_apply_upserts_rollups_before_pruning_raw_events(self) -> None:
calls = []
class Conn:
async def fetchrow(self, query, *args, **kwargs):
calls.append(("fetchrow", query, args))
fetchrow_count = len([call for call in calls if call[0] == "fetchrow"])
if fetchrow_count == 1:
return {"event_count": 7, "bucket_count": 2}
if fetchrow_count == 2:
return {"event_count": 5}
return {"rollup_count": 3}
async def fetch(self, query, *args, **kwargs):
calls.append(("fetch", query, args))
if "FROM pg_policy AS policy" in query:
return [_VALID_ROLLUP_DELETE_POLICY]
return [1, 1]
async def execute(self, query, *args, **kwargs):
calls.append(("execute", query, args))
return "DELETE 5" if "admin_health_event" in query else "DELETE 3"
with unittest.mock.patch.object(maintenance, "acquire", return_value=_Acquire(Conn())):
result = await maintenance.maintain_admin_health_events(
rollup_days=3,
retention_days=30,
apply=True,
)
self.assertTrue(result.applied)
self.assertEqual(result.upserted_rollups, 2)
self.assertEqual(result.deleted_events, 5)
self.assertEqual(result.deleted_rollups, 3)
self.assertEqual(
[call[0] for call in calls],
["fetchrow", "fetchrow", "fetchrow", "fetch", "fetch", "execute", "execute"],
)
self.assertIn("pg_get_expr(policy.polqual, policy.polrelid)", calls[3][1])
self.assertNotIn("LIKE", calls[3][1])
self.assertIn("INSERT INTO app.admin_health_daily_rollup", calls[4][1])
self.assertIn("last_down_at", calls[4][1])
self.assertIn("DELETE FROM app.admin_health_event", calls[5][1])
self.assertIn("DELETE FROM app.admin_health_daily_rollup", calls[6][1])
self.assertEqual(calls[6][2], (365,))
def test_invalid_windows_are_rejected(self) -> None:
with self.assertRaises(ValueError):
maintenance._validate_windows(
rollup_days=0,
retention_days=30,
rollup_retention_days=365,
)
with self.assertRaises(ValueError):
maintenance._validate_windows(
rollup_days=7,
retention_days=2,
rollup_retention_days=365,
)
with self.assertRaises(ValueError):
maintenance._validate_windows(
rollup_days=7,
retention_days=30,
rollup_retention_days=29,
)
async def test_rollup_delete_policy_requires_exact_admin_expression(self) -> None:
class Conn:
def __init__(self, policies):
self.policies = policies
self.query = ""
async def fetch(self, query, *args, **kwargs):
self.query = query
return self.policies
valid = Conn([_VALID_ROLLUP_DELETE_POLICY])
await maintenance._require_rollup_delete_policy(valid)
self.assertIn("policy.polcmd::text AS command", valid.query)
self.assertIn("pg_get_expr(policy.polqual, policy.polrelid)", valid.query)
self.assertIn("policy.polpermissive IS TRUE", valid.query)
self.assertIn("relation.relrowsecurity AS rls_enabled", valid.query)
self.assertIn("policy.polcmd IN ('d', '*')", valid.query)
self.assertNotIn("LIKE", valid.query)
invalid_policy_sets = (
[
{
**_VALID_ROLLUP_DELETE_POLICY,
"qual": "(app.current_role_name() = 'admin'::text) OR true",
}
],
[
{
**_VALID_ROLLUP_DELETE_POLICY,
"qual": "(app.current_role_name() = 'learner'::text)",
}
],
[
{
**_VALID_ROLLUP_DELETE_POLICY,
"permissive": 1,
}
],
[
{
**_VALID_ROLLUP_DELETE_POLICY,
"rls_enabled": False,
}
],
[
_VALID_ROLLUP_DELETE_POLICY,
{
"policy_name": "p_admin_health_daily_rollup_extra_delete",
"command": "d",
"permissive": True,
"qual": "true",
},
],
[
_VALID_ROLLUP_DELETE_POLICY,
{
"policy_name": "p_admin_health_daily_rollup_all",
"command": "*",
"permissive": True,
"qual": "true",
},
],
)
for policies in invalid_policy_sets:
with self.subTest(policies=policies):
with self.assertRaisesRegex(RuntimeError, "missing, invalid, or permissive"):
await maintenance._require_rollup_delete_policy(Conn(policies))
async def test_apply_stops_before_dml_when_rollup_delete_policy_is_missing(
self,
) -> None:
class Conn:
def __init__(self):
self.fetchrow_calls = 0
async def fetchrow(self, query, *args, **kwargs):
self.fetchrow_calls += 1
if self.fetchrow_calls == 1:
return {"event_count": 1, "bucket_count": 1}
if self.fetchrow_calls == 2:
return {"event_count": 0}
if self.fetchrow_calls == 3:
return {"rollup_count": 0}
async def fetch(self, query, *args, **kwargs):
if "FROM pg_policy AS policy" in query:
return []
raise AssertionError("missing policy must stop before rollup upsert")
async def execute(self, *args, **kwargs):
raise AssertionError("missing policy must stop before deletion")
context = _Acquire(Conn())
with unittest.mock.patch.object(maintenance, "acquire", return_value=context):
with self.assertRaisesRegex(
RuntimeError,
"owner must apply migration 25_admin_health_rollup_retention.sql",
):
await maintenance.maintain_admin_health_events(
rollup_days=90,
retention_days=90,
rollup_retention_days=365,
apply=True,
)
self.assertIsInstance(context.exit_error, RuntimeError)
async def test_repeat_apply_keeps_rollup_upsert_and_cutoff_contract(self) -> None:
calls = []
class Conn:
async def fetchrow(self, query, *args, **kwargs):
calls.append(("fetchrow", query, args))
if "admin_health_daily_rollup" in query:
return {"rollup_count": 0}
if "COUNT(DISTINCT" in query:
return {"event_count": 1, "bucket_count": 1}
return {"event_count": 0}
async def fetch(self, query, *args, **kwargs):
calls.append(("fetch", query, args))
if "FROM pg_policy AS policy" in query:
return [_VALID_ROLLUP_DELETE_POLICY]
return [1]
async def execute(self, query, *args, **kwargs):
calls.append(("execute", query, args))
return "DELETE 0"
context = _Acquire(Conn())
with unittest.mock.patch.object(maintenance, "acquire", return_value=context):
first = await maintenance.maintain_admin_health_events(
rollup_days=90,
retention_days=90,
rollup_retention_days=365,
apply=True,
)
second = await maintenance.maintain_admin_health_events(
rollup_days=90,
retention_days=90,
rollup_retention_days=365,
apply=True,
)
self.assertEqual(first.upserted_rollups, second.upserted_rollups)
upserts = [
call
for call in calls
if call[0] == "fetch" and "INSERT INTO app.admin_health_daily_rollup" in call[1]
]
self.assertEqual(2, len(upserts))
self.assertTrue(
all("ON CONFLICT (rollup_date, environment, engine_mode, service_key)" in call[1] for call in upserts)
)
rollup_prunes = [
call
for call in calls
if call[0] == "execute" and "admin_health_daily_rollup" in call[1]
]
self.assertEqual(2, len(rollup_prunes))
self.assertTrue(
all("rollup_date < current_date - $1::int" in call[1] for call in rollup_prunes)
)
self.assertTrue(all(call[2] == (365,) for call in rollup_prunes))
async def test_raw_prune_failure_stops_before_rollup_prune(self) -> None:
calls = []
class Conn:
async def fetchrow(self, query, *args, **kwargs):
if "admin_health_daily_rollup" in query:
return {"rollup_count": 0}
if "COUNT(DISTINCT" in query:
return {"event_count": 1, "bucket_count": 1}
return {"event_count": 1}
async def fetch(self, query, *args, **kwargs):
calls.append(("fetch", query))
if "FROM pg_policy AS policy" in query:
return [_VALID_ROLLUP_DELETE_POLICY]
return [1]
async def execute(self, query, *args, **kwargs):
calls.append(("execute", query))
raise RuntimeError("raw prune failed")
context = _Acquire(Conn())
with unittest.mock.patch.object(maintenance, "acquire", return_value=context):
with self.assertRaisesRegex(RuntimeError, "raw prune failed"):
await maintenance.maintain_admin_health_events(
rollup_days=90,
retention_days=90,
rollup_retention_days=365,
apply=True,
)
self.assertIsInstance(context.exit_error, RuntimeError)
self.assertEqual([call[0] for call in calls], ["fetch", "fetch", "execute"])
self.assertIn("FROM pg_policy AS policy", calls[0][1])
self.assertIn("DELETE FROM app.admin_health_event", calls[2][1])
def test_schema_defines_rollup_table_and_rls(self) -> None:
from pathlib import Path
root = Path(__file__).resolve().parents[3]
schema = (root / "infra" / "db" / "init" / "05_runtime_auth.sql").read_text(
encoding="utf-8"
)
self.assertIn("CREATE TABLE IF NOT EXISTS app.admin_health_daily_rollup", schema)
self.assertIn("PRIMARY KEY (rollup_date, environment, engine_mode, service_key)", schema)
self.assertIn("last_down_at TIMESTAMPTZ", schema)
self.assertIn("CREATE POLICY p_admin_health_daily_rollup_select", schema)
self.assertIn("CREATE POLICY p_admin_health_daily_rollup_update", schema)
self.assertIn("CREATE POLICY p_admin_health_event_delete", schema)
self.assertIn("CREATE POLICY p_admin_health_daily_rollup_delete", schema)
self.assertIn("USING (app.current_role_name() = 'admin');", schema)
migration = (
root / "infra" / "db" / "init" / "25_admin_health_rollup_retention.sql"
).read_text(encoding="utf-8")
self.assertIn("DROP POLICY IF EXISTS p_admin_health_daily_rollup_delete", migration)
self.assertIn("CREATE POLICY p_admin_health_daily_rollup_delete", migration)
self.assertIn("FOR DELETE", migration)
self.assertIn("app.current_role_name() = 'admin'", migration)
self.assertNotIn("learner", migration)
bootstrap = (root / "apps" / "api" / "app" / "auth_sessions.py").read_text(
encoding="utf-8"
)
self.assertIn("CREATE POLICY p_admin_health_daily_rollup_delete", bootstrap)