"""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()