Files
next-tjwater-server/tests/api/test_scada_replay_api.py
T
jiang 9cd1400723
Generic Container CI/CD / test-build-publish (push) Successful in 4m23s
Server CI/CD v2 / build-test-publish-and-deploy (push) Successful in 4m23s
fix(replay): preserve failed periodic execution boundaries
2026-11-16 16:21:58 +08:00

163 lines
7.3 KiB
Python

import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock
from uuid import uuid4
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.api.v1.endpoints import scada_replay
from app.auth.project_dependencies import ProjectContext, get_project_context
@pytest.fixture
def replay_api(monkeypatch):
context = ProjectContext(uuid4(), "demo", uuid4(), "member")
project = SimpleNamespace(settings={"scada_monitoring_interval_seconds": 900, "other": True})
metadata = SimpleNamespace(get_project_by_id=AsyncMock(return_value=project))
repo = SimpleNamespace(available=AsyncMock(return_value=True), current=AsyncMock(return_value=None))
create = AsyncMock(side_effect=RuntimeError("creation mock must be configured"))
monkeypatch.setattr(scada_replay.ScadaReplayService, "create", create)
app = FastAPI()
app.include_router(scada_replay.router)
app.dependency_overrides[get_project_context] = lambda: context
app.dependency_overrides[scada_replay.repository] = lambda: repo
app.dependency_overrides[scada_replay.get_metadata_repository] = lambda: metadata
with TestClient(app) as client:
yield client, project, metadata, context, create
def test_capabilities_reads_frequency_from_current_project_settings(replay_api):
client, project, metadata, context, _ = replay_api
response = client.get("/scada-replays/capabilities")
assert response.status_code == 200
assert response.json()["monitoring_interval_seconds"] == 900
assert response.json()["burst_monitoring_ready"] is False
assert "尚未配置" in response.json()["burst_monitoring_reason"]
metadata.get_project_by_id.assert_awaited_once_with(context.project_id)
project.settings = {}
assert client.get("/scada-replays/capabilities").json()["monitoring_interval_seconds"] is None
def test_capabilities_reports_ready_only_with_five_pressures_and_outlet_flow(replay_api):
client, project, *_ = replay_api
project.settings = {
"scada_monitoring_interval_seconds": 900,
"scada_monitoring": {
"pressure_device_ids": ["P1", "P2", "P3", "P4", "P5"],
"outlet_flow_device_ids": ["F1"],
},
}
response = client.get("/scada-replays/capabilities")
assert response.status_code == 200
assert response.json()["burst_monitoring_ready"] is True
assert response.json()["burst_monitoring_reason"] is None
rules = response.json()["monitoring_config"]
assert rules["decision_policy"] == "weighted"
assert rules["weights"] == {"burst_detection": 0.5, "pressure": 0.4, "outlet_flow": 0.1}
assert rules["alert_threshold"] == 0.8
assert rules["pressure_device_ids"] == ["P1", "P2", "P3", "P4", "P5"]
def test_capabilities_reports_only_missing_storage_not_worker():
repo = SimpleNamespace(available=AsyncMock(return_value=False))
context = ProjectContext(uuid4(), "demo", uuid4(), "member")
result = asyncio.run(scada_replay.replay_capabilities(
repo=repo,
ctx=context,
settings=scada_replay.ProjectSettings(scada_monitoring_interval_seconds=900),
))
assert result.available is False
assert result.reason == "需先部署 SCADA 回放存储结构"
def test_weighted_capabilities_allow_flow_as_optional_support(replay_api):
client, project, *_ = replay_api
monitoring = {"pressure_device_ids": ["P1", "P2", "P3", "P4", "P5"]}
project.settings = {"scada_monitoring": monitoring}
assert client.get("/scada-replays/capabilities").json()["burst_monitoring_ready"] is True
monitoring["decision_policy"] = "all_signals"
assert client.get("/scada-replays/capabilities").json()["burst_monitoring_ready"] is False
@pytest.mark.parametrize("action", ["step", "monitor"])
def test_monitoring_command_processes_pending_period_in_same_request(monkeypatch, action):
calls = []
class Service:
def __init__(self, repo, context, timescale):
calls.append((repo, context, timescale))
async def command(self, replay_id, command):
calls.append((replay_id, command.action))
return SimpleNamespace(step_pending=True)
async def process_pending_step(self, replay_id):
calls.append((replay_id, "processed"))
return "completed-period"
monkeypatch.setattr(scada_replay, "ScadaReplayService", Service)
replay_id = uuid4()
context = ProjectContext(uuid4(), "demo", uuid4(), "member")
command = scada_replay.ScadaReplayCommand(
request_id=uuid4(), expected_revision=1, action=action,
**({"at_time": "2026-07-16T00:00:00Z"} if action == "monitor" else {}),
)
result = asyncio.run(scada_replay.replay_command(
replay_id, command, repo=SimpleNamespace(get=AsyncMock(return_value={"config": {}})), ctx=context, timescale="timescale"
))
assert result == "completed-period"
assert calls[-2:] == [(replay_id, action), (replay_id, "processed")]
def test_client_cannot_override_project_frequency_on_creation(replay_api):
client, _, _, _, create = replay_api
response = client.post("/scada-replays", json={
"request_id": str(uuid4()), "start_time": "2026-10-08T00:00:00Z",
"end_time": "2026-10-08T01:00:00Z", "device_ids": ["P1"],
"rules": [{"rule_id": "p", "device_ids": ["P1"], "kind": "bounds", "upper": 10, "unit": "m"}],
"monitoring_interval_seconds": 300,
})
assert response.status_code == 422
create.assert_not_awaited()
def test_periodic_endpoint_returns_only_persisted_diagnosis_and_simulation_without_creating_runs(replay_api, monkeypatch):
from app.services import periodic_tasks
from app.services.periodic_diagnosis import execution_record
client, _, _, context, _ = replay_api
replay_id = uuid4()
document = {"replay_id": str(replay_id)}
monitoring = {"period_start": "2026-07-16T07:45:00+08:00", "period_end": "2026-07-16T08:00:00+08:00",
"knowledge_cutoff": "2026-07-16T08:00:00+08:00", "batch_sequence": 2}
records = [execution_record(document, monitoring, key) for key in ("scada-diagnosis", "network-simulation")]
for record in records:
record.update(status="completed", conclusion="normal", summary="已完成本周期实际处理。")
repo = SimpleNamespace(connection=object(), project_id=context.project_id,
available=AsyncMock(return_value=True), get=AsyncMock(return_value=document),
periodic_tasks=AsyncMock(return_value=records))
ensure = AsyncMock()
monkeypatch.setattr(scada_replay, "ensure_periodic_tasks", ensure)
monkeypatch.setattr(periodic_tasks, "CalculationJobRepository", lambda *_: SimpleNamespace())
client.app.dependency_overrides[scada_replay.repository] = lambda: repo
response = client.get(f"/scada-replays/{replay_id}/scheduled-tasks")
assert response.status_code == 200
items = response.json()["items"]
assert {item["task_key"] for item in items} == {"scada-diagnosis", "network-simulation"}
assert [item["execution_id"] for item in items] == [item["execution_id"] for item in records]
assert all(item["status"] == "completed" for item in items)
assert response.json()["next_offset"] is None
repo.get.assert_awaited_once_with(replay_id)
repo.periodic_tasks.assert_awaited_once_with(replay_id, 0, 101)
ensure.assert_not_awaited()