96 lines
6.2 KiB
Python
96 lines
6.2 KiB
Python
"""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()
|