class TestWidget(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
self.data = np.arange(30.0).reshape(5, 6)
self.model = ArrayDataModel(data=self.data, value_type=FloatValue())
return DataViewWidget(parent=self.parent.control,
data_model=self.model)
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.widget.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
def test_defaults(self):
self.assertTrue(self.widget.header_visible)
def test_lifecycle(self):
self._create_widget_control()
def test_header_visible(self):
self._create_widget_control()
self.widget.header_visible = False
self.gui.process_events()
self.assertFalse(self.widget._get_control_header_visible())
def test_header_visible_before_control(self):
self.widget.header_visible = False
self._create_widget_control()
self.assertFalse(self.widget._get_control_header_visible())
def test_create_parent(self):
# test that creation and destruction works as expected with a parent
parent = Window()
self.dialog.parent = parent.control
with self.event_loop():
parent._create()
self.dialog._create()
with self.event_loop():
self.dialog.destroy()
with self.event_loop():
parent.destroy()
class FieldMixin(UnittestTools):
""" Mixin which provides standard methods for all fields. """
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
raise NotImplementedError()
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.widget.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
# Tests ------------------------------------------------------------------
def test_field_tooltip(self):
self._create_widget_control()
self.widget.tooltip = "New tooltip."
self.gui.process_events()
self.assertEqual(self.widget._get_control_tooltip(), "New tooltip.")
def test_field_menu(self):
self._create_widget_control()
self.widget.menu = MenuManager(Action(name='Test'), name='Test')
self.gui.process_events()
class FieldMixin(UnittestTools):
""" Mixin which provides standard methods for all fields. """
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
raise NotImplementedError()
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.widget.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
# Tests ------------------------------------------------------------------
def test_field_tooltip(self):
self._create_widget_control()
self.widget.tooltip = "New tooltip."
self.gui.process_events()
self.assertEqual(self.widget._get_control_tooltip(), "New tooltip.")
def test_field_menu(self):
self._create_widget_control()
self.widget.menu = MenuManager(Action(name="Test"), name="Test")
self.gui.process_events()
class TestTraitsUIWidgetAction(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.parent.open()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def create_model(self):
from traitsui.api import View, Item
class SimpleEnum(HasTraits):
value = Enum('a', 'b', 'c')
view = View(Item('value'))
return SimpleEnum()
def test_traitsui_widget_action(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
value = Enum('a', 'b', 'c')
view = View(Item('value'))
action = SimpleEnumAction(name="Simple")
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors('value')[0]
with self.assertTraitChanges(action, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == 'wx':
import wx
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('b')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, 'b')
def test_traitsui_widget_action_model(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
view = View(Item('value'))
model = self.create_model()
action = SimpleEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors('value')[0]
with self.assertTraitChanges(model, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == 'wx':
import wx
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('b')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, 'b')
def test_traitsui_widget_action_model_view(self):
from traitsui.api import HGroup, View, Item
class ComplexEnumAction(TraitsUIWidgetAction):
value = Enum('a', 'b', 'c')
view = View(
HGroup(
Item('value'),
Item('action.value'),
)
)
model = self.create_model()
action = ComplexEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors('value')[0]
with self.assertTraitChanges(model, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == 'wx':
import wx
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('b')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, 'b')
editor = control._ui.get_editors('value')[1]
with self.assertTraitChanges(action, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(2)
editor.control.activated.emit(2)
elif toolkit.toolkit == 'wx':
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('c')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, 'c')
class TestFieldAction(unittest.TestCase):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
def _destroy_parent(self):
self.parent.destroy()
self.parent = None
def test_combo_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=ComboField,
field_defaults={
'values': ['a', 'b', 'c'],
'value': 'a',
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 'b'
self.gui.process_events()
self.assertEqual(memo, ['b'])
finally:
control._field.destroy()
def test_text_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=TextField,
field_defaults={
'value': 'a',
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 'b'
self.gui.process_events()
self.assertEqual(memo, ['b'])
finally:
control._field.destroy()
def test_spin_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=SpinField,
field_defaults={
'value': 1,
'bounds': (0, 100),
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 5
self.gui.process_events()
self.assertEqual(memo, [5])
finally:
control._field.destroy()
class TestFieldAction(unittest.TestCase):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
def _destroy_parent(self):
self.parent.destroy()
self.parent = None
def test_combo_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=ComboField,
field_defaults={
'values': ['a', 'b', 'c'],
'value': 'a',
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 'b'
self.gui.process_events()
self.assertEqual(memo, ['b'])
finally:
control._field.destroy()
def test_text_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=TextField,
field_defaults={
'value': 'a',
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 'b'
self.gui.process_events()
self.assertEqual(memo, ['b'])
finally:
control._field.destroy()
def test_spin_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=SpinField,
field_defaults={
'value': 1,
'bounds': (0, 100),
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 5
self.gui.process_events()
self.assertEqual(memo, [5])
finally:
control._field.destroy()
class TestTraitsUIWidgetAction(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.parent.open()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def create_model(self):
from traitsui.api import View, Item
class SimpleEnum(HasTraits):
value = Enum("a", "b", "c")
view = View(Item("value"))
return SimpleEnum()
def test_traitsui_widget_action(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
value = Enum("a", "b", "c")
view = View(Item("value"))
action = SimpleEnumAction(name="Simple")
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors("value")[0]
with self.assertTraitChanges(action, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == "wx":
import wx
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("b")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, "b")
def test_traitsui_widget_action_model(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
view = View(Item("value"))
model = self.create_model()
action = SimpleEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors("value")[0]
with self.assertTraitChanges(model, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == "wx":
import wx
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("b")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, "b")
def test_traitsui_widget_action_model_view(self):
from traitsui.api import HGroup, View, Item
class ComplexEnumAction(TraitsUIWidgetAction):
value = Enum("a", "b", "c")
view = View(HGroup(Item("value"), Item("action.value")))
model = self.create_model()
action = ComplexEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors("value")[0]
with self.assertTraitChanges(model, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == "wx":
import wx
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("b")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, "b")
editor = control._ui.get_editors("value")[1]
with self.assertTraitChanges(action, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(2)
editor.control.activated.emit(2)
elif toolkit.toolkit == "wx":
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("c")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, "c")
class TestMainWindowLayout(unittest.TestCase, GuiTestAssistant):
""" Test Qt specific MainWindowLayout.
Note that MainWindowLayout does not have a toolkit-agnostic interface
in the ``pyface.tasks`` package. Therefore this test is Qt-only.
"""
def setUp(self):
GuiTestAssistant.setUp(self)
self.window = Window(size=(500, 500))
self.window._create()
def tearDown(self):
if self.window.control is not None:
with self.delete_widget(self.window.control):
self.window.destroy()
del self.window
GuiTestAssistant.tearDown(self)
def setup_window_with_central_widget(self):
# Add a central widget to the main window.
# The main window takes ownership of the child widget.
central_widget = QtGui.QWidget(parent=self.window.control)
self.window.control.setCentralWidget(central_widget)
def test_set_pane_item_width_in_main_window_layout(self):
# Test the dock pane width is as expected.
self.setup_window_with_central_widget()
# Set the dock widget expected width to be smaller than the window
# for a meaningful test.
expected_width = self.window.size[0] // 2
window_layout = MainWindowLayout(control=self.window.control)
dock_layout = TaskLayout(left=PaneItem(width=expected_width))
dock_widget = create_dummy_dock_widget(parent=self.window.control)
patch_get_dock_widget = mock.patch.object(
MainWindowLayout,
"_get_dock_widget",
return_value=dock_widget,
)
# when
with self.event_loop():
with patch_get_dock_widget:
window_layout.set_layout(dock_layout)
# then
size = dock_widget.widget().size()
self.assertEqual(size.width(), expected_width)
def test_set_pane_item_height_in_main_window_layout(self):
# Test the dock pane height is as expected.
self.setup_window_with_central_widget()
# Set the dock widget expected height to be smaller than the window
# for a meaningful test.
expected_height = self.window.size[1] // 2
window_layout = MainWindowLayout(control=self.window.control)
dock_layout = TaskLayout(bottom=PaneItem(height=expected_height))
dock_widget = create_dummy_dock_widget(parent=self.window.control)
patch_get_dock_widget = mock.patch.object(
MainWindowLayout,
"_get_dock_widget",
return_value=dock_widget,
)
# when
with self.event_loop():
with patch_get_dock_widget:
window_layout.set_layout(dock_layout)
# then
size = dock_widget.widget().size()
self.assertEqual(size.height(), expected_height)
class TestWindow(unittest.TestCase, GuiTestAssistant):
def setUp(self):
GuiTestAssistant.setUp(self)
self.window = Window()
def tearDown(self):
if self.window.control is not None:
with self.delete_widget(self.window.control):
self.window.destroy()
self.window = None
GuiTestAssistant.tearDown(self)
def test_destroy(self):
# test that destroy works even when no control
with self.event_loop():
self.window.destroy()
def test_open_close(self):
# test that opening and closing works as expected
with self.assertTraitChanges(self.window, "opening", count=1):
with self.assertTraitChanges(self.window, "opened", count=1):
with self.event_loop():
self.window.open()
with self.assertTraitChanges(self.window, "closing", count=1):
with self.assertTraitChanges(self.window, "closed", count=1):
with self.event_loop():
self.window.close()
def test_show(self):
# test that showing works as expected
with self.event_loop():
self.window._create()
with self.event_loop():
self.window.show(True)
with self.event_loop():
self.window.show(False)
with self.event_loop():
self.window.destroy()
def test_activate(self):
# test that activation works as expected
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.activate()
with self.event_loop():
self.window.close()
def test_position(self):
# test that default position works as expected
self.window.position = (100, 100)
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.close()
def test_reposition(self):
# test that changing position works as expected
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.position = (100, 100)
with self.event_loop():
self.window.close()
def test_size(self):
# test that default size works as expected
self.window.size = (100, 100)
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.close()
def test_resize(self):
# test that changing size works as expected
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.size = (100, 100)
with self.event_loop():
self.window.close()
def test_title(self):
# test that default title works as expected
self.window.title = "Test Title"
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.close()
def test_retitle(self):
# test that changing title works as expected
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.title = "Test Title"
with self.event_loop():
self.window.close()
def test_show_event(self):
with self.event_loop():
self.window.open()
with self.event_loop():
self.window.visible = False
with self.assertTraitChanges(self.window, "visible", count=1):
with self.event_loop():
self.window.control.show()
self.assertTrue(self.window.visible)
def test_hide_event(self):
with self.event_loop():
self.window.open()
with self.assertTraitChanges(self.window, "visible", count=1):
with self.event_loop():
self.window.control.hide()
self.assertFalse(self.window.visible)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Confirmation dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Confirmation dialog click tests don't work reliably on linux. Issue #282.",
)
def test_confirm_reject(self):
# test that cancel works as expected
tester = ModalDialogTester(
lambda: self.window.confirm("message", cancel=True))
tester.open_and_run(when_opened=lambda x: x.close(accept=False))
self.assertEqual(tester.result, CANCEL)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Confirmation dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Confirmation dialog click tests don't work reliably on linux. Issue #282.",
)
def test_confirm_yes(self):
# test that yes works as expected
tester = ModalDialogTester(lambda: self.window.confirm("message"))
tester.open_and_wait(when_opened=lambda x: x.click_button(YES))
self.assertEqual(tester.result, YES)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Confirmation dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Confirmation dialog click tests don't work reliably on linux. Issue #282.",
)
def test_confirm_no(self):
# test that no works as expected
tester = ModalDialogTester(lambda: self.window.confirm("message"))
tester.open_and_wait(when_opened=lambda x: x.click_button(NO))
self.assertEqual(tester.result, NO)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Confirmation dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Confirmation dialog click tests don't work reliably on linux. Issue #282.",
)
def test_confirm_cancel(self):
# test that cncel works as expected
tester = ModalDialogTester(
lambda: self.window.confirm("message", cancel=True))
tester.open_and_wait(when_opened=lambda x: x.click_button(CANCEL))
self.assertEqual(tester.result, CANCEL)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
def test_information_accept(self):
self._check_message_dialog_accept(self.window.information)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Message dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Message dialog click tests don't work reliably on linux. Issue #282.",
)
def test_information_ok(self):
self._check_message_dialog_ok(self.window.information)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
def test_warning_accept(self):
self._check_message_dialog_accept(self.window.warning)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Message dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Message dialog click tests don't work reliably on linux. Issue #282.",
)
def test_warning_ok(self):
self._check_message_dialog_ok(self.window.warning)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
def test_error_accept(self):
self._check_message_dialog_accept(self.window.error)
@unittest.skipIf(no_modal_dialog_tester, "ModalDialogTester unavailable")
@unittest.skipIf(is_pyqt5,
"Message dialog click tests don't work on pyqt5.")
@unittest.skipIf(
is_pyqt4_linux,
"Message dialog click tests don't work reliably on linux. Issue #282.",
)
def test_error_ok(self):
self._check_message_dialog_ok(self.window.error)
def _check_message_dialog_ok(self, method):
tester = self._setup_tester(method)
tester.open_and_wait(when_opened=lambda x: x.click_button(OK))
self.assertIsNone(tester.result)
def _check_message_dialog_accept(self, method):
tester = self._setup_tester(method)
tester.open_and_run(when_opened=lambda x: x.close(accept=True))
self.assertIsNone(tester.result)
def _setup_tester(self, method):
kwargs = {
"title": "Title",
"detail": "Detail",
"informative": "Informative",
}
tester = ModalDialogTester(lambda: method("message", **kwargs))
return tester
class TestWidget(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
self.data = np.arange(120.0).reshape(4, 5, 6)
self.model = ArrayDataModel(data=self.data, value_type=FloatValue())
return DataViewWidget(parent=self.parent.control,
data_model=self.model)
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.parent.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
def test_defaults(self):
self.assertTrue(self.widget.header_visible)
def test_lifecycle(self):
self._create_widget_control()
def test_header_visible(self):
self._create_widget_control()
self.assertTrue(self.widget._get_control_header_visible())
self.widget.header_visible = False
self.gui.process_events()
self.assertFalse(self.widget._get_control_header_visible())
def test_header_visible_before_control(self):
self.widget.header_visible = False
self._create_widget_control()
self.assertFalse(self.widget._get_control_header_visible())
def test_init_selection(self):
self.widget.selection = [((1, ), ())]
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection(), [((1, ), ())])
def test_selection_mode_change(self):
self._create_widget_control()
self.widget.selection = [((1, 4), ()), ((2, 0), ())]
self.widget.selection_mode = "single"
self.assertEqual(self.widget._get_control_selection_mode(), "single")
self.assertEqual(self.widget.selection, [])
self.widget.selection = [((1, 4), ())]
if "none" in selection_modes:
self.widget.selection_mode = "none"
self.assertEqual(self.widget._get_control_selection_mode(), "none")
self.assertEqual(self.widget.selection, [])
self.widget.selection_mode = "extended"
self.assertEqual(self.widget._get_control_selection_mode(), "extended")
self.assertEqual(self.widget.selection, [])
@unittest.skipIf(
len(selection_types) <= 1,
"Changing selection types not supported",
)
def test_selection_type_change(self):
self._create_widget_control()
if "column" in selection_types:
self.widget.selection_type = "column"
self.assertEqual(
self.widget._get_control_selection_type(),
"column",
)
self.assertEqual(self.widget.selection, [])
if "item" in selection_types:
self.widget.selection_type = "item"
self.assertEqual(self.widget._get_control_selection_type(), "item")
self.assertEqual(self.widget.selection, [])
if "row" in selection_types:
self.widget.selection_type = "row"
self.assertEqual(self.widget._get_control_selection_type(), "row")
self.assertEqual(self.widget.selection, [])
@unittest.skipIf(
"none" not in selection_modes,
"Selection mode 'none' not supported",
)
def test_selection_mode_none(self):
self.widget.selection_mode = "none"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_mode(), "none")
self.widget.selection = []
self.gui.process_events()
self.assertEqual(self.widget.selection, [])
self.assertEqual(self.widget._get_control_selection(), [])
@unittest.skipIf(
"none" not in selection_modes,
"Selection mode 'none' not supported",
)
def test_selection_mode_none_invalid(self):
self.widget.selection_mode = "none"
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4), ()), (2, 1), ()]
def test_selection_mode_single(self):
self.widget.selection_mode = "single"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_mode(), "single")
self.widget.selection = [((1, 4), ())]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), ())])
self.assertEqual(self.widget._get_control_selection(), [((1, 4), ())])
def test_selection_mode_single_invalid(self):
self.widget.selection_mode = "single"
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4), ()), (2, 1), ()]
@unittest.skipIf(
is_wx and is_linux,
"Selection mode 'extended' not working on Linux",
)
def test_selection_mode_extended(self):
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_mode(), "extended")
self.widget.selection = [((1, 4), ()), ((2, 0), ())]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), ()), ((2, 0), ())])
self.assertEqual(
self.widget._get_control_selection(),
[((1, 4), ()), ((2, 0), ())],
)
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column(self):
self.widget.selection_type = "column"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_type(), "column")
self.widget.selection = [((0, ), (2, )), ((1, ), (4, ))]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((0, ), (2, )),
((1, ), (4, ))])
self.assertEqual(self.widget._get_control_selection(),
[((0, ), (2, )), ((1, ), (4, ))])
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'item' not supported",
)
def test_selection_type_item(self):
self.widget.selection_type = "item"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_type(), "item")
self.widget.selection = [((1, 4), (2, )), ((2, 0), (4, ))]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), (2, )),
((2, 0), (4, ))])
self.assertEqual(
self.widget._get_control_selection(),
[((1, 4), (2, )), ((2, 0), (4, ))],
)
def test_selection_type_row_invalid_row_big(self):
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((10, ), ())]
def test_selection_type_row_invalid_row_long(self):
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 1, 1), ())]
def test_selection_type_row_invalid_column(self):
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 2), (2, ))]
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_item_invalid_row_too_big(self):
self.widget.selection_type = 'item'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 10), (2, ))]
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_item_invalid_row_too_long(self):
self.widget.selection_type = 'item'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4, 5, 6), (2, ))]
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_item_invalid_column(self):
self.widget.selection_type = 'item'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 2), (10, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_row_too_long(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4, 5, 6), (2, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_row_too_big(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((10, ), (2, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_row_not_parent(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 2), (2, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_column(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((), (10, ))]
def test_selection_updated(self):
self._create_widget_control()
with self.assertTraitChanges(self.widget, 'selection'):
self.widget._set_control_selection([((1, 4), ())])
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), ())])
self.assertEqual(
self.widget._get_control_selection(),
[((1, 4), ())],
)
def test_selection_updating_context_manager(self):
self.assertFalse(self.widget._selection_updating_flag)
with self.widget._selection_updating():
self.assertTrue(self.widget._selection_updating_flag)
with self.widget._selection_updating():
self.assertTrue(self.widget._selection_updating_flag)
self.assertTrue(self.widget._selection_updating_flag)
self.assertFalse(self.widget._selection_updating_flag)
def test_selection_updating_context_manager_exception(self):
with self.assertRaises(ZeroDivisionError):
with self.widget._selection_updating():
with self.widget._selection_updating():
1 / 0
self.assertFalse(self.widget._selection_updating_flag)
