geng

app/tests/test_prescription_list_density.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+import pytest
+from PySide6.QtCore import QPoint
+from PySide6.QtGui import QImage
+from PySide6.QtWidgets import QAbstractItemView, QApplication, QComboBox, QFrame, QWidget
+
+from doctor_workstation.ui.pages import prescription_library as library_module
+from doctor_workstation.ui.pages import prescriptions as prescriptions_module
+from doctor_workstation.ui.pages.prescription_library import PrescriptionLibraryPage
+from doctor_workstation.ui.pages.prescriptions import PrescriptionsPage
+from doctor_workstation.ui.widgets import BusinessPager
+
+
+@pytest.fixture(scope="module")
+def application() -> QApplication:
+    return QApplication.instance() or QApplication([])
+
+
+@pytest.fixture(autouse=True)
+def immediate_async(monkeypatch: pytest.MonkeyPatch) -> None:
+    def run_immediately(
+        function: Any,
+        *args: Any,
+        on_success: Any = None,
+        on_error: Any = None,
+        on_finished: Any = None,
+        **kwargs: Any,
+    ) -> object:
+        try:
+            result = function(*args, **kwargs)
+        except Exception as error:
+            if on_error is not None:
+                on_error(error)
+        else:
+            if on_success is not None:
+                on_success(result)
+        finally:
+            if on_finished is not None:
+                on_finished()
+        return object()
+
+    monkeypatch.setattr(prescriptions_module, "run_async", run_immediately)
+    monkeypatch.setattr(library_module, "run_async", run_immediately)
+
+
+def _issued_row(index: int) -> dict[str, Any]:
+    return {
+        "id": 1000 + index,
+        "sn": f"CF-202608-{1000 + index}",
+        "prescription_type": "汤剂",
+        "is_system_auto": index % 2,
+        "patient_name": ("林晓岚", "周明远", "许安然")[index % 3],
+        "gender": 2 if index % 2 else 1,
+        "age": 29 + index,
+        "audit_status": index % 3,
+        "void_status": 0,
+        "has_prescription_order": index % 2,
+        "creator_id": 7,
+        "doctor_name": "陈医生",
+        "assistant_name": "赵医助",
+        "create_time": f"2026-08-{(index % 9) + 10:02d} 09:30:00",
+        "herbs": [{"name": "黄芪", "dosage": 15}],
+    }
+
+
+def _library_row(index: int) -> dict[str, Any]:
+    return {
+        "id": 2000 + index,
+        "prescription_name": ("益气养阴方", "清热祛湿方", "滋阴调和方")[index % 3],
+        "formula_type": "主方" if index % 3 else "辅方",
+        "herbs": [
+            {"name": "黄芪", "dosage": 15},
+            {"name": "党参", "dosage": 12},
+        ],
+        "efficacy": ("益气养阴", "清热祛湿", "滋阴补肾")[index % 3],
+        "is_public": index % 2,
+        "disable_edit": 0,
+        "creator_id": 7,
+        "creator_name": "陈医生",
+        "create_time": f"2026-08-{(index % 9) + 10:02d} 08:20:00",
+    }
+
+
+class DensityRepository:
+    def __init__(self) -> None:
+        self.issued_rows = [_issued_row(index) for index in range(15)]
+        self.library_rows = [_library_row(index) for index in range(15)]
+
+    def list_diagnosis_doctors(self) -> list[dict[str, Any]]:
+        return [{"id": 7, "name": "陈医生"}, {"id": 8, "name": "孙医生"}]
+
+    def list_prescriptions(self, **_filters: Any) -> dict[str, Any]:
+        return {"lists": self.issued_rows, "count": 44}
+
+    def list_prescription_templates(self, **_filters: Any) -> dict[str, Any]:
+        return {"lists": self.library_rows, "count": 41}
+
+
+def _new_page(kind: str) -> PrescriptionsPage | PrescriptionLibraryPage:
+    repository = DensityRepository()
+    user = SimpleNamespace(id=7, name="陈医生", root=1, role_ids=[0])
+    permissions = {"*"}
+    if kind == "issued":
+        page: PrescriptionsPage | PrescriptionLibraryPage = PrescriptionsPage(
+            repository, permissions, user
+        )
+    else:
+        page = PrescriptionLibraryPage(repository, permissions, user)
+    page.refresh()
+    return page
+
+
+def _settle(application: QApplication) -> None:
+    for _ in range(5):
+        application.processEvents()
+
+
+def _fully_visible_rows(page: PrescriptionsPage | PrescriptionLibraryPage) -> int:
+    viewport = page.table.viewport()
+    return sum(
+        1
+        for row in range(page.table.rowCount())
+        if (
+            (item := page.table.item(row, 0)) is not None
+            and (rect := page.table.visualItemRect(item)).isValid()
+            and rect.top() >= 0
+            and rect.bottom() < viewport.height()
+        )
+    )
+
+
+def test_business_pager_is_shared_fixed_and_not_a_fake_dropdown(
+    application: QApplication,
+) -> None:
+    pager = BusinessPager(15)
+    pager.update_state(2, 44)
+    pager.show()
+    _settle(application)
+
+    assert prescriptions_module.BusinessPager is BusinessPager
+    assert 40 <= pager.height() <= 44
+    assert pager.minimumHeight() == pager.maximumHeight() == 42
+    assert pager.findChildren(QComboBox) == []
+    assert pager.page_size_label.text() == "15 条/页"
+    margins = pager.layout().contentsMargins()
+    assert (margins.left(), margins.top(), margins.right(), margins.bottom()) == (16, 4, 16, 4)
+    assert pager.page_label is not None and pager.page_label.text() == "2"
+    pager.close()
+
+
+@pytest.mark.parametrize("kind", ["issued", "library"])
+@pytest.mark.parametrize(
+    ("size", "minimum_visible_rows"),
+    [((1366, 768), 6), ((1710, 920), 9)],
+)
+def test_desktop_sizes_keep_rows_and_pager_visible_and_aligned(
+    application: QApplication,
+    kind: str,
+    size: tuple[int, int],
+    minimum_visible_rows: int,
+) -> None:
+    page = _new_page(kind)
+    page.resize(*size)
+    page.show()
+    _settle(application)
+
+    header = page.findChild(QWidget, "PageHeader")
+    toolbar_name = "PrescriptionToolbar" if kind == "issued" else "PrescriptionLibraryToolbar"
+    toolbar = page.findChild(QFrame, toolbar_name)
+    assert header is not None and 60 <= header.height() <= 64
+    assert toolbar is not None and 44 <= toolbar.height() <= 48
+    assert 40 <= page.pager.height() <= 44
+    assert page.pager.minimumHeight() == page.pager.maximumHeight()
+    assert page.table.minimumHeight() == 0
+    assert page.table.horizontalScrollMode() == QAbstractItemView.ScrollMode.ScrollPerPixel
+    assert page.table.verticalScrollMode() == QAbstractItemView.ScrollMode.ScrollPerPixel
+    assert _fully_visible_rows(page) >= minimum_visible_rows
+
+    pager_position = page.pager.mapTo(page, QPoint())
+    assert pager_position.x() >= 0
+    assert pager_position.x() + page.pager.width() <= page.width()
+    assert pager_position.y() >= 0
+    assert pager_position.y() + page.pager.height() <= page.height()
+    page_size_right = page.pager.page_size_label.mapTo(page, QPoint()).x() + (
+        page.pager.page_size_label.width()
+    )
+    assert page_size_right <= page.width()
+    pager_margins = page.pager.layout().contentsMargins()
+    toolbar_margins = toolbar.layout().contentsMargins()
+    assert pager_margins.left() == toolbar_margins.left() == 16
+    assert pager_margins.right() == toolbar_margins.right() == 16
+
+    if kind == "issued":
+        filters = page.findChild(QFrame, "PrescriptionFilterBar")
+        assert filters is not None and 84 <= filters.height() <= 92
+    else:
+        filters = page.findChild(QFrame, "PrescriptionLibraryFilterBar")
+        assert filters is not None
+        assert page.name_filter.minimumWidth() < 500
+        filter_right = filters.contentsRect().right()
+        for control in (
+            page.name_filter,
+            page.formula_filter,
+            page.visibility_filter,
+            page.effect_filter,
+            page.query_button,
+            page.reset_button,
+        ):
+            right = control.mapTo(filters, QPoint()).x() + control.width()
+            assert right <= filter_right
+
+    page.close()
+    _settle(application)
+
+
+def test_density_reference_artifacts_exist() -> None:
+    root = Path(__file__).resolve().parents[1]
+    expected = {
+        root / "artifacts" / "prescription_list_density" / "prescriptions_1366x768.png": (
+            1366,
+            768,
+        ),
+        root / "artifacts" / "prescription_list_density" / "prescriptions_1710x920.png": (
+            1710,
+            920,
+        ),
+        root
+        / "artifacts"
+        / "prescription_list_density"
+        / "prescription_library_1366x768.png": (1366, 768),
+        root
+        / "artifacts"
+        / "prescription_list_density"
+        / "prescription_library_1710x920.png": (1710, 920),
+    }
+    for path, dimensions in expected.items():
+        image = QImage(str(path))
+        assert not image.isNull(), path
+        assert (image.width(), image.height()) == dimensions