472 lines
25 KiB
Python
472 lines
25 KiB
Python
"""SCADA display coverage is independent of whether a device supports a conclusion."""
|
|
from datetime import datetime, timedelta, timezone
|
|
from copy import deepcopy
|
|
from uuid import uuid4
|
|
|
|
import pytest
|
|
|
|
from app.domain.domain_errors import DomainError
|
|
from app.domain.schemas.operational_data import TaskDataSnapshot
|
|
from app.domain.schemas.operational_task import AgentArtifactsCommand, AgentRunCommand, TaskPresentationEventCommand
|
|
from app.services.operational_tasks import OperationalTaskService
|
|
from tests.support.operational_task_repository import TaskRepository, _active_run, _context, _task_document
|
|
|
|
|
|
DEVICES = ["486033", "542017", "541061", "524529"]
|
|
END = datetime(2026, 7, 16, tzinfo=timezone.utc)
|
|
START = END - timedelta(hours=3)
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_value_only_detail_evidence_cannot_claim_missing_observations():
|
|
from app.services.scada_presentation_coverage import verify_chart
|
|
task, repository, _, evidence_id = await investigation()
|
|
detail = deepcopy(repository.evidence[evidence_id])
|
|
detail["evidence_id"] = "detail-values"
|
|
rows = detail["data_snapshot"]["data"]["data"]["readings"]
|
|
detail["data_snapshot"]["data"]["data"] = [
|
|
{"device_id": row["device_id"], "time": row["time"], "value": row["monitored_value"]}
|
|
for row in rows
|
|
]
|
|
value = chart(devices=["524529"])
|
|
value["series"][0].update(data=[None] * 13, sample_times=[None] * 13)
|
|
with pytest.raises(DomainError) as failure:
|
|
verify_chart(task, value, [repository.evidence[evidence_id], detail], ["detail-values"])
|
|
assert failure.value.code == "SCADA_CHART_EVIDENCE_REQUIRED"
|
|
|
|
|
|
@pytest.mark.anyio
|
|
@pytest.mark.parametrize("field", ["monitored_value", "cleaned_value"])
|
|
async def test_detail_fields_do_not_discard_other_observed_fields(field):
|
|
from app.services.scada_presentation_coverage import verify_chart
|
|
task, repository, _, evidence_id = await investigation()
|
|
detail = deepcopy(repository.evidence[evidence_id])
|
|
detail["evidence_id"] = "detail-cleaned"
|
|
rows = detail["data_snapshot"]["data"]["data"]["readings"]
|
|
detail["data_snapshot"]["data"]["data"] = [
|
|
{"device_id": row["device_id"], "time": row["time"], "value": row["cleaned_value"] + 10,
|
|
"cleaned_value": row["cleaned_value"] + 10} for row in rows
|
|
]
|
|
value = chart(devices=["524529"])
|
|
value["scada"]["value_field"] = field
|
|
if field == "cleaned_value":
|
|
value["series"][0]["data"] = [point + 10 for point in value["series"][0]["data"]]
|
|
result = verify_chart(task, value, [repository.evidence[evidence_id], detail], [evidence_id, "detail-cleaned"])
|
|
assert result["gaps"] == []
|
|
|
|
|
|
@pytest.fixture
|
|
def anyio_backend():
|
|
return "asyncio"
|
|
|
|
|
|
async def investigation():
|
|
context = _context()
|
|
task = _task_document(context, END, lease=END + timedelta(minutes=1))
|
|
task["workflow"] = "scada_anomaly"
|
|
repository = TaskRepository(task, _active_run(task, END))
|
|
service = OperationalTaskService(repository, context, set(), clock=lambda: END)
|
|
readings = []
|
|
for day in range(8):
|
|
slots = range(13) if day == 0 else range(10, 13)
|
|
for slot in slots:
|
|
for device in DEVICES:
|
|
readings.append({"device_id": device, "time": (START + timedelta(minutes=15 * slot, days=-day)).isoformat(),
|
|
"monitored_value": float(slot + 1), "cleaned_value": float(slot + 1)})
|
|
evidence, _ = await service.record_data_snapshot(task["task_id"], TaskDataSnapshot(
|
|
source="query_scada_readings", source_ref="mcp:observations", queried_at=END,
|
|
origin="system_data", truncated=False, data={
|
|
"window": {"start": (START - timedelta(days=7)).isoformat(), "end": END.isoformat()},
|
|
"data": {"devices": [{"device_id": device, "device_type": "pipe_flow", "measurement_unit": "m3/h",
|
|
"transmission_frequency": "0:15:00"} for device in DEVICES],
|
|
"readings": readings, "coverage": {"mode": "all_scada", "query_complete": True}},
|
|
},
|
|
))
|
|
return task, repository, service, evidence.evidence_id
|
|
|
|
|
|
def coverage(comparison_devices):
|
|
slots = [(START + timedelta(minutes=15 * i)).isoformat() for i in range(13)]
|
|
common = {"coverage": {device: {"covered": slots} for device in DEVICES}, "metric": "flow", "window_start": START.isoformat(), "window_end": END.isoformat(), "gaps": []}
|
|
return {"version": 1, "targets": DEVICES.copy(), "charts": {
|
|
"overview": {**common, "role": "current", "device_ids": DEVICES.copy()},
|
|
**{f"comparison-{device}": {**common, "role": "comparison", "device_ids": [device],
|
|
"coverage": {device: {"covered": slots}}}
|
|
for device in comparison_devices},
|
|
}}
|
|
|
|
|
|
def final_report(evidence_id):
|
|
return {"stage": "final", "outcome": "concluded", "title": "调查结果",
|
|
"current_conclusion": "524529 仅作参考", "conclusion_boundary": "待现场核验",
|
|
"evidence_refs": [evidence_id], "data_gaps": [], "scada_device_ids": DEVICES}
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_final_rejects_four_target_devices_with_three_comparisons():
|
|
task, repository, service, evidence_id = await investigation()
|
|
repository.scada_presentations = {(task["task_id"], repository.run["run_id"]): coverage(DEVICES[:3])}
|
|
with pytest.raises(DomainError) as failure:
|
|
await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report=final_report(evidence_id),
|
|
))
|
|
assert failure.value.code == "SCADA_PRESENTATION_INCOMPLETE"
|
|
assert "524529" in failure.value.message
|
|
assert not repository.reports
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_final_accepts_all_four_devices():
|
|
task, repository, service, evidence_id = await investigation()
|
|
repository.scada_presentations = {(task["task_id"], repository.run["run_id"]): coverage(DEVICES)}
|
|
result = await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report=final_report(evidence_id),
|
|
))
|
|
assert result.report_revision == 1
|
|
|
|
|
|
def chart(role="current", devices=None):
|
|
devices = DEVICES if devices is None else devices
|
|
comparison = role == "comparison"
|
|
series = []
|
|
for device in devices:
|
|
for day in (range(8) if comparison else [0]):
|
|
slots = range(13) if day == 0 else range(10, 13)
|
|
series.append({"name": f"{device} {day}", "device_id": device, "day_offset": day,
|
|
"type": "scatter" if day else "line",
|
|
"data": [float(index + 1) if index in slots else None for index in range(13)],
|
|
"sample_times": [(START + timedelta(minutes=15 * index, days=-day)).isoformat()
|
|
if index in slots else None for index in range(13)]})
|
|
return {"title": "流量观测", "chart_type": "time_comparison" if comparison else "line",
|
|
"x_data": [(START + timedelta(minutes=15 * index, hours=8)).strftime("%H:%M") for index in range(13)],
|
|
"series": series, "scada": {"role": role, "metric": "flow", "unit": "m3/h",
|
|
"window_start": START.isoformat(), "window_end": END.isoformat()}}
|
|
|
|
|
|
async def publish(task, repository, service, evidence_id, chart_id, data):
|
|
command = TaskPresentationEventCommand(
|
|
request_id=uuid4(), run_id=repository.run["run_id"], source_session_id="session-1",
|
|
command={"action": "open_chart", "chart_id": chart_id, "chart": data, "evidence_refs": [evidence_id]},
|
|
)
|
|
return await service.publish_presentation_event(task["task_id"], command)
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_publications_require_complete_targets_and_retry_without_a_browser():
|
|
task, repository, service, evidence_id = await investigation()
|
|
await publish(task, repository, service, evidence_id, "overview", chart())
|
|
for device in DEVICES[:3]:
|
|
await publish(task, repository, service, evidence_id, device, chart("comparison", [device]))
|
|
interim = {**final_report(evidence_id), "stage": "interim"}
|
|
await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report=interim,
|
|
))
|
|
final = AgentArtifactsCommand(request_id=uuid4(), source_session_id="session-1", report=final_report(evidence_id))
|
|
with pytest.raises(DomainError) as failure:
|
|
await service.publish_artifacts(task["task_id"], final)
|
|
assert failure.value.code == "SCADA_PRESENTATION_INCOMPLETE"
|
|
assert failure.value.refs == ["524529"]
|
|
await publish(task, repository, service, evidence_id, "524529", chart("comparison", ["524529"]))
|
|
await service.publish_presentation_event(task["task_id"], TaskPresentationEventCommand(
|
|
request_id=uuid4(), run_id=repository.run["run_id"], source_session_id="session-1",
|
|
command={"action": "close_chart", "chart_id": "524529"},
|
|
))
|
|
result = await service.publish_artifacts(task["task_id"], final)
|
|
assert result.task.latest_report.report.stage == "final"
|
|
# Neither retained event history nor a browser acknowledgement is required.
|
|
repository.events.clear()
|
|
complete = await service.complete_run(task["task_id"], repository.run["run_id"], AgentRunCommand(
|
|
request_id=uuid4(), expected_revision=repository.run["revision"], source_session_id="session-1",
|
|
))
|
|
assert complete.latest_run.status == "succeeded"
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_successful_completion_rechecks_coverage_after_final_report():
|
|
task, repository, service, evidence_id = await investigation()
|
|
repository.scada_presentations[(task["task_id"], repository.run["run_id"])] = coverage(DEVICES)
|
|
await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report=final_report(evidence_id),
|
|
))
|
|
# Replacing a chart cannot erase its fourth target from the required set.
|
|
await publish(task, repository, service, evidence_id, "overview", chart(devices=DEVICES[:3]))
|
|
with pytest.raises(DomainError) as failure:
|
|
await service.complete_run(task["task_id"], repository.run["run_id"], AgentRunCommand(
|
|
request_id=uuid4(), expected_revision=repository.run["revision"], source_session_id="session-1",
|
|
))
|
|
assert failure.value.code == "SCADA_PRESENTATION_INCOMPLETE"
|
|
assert "524529" in failure.value.message
|
|
assert repository.run["status"] == "running"
|
|
|
|
|
|
@pytest.mark.anyio
|
|
@pytest.mark.parametrize("missing_current", [False, True])
|
|
async def test_missing_observations_keep_the_object_and_server_derived_gaps(missing_current):
|
|
task, repository, service, evidence_id = await investigation()
|
|
data = repository.evidence[evidence_id]["data_snapshot"]["data"]["data"]
|
|
data["readings"] = [row for row in data["readings"] if row["device_id"] != "524529"
|
|
or not missing_current and datetime.fromisoformat(row["time"]) >= START]
|
|
value = chart("comparison", ["524529"])
|
|
for series in value["series"]:
|
|
if missing_current or series["day_offset"]:
|
|
series["data"] = [None] * 13
|
|
series["sample_times"] = [None] * 13
|
|
await publish(task, repository, service, evidence_id, "524529", value)
|
|
saved = repository.events[-1]["metadata"]["command"]["chart"]
|
|
assert len(saved["scada"]["gaps"]) == (8 if missing_current else 7)
|
|
assert sum(gap["missing_count"] for gap in saved["scada"]["gaps"]) == (34 if missing_current else 21)
|
|
document = await repository.get_scada_presentation(task["task_id"], repository.run["run_id"])
|
|
assert document["targets"] == ["524529"]
|
|
assert document["charts"]["524529"]["device_ids"] == ["524529"]
|
|
|
|
|
|
@pytest.mark.anyio
|
|
@pytest.mark.parametrize("defect,code", [
|
|
("null_existing_value", "SCADA_CHART_DATA_MISMATCH"),
|
|
("invented_value", "SCADA_CHART_DATA_MISMATCH"),
|
|
("wrong_window", "SCADA_CHART_WINDOW_INVALID"),
|
|
("missing_day", "SCADA_CHART_INVALID"),
|
|
("wrong_unit", "SCADA_CHART_INVALID"),
|
|
("unqueried_history", "SCADA_CHART_EVIDENCE_REQUIRED"),
|
|
])
|
|
async def test_scada_chart_cannot_fake_coverage(defect, code):
|
|
task, repository, service, evidence_id = await investigation()
|
|
value = chart("comparison", ["524529"])
|
|
if defect == "null_existing_value":
|
|
value["series"][1]["data"][10] = None
|
|
value["series"][1]["sample_times"][10] = None
|
|
elif defect == "invented_value":
|
|
value["series"][0]["data"][0] = 999.
|
|
elif defect == "wrong_window":
|
|
value["scada"]["window_end"] = (END - timedelta(minutes=15)).isoformat()
|
|
elif defect == "missing_day":
|
|
value["series"].pop()
|
|
elif defect == "wrong_unit":
|
|
value["scada"]["unit"] = "m"
|
|
elif defect == "unqueried_history":
|
|
repository.evidence[evidence_id]["data_snapshot"]["data"]["window"]["start"] = START.isoformat()
|
|
with pytest.raises(DomainError) as failure:
|
|
await publish(task, repository, service, evidence_id, "524529", value)
|
|
assert failure.value.code == code
|
|
assert not repository.scada_presentations
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_previous_run_charts_never_satisfy_a_new_run():
|
|
task, repository, service, evidence_id = await investigation()
|
|
original = repository.run["run_id"]
|
|
repository.scada_presentations[(task["task_id"], original)] = coverage(DEVICES)
|
|
task["execution_generation"] += 1
|
|
repository.run = _active_run(task, END)
|
|
repository.runs[repository.run["run_id"]] = repository.run
|
|
with pytest.raises(DomainError) as failure:
|
|
await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report=final_report(evidence_id),
|
|
))
|
|
assert failure.value.code == "SCADA_PRESENTATION_INCOMPLETE"
|
|
assert original != repository.run["run_id"]
|
|
assert (task["task_id"], original) in repository.scada_presentations
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_one_device_cannot_inflate_comparison_object_count_with_a_new_chart_id():
|
|
task, repository, service, evidence_id = await investigation()
|
|
await publish(task, repository, service, evidence_id, "524529", chart("comparison", ["524529"]))
|
|
with pytest.raises(DomainError) as failure:
|
|
await publish(task, repository, service, evidence_id, "524529-duplicate", chart("comparison", ["524529"]))
|
|
assert failure.value.code == "SCADA_CHART_DUPLICATE_DEVICE"
|
|
assert failure.value.refs == ["524529"]
|
|
await publish(task, repository, service, evidence_id, "524529", chart("comparison", ["524529"]))
|
|
assert len(repository.scada_presentations[(task["task_id"], repository.run["run_id"])]["charts"]) == 1
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_server_frozen_boundary_proves_unavailable_history_without_fabricating_a_query():
|
|
task, repository, service, evidence_id = await investigation()
|
|
replay_id = str(uuid4())
|
|
task["source"]["replay_context"] = {"replay_id": replay_id, "knowledge_cutoff": END.isoformat(), "batch_sequence": 3}
|
|
snapshot = repository.evidence[evidence_id]["data_snapshot"]["data"]
|
|
snapshot["window"]["start"] = START.isoformat()
|
|
snapshot["data"]["coverage"].update(replay_id=replay_id, batch_sequence=3, frozen_start=START.isoformat())
|
|
value = chart("comparison", ["524529"])
|
|
for series in value["series"][1:]:
|
|
series["data"] = [None] * 13
|
|
series["sample_times"] = [None] * 13
|
|
await publish(task, repository, service, evidence_id, "524529", value)
|
|
gaps = repository.events[-1]["metadata"]["command"]["chart"]["scada"]["gaps"]
|
|
assert len(gaps) == 7
|
|
assert {gap["reason"] for gap in gaps} == {"outside_frozen_window"}
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_interim_monitoring_table_targets_cannot_be_removed_from_a_later_final_report():
|
|
task, repository, service, evidence_id = await investigation()
|
|
incomplete = coverage(DEVICES[:3])
|
|
incomplete["targets"] = DEVICES[:3]
|
|
incomplete["charts"]["overview"]["device_ids"] = DEVICES[:3]
|
|
repository.scada_presentations[(task["task_id"], repository.run["run_id"])] = incomplete
|
|
await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report={**final_report(evidence_id), "stage": "interim"},
|
|
))
|
|
with pytest.raises(DomainError) as failure:
|
|
await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report={**final_report(evidence_id), "scada_device_ids": DEVICES[:3]},
|
|
))
|
|
assert failure.value.code == "SCADA_PRESENTATION_INCOMPLETE"
|
|
assert failure.value.refs == ["524529"]
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_narrative_diagram_references_do_not_declare_business_display_targets():
|
|
task, repository, service, evidence_id = await investigation()
|
|
selected = DEVICES[:3]
|
|
document = coverage(selected)
|
|
document["targets"] = selected
|
|
document["charts"]["overview"]["device_ids"] = selected
|
|
repository.scada_presentations[(task["task_id"], repository.run["run_id"])] = document
|
|
report = {**final_report(evidence_id), "scada_device_ids": selected, "diagram": {
|
|
"title": "待选参考测点", "mermaid": "flowchart LR\nreference[参考测点]", "node_refs": [{
|
|
"node_id": "reference", "label": "参考测点", "map_targets": [{"source_id": "scada", "feature_id": "524529"}],
|
|
}],
|
|
}}
|
|
result = await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report=report,
|
|
))
|
|
assert result.report_revision == 1
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_unaligned_cutoff_keeps_actual_quarter_hour_samples():
|
|
task, repository, service, evidence_id = await investigation()
|
|
task["trigger"]["occurred_at"] = (END + timedelta(minutes=8)).isoformat()
|
|
value = chart("comparison", ["524529"])
|
|
value["scada"].update(window_start=(START + timedelta(minutes=8)).isoformat(),
|
|
window_end=(END + timedelta(minutes=8)).isoformat())
|
|
value["x_data"] = value["x_data"][1:]
|
|
for item in value["series"]:
|
|
item["data"] = item["data"][1:]
|
|
item["sample_times"] = item["sample_times"][1:]
|
|
await publish(task, repository, service, evidence_id, "unaligned", value)
|
|
|
|
|
|
@pytest.mark.anyio
|
|
@pytest.mark.parametrize("frequency", ["15min", "15分钟"])
|
|
async def test_wholly_missing_devices_accept_supported_cadence_formats(frequency):
|
|
task, repository, service, evidence_id = await investigation()
|
|
data = repository.evidence[evidence_id]["data_snapshot"]["data"]["data"]
|
|
data["readings"] = []
|
|
for device in data["devices"]:
|
|
device["transmission_frequency"] = frequency
|
|
value = chart("comparison", ["524529"])
|
|
for item in value["series"]:
|
|
item["data"] = [None] * 13
|
|
item["sample_times"] = [None] * 13
|
|
await publish(task, repository, service, evidence_id, "missing", value)
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_one_minute_chunks_require_union_of_verified_slots():
|
|
task, repository, service, evidence_id = await investigation()
|
|
data = repository.evidence[evidence_id]["data_snapshot"]["data"]["data"]
|
|
data["devices"] = [{**data["devices"][0], "transmission_frequency": "1min"}]
|
|
device = DEVICES[0]
|
|
data["readings"] = [{"device_id": device, "time": (START + timedelta(minutes=i, days=-day)).isoformat(),
|
|
"monitored_value": float(i + 1)}
|
|
for day in range(8) for i in (range(181) if day == 0 else range(178, 181))]
|
|
|
|
def chunk(role, first, stop, missing_current=False):
|
|
value = chart(role, [device])
|
|
value["x_data"] = [(START + timedelta(minutes=i, hours=8)).strftime("%H:%M") for i in range(first, stop)]
|
|
for item in value["series"]:
|
|
day = item["day_offset"]
|
|
present = lambda i: (not day or i >= 178) and not (missing_current and day == 0)
|
|
item["data"] = [float(i + 1) if present(i) else None for i in range(first, stop)]
|
|
item["sample_times"] = [(START + timedelta(minutes=i, days=-day)).isoformat() if present(i) else None
|
|
for i in range(first, stop)]
|
|
return value
|
|
|
|
report = {**final_report(evidence_id), "scada_device_ids": [device]}
|
|
for role in ("current", "comparison"):
|
|
await publish(task, repository, service, evidence_id, role + "-first", chunk(role, 0, 100))
|
|
with pytest.raises(DomainError) as failure:
|
|
await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report=report))
|
|
assert failure.value.code == "SCADA_PRESENTATION_INCOMPLETE"
|
|
with pytest.raises(DomainError) as duplicate:
|
|
await publish(task, repository, service, evidence_id, "overlap", chunk("comparison", 99, 181))
|
|
assert duplicate.value.code == "SCADA_CHART_DUPLICATE_DEVICE"
|
|
for role in ("current", "comparison"):
|
|
await publish(task, repository, service, evidence_id, role + "-last", chunk(role, 100, 181))
|
|
await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report=report))
|
|
# Missing current data still permits the last chunk's historical dates across midnight.
|
|
data["readings"] = [row for row in data["readings"] if datetime.fromisoformat(row["time"]) < START]
|
|
await publish(task, repository, service, evidence_id, "comparison-last", chunk("comparison", 100, 181, True))
|
|
|
|
|
|
@pytest.mark.parametrize("start,end,labels,historical", [
|
|
("2026-07-16T05:08:00+08:00", "2026-07-16T08:08:00+08:00", ["07:45", "08:00"],
|
|
["2026-07-15T07:45:00+08:00", "2026-07-15T08:00:00+08:00"]),
|
|
("2026-07-15T22:08:00+08:00", "2026-07-16T01:08:00+08:00", ["00:45", "01:00"],
|
|
["2026-07-15T00:45:00+08:00", "2026-07-15T01:00:00+08:00"]),
|
|
])
|
|
def test_missing_current_chunk_uses_its_first_slot_date(start, end, labels, historical):
|
|
from app.services.time_comparison_chart import validate_time_comparison_chart
|
|
|
|
validate_time_comparison_chart({"chart_type": "time_comparison", "x_data": labels,
|
|
"scada": {"role": "comparison", "window_start": start, "window_end": end},
|
|
"series": [{"type": "line", "data": [None, None], "sample_times": [None, None]},
|
|
{"type": "scatter", "data": [1., 2.], "sample_times": historical}]},
|
|
allow_missing_current=True)
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_missing_current_preserves_observed_historical_sampling_phase():
|
|
task, repository, service, evidence_id = await investigation()
|
|
data = repository.evidence[evidence_id]["data_snapshot"]["data"]["data"]
|
|
data["readings"] = [{**row, "time": (datetime.fromisoformat(row["time"]) + timedelta(minutes=5)).isoformat()}
|
|
for row in data["readings"] if datetime.fromisoformat(row["time"]) < START]
|
|
value = chart("comparison", ["524529"])
|
|
value["x_data"] = [(START + timedelta(minutes=15 * i + 5, hours=8)).strftime("%H:%M") for i in range(12)]
|
|
for item in value["series"]:
|
|
day = item["day_offset"]
|
|
item["data"] = [float(i + 1) if day and i >= 9 else None for i in range(12)]
|
|
item["sample_times"] = [(START + timedelta(minutes=15 * i + 5, days=-day)).isoformat()
|
|
if day and i >= 9 else None for i in range(12)]
|
|
# The final three corresponding slots are now 23:20,23:35,23:50 UTC.
|
|
for day in range(1, 8):
|
|
data["readings"].append({"device_id": "524529", "time": (START + timedelta(minutes=140, days=-day)).isoformat(),
|
|
"monitored_value": 10.})
|
|
await publish(task, repository, service, evidence_id, "historical-phase", value)
|
|
|
|
|
|
@pytest.mark.anyio
|
|
@pytest.mark.parametrize("point_only", [False, True])
|
|
async def test_six_hour_devices_with_no_scheduled_slots_require_full_absence_proof(point_only):
|
|
task, repository, service, evidence_id = await investigation()
|
|
end = END + timedelta(hours=2)
|
|
start = end - timedelta(hours=3)
|
|
task["trigger"]["occurred_at"] = end.isoformat()
|
|
snapshot = repository.evidence[evidence_id]["data_snapshot"]["data"]
|
|
snapshot["window"] = {"start": (end if point_only else start - timedelta(days=7)).isoformat(), "end": end.isoformat()}
|
|
snapshot["data"]["readings"] = []
|
|
for device in snapshot["data"]["devices"]:
|
|
device["transmission_frequency"] = "6:00:00"
|
|
for role in ("current", "comparison"):
|
|
value = chart(role, ["524529"])
|
|
value["scada"].update(window_start=start.isoformat(), window_end=end.isoformat())
|
|
value["x_data"] = ["10:00"]
|
|
for item in value["series"]:
|
|
item["data"], item["sample_times"] = [None], [None]
|
|
if point_only:
|
|
with pytest.raises(DomainError) as failure:
|
|
await publish(task, repository, service, evidence_id, role, value)
|
|
assert failure.value.code == "SCADA_CHART_EVIDENCE_REQUIRED"
|
|
else:
|
|
await publish(task, repository, service, evidence_id, role, value)
|
|
gaps = repository.events[-1]["metadata"]["command"]["chart"]["scada"]["gaps"]
|
|
assert all(gap["reason"] == "no_scheduled_samples" for gap in gaps)
|
|
if not point_only:
|
|
await service.publish_artifacts(task["task_id"], AgentArtifactsCommand(
|
|
request_id=uuid4(), source_session_id="session-1", report={**final_report(evidence_id), "scada_device_ids": ["524529"]}))
|