Files
bec_widgets/tests/unit_tests/test_widget_io.py

434 lines
15 KiB
Python

# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
from unittest import mock
import pytest
from qtpy.QtCore import Qt
from qtpy.QtWidgets import (
QComboBox,
QLabel,
QLineEdit,
QPushButton,
QSpinBox,
QTableWidget,
QTableWidgetItem,
QVBoxLayout,
QWidget,
)
from bec_widgets.tests.client_mocks import mocked_client
from bec_widgets.utils.widget_io import WidgetHierarchy, WidgetIO, WidgetTreeNode
from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
from bec_widgets.widgets.utility.toggle.toggle import ToggleSwitch
@pytest.fixture(scope="function")
def example_widget(qtbot):
# Create a widget with a few child widgets
main_widget = QWidget()
layout = QVBoxLayout(main_widget)
line_edit = QLineEdit(main_widget)
combo_box = QComboBox(main_widget)
table_widget = QTableWidget(2, 2, main_widget)
spin_box = QSpinBox(main_widget)
toggle = ToggleSwitch(main_widget)
layout.addWidget(line_edit)
layout.addWidget(combo_box)
layout.addWidget(table_widget)
layout.addWidget(spin_box)
layout.addWidget(toggle)
# Add text items to the combo box
combo_box.addItems(["Option 1", "Option 2", "Option 3"])
# Populate the table widget
table_widget.setItem(0, 0, QTableWidgetItem("Initial A"))
table_widget.setItem(0, 1, QTableWidgetItem("Initial B"))
table_widget.setItem(1, 0, QTableWidgetItem("Initial C"))
table_widget.setItem(1, 1, QTableWidgetItem("Initial D"))
qtbot.addWidget(main_widget)
qtbot.waitExposed(main_widget)
yield main_widget
def test_export_import_config(example_widget):
initial_config = {
"QWidget ()": {
"QLineEdit ()": {"value": "New Text"},
"QComboBox ()": {"value": 1},
"QTableWidget ()": {"value": [["a", "b"], ["c", "d"]]},
"QSpinBox ()": {"value": 10},
}
}
WidgetHierarchy.import_config_from_dict(example_widget, initial_config, set_values=True)
exported_config_full = WidgetHierarchy.export_config_to_dict(example_widget, grab_values=True)
exported_config_reduced = WidgetHierarchy.export_config_to_dict(
example_widget, grab_values=True, save_all=False
)
expected_full = {
"QWidget ()": {
"QComboBox ()": {"QStandardItemModel ()": {}, "value": 1},
"QLineEdit ()": {"QObject ()": {}, "value": "New Text"},
"QSpinBox ()": {
"QLineEdit (qt_spinbox_lineedit)": {"QObject ()": {}, "value": "10"},
"QValidator (qt_spinboxvalidator)": {},
"value": 10,
},
"QTableWidget ()": {
"QAbstractButton (qt_tableview_cornerbutton)": {},
"QAbstractTableModel ()": {},
"QHeaderView ()": {
"QItemSelectionModel ()": {},
"QWidget (qt_scrollarea_hcontainer)": {
"QBoxLayout ()": {},
"QScrollBar ()": {},
},
"QWidget (qt_scrollarea_vcontainer)": {
"QBoxLayout ()": {},
"QScrollBar ()": {},
},
"QWidget (qt_scrollarea_viewport)": {},
},
"QItemSelectionModel ()": {},
"QStyledItemDelegate ()": {},
"QWidget (qt_scrollarea_hcontainer)": {"QBoxLayout ()": {}, "QScrollBar ()": {}},
"QWidget (qt_scrollarea_vcontainer)": {"QBoxLayout ()": {}, "QScrollBar ()": {}},
"QWidget (qt_scrollarea_viewport)": {},
"value": [["a", "b"], ["c", "d"]],
},
"QVBoxLayout ()": {},
"ToggleSwitch ()": {"value": True},
}
}
expected_reduced = {
"QWidget ()": {
"QComboBox ()": {"value": 1},
"QLineEdit ()": {"value": "New Text"},
"QSpinBox ()": {"QLineEdit (qt_spinbox_lineedit)": {"value": "10"}, "value": 10},
"QTableWidget ()": {"value": [["a", "b"], ["c", "d"]]},
"ToggleSwitch ()": {"value": True},
}
}
assert exported_config_full == expected_full
assert exported_config_reduced == expected_reduced
def test_widget_io_get_set_value(example_widget):
# Extract widgets
line_edit = example_widget.findChild(QLineEdit)
combo_box = example_widget.findChild(QComboBox)
table_widget = example_widget.findChild(QTableWidget)
spin_box = example_widget.findChild(QSpinBox)
toggle = example_widget.findChild(ToggleSwitch)
# Check initial values
assert WidgetIO.get_value(line_edit) == ""
assert WidgetIO.get_value(combo_box) == 0 # first index
assert WidgetIO.get_value(table_widget) == [
["Initial A", "Initial B"],
["Initial C", "Initial D"],
]
assert WidgetIO.get_value(spin_box) == 0
assert WidgetIO.get_value(toggle) == True
# Set new values
WidgetIO.set_value(line_edit, "Hello")
WidgetIO.set_value(combo_box, "Option 2")
WidgetIO.set_value(table_widget, [["X", "Y"], ["Z", "W"]])
WidgetIO.set_value(spin_box, 5)
WidgetIO.set_value(toggle, False)
# Check updated values
assert WidgetIO.get_value(line_edit) == "Hello"
assert WidgetIO.get_value(combo_box, as_string=True) == "Option 2"
assert WidgetIO.get_value(table_widget) == [["X", "Y"], ["Z", "W"]]
assert WidgetIO.get_value(spin_box) == 5
assert WidgetIO.get_value(toggle) == False
def test_widget_io_signal(qtbot, example_widget):
# Extract widgets
line_edit = example_widget.findChild(QLineEdit)
combo_box = example_widget.findChild(QComboBox)
spin_box = example_widget.findChild(QSpinBox)
table_widget = example_widget.findChild(QTableWidget)
toggle = example_widget.findChild(ToggleSwitch)
# We'll store changes in a list to verify the slot is called
changes = []
def universal_slot(w, val):
changes.append((w, val))
# Connect signals
WidgetIO.connect_widget_change_signal(line_edit, universal_slot)
WidgetIO.connect_widget_change_signal(combo_box, universal_slot)
WidgetIO.connect_widget_change_signal(spin_box, universal_slot)
WidgetIO.connect_widget_change_signal(table_widget, universal_slot)
WidgetIO.connect_widget_change_signal(toggle, universal_slot)
# Trigger changes
line_edit.setText("NewText")
qtbot.waitUntil(lambda: len(changes) > 0)
assert changes[-1][1] == "NewText"
combo_box.setCurrentIndex(2)
qtbot.waitUntil(lambda: len(changes) > 1)
# combo_box change should give the current index or value
# We set "Option 3" is index 2
assert changes[-1][1] == 2 or changes[-1][1] == "Option 3"
spin_box.setValue(42)
qtbot.waitUntil(lambda: len(changes) > 2)
assert changes[-1][1] == 42
# For the table widget, changing a cell triggers cellChanged
table_widget.setItem(0, 0, QTableWidgetItem("ChangedCell"))
qtbot.waitUntil(lambda: len(changes) > 3)
# The entire table value should be retrieved
assert changes[-1][1][0][0] == "ChangedCell"
# Test the toggle switch
toggle.checked = False
qtbot.waitUntil(lambda: len(changes) > 4)
assert changes[-1][1] == False
def test_widget_io_device_combobox_handler(qtbot, mocked_client):
widget = DeviceComboBox(client=mocked_client)
qtbot.addWidget(widget)
changes = []
WidgetIO.connect_widget_change_signal(widget, lambda _widget, value: changes.append(value))
WidgetIO.set_value(widget, "samx")
assert WidgetIO.get_value(widget) == "samx"
assert changes[-1] == "samx"
def test_widget_io_device_combobox_handler_accepts_subclasses(qtbot, mocked_client):
class PromotedDeviceComboBox(DeviceComboBox):
pass
widget = PromotedDeviceComboBox(client=mocked_client)
qtbot.addWidget(widget)
WidgetIO.set_value(widget, "samx")
assert WidgetIO.get_value(widget) == "samx"
def test_widget_io_signal_combobox_handler(qtbot, mocked_client):
widget = SignalComboBox(client=mocked_client, require_device=True)
qtbot.addWidget(widget)
changes = []
widget.set_device("samx")
WidgetIO.connect_widget_change_signal(widget, lambda _widget, value: changes.append(value))
WidgetIO.set_value(widget, "samx")
assert WidgetIO.get_value(widget) == "samx"
widget.setCurrentText("")
widget.setCurrentText("samx")
assert changes[-1] == "samx"
def test_widget_io_signal_combobox_handler_accepts_subclasses(qtbot, mocked_client):
class PromotedSignalComboBox(SignalComboBox):
pass
widget = PromotedSignalComboBox(client=mocked_client, require_device=True)
qtbot.addWidget(widget)
widget.set_device("samx")
WidgetIO.set_value(widget, "samx")
assert WidgetIO.get_value(widget) == "samx"
def test_find_widgets(example_widget):
# Test find_widgets by class type
line_edits = WidgetIO.find_widgets(QLineEdit)
assert len(line_edits) == 2 # one LineEdit and one in the SpinBox
assert isinstance(line_edits[0], QLineEdit)
# Test find_widgets by class-name string
combo_boxes = WidgetIO.find_widgets("QComboBox")
assert len(combo_boxes) == 1
assert isinstance(combo_boxes[0], QComboBox)
# Test non-recursive search returns the same widgets
combo_boxes_flat = WidgetIO.find_widgets(QComboBox, recursive=False)
assert combo_boxes_flat == combo_boxes
# Test search for non-existent widget returns empty list
non_exist = WidgetIO.find_widgets("NonExistentWidget")
assert non_exist == []
# ── WidgetHierarchy._build_prefix ─────────────────────────────────────────────
def test_build_prefix_empty():
assert WidgetHierarchy._build_prefix([]) == ""
def test_build_prefix_single_last():
assert WidgetHierarchy._build_prefix([True]) == "└─ "
def test_build_prefix_single_not_last():
assert WidgetHierarchy._build_prefix([False]) == "├─ "
def test_build_prefix_nested_last_last():
# parent is last (True), child is last (True): " └─ "
assert WidgetHierarchy._build_prefix([True, True]) == " └─ "
def test_build_prefix_nested_not_last_last():
# parent is not last (False), child is last (True): "│ └─ "
assert WidgetHierarchy._build_prefix([False, True]) == "│ └─ "
def test_build_prefix_nested_not_last_not_last():
# parent is not last (False), child is not last (False): "│ ├─ "
assert WidgetHierarchy._build_prefix([False, False]) == "│ ├─ "
def test_build_prefix_deep_tree():
# Three levels: not-last → not-last → last
assert WidgetHierarchy._build_prefix([False, False, True]) == "│ │ └─ "
# ── WidgetHierarchy._filtered_children ────────────────────────────────────────
def test_filtered_children_plain_widget(qtbot):
parent = QWidget()
qtbot.addWidget(parent)
child1 = QLabel(parent)
child2 = QPushButton(parent)
result = WidgetHierarchy._filtered_children(parent, exclude_internal_widgets=True)
assert child1 in result
assert child2 in result
def test_filtered_children_combobox_excludes_internal(qtbot):
combo = QComboBox()
qtbot.addWidget(combo)
combo.addItems(["a", "b"])
result_excluded = WidgetHierarchy._filtered_children(combo, exclude_internal_widgets=True)
result_included = WidgetHierarchy._filtered_children(combo, exclude_internal_widgets=False)
internal_names = {c.__class__.__name__ for c in result_included}
excluded_names = {c.__class__.__name__ for c in result_excluded}
# At least one internal widget type is present when not excluded
assert internal_names & {"QFrame", "QListView"}
# The same internal types should be absent when excluded
assert not (excluded_names & {"QFrame", "QListView"})
def test_filtered_children_skips_invalid_child(qtbot):
parent = QWidget()
qtbot.addWidget(parent)
child = QLabel(parent)
with mock.patch("shiboken6.isValid", side_effect=lambda w: w is not child):
result = WidgetHierarchy._filtered_children(parent, exclude_internal_widgets=False)
assert child not in result
# ── WidgetHierarchy.iter_widget_tree ──────────────────────────────────────────
def test_iter_widget_tree_basic(qtbot):
root = QWidget()
qtbot.addWidget(root)
child = QLabel(root)
nodes = list(WidgetHierarchy.iter_widget_tree(root))
widgets = [n.widget for n in nodes]
assert root in widgets
assert child in widgets
def test_iter_widget_tree_root_node_attrs(qtbot):
root = QWidget()
qtbot.addWidget(root)
nodes = list(WidgetHierarchy.iter_widget_tree(root))
root_node = nodes[0]
assert root_node.widget is root
assert root_node.parent is None
assert root_node.depth == 0
assert root_node.prefix == ""
def test_iter_widget_tree_child_node_attrs(qtbot):
root = QWidget()
qtbot.addWidget(root)
child = QLabel(root)
nodes = list(WidgetHierarchy.iter_widget_tree(root))
child_node = next(n for n in nodes if n.widget is child)
assert child_node.parent is root
assert child_node.depth == 1
assert child_node.prefix in ("├─ ", "└─ ")
def test_iter_widget_tree_none_widget():
nodes = list(WidgetHierarchy.iter_widget_tree(None))
assert nodes == []
def test_iter_widget_tree_invalid_widget(qtbot):
root = QWidget()
qtbot.addWidget(root)
with mock.patch("shiboken6.isValid", return_value=False):
nodes = list(WidgetHierarchy.iter_widget_tree(root))
assert nodes == []
def test_iter_widget_tree_prevents_revisiting(qtbot):
"""Visited-set prevents infinite loops when the same widget is returned
more than once by _filtered_children (simulates a circular-reference
scenario that cannot arise naturally in Qt but is handled defensively)."""
root = QWidget()
qtbot.addWidget(root)
child = QLabel(root)
call_count = 0
original = WidgetHierarchy._filtered_children
def patched(widget, exclude):
nonlocal call_count
result = original(widget, exclude)
# After the first call (for root), inject root itself as a child of child
if widget is child:
call_count += 1
result = [root] + result # root already visited – should be skipped
return result
with mock.patch.object(WidgetHierarchy, "_filtered_children", staticmethod(patched)):
nodes = list(WidgetHierarchy.iter_widget_tree(root))
widget_ids = [id(n.widget) for n in nodes]
# root must appear exactly once despite being injected as a child of child
assert widget_ids.count(id(root)) == 1
assert call_count >= 1
def test_iter_widget_tree_depth_and_prefix_for_multiple_children(qtbot):
root = QWidget()
qtbot.addWidget(root)
first = QLabel(root)
second = QPushButton(root)
nodes = list(WidgetHierarchy.iter_widget_tree(root))
child_nodes = [n for n in nodes if n.depth == 1]
prefixes = {n.prefix for n in child_nodes}
# Non-last child gets "├─ " and last child gets "└─ "
assert "├─ " in prefixes
assert "└─ " in prefixes