mirror of
https://github.com/bec-project/bec_widgets.git
synced 2026-11-16 14:34:06 +01:00
refactor(scan_metadata): build the scan metadata form on PydanticWidgetForm
This commit is contained in:
9 files changed
+1144
-349
No files matched your search
@@ -7,7 +7,6 @@ try:
|
||||
except ImportError:
|
||||
pytest.skip(reason="Requires plugin repo!", allow_module_level=True)
|
||||
|
||||
|
||||
from bec_widgets.utils.widget_io import WidgetIO
|
||||
from bec_widgets.widgets.control.scan_control import ScanControl
|
||||
|
||||
@@ -67,9 +66,10 @@ def test_scan_metadata_for_custom_scan(
|
||||
|
||||
def do_test():
|
||||
# Set the metadata
|
||||
for field_name, widget in scan_control._metadata_form.widget_dict.items():
|
||||
form = scan_control._metadata_form.form
|
||||
for field_name in list(form.widgets):
|
||||
if (value_to_set := md.pop(field_name, None)) is not None:
|
||||
widget.setValue(value_to_set)
|
||||
form.set_partial_data({field_name: value_to_set})
|
||||
# all values should be used
|
||||
assert md == {}
|
||||
assert scan_control.button_run_scan.isEnabled()
|
||||
|
||||
@@ -16,7 +16,6 @@ from qtpy.QtTest import QAbstractItemModelTester
|
||||
|
||||
from bec_widgets.tests.utils import create_widget
|
||||
from bec_widgets.widgets.editors.dict_backed_table import DictBackedTable
|
||||
from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
|
||||
|
||||
INITIAL_DATA = [["key1", "value1"], ["key2", "value2"], ["key3", "value3"]]
|
||||
|
||||
@@ -171,22 +170,6 @@ def test_tables_do_not_share_backing_data(qtbot):
|
||||
assert second._table_model.rowCount() == 0
|
||||
|
||||
|
||||
def test_scan_metadata_form_drops_deleted_extra_row(qtbot):
|
||||
widget = create_widget(qtbot, ScanMetadata, initial_extras=[["k1", "v1"], ["k2", "v2"]])
|
||||
received: list[dict] = []
|
||||
widget.form_data_updated.connect(received.append)
|
||||
table = widget._additional_metadata
|
||||
|
||||
selection = table._table_view.selectionModel()
|
||||
selection.select(table._table_model.index(0, 0), QItemSelectionModel.SelectionFlag.Select)
|
||||
table.delete_selected_rows()
|
||||
|
||||
assert table.dump_dict() == {"k2": "v2"}
|
||||
assert received, "deleting a row must re-validate the form"
|
||||
assert "k1" not in received[-1]
|
||||
assert received[-1]["k2"] == "v2"
|
||||
|
||||
|
||||
def test_values_are_not_checked_against_keys(table):
|
||||
model = table._table_model
|
||||
table.update_disallowed_keys(["forbidden"])
|
||||
|
||||
@@ -1,16 +1,19 @@
|
||||
from decimal import Decimal
|
||||
from typing import Literal
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
from bec_lib.device import Device, Signal
|
||||
from bec_lib.scan_args import ScanArgument
|
||||
from pydantic import BaseModel, Field
|
||||
from qtpy.QtWidgets import QCheckBox, QLabel, QLineEdit
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
from qtpy.QtWidgets import QCheckBox, QComboBox, QDoubleSpinBox, QLabel, QLineEdit
|
||||
|
||||
from bec_widgets.tests.client_mocks import mocked_client
|
||||
from bec_widgets.utils.forms_from_types.entry_list_editor import EntryListEditor
|
||||
from bec_widgets.utils.forms_from_types.forms import PydanticModelForm, TypedForm
|
||||
from bec_widgets.utils.forms_from_types.items import FloatDecimalFormItem, IntFormItem, StrFormItem
|
||||
from bec_widgets.utils.forms_from_types.pydantic_widget_form import (
|
||||
EXTRA_FIELDS_KEY,
|
||||
OptionalValueWidget,
|
||||
PydanticWidgetForm,
|
||||
)
|
||||
@@ -326,3 +329,118 @@ def test_pydantic_widget_form_preserves_optional_bool_none(qtbot):
|
||||
|
||||
assert form.raw_data()["enabled"] is True
|
||||
assert form.model_instance().enabled is True
|
||||
|
||||
|
||||
class GeneratedExtraSchema(BaseModel):
|
||||
model_config = ConfigDict(extra="allow")
|
||||
|
||||
sample: str = Field(title="Sample", description="Sample identifier", max_length=8)
|
||||
dose: Decimal = Field(Decimal("0.50"), decimal_places=2, ge=0)
|
||||
tags: list[int] = Field(default_factory=list)
|
||||
settings: dict[str, int] = Field(default_factory=dict)
|
||||
mode: Literal["fast", "slow"] | None = None
|
||||
|
||||
|
||||
def test_pydantic_widget_form_extra_fields_round_trip(qtbot):
|
||||
form = PydanticWidgetForm(GeneratedExtraSchema, allow_extra_fields=True)
|
||||
qtbot.addWidget(form)
|
||||
form.set_data({"sample": "s1", "operator": "jan"})
|
||||
|
||||
assert form.extra_data() == {"operator": "jan"}
|
||||
assert form.raw_data()["operator"] == "jan"
|
||||
assert form.get_data()["operator"] == "jan"
|
||||
|
||||
|
||||
def test_pydantic_widget_form_extra_fields_survive_model_change(qtbot):
|
||||
class Other(BaseModel):
|
||||
model_config = ConfigDict(extra="allow")
|
||||
sample: str = ""
|
||||
|
||||
form = PydanticWidgetForm(GeneratedExtraSchema, allow_extra_fields=True)
|
||||
qtbot.addWidget(form)
|
||||
form.set_data({"sample": "s1", "operator": "jan"})
|
||||
form.set_model(Other)
|
||||
|
||||
assert form.layout().indexOf(form.extra_fields_section) >= 0
|
||||
assert form.raw_data() == {"sample": "s1", "operator": "jan"}
|
||||
|
||||
|
||||
def test_pydantic_widget_form_reports_invalid_extra_keys(qtbot):
|
||||
form = PydanticWidgetForm(GeneratedExtraSchema, allow_extra_fields=True)
|
||||
qtbot.addWidget(form)
|
||||
form.set_partial_data({"sample": "s1"})
|
||||
form.set_extra_data({"sample": "clash"})
|
||||
|
||||
assert form.validation_errors() == {
|
||||
EXTRA_FIELDS_KEY: "'sample' is already a field of this form."
|
||||
}
|
||||
assert not form.validate()
|
||||
with pytest.raises(ValueError, match="already a field"):
|
||||
form.get_data()
|
||||
row = form.extra_fields_section.editor.rows()[0]
|
||||
assert row.key_edit.property("state") == "error"
|
||||
|
||||
|
||||
def test_pydantic_widget_form_without_extra_fields_has_no_section(qtbot):
|
||||
form = PydanticWidgetForm(GeneratedExtraSchema)
|
||||
qtbot.addWidget(form)
|
||||
assert form.extra_fields_section is None
|
||||
assert form.extra_data() == {}
|
||||
|
||||
|
||||
def test_pydantic_widget_form_decimal_list_dict_and_optional_literal(qtbot):
|
||||
form = PydanticWidgetForm(GeneratedExtraSchema)
|
||||
qtbot.addWidget(form)
|
||||
|
||||
dose = form.input_widget("dose")
|
||||
assert type(dose) is QDoubleSpinBox
|
||||
assert dose.decimals() == 2
|
||||
assert form.raw_data()["dose"] == Decimal("0.50")
|
||||
assert isinstance(form.input_widget("tags"), EntryListEditor)
|
||||
assert not form.input_widget("tags").key_value
|
||||
assert form.input_widget("settings").key_value
|
||||
mode = form.input_widget("mode")
|
||||
assert isinstance(mode, QComboBox)
|
||||
assert [mode.itemText(i) for i in range(mode.count())] == ["", "fast", "slow"]
|
||||
|
||||
form.set_partial_data(
|
||||
{"sample": "s1", "tags": [1, 2], "settings": {"gain": 3}, "dose": Decimal("1.25")}
|
||||
)
|
||||
data = form.get_data()
|
||||
assert data["tags"] == [1, 2]
|
||||
assert data["settings"] == {"gain": 3}
|
||||
assert data["dose"] == Decimal("1.25")
|
||||
assert data["mode"] is None
|
||||
|
||||
mode.setCurrentText("slow")
|
||||
assert form.get_data()["mode"] == "slow"
|
||||
|
||||
|
||||
def test_pydantic_widget_form_text_constraints_and_placeholder(qtbot):
|
||||
form = PydanticWidgetForm(GeneratedExtraSchema)
|
||||
qtbot.addWidget(form)
|
||||
sample = form.input_widget("sample")
|
||||
assert sample.maxLength() == 8
|
||||
assert sample.placeholderText() == "Sample identifier"
|
||||
|
||||
|
||||
def test_pydantic_widget_form_required_markers_and_empty_text(qtbot):
|
||||
plain = PydanticWidgetForm(GeneratedExtraSchema)
|
||||
strict = PydanticWidgetForm(
|
||||
GeneratedExtraSchema, mark_required=True, empty_text_as_missing=True
|
||||
)
|
||||
qtbot.addWidget(plain)
|
||||
qtbot.addWidget(strict)
|
||||
|
||||
# default behaviour is unchanged: an empty required text is an empty string
|
||||
assert plain.layout().labelForField(plain.field_widget("sample")).text() == "Sample"
|
||||
assert plain.validate()
|
||||
|
||||
assert strict.layout().labelForField(strict.field_widget("sample")).text() == "Sample *"
|
||||
assert strict.validation_errors() == {"sample": "Required - please fill in"}
|
||||
assert not strict.validate()
|
||||
assert strict.input_widget("sample").property("state") == "error"
|
||||
|
||||
strict.input_widget("sample").setText("s1")
|
||||
assert strict.validate()
|
||||
assert strict.input_widget("sample").property("state") == ""
|
||||
@@ -8,11 +8,10 @@ import pytest
|
||||
from bec_lib.endpoints import MessageEndpoints
|
||||
from bec_lib.messages import AvailableResourceMessage, ScanHistoryMessage
|
||||
from bec_lib.scan_history import ScanHistory
|
||||
from qtpy.QtCore import QModelIndex, QPoint, Qt
|
||||
from qtpy.QtWidgets import QCheckBox, QComboBox, QDialog, QStyle
|
||||
from qtpy.QtCore import QPoint, Qt
|
||||
from qtpy.QtWidgets import QCheckBox, QComboBox, QDialog, QLineEdit, QStyle
|
||||
|
||||
from bec_widgets.tests.client_mocks import mocked_client
|
||||
from bec_widgets.utils.forms_from_types.items import StrFormItem
|
||||
from bec_widgets.utils.widget_io import WidgetIO
|
||||
from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
|
||||
from bec_widgets.widgets.control.scan_control import ScanControl
|
||||
@@ -1750,16 +1749,12 @@ def test_scan_metadata_is_updated_even_without_default_form_changes(
|
||||
assert scan_control._metadata_form._scan_name == "line_scan"
|
||||
scan_control.comboBox_scan_selection.setCurrentText("grid_scan")
|
||||
assert scan_control._metadata_form._scan_name == "grid_scan"
|
||||
scan_control._metadata_form._additional_metadata._add_button.click()
|
||||
qtbot.wait(100)
|
||||
table_model = scan_control._metadata_form._additional_metadata._table_model
|
||||
model_key = table_model.index(0, 0, QModelIndex())
|
||||
table_model.setData(model_key, "test key 1", Qt.EditRole)
|
||||
model_value = model_key.siblingAtColumn(1)
|
||||
table_model.setData(model_value, "test value 1", Qt.EditRole)
|
||||
assert scan_control._metadata_form._additional_metadata.dump_dict() == {
|
||||
"test key 1": "test value 1"
|
||||
}
|
||||
editor = scan_control._metadata_form.form.extra_fields_section.editor
|
||||
editor.add_button.click()
|
||||
row = editor.rows()[0]
|
||||
row.key_edit.setText("test key 1")
|
||||
row.value_edit.setText("test value 1")
|
||||
assert editor.value() == {"test key 1": "test value 1"}
|
||||
assert scan_control._scan_metadata == {
|
||||
"comment": "",
|
||||
"sample_name": "",
|
||||
@@ -1772,22 +1767,19 @@ def test_scan_metadata_is_connected(scan_control):
|
||||
assert scan_control._metadata_form._scan_name == "line_scan"
|
||||
scan_control.comboBox_scan_selection.setCurrentText("grid_scan")
|
||||
assert scan_control._metadata_form._scan_name == "grid_scan"
|
||||
sample_name = scan_control._metadata_form.widget_dict["sample_name"]
|
||||
assert isinstance(sample_name, StrFormItem)
|
||||
sample_name._main_widget.setText("Test Sample")
|
||||
sample_name = scan_control._metadata_form.form.input_widget("sample_name")
|
||||
assert isinstance(sample_name, QLineEdit)
|
||||
sample_name.setText("Test Sample")
|
||||
|
||||
scan_control._metadata_form._additional_metadata._table_model._data = TEST_TABLE_ENTRY
|
||||
scan_control._metadata_form.validate_form()
|
||||
scan_control._metadata_form.set_extra_metadata(dict(TEST_TABLE_ENTRY))
|
||||
assert scan_control._scan_metadata == TEST_MD
|
||||
|
||||
|
||||
def test_scan_metadata_is_passed_to_scan_function(scan_control: ScanControl):
|
||||
scan_control.comboBox_scan_selection.setCurrentText("grid_scan")
|
||||
|
||||
sample_name = scan_control._metadata_form.widget_dict["sample_name"]
|
||||
sample_name._main_widget.setText("Test Sample")
|
||||
scan_control._metadata_form._additional_metadata._table_model._data = TEST_TABLE_ENTRY
|
||||
scan_control._metadata_form.validate_form()
|
||||
scan_control._metadata_form.form.input_widget("sample_name").setText("Test Sample")
|
||||
scan_control._metadata_form.set_extra_metadata(dict(TEST_TABLE_ENTRY))
|
||||
|
||||
assert scan_control._scan_metadata == TEST_MD
|
||||
|
||||
|
||||
@@ -1,22 +1,18 @@
|
||||
from decimal import Decimal
|
||||
from typing import Set
|
||||
|
||||
import pytest
|
||||
from bec_lib.metadata_schema import BasicScanMetadata
|
||||
from pydantic import BaseModel, Field, ValidationError
|
||||
from pydantic import Field, ValidationError
|
||||
from pydantic.types import Json
|
||||
from qtpy.QtCore import QItemSelectionModel, QPoint, Qt
|
||||
from qtpy.QtWidgets import QCheckBox, QDoubleSpinBox, QFormLayout, QLineEdit, QSpinBox
|
||||
|
||||
from bec_widgets.utils.forms_from_types.items import (
|
||||
BoolFormItem,
|
||||
DictFormItem,
|
||||
DynamicFormItem,
|
||||
FloatDecimalFormItem,
|
||||
IntFormItem,
|
||||
StrFormItem,
|
||||
)
|
||||
from bec_widgets.tests.utils import create_widget
|
||||
from bec_widgets.utils.forms_from_types.entry_list_editor import EntryListEditor
|
||||
from bec_widgets.utils.forms_from_types.pydantic_widget_form import OptionalValueWidget
|
||||
from bec_widgets.widgets.editors.dict_backed_table import DictBackedTable
|
||||
from bec_widgets.widgets.editors.scan_metadata.scan_metadata import ScanMetadata
|
||||
from bec_widgets.widgets.utility.spinbox.decimal_spinbox import BECSpinBox
|
||||
|
||||
# pylint: disable=no-member
|
||||
# pylint: disable=missing-function-docstring
|
||||
@@ -40,8 +36,27 @@ class ExampleSchema(BasicScanMetadata):
|
||||
unsupported_class: Json = Field(default=set())
|
||||
|
||||
|
||||
class TwoRequiredSchema(BasicScanMetadata):
|
||||
sample_id: str = Field(title="Sample ID")
|
||||
operator: str = Field(title="Operator")
|
||||
|
||||
|
||||
TEST_VALUES = {
|
||||
"sample_name": "test name",
|
||||
"str_optional": None,
|
||||
"str_required": "something",
|
||||
"bool_optional": None,
|
||||
"bool_required_nodefault": False,
|
||||
"int_default": 21,
|
||||
"int_nodefault_optional": -10,
|
||||
"float_nodefault": 0.1,
|
||||
"decimal_dp_limits_nodefault": 456.789,
|
||||
"dict_default": {"test_dict": "values"},
|
||||
"unsupported_class": '["set", "item"]',
|
||||
}
|
||||
|
||||
TEST_DICT = {
|
||||
"scan_name": "",
|
||||
"scan_name": "example_scan",
|
||||
"comment": "",
|
||||
"sample_name": "test name",
|
||||
"str_optional": None,
|
||||
@@ -59,255 +74,241 @@ TEST_DICT = {
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def example_md():
|
||||
return ExampleSchema.model_validate(TEST_DICT)
|
||||
def schema_registry(monkeypatch):
|
||||
monkeypatch.setattr(
|
||||
"bec_lib.metadata_schema._get_metadata_schema_registry",
|
||||
lambda: {"example_scan": ExampleSchema, "two_required": TwoRequiredSchema},
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def empty_metadata_widget(qtbot):
|
||||
widget = ScanMetadata()
|
||||
widget._additional_metadata._table_model._data = [["extra_field", "extra_data"]]
|
||||
qtbot.addWidget(widget)
|
||||
def metadata_widget(qtbot, schema_registry):
|
||||
widget = create_widget(
|
||||
qtbot,
|
||||
ScanMetadata,
|
||||
scan_name="example_scan",
|
||||
initial_extras=[["extra_field", "extra_data"]],
|
||||
)
|
||||
yield widget
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def metadata_widget(empty_metadata_widget: ScanMetadata):
|
||||
widget = empty_metadata_widget
|
||||
widget._md_schema = ExampleSchema
|
||||
widget.populate()
|
||||
|
||||
yield widget, widget.widget_dict
|
||||
def test_fields_use_matching_widgets(metadata_widget: ScanMetadata):
|
||||
widgets = metadata_widget.form.widgets
|
||||
for name in ["scan_name", "comment", "sample_name", "str_required", "unsupported_class"]:
|
||||
assert type(widgets[name]) is QLineEdit, name
|
||||
assert isinstance(metadata_widget.form.input_widget("str_optional"), QLineEdit)
|
||||
assert metadata_widget.form.input_widget("str_optional").maxLength() == 23
|
||||
assert isinstance(widgets["bool_optional"], OptionalValueWidget)
|
||||
assert isinstance(widgets["bool_required_default"], QCheckBox)
|
||||
assert isinstance(widgets["bool_required_nodefault"], QCheckBox)
|
||||
assert isinstance(widgets["int_default"], QSpinBox)
|
||||
assert isinstance(widgets["int_nodefault_optional"], OptionalValueWidget)
|
||||
assert isinstance(widgets["float_nodefault"], BECSpinBox)
|
||||
decimal = widgets["decimal_dp_limits_nodefault"]
|
||||
assert type(decimal) is QDoubleSpinBox
|
||||
assert decimal.decimals() == 2
|
||||
assert (decimal.minimum(), decimal.maximum()) == (pytest.approx(1.01), pytest.approx(34.5))
|
||||
assert isinstance(widgets["dict_default"], EntryListEditor)
|
||||
|
||||
|
||||
def fill_components(components: dict[str, DynamicFormItem]):
|
||||
components["sample_name"].setValue("test name")
|
||||
components["str_optional"].setValue(None)
|
||||
components["str_required"].setValue("something")
|
||||
components["bool_optional"].setValue(None)
|
||||
components["bool_required_nodefault"].setValue(False)
|
||||
components["int_default"].setValue(21)
|
||||
components["int_nodefault_optional"].setValue(-10)
|
||||
components["float_nodefault"].setValue(0.1)
|
||||
components["decimal_dp_limits_nodefault"].setValue(456.789)
|
||||
components["dict_default"].setValue({"test_dict": "values"})
|
||||
components["unsupported_class"].setValue(r'["set", "item"]')
|
||||
|
||||
|
||||
def test_griditems_are_correct_class(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
_, components = metadata_widget
|
||||
assert isinstance(components["sample_name"], StrFormItem)
|
||||
assert isinstance(components["str_optional"], StrFormItem)
|
||||
assert isinstance(components["str_required"], StrFormItem)
|
||||
assert isinstance(components["bool_optional"], BoolFormItem)
|
||||
assert isinstance(components["bool_required_default"], BoolFormItem)
|
||||
assert isinstance(components["bool_required_nodefault"], BoolFormItem)
|
||||
assert isinstance(components["int_default"], IntFormItem)
|
||||
assert isinstance(components["int_nodefault_optional"], IntFormItem)
|
||||
assert isinstance(components["float_nodefault"], FloatDecimalFormItem)
|
||||
assert isinstance(components["decimal_dp_limits_nodefault"], FloatDecimalFormItem)
|
||||
assert isinstance(components["dict_default"], DictFormItem)
|
||||
assert isinstance(components["unsupported_class"], StrFormItem)
|
||||
|
||||
|
||||
def test_grid_to_dict(metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]]):
|
||||
widget, components = metadata_widget = metadata_widget
|
||||
fill_components(components)
|
||||
|
||||
assert widget._dict_from_grid() == TEST_DICT
|
||||
assert widget.get_form_data() == TEST_DICT | {"extra_field": "extra_data"}
|
||||
|
||||
|
||||
def test_validation(metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]]):
|
||||
widget, components = metadata_widget = metadata_widget
|
||||
assert widget._validity_state is None
|
||||
assert widget._validity_message.text() == "Not yet validated"
|
||||
|
||||
fill_components(components)
|
||||
widget.validate_form()
|
||||
assert widget._validity_state is True
|
||||
assert widget._validity_message.text() == "No errors!"
|
||||
|
||||
components["bool_required_nodefault"]._main_widget.clear()
|
||||
widget.validate_form()
|
||||
assert widget._validity_state is False
|
||||
assert widget._validity_message.text() == "Invalid field: bool_required_nodefault"
|
||||
assert (
|
||||
widget._validity_message.toolTip() == "bool_required_nodefault: Required - please fill in"
|
||||
def test_required_fields_are_marked(metadata_widget: ScanMetadata):
|
||||
form = metadata_widget.form
|
||||
assert form.layout().labelForField(form.field_widget("str_required")).text() == (
|
||||
"Str required *"
|
||||
)
|
||||
components["bool_required_nodefault"].setValue(True)
|
||||
|
||||
components["float_nodefault"]._main_widget.clear()
|
||||
widget.validate_form()
|
||||
assert widget._validity_message.text() == "Invalid field: float_nodefault"
|
||||
assert widget._validity_message.toolTip() == "float_nodefault: Required - please fill in"
|
||||
components["float_nodefault"].setValue(True)
|
||||
assert form.layout().labelForField(form.field_widget("comment")).text() == "Comment"
|
||||
|
||||
|
||||
def test_validation_summary_stays_short(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
widget, components = metadata_widget
|
||||
fill_components(components)
|
||||
components["bool_required_nodefault"]._main_widget.clear()
|
||||
components["float_nodefault"]._main_widget.clear()
|
||||
widget.validate_form()
|
||||
summary = widget._validity_summary
|
||||
assert summary == "2 invalid fields: bool_required_nodefault, float_nodefault"
|
||||
def test_form_data_includes_extras_and_scan_name(metadata_widget: ScanMetadata, qtbot):
|
||||
metadata_widget.set_field_values(TEST_VALUES)
|
||||
received = []
|
||||
metadata_widget.form_data_updated.connect(received.append)
|
||||
|
||||
assert metadata_widget.validate_form()
|
||||
# the emitted metadata is validated, so the Json field arrives parsed
|
||||
assert received[-1] == TEST_DICT | {
|
||||
"unsupported_class": ["set", "item"],
|
||||
"extra_field": "extra_data",
|
||||
}
|
||||
# Decimals are sent as floats, like the other numbers
|
||||
assert isinstance(received[-1]["decimal_dp_limits_nodefault"], float)
|
||||
assert metadata_widget.get_form_data()["extra_field"] == "extra_data"
|
||||
|
||||
|
||||
def test_validation_messages(metadata_widget: ScanMetadata):
|
||||
assert metadata_widget._validity_message.text() == "Not yet validated"
|
||||
metadata_widget.set_field_values(TEST_VALUES | {"str_required": ""})
|
||||
cleared = []
|
||||
metadata_widget.form_data_cleared.connect(cleared.append)
|
||||
|
||||
assert not metadata_widget.validate_form()
|
||||
assert cleared == [None]
|
||||
assert metadata_widget.validation_messages() == ["Str required: Required - please fill in"]
|
||||
assert metadata_widget._validity_message.text() == "Invalid field: Str required"
|
||||
assert metadata_widget._validity_message.toolTip() == "Str required: Required - please fill in"
|
||||
assert metadata_widget.form.input_widget("str_required").property("state") == "error"
|
||||
|
||||
metadata_widget.set_field_values({"str_required": "something"})
|
||||
assert metadata_widget.validate_form()
|
||||
assert metadata_widget._validity_message.text() == "No errors!"
|
||||
assert metadata_widget._validity_message.toolTip() == ""
|
||||
assert metadata_widget.form.input_widget("str_required").property("state") == ""
|
||||
|
||||
|
||||
def test_validation_summary_stays_short(metadata_widget: ScanMetadata):
|
||||
metadata_widget.set_field_values(TEST_VALUES | {"str_required": ""})
|
||||
metadata_widget.set_extra_metadata({"comment": "clash"})
|
||||
assert not metadata_widget.validate_form()
|
||||
summary = metadata_widget._validity_message.text()
|
||||
assert summary == "2 invalid fields: Str required, Additional metadata"
|
||||
assert "\n" not in summary
|
||||
assert "errors.pydantic.dev" not in widget._validity_message.toolTip()
|
||||
assert "errors.pydantic.dev" not in metadata_widget._validity_message.toolTip()
|
||||
|
||||
|
||||
def test_validation_summary_uses_field_titles(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
widget, _ = metadata_widget
|
||||
with pytest.raises(ValidationError) as excinfo:
|
||||
ExampleSchema.model_validate(TEST_DICT | {"str_optional": "x" * 30})
|
||||
assert "Optional string" in widget._summarize_errors(excinfo.value)
|
||||
def test_validation_errors_under_each_field(metadata_widget: ScanMetadata):
|
||||
metadata_widget.update_with_new_scan("two_required")
|
||||
form = metadata_widget.form
|
||||
errors = {name: form.field_error_label(name) for name in form.widgets}
|
||||
shown = {name for name, label in errors.items() if label.isVisibleTo(metadata_widget)}
|
||||
assert shown == {"sample_id", "operator"}
|
||||
assert errors["operator"].text() == "Required - please fill in"
|
||||
assert "errors.pydantic.dev" not in errors["operator"].text()
|
||||
assert metadata_widget._validity_message.text() == "2 invalid fields: Sample ID, Operator"
|
||||
|
||||
form.input_widget("sample_id").setText("s1")
|
||||
shown = {name for name, label in errors.items() if label.isVisibleTo(metadata_widget)}
|
||||
assert shown == {"operator"}
|
||||
assert metadata_widget._validity_message.text() == "Invalid field: Operator"
|
||||
|
||||
form.input_widget("operator").setText("jan")
|
||||
assert not any(label.isVisibleTo(metadata_widget) for label in errors.values())
|
||||
assert metadata_widget._validity_message.text() == "No errors!"
|
||||
|
||||
|
||||
def test_validation_summary_groups_union_and_list_errors(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
class UnionListSchema(BasicScanMetadata):
|
||||
u: int | float = Field(title="Union")
|
||||
lst: list[int] = Field(default_factory=list, title="List")
|
||||
|
||||
widget, _ = metadata_widget
|
||||
with pytest.raises(ValidationError) as excinfo:
|
||||
UnionListSchema.model_validate({"u": "x", "lst": [1, "a", "b"]})
|
||||
widget._md_schema = UnionListSchema
|
||||
assert widget._summarize_errors(excinfo.value) == "2 invalid fields: Union, List"
|
||||
def test_validation_error_line_sits_under_its_field(metadata_widget: ScanMetadata):
|
||||
form = metadata_widget.form
|
||||
layout = form.layout()
|
||||
for name, widget in form.widgets.items():
|
||||
field_row, _ = layout.getWidgetPosition(widget)
|
||||
error_row, role = layout.getWidgetPosition(form.field_error_label(name))
|
||||
assert (error_row, role) == (field_row + 1, QFormLayout.ItemRole.FieldRole)
|
||||
|
||||
|
||||
def test_validation_issues_are_readable(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
class ReadableSchema(BasicScanMetadata):
|
||||
name: str = Field(max_length=3, title="Name")
|
||||
count: int = Field(title="Count")
|
||||
value: Decimal = Field(decimal_places=1, title="Value")
|
||||
|
||||
widget, _ = metadata_widget
|
||||
widget._md_schema = ReadableSchema
|
||||
with pytest.raises(ValidationError) as excinfo:
|
||||
ReadableSchema.model_validate({"name": "toolong", "count": None, "value": Decimal("1.25")})
|
||||
issues = widget._describe_errors(excinfo.value)
|
||||
assert [(i.field, i.title, i.entered) for i in issues] == [
|
||||
("name", "Name", "'toolong'"),
|
||||
("count", "Count", "empty"),
|
||||
("value", "Value", "1.25"),
|
||||
]
|
||||
assert issues[0].problem == "String should have at most 3 characters"
|
||||
assert issues[1].problem == "Required - please fill in"
|
||||
def test_validation_error_lines_follow_schema_change(metadata_widget: ScanMetadata):
|
||||
metadata_widget.update_with_new_scan("other_scan")
|
||||
form = metadata_widget.form
|
||||
assert {name for name in form.widgets if form.field_error_label(name)} == {
|
||||
"scan_name",
|
||||
"comment",
|
||||
"sample_name",
|
||||
}
|
||||
metadata_widget.update_with_new_scan("two_required")
|
||||
assert form.field_error_label("operator").isVisibleTo(metadata_widget)
|
||||
assert form.field_error_label("str_required") is None
|
||||
|
||||
|
||||
def test_validation_issues_keep_nested_locations(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
class Detector(BaseModel):
|
||||
prefix: str
|
||||
gain: int
|
||||
|
||||
def test_validation_messages_list_every_failing_entry(metadata_widget: ScanMetadata):
|
||||
class NestedSchema(BasicScanMetadata):
|
||||
positions: list[int] = Field(default_factory=list, title="Positions")
|
||||
offsets: dict[str, int] = Field(default_factory=dict, title="Offsets")
|
||||
detector: Detector | None = Field(None, title="Detector")
|
||||
value: int | float = Field(0, title="Value")
|
||||
|
||||
widget, _ = metadata_widget
|
||||
widget._md_schema = NestedSchema
|
||||
metadata_widget.form.set_model(NestedSchema)
|
||||
with pytest.raises(ValidationError) as excinfo:
|
||||
NestedSchema.model_validate(
|
||||
{
|
||||
"positions": [1, "a", 3, "b"],
|
||||
"offsets": {"x": 1, "y": "bad"},
|
||||
"detector": {"gain": "hi"},
|
||||
"value": "x",
|
||||
}
|
||||
)
|
||||
issues = {issue.field: issue for issue in widget._describe_errors(excinfo.value)}
|
||||
positions = issues["positions"].problem.split("\n")
|
||||
assert [line.split(":")[0] for line in positions] == ["[1]", "[3]"]
|
||||
assert issues["offsets"].problem.startswith("y: Input should be a valid integer")
|
||||
assert issues["detector"].problem.split("\n") == [
|
||||
"prefix: Required - please fill in",
|
||||
"gain: Input should be a valid integer, unable to parse string as an integer",
|
||||
]
|
||||
NestedSchema.model_validate({"positions": [1, "a", 3, "b"], "value": "x"})
|
||||
problems = metadata_widget.form._describe_validation_error(excinfo.value)
|
||||
assert [line.split(":")[0] for line in problems["positions"].split("\n")] == ["[1]", "[3]"]
|
||||
# union members are tagged with their type name, which is not a location
|
||||
assert not any(
|
||||
line.startswith(("int:", "float:")) for line in issues["value"].problem.split("\n")
|
||||
)
|
||||
assert len(issues["value"].problem.split("\n")) == 2
|
||||
assert not any(line.startswith(("int:", "float:")) for line in problems["value"].split("\n"))
|
||||
assert len(problems["value"].split("\n")) == 2
|
||||
|
||||
|
||||
def test_validation_errors_under_each_field(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
widget, components = metadata_widget
|
||||
errors = widget._field_errors
|
||||
assert set(errors) == set(components)
|
||||
assert not any(label.isVisibleTo(widget) for label in errors.values())
|
||||
|
||||
fill_components(components)
|
||||
components["bool_required_nodefault"]._main_widget.clear()
|
||||
components["float_nodefault"]._main_widget.clear()
|
||||
widget.validate_form()
|
||||
shown = {name for name, label in errors.items() if label.isVisibleTo(widget)}
|
||||
assert shown == {"bool_required_nodefault", "float_nodefault"}
|
||||
assert errors["float_nodefault"].text() == "Required - please fill in"
|
||||
assert "errors.pydantic.dev" not in errors["float_nodefault"].text()
|
||||
|
||||
components["bool_required_nodefault"].setValue(True)
|
||||
widget.validate_form()
|
||||
shown = {name for name, label in errors.items() if label.isVisibleTo(widget)}
|
||||
assert shown == {"float_nodefault"}
|
||||
|
||||
components["float_nodefault"].setValue(1.5)
|
||||
widget.validate_form()
|
||||
assert not any(label.isVisibleTo(widget) for label in errors.values())
|
||||
def test_numbers_clipped_to_limits(metadata_widget: ScanMetadata):
|
||||
metadata_widget.set_field_values(TEST_VALUES | {"decimal_dp_limits_nodefault": -56})
|
||||
assert metadata_widget.get_form_data()["decimal_dp_limits_nodefault"] == pytest.approx(1.01)
|
||||
assert metadata_widget.validate_form()
|
||||
|
||||
|
||||
def test_validation_error_line_sits_under_its_field(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
widget, components = metadata_widget
|
||||
grid = widget._form_grid.layout()
|
||||
rows = list(widget.enumerate_form_widgets())
|
||||
assert len(rows) == len(components) # error lines are not form rows
|
||||
for row in rows:
|
||||
name = row.label.property("_model_field_name")
|
||||
index = grid.indexOf(widget._field_errors[name])
|
||||
assert grid.getItemPosition(index)[:2] == (row.i + 1, 1)
|
||||
def test_editing_a_field_revalidates(metadata_widget: ScanMetadata):
|
||||
metadata_widget.set_field_values(TEST_VALUES)
|
||||
received = []
|
||||
metadata_widget.validity_proc.connect(received.append)
|
||||
metadata_widget.form.input_widget("str_required").setText("x")
|
||||
assert received[-1] is True
|
||||
metadata_widget.form.input_widget("str_required").setText("")
|
||||
assert received[-1] is False
|
||||
|
||||
|
||||
def test_validation_error_lines_follow_schema_change(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
class OtherSchema(BasicScanMetadata):
|
||||
count: int = Field(title="Count")
|
||||
@pytest.mark.parametrize(
|
||||
"key, message",
|
||||
[
|
||||
("sample_name", "'sample_name' is already a field of this form."),
|
||||
("extra_field", "Key 'extra_field' is used more than once."),
|
||||
("", "Enter a key for the value."),
|
||||
],
|
||||
)
|
||||
def test_invalid_additional_metadata_keys(metadata_widget: ScanMetadata, key, message):
|
||||
metadata_widget.set_field_values(TEST_VALUES)
|
||||
editor = metadata_widget.form.extra_fields_section.editor
|
||||
row = editor.add_entry(key, "value")
|
||||
|
||||
widget, _ = metadata_widget
|
||||
widget.set_schema(OtherSchema)
|
||||
assert set(widget._field_errors) == {"scan_name", "comment", "sample_name", "count"}
|
||||
widget.validate_form()
|
||||
assert widget._field_errors["count"].isVisibleTo(widget)
|
||||
assert widget._validity_message.text() == "Invalid field: Count"
|
||||
assert not metadata_widget.validate_form()
|
||||
assert metadata_widget.validation_messages() == [f"Additional metadata: {message}"]
|
||||
assert row.key_edit.property("state") == "error"
|
||||
|
||||
row.key_edit.setText("unique_key")
|
||||
assert metadata_widget.validate_form()
|
||||
assert row.key_edit.property("state") == ""
|
||||
assert metadata_widget.get_form_data()["unique_key"] == "value"
|
||||
|
||||
|
||||
def test_numbers_clipped_to_limits(
|
||||
metadata_widget: tuple[ScanMetadata, dict[str, DynamicFormItem]],
|
||||
):
|
||||
widget, components = metadata_widget = metadata_widget
|
||||
fill_components(components)
|
||||
def test_blank_additional_metadata_rows_are_ignored(metadata_widget: ScanMetadata):
|
||||
metadata_widget.set_field_values(TEST_VALUES)
|
||||
metadata_widget.form.extra_fields_section.editor.add_button.click()
|
||||
|
||||
components["decimal_dp_limits_nodefault"].setValue(-56)
|
||||
assert components["decimal_dp_limits_nodefault"].getValue() == pytest.approx(1.01)
|
||||
widget.validate_form()
|
||||
assert widget._validity_message.text() == "No errors!"
|
||||
assert metadata_widget.validate_form()
|
||||
assert "" not in metadata_widget.get_form_data()
|
||||
|
||||
|
||||
def test_switching_scans_keeps_shared_values_and_extras(metadata_widget: ScanMetadata):
|
||||
metadata_widget.set_field_values(TEST_VALUES | {"comment": "keep me"})
|
||||
metadata_widget.update_with_new_scan("other_scan")
|
||||
|
||||
assert metadata_widget._md_schema is BasicScanMetadata
|
||||
assert set(metadata_widget.form.widgets) == {"scan_name", "comment", "sample_name"}
|
||||
assert metadata_widget.form.input_widget("scan_name").placeholderText() == "other_scan"
|
||||
assert metadata_widget.get_form_data() == {
|
||||
"scan_name": "other_scan",
|
||||
"comment": "keep me",
|
||||
"sample_name": "test name",
|
||||
"extra_field": "extra_data",
|
||||
}
|
||||
|
||||
|
||||
def test_typed_scan_name_is_kept(metadata_widget: ScanMetadata):
|
||||
metadata_widget.set_field_values({"scan_name": "my alignment"})
|
||||
assert metadata_widget.get_form_data()["scan_name"] == "my alignment"
|
||||
|
||||
|
||||
def test_hide_optional_metadata(metadata_widget: ScanMetadata):
|
||||
section = metadata_widget.form.extra_fields_section
|
||||
assert section.isVisibleTo(metadata_widget)
|
||||
metadata_widget.hide_optional_metadata = True
|
||||
assert metadata_widget.hide_optional_metadata
|
||||
assert not section.isVisibleTo(metadata_widget)
|
||||
|
||||
|
||||
def test_scan_metadata_form_drops_deleted_extra_row(qtbot):
|
||||
widget = create_widget(qtbot, ScanMetadata, initial_extras=[["k1", "v1"], ["k2", "v2"]])
|
||||
received: list[dict] = []
|
||||
widget.form_data_updated.connect(received.append)
|
||||
editor = widget.form.extra_fields_section.editor
|
||||
|
||||
editor.rows()[0].remove_button.click()
|
||||
|
||||
assert editor.value() == {"k2": "v2"}
|
||||
assert received, "deleting a row must re-validate the form"
|
||||
assert "k1" not in received[-1]
|
||||
assert received[-1]["k2"] == "v2"
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
|
||||
Reference in new issue
Block a user