432 lines
16 KiB
Python
432 lines
16 KiB
Python
from __future__ import annotations
|
|
|
|
import os
|
|
from copy import deepcopy
|
|
from dataclasses import FrozenInstanceError
|
|
from datetime import datetime
|
|
from typing import Any
|
|
|
|
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
|
|
|
|
import pytest
|
|
from PySide6.QtCore import QPoint, Qt
|
|
from PySide6.QtTest import QTest
|
|
from PySide6.QtWidgets import QApplication, QLabel, QToolTip
|
|
|
|
from doctor_workstation.ui.dialogs.ai_consult_charts import (
|
|
GlucoseReportCard,
|
|
build_glucose_chart_data,
|
|
)
|
|
from doctor_workstation.ui.dialogs.ai_consult_metric_state import (
|
|
ABNORMAL_COLOR,
|
|
NORMAL_COLOR,
|
|
UNKNOWN_COLOR,
|
|
)
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def application() -> QApplication:
|
|
return QApplication.instance() or QApplication([])
|
|
|
|
|
|
def _row(day: str = "2026-08-18", **changes: Any) -> dict[str, Any]:
|
|
return {
|
|
"diagnosis_id": 501,
|
|
"patient_id": 1501,
|
|
"record_date": day,
|
|
"fasting_blood_sugar": 6.8,
|
|
**changes,
|
|
}
|
|
|
|
|
|
def _tracking(*rows: Any, **changes: Any) -> dict[str, Any]:
|
|
return {"diagnosis_id": 501, "patient_id": 1501, "blood_records": list(rows), **changes}
|
|
|
|
|
|
def _build(tracking: Any):
|
|
return build_glucose_chart_data(tracking, diagnosis_id=501, patient_id=1501)
|
|
|
|
|
|
def test_real_dto_is_immutable_chronological_and_does_not_average_same_day() -> None:
|
|
tracking = _tracking(
|
|
_row("2026-08-20", record_time="09:10", fasting_blood_sugar="7.2 mmol/L"),
|
|
_row("2026-08-18", record_time="09:00", fasting_blood_sugar=6.1),
|
|
_row("2026-08-18", record_time="08:00", fasting_blood_sugar=5.9),
|
|
_row("2026-08-19", fasting_blood_sugar=None, postprandial_blood_sugar="9.1"),
|
|
)
|
|
before = deepcopy(tracking)
|
|
data = _build(tracking)
|
|
assert tracking == before
|
|
assert data.available and data.readout_count == 4 and data.record_count == 4
|
|
assert [reading.fasting for reading in data.readings] == [5.9, 6.1, None, 7.2]
|
|
assert data.readings[2].postprandial == 9.1
|
|
assert data.readings[0].recorded_at == datetime(2026, 8, 18, 8)
|
|
assert data.readings[0].time_label == "2026-08-18 08:00"
|
|
assert data.readings[2].time_label == "2026-08-19"
|
|
assert data.date_range is not None
|
|
assert tuple(day.isoformat() for day in data.date_range) == ("2026-08-18", "2026-08-20")
|
|
assert data.excluded_count == 0
|
|
with pytest.raises(FrozenInstanceError):
|
|
data.readings[0].fasting = 99 # type: ignore[misc]
|
|
tracking["blood_records"][0]["fasting_blood_sugar"] = 99
|
|
assert data.readings[-1].fasting == 7.2
|
|
|
|
|
|
@pytest.mark.parametrize("owner", [None, True, 501.0, "501", 502, 0])
|
|
def test_tracking_root_requires_exact_diagnosis_owner(owner: Any) -> None:
|
|
data = _build(_tracking(_row(), diagnosis_id=owner))
|
|
assert not data.available and data.readings == ()
|
|
assert "归属" in data.unavailable_reason
|
|
|
|
|
|
def test_ownerless_root_is_rejected() -> None:
|
|
tracking = _tracking(_row())
|
|
del tracking["diagnosis_id"]
|
|
assert not _build(tracking).available
|
|
|
|
|
|
@pytest.mark.parametrize("owner", [None, True, 501.0, "501", 502, 0])
|
|
def test_rows_require_exact_diagnosis_owner(owner: Any) -> None:
|
|
data = _build(_tracking(_row(diagnosis_id=owner), _row("2026-08-19")))
|
|
assert data.record_count == 1
|
|
assert data.readings[0].recorded_at.day == 19
|
|
assert data.excluded_count == 1
|
|
|
|
|
|
@pytest.mark.parametrize("owner", [None, True, 1501.0, "1501", 1502, 0])
|
|
def test_declared_patient_owner_is_strict_at_root_and_row(owner: Any) -> None:
|
|
assert not _build(_tracking(_row(), patient_id=owner)).available
|
|
data = _build(_tracking(_row(patient_id=owner)))
|
|
assert not data.available and data.readings == ()
|
|
assert data.excluded_count == 1
|
|
|
|
|
|
def test_diagnosis_owned_rows_may_omit_patient_id_but_not_diagnosis_id() -> None:
|
|
row = _row()
|
|
del row["patient_id"]
|
|
assert _build(_tracking(row)).readout_count == 1
|
|
del row["diagnosis_id"]
|
|
assert not _build(_tracking(row)).available
|
|
|
|
|
|
def test_root_patient_owner_is_used_when_the_caller_has_no_patient_id() -> None:
|
|
data = build_glucose_chart_data(_tracking(_row(patient_id=1502)), diagnosis_id=501)
|
|
assert not data.available and data.excluded_count == 1
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"value",
|
|
[
|
|
True,
|
|
False,
|
|
float("nan"),
|
|
float("inf"),
|
|
-float("inf"),
|
|
-1,
|
|
"-1",
|
|
"6-9",
|
|
"约 6.8",
|
|
"~6.8",
|
|
"<6.8",
|
|
"6.8±0.2",
|
|
"6.8 mg/dL",
|
|
"血糖6.8",
|
|
{"value": 6.8},
|
|
"Infinity",
|
|
],
|
|
)
|
|
def test_ambiguous_readings_stay_gaps_and_are_never_guessed(value: Any) -> None:
|
|
data = _build(_tracking(_row(fasting_blood_sugar=value)))
|
|
assert not data.available and data.readout_count == 0
|
|
assert len(data.readings) == 1 and data.readings[0].fasting is None
|
|
assert data.excluded_count == 1
|
|
|
|
|
|
@pytest.mark.parametrize("value", [None, "", "—", "未填写", 0, 0.0, "0", "0.0 mmol/L"])
|
|
def test_daily_zero_and_missing_defaults_are_absent_without_ambiguous_warning(value: Any) -> None:
|
|
data = _build(
|
|
_tracking(
|
|
_row(
|
|
fasting_blood_sugar=value,
|
|
postprandial_blood_sugar=0,
|
|
other_blood_sugar=0,
|
|
remark="继续观察",
|
|
)
|
|
)
|
|
)
|
|
assert not data.available and data.readout_count == 0
|
|
assert data.excluded_count == 0
|
|
assert all(reading.readout_count == 0 for reading in data.readings)
|
|
|
|
|
|
@pytest.mark.parametrize("value", ["6.80", "6.8 mmol/L", " 6.8 MMOL / l ", 6.8])
|
|
def test_exact_mmol_readings_are_accepted(value: Any) -> None:
|
|
data = _build(_tracking(_row(fasting_blood_sugar=value)))
|
|
assert data.readings[0].fasting == 6.8
|
|
assert data.excluded_count == 0
|
|
|
|
|
|
def test_partial_ambiguous_row_preserves_verified_series_and_records_one_exclusion() -> None:
|
|
data = _build(
|
|
_tracking(
|
|
_row(fasting_blood_sugar="6-9", postprandial_blood_sugar=9.3, other_blood_sugar="约7")
|
|
)
|
|
)
|
|
assert data.available and data.readout_count == 1
|
|
assert data.readings[0].fasting is None
|
|
assert data.readings[0].postprandial == 9.3
|
|
assert data.excluded_count == 1
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"day", [None, "", "2026-02-30", "08-18", "2026-8-18", "2026-08-18 大约", 1787040000]
|
|
)
|
|
def test_missing_or_ambiguous_date_never_becomes_today(day: Any) -> None:
|
|
data = _build(_tracking(_row(day)))
|
|
assert data.readings == () and data.excluded_count == 1
|
|
|
|
|
|
@pytest.mark.parametrize("clock", ["25:10", "8:30", "上午", True])
|
|
def test_invalid_declared_record_time_is_excluded(clock: Any) -> None:
|
|
assert _build(_tracking(_row(record_time=clock))).excluded_count == 1
|
|
|
|
|
|
def test_legacy_entries_require_owners_and_keep_periods_distinct() -> None:
|
|
tracking = {
|
|
"diagnosis_id": 501,
|
|
"blood_sugar": {
|
|
"entries": [
|
|
{"diagnosis_id": 501, "date": "2026-08-18", "value": "6.2", "period": "空腹"},
|
|
{"diagnosis_id": 501, "date": "2026-08-19", "value": "9.1", "period": "餐后"},
|
|
{
|
|
"diagnosis_id": 501,
|
|
"measured_at": "2026-08-19T20:10:00",
|
|
"value": "7.4",
|
|
"period": "睡前",
|
|
},
|
|
{"date": "2026-08-20", "value": "20.2", "period": "空腹"},
|
|
]
|
|
},
|
|
}
|
|
data = _build(tracking)
|
|
assert data.readout_count == 3 and data.excluded_count == 1
|
|
assert data.readings[0].fasting == 6.2
|
|
assert data.readings[1].postprandial == 9.1
|
|
assert data.readings[2].other == 7.4
|
|
assert data.readings[2].time_label == "2026-08-19 20:10"
|
|
tracking["blood_sugar"]["diagnosis_id"] = 502
|
|
assert not _build(tracking).available
|
|
|
|
|
|
def test_unit_metadata_cannot_relabel_mg_dl_as_mmol() -> None:
|
|
assert not _build(_tracking(_row(), unit="mg/dL")).available
|
|
assert not _build(_tracking(_row(unit="mg/dL"))).available
|
|
assert _build(_tracking(_row(unit="mmol/L"))).available
|
|
|
|
|
|
def test_production_source_takes_precedence_to_avoid_duplicate_representations() -> None:
|
|
tracking = _tracking(
|
|
_row(), blood_sugar={"entries": [{"diagnosis_id": 501, "date": "2026-08-18", "value": 9.9}]}
|
|
)
|
|
assert _build(tracking).readout_count == 1
|
|
|
|
|
|
def test_source_states_are_immutable_and_require_the_same_owned_row() -> None:
|
|
tracking = _tracking(
|
|
_row(fasting_glucose_status="normal", postprandial_glucose=9.3,
|
|
postprandial_glucose_status="low", other_glucose=7.1, other_glucose_status="warning"),
|
|
_row("2026-08-19", diagnosis_id=502, fasting_blood_sugar_status="high"),
|
|
fasting_blood_sugar_status="high",
|
|
)
|
|
before = deepcopy(tracking)
|
|
data = _build(tracking)
|
|
assert tracking == before and data.excluded_count == 1
|
|
assert len(data.readings) == 1
|
|
reading = data.readings[0]
|
|
assert (reading.fasting_status, reading.postprandial_status, reading.other_status) == (
|
|
"normal", "low", "warning",
|
|
)
|
|
tracking["blood_records"][0]["fasting_glucose_status"] = "high"
|
|
assert reading.fasting_status == "normal"
|
|
with pytest.raises(FrozenInstanceError):
|
|
reading.fasting_status = "high" # type: ignore[misc]
|
|
|
|
|
|
@pytest.mark.parametrize("status", [None, True, False, ["normal"], {"status": "normal"}])
|
|
def test_untyped_glucose_states_stay_unclassified(status: Any) -> None:
|
|
data = _build(_tracking(_row(fasting_blood_sugar_status=status)))
|
|
assert data.readings[0].fasting_status == ""
|
|
|
|
|
|
def test_glucose_points_tables_and_accessibility_share_explicit_states(application) -> None:
|
|
data = _build(_tracking(
|
|
_row("2026-08-18", fasting_blood_sugar=20, fasting_blood_sugar_status="normal",
|
|
postprandial_blood_sugar=3, postprandial_blood_sugar_status="low",
|
|
other_blood_sugar=12, other_blood_sugar_status="unclassified"),
|
|
_row("2026-08-19", fasting_blood_sugar=30),
|
|
_row("2026-08-20", fasting_blood_sugar=0, fasting_blood_sugar_status="normal"),
|
|
))
|
|
card = GlucoseReportCard(data)
|
|
card.resize(650, 420)
|
|
card.show()
|
|
application.processEvents()
|
|
assert card.chart is not None
|
|
chart = card.chart
|
|
image = chart.grab().toImage()
|
|
first = data.readings[0]
|
|
for column, field, color, status in (
|
|
(1, "fasting", NORMAL_COLOR, "normal"),
|
|
(2, "postprandial", ABNORMAL_COLOR, "low"),
|
|
(3, "other", UNKNOWN_COLOR, "unclassified"),
|
|
):
|
|
point = chart._position(first, getattr(first, field))
|
|
assert chart._point_color(first, field) == color
|
|
assert image.pixelColor(point.toPoint()).name().casefold() == color.casefold()
|
|
assert card.table.item(0, column).foreground().color().name().casefold() == color.casefold()
|
|
assert status in card.table.item(0, column).toolTip()
|
|
assert status in chart._point_tooltip(point)
|
|
assert status in chart.accessibleDescription()
|
|
assert card.table.item(1, 1).foreground().color().name() == UNKNOWN_COLOR.casefold()
|
|
assert "未标注" in card.table.item(1, 1).toolTip()
|
|
assert card.table.item(2, 1).text() == "—"
|
|
assert card.table.item(2, 1).foreground().color().name() == UNKNOWN_COLOR.casefold()
|
|
assert "未记录" in card.table.item(2, 1).toolTip()
|
|
assert "空腹血糖 — · 状态 未记录" in chart.accessibleDescription()
|
|
assert "红色异常、绿色正常、灰色未记录/未标注" in chart.accessibleDescription()
|
|
card.close()
|
|
|
|
|
|
def test_glucose_connection_is_gray_between_explicit_normal_points(application) -> None:
|
|
data = _build(_tracking(
|
|
_row("2026-08-18", fasting_blood_sugar=5, fasting_blood_sugar_status="normal"),
|
|
_row("2026-08-20", fasting_blood_sugar=5, fasting_blood_sugar_status="normal"),
|
|
))
|
|
card = GlucoseReportCard(data)
|
|
card.resize(640, 420)
|
|
card.show()
|
|
application.processEvents()
|
|
assert card.chart is not None
|
|
left, right = [card.chart._position(reading, 5) for reading in data.readings]
|
|
midpoint = (left + right) / 2
|
|
image = card.chart.grab().toImage()
|
|
center = midpoint.toPoint()
|
|
assert UNKNOWN_COLOR.casefold() in {
|
|
image.pixelColor(center.x() + dx, center.y() + dy).name()
|
|
for dx in (-1, 0, 1) for dy in (-1, 0, 1)
|
|
}
|
|
assert image.pixelColor(left.toPoint()).name() == NORMAL_COLOR.casefold()
|
|
card.close()
|
|
|
|
|
|
def test_explicit_missing_series_preserve_gaps_and_actual_date_spacing(
|
|
application: QApplication,
|
|
) -> None:
|
|
data = _build(
|
|
_tracking(
|
|
_row("2026-08-01", fasting_blood_sugar=5.8),
|
|
_row("2026-08-02", fasting_blood_sugar="6-9"),
|
|
_row("2026-08-11", fasting_blood_sugar=7.1),
|
|
)
|
|
)
|
|
assert [reading.fasting for reading in data.readings] == [5.8, None, 7.1]
|
|
card = GlucoseReportCard(data)
|
|
card.resize(700, 400)
|
|
card.show()
|
|
application.processEvents()
|
|
assert card.chart is not None
|
|
first = card.chart._position(data.readings[0], 5.8)
|
|
gap = card.chart._position(data.readings[1], 5.8)
|
|
last = card.chart._position(data.readings[2], 5.8)
|
|
assert (gap.x() - first.x()) / (last.x() - first.x()) == pytest.approx(0.1)
|
|
assert not card.grab().isNull()
|
|
card.close()
|
|
|
|
|
|
def test_single_point_hover_and_original_records_toggle(
|
|
application: QApplication, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
data = _build(_tracking(_row(record_time="08:15", fasting_blood_sugar=6.83)))
|
|
card = GlucoseReportCard(data)
|
|
card.resize(500, 420)
|
|
card.show()
|
|
application.processEvents()
|
|
assert card.objectName() == "AiConsultGlucoseReport"
|
|
assert card.chart is not None and card.chart.data is data
|
|
assert card.chart.objectName() == "AiConsultGlucoseChart"
|
|
assert card.toggle_button is not None
|
|
assert card.table.isHidden()
|
|
assert card.table.item(0, 0).text() == "2026-08-18 08:15"
|
|
assert card.table.item(0, 1).text() == "6.83"
|
|
assert card.table.item(0, 2).text() == "—"
|
|
assert "6.83 mmol/L" in card.chart.accessibleDescription()
|
|
tooltips: list[str] = []
|
|
monkeypatch.setattr(QToolTip, "showText", lambda _position, text, *_args: tooltips.append(text))
|
|
point = card.chart._position(data.readings[0], 6.83)
|
|
QTest.mouseMove(card.chart, QPoint(round(point.x()), round(point.y())))
|
|
application.processEvents()
|
|
assert tooltips and "2026-08-18 08:15" in tooltips[-1] and "6.83 mmol/L" in tooltips[-1]
|
|
QTest.mouseClick(card.toggle_button, Qt.MouseButton.LeftButton)
|
|
assert not card.table.isHidden() and card.toggle_button.isChecked()
|
|
assert card.toggle_button.text() == "收起原始记录"
|
|
QTest.mouseClick(card.toggle_button, Qt.MouseButton.LeftButton)
|
|
assert card.table.isHidden()
|
|
card.close()
|
|
|
|
|
|
def test_overlapping_observations_remain_separate_in_hover_and_table(
|
|
application: QApplication,
|
|
) -> None:
|
|
data = _build(_tracking(_row(record_time="08:15"), _row(record_time="08:15")))
|
|
card = GlucoseReportCard(data)
|
|
card.resize(500, 420)
|
|
card.show()
|
|
application.processEvents()
|
|
assert card.chart is not None
|
|
tip = card.chart._point_tooltip(card.chart._position(data.readings[0], 6.8))
|
|
assert "记录 1" in tip and "记录 2" in tip
|
|
assert card.table.rowCount() == 2
|
|
card.close()
|
|
|
|
|
|
@pytest.mark.parametrize("width", [320, 580, 880])
|
|
def test_report_card_fits_narrow_and_wide_columns(application: QApplication, width: int) -> None:
|
|
data = _build(
|
|
_tracking(
|
|
_row(other_blood_sugar=8.2, postprandial_blood_sugar=9.1),
|
|
_row("2026-08-19", fasting_blood_sugar="6-9"),
|
|
)
|
|
)
|
|
card = GlucoseReportCard(data)
|
|
card.resize(width, card.sizeHint().height())
|
|
card.show()
|
|
application.processEvents()
|
|
assert card.width() == width
|
|
assert card.chart is not None and card.chart.height() >= 210
|
|
assert card.chart.geometry().right() < width
|
|
for label in card.findChildren(QLabel):
|
|
assert label.geometry().right() < width
|
|
assert not card.grab().isNull()
|
|
assert card.toggle_button is not None
|
|
card.toggle_button.click()
|
|
application.processEvents()
|
|
assert card.table.geometry().right() < width
|
|
assert not card.grab().isNull()
|
|
card.close()
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"tracking", [None, {}, _tracking(), _tracking(_row(fasting_blood_sugar=0, remark="仅有备注"))]
|
|
)
|
|
def test_unavailable_state_has_no_fabricated_chart_or_empty_toggle(
|
|
application: QApplication, tracking: Any
|
|
) -> None:
|
|
card = GlucoseReportCard(_build(tracking))
|
|
card.resize(380, card.sizeHint().height())
|
|
card.show()
|
|
application.processEvents()
|
|
assert card.chart is None and card.toggle_button is None and card.table.isHidden()
|
|
assert card.height() < 210
|
|
assert any("暂无可绘制" in label.text() for label in card.findChildren(QLabel))
|
|
assert not card.grab().isNull()
|
|
card.close()
|