feat(replay): execute periodic diagnosis and hydraulic checks

This commit is contained in:
2026-11-16 15:13:22 +08:00
parent 4c441fcbf2
commit 389892cb3f
22 changed files with 1934 additions and 12 deletions
@@ -0,0 +1,95 @@
"""Native calculation and real SQL under an isolated project UUID, always rolled back."""
import os
from datetime import datetime, timezone
from uuid import UUID, uuid4
import psycopg
from psycopg.rows import dict_row
import pytest
from app.auth.project_dependencies import ProjectContext
from app.infra.db.metadb.database import SessionLocal, engine
from app.infra.db.metadb.repositories.metadata_repository import MetadataRepository
from app.infra.db.postgresql.calculation_jobs import CalculationJobRepository
from app.infra.db.postgresql.scada_replays import ScadaReplayRepository
from app.services.periodic_tasks import ensure_periodic_tasks, execute_periodic_calculation, persist_periodic_terminal, project_periodic_tasks
from app.infra.epanet.model_snapshot import pack_model_input
from types import SimpleNamespace
pytestmark = pytest.mark.skipif(os.getenv("PERIODIC_TASK_STORAGE_TEST") != "1", reason="explicit rollback-only SQL test required")
@pytest.fixture
def anyio_backend(): return "asyncio"
@pytest.mark.anyio
async def test_frozen_period_queue_native_result_and_retry_storage():
from tests.unit.test_periodic_hydraulics import MODEL
async with SessionLocal() as session:
metadata = MetadataRepository(session)
routing = await metadata.get_project_db_routing(UUID("871d7538-589c-47de-a6d5-3185ccb9f0e1"), "biz_data")
await engine.dispose()
if not routing:
pytest.skip("Project route unavailable")
connection = await psycopg.AsyncConnection.connect(routing.dsn, row_factory=dict_row, connect_timeout=5)
project_id, user_id, replay_id, request_id = uuid4(), uuid4(), uuid4(), uuid4()
try:
async with connection.transaction(force_rollback=True):
repo = ScadaReplayRepository(connection, project_id)
if not await repo.available() or not await repo.queue_available():
pytest.skip("Replay or calculation storage is not provisioned")
start, end = "2026-07-16T07:45:00+08:00", "2026-07-16T08:00:00+08:00"
devices = [{"device_id": "P1", "device_type": "pressure", "node_id": "J1", "measurement_unit": "m", "transmission_frequency": "0:15:00"},
{"device_id": "F1", "device_type": "pipe_flow", "link_id": "L1", "measurement_unit": "m3/h", "transmission_frequency": "0:15:00"}]
rows = [{"device_id": device, "time": at, "quality": "valid", "cleaned_value": value}
for at in (start, end) for device, value in (("P1", 39.8), ("F1", 3.6))]
monitoring = {"monitoring_id": str(uuid4()), "period_start": start, "period_end": end, "knowledge_cutoff": end,
"batch_sequence": 1, "status": "normal", "detail": "本周期正常", "task_id": None}
document = {"project_id": str(project_id), "replay_id": str(replay_id), "created_by": str(user_id), "status": "paused",
"config": {"request_id": str(request_id), "scheduled_tasks_enabled": True, "device_ids": ["P1", "F1"], "rules": []},
"devices": devices, "latest": {row["device_id"]: row for row in rows},
"monitoring_interval_seconds": 900, "last_monitoring": monitoring,
"scheduled_model_ready": True, "scheduled_model_digest": "frozen-test-model",
"updated_at": datetime.now(timezone.utc).isoformat()}
await repo.insert(document)
await repo.save_batch(replay_id, {"sequence": 0, "stage": "detected", "kind": "model_snapshot",
"model_input_gzip": pack_model_input(MODEL), "model_digest": "frozen-test-model"})
await repo.save_batch(replay_id, {"sequence": 1, "stage": "detected", "monitoring": monitoring, "outputs": rows})
context = ProjectContext(project_id, "tjwater2_v2", user_id, "member")
await ensure_periodic_tasks(repo, context, replay_id)
await ensure_periodic_tasks(repo, context, replay_id)
page = await project_periodic_tasks(repo, replay_id, 0, 100)
assert len(page) == 2
simulation = next(item for item in page if item["task_key"] == "network-simulation")
assert simulation["status"] == "pending"
queue = CalculationJobRepository(connection, project_id)
owner = str(uuid4())
job = await queue.claim(owner, 30)
# Avoid committing the enclosing test rollback transaction: production
# releases its read transaction before computation, tested separately.
class ReadScopeConnection:
def __getattr__(self, key): return getattr(connection, key)
async def commit(self): pass
result = await execute_periodic_calculation(SimpleNamespace(project=context, connection=ReadScopeConnection()), job)
assert result.data["conclusion"] == "normal"
assert len(result.data["result"]["comparisons"]) == 4
terminal = {"status": "succeeded", "result": result.model_dump(mode="json")}
assert await queue.finish(job, owner, **terminal)
await persist_periodic_terminal(connection, job, terminal)
# A stale worker must not republish another result after its fence closed.
assert not await queue.finish(job, owner, **terminal)
stored = await repo.periodic_task(replay_id, simulation["execution_id"])
assert stored["status"] == "completed"
assert len(stored["result"]["comparisons"]) == 4
await repo.save_retry_receipt(replay_id, 1, request_id, simulation["execution_id"])
assert (await repo.batch(replay_id, 1))["periodic_retry_receipts"][str(request_id)] == simulation["execution_id"]
assert len(await repo.periodic_tasks(replay_id, 0, 1)) == 1
assert len(await repo.periodic_tasks(replay_id, 1, 1)) == 1
assert (await repo.get(replay_id))["last_scheduled_simulation"]["status"] == "completed"
# Check rollback on the same connection, with no application rows retained.
row = await (await connection.execute("SELECT count(*) AS count FROM peripheral_sample.scada_replays WHERE project_id=%s", (project_id,))).fetchone()
assert row["count"] == 0
finally:
await connection.close()