def testSetItem(self):
self.model.initializeDataRows(COUNTER_OPTS_2, COUNTER_NAMES_2)
spy = QSignalSpy(self.model.dataChanged)
self.model.setItem(0, 2, True)
self.assertEqual(len(spy), 1)
self.model.setItem(1, 2, True)
self.assertEqual(len(spy), 2)
self.model.setItem(2, 2, True)
self.assertEqual(len(spy), 3)
with self.assertRaises(IndexError):
self.model.setItem(3, 2, True)
with self.assertRaises(IndexError):
self.model.setItem(0, 5, True)
with self.assertRaises(IndexError):
self.model.setItem(1, 0, True)
with self.assertRaises(ValueError):
self.model.setItem(1, 1, 0)
with self.assertRaises(ValueError):
self.model.setItem(1, 1, "True")
with self.assertRaises(ValueError):
self.model.setItem(1, 3, 3.54)
with self.assertRaises(ValueError):
self.model.setItem(1, 3, (3, 2))
self.assertEqual(len(spy), 3)
def testContextMenu(self):
area = self._area
event = object()
menus = self._area.getContextMenus(event)
self.assertEqual(3, len(menus))
self.assertEqual("Meter", menus[0].title())
self.assertEqual("Grid", menus[1].title())
self.assertEqual("Transform", menus[2].title())
# test "Meter" actions
meter_actions = menus[0].actions()
self.assertFalse(area._show_meter)
self.assertFalse(area._meter.isVisible())
spy = QSignalSpy(area.cross_toggled_sgn)
meter_actions[0].defaultWidget().setChecked(True)
self.assertTrue(area._show_meter)
self.assertTrue(area._meter.isVisible())
self.assertEqual(1, len(spy))
meter_actions[0].defaultWidget().setChecked(False)
self.assertFalse(area._show_meter)
self.assertFalse(area._meter.isVisible())
self.assertEqual(2, len(spy))
# test "Grid" actions
grid_actions = menus[1].actions()
alpha = area._grid_opacity_sld.value()
grid_actions[0].defaultWidget().setChecked(True)
self.assertEqual(alpha, area.getAxis("bottom").grid)
grid_actions[1].defaultWidget().setChecked(True)
self.assertEqual(alpha, area.getAxis("left").grid)
# test "Transform" actions
plot_item = CurvePlotItem()
plot_item2 = ScatterPlotItem()
area.addItem(plot_item)
area.addItem(plot_item2, y2=True)
transform_actions = menus[2].actions()
with patch.object(plot_item, "updateGraph") as mocked:
with patch.object(plot_item2, "updateGraph") as mocked2:
transform_actions[0].defaultWidget().setChecked(True)
self.assertTrue(area.getAxis("bottom").logMode)
# self.assertTrue(area.getAxis("top").logMode)
self.assertTrue(plot_item._log_x_mode)
self.assertTrue(plot_item2._log_x_mode)
mocked.assert_called_once()
mocked2.assert_called_once()
plot_item3 = CurvePlotItem()
plot_item4 = ScatterPlotItem()
area.addItem(plot_item3)
area.addItem(plot_item4, y2=True)
self.assertTrue(plot_item3._log_x_mode)
self.assertTrue(plot_item4._log_x_mode)
with patch.object(plot_item, "updateGraph") as mocked:
with patch.object(plot_item2, "updateGraph") as mocked2:
transform_actions[1].defaultWidget().setChecked(True)
self.assertTrue(area.getAxis("left").logMode)
# self.assertTrue(area.getAxis("right").logMode)
self.assertTrue(plot_item._log_y_mode)
self.assertFalse(plot_item2._log_y_mode)
mocked.assert_called_once()
mocked2.assert_not_called()
plot_item5 = CurvePlotItem()
plot_item6 = ScatterPlotItem()
area.addItem(plot_item5)
area.addItem(plot_item6, y2=True)
self.assertTrue(plot_item5._log_y_mode)
self.assertFalse(plot_item6._log_y_mode)
area._enable_meter = False
menus = self._area.getContextMenus(event)
self.assertEqual(2, len(menus))
self.assertEqual("Grid", menus[0].title())
self.assertEqual("Transform", menus[1].title())
area._enable_transform = False
menus = self._area.getContextMenus(event)
self.assertEqual(1, len(menus))
self.assertEqual("Grid", menus[0].title())
def setUp(self):
self.scanBrowser = ScanBrowser()
self.dataPath = os.environ.get('DATAPATH')
self.spyLoaded = QSignalSpy(self.scanBrowser.scanLoaded)
self.spySelected = QSignalSpy(self.scanBrowser.scanSelected)
print("self.dataPath %s" % self.dataPath)
def testAutoLevel(self):
widget = self.image_tool._image_ctrl_widget
spy = QSignalSpy(self.image_tool._mediator.reset_image_level_sgn)
widget.auto_level_btn.clicked.emit()
self.assertEqual(1, len(spy))
def wait_for(self, timeout=None, *, override_waited_for=False, **kwargs):
"""Wait until a given value is found in the data.
Keyword arguments to this function get interpreted as attributes of the
searched data. Every given argument is treated as a pattern which
the attribute has to match against.
Args:
timeout: How long to wait for the message.
override_waited_for: If set, gets triggered by previous messages
again.
Return:
The matched line.
"""
__tracebackhide__ = True
if timeout is None:
if 'CI' in os.environ:
timeout = 15000
else:
timeout = 5000
for key in kwargs:
assert key in self.KEYS
# Search existing messages
for line in self._data:
matches = []
for key, expected in kwargs.items():
value = getattr(line, key)
matches.append(self._match_data(value, expected))
if all(matches) and (not line.waited_for or override_waited_for):
# If we waited for this line, chances are we don't mean the
# same thing the next time we use wait_for and it matches
# this line again.
line.waited_for = True
return line
# If there is none, wait for the message
spy = QSignalSpy(self.new_data)
elapsed_timer = QElapsedTimer()
elapsed_timer.start()
while True:
got_signal = spy.wait(timeout)
if not got_signal or elapsed_timer.hasExpired(timeout):
raise WaitForTimeout("Timed out after {}ms waiting for "
"{!r}.".format(timeout, kwargs))
for args in spy:
assert len(args) == 1
line = args[0]
matches = []
for key, expected in kwargs.items():
value = getattr(line, key)
matches.append(self._match_data(value, expected))
if all(matches):
# If we waited for this line, chances are we don't mean the
# same thing the next time we use wait_for and it matches
# this line again.
line.waited_for = True
return line
def testStandAlone(self):
with self.assertRaises(ValueError):
FileStreamWindow(port=454522)
win = FileStreamWindow(port=45449)
widget = win._ctrl_widget
self.assertEqual('45449', widget.port_le.text())
self.assertIsNone(win._mediator)
with patch("extra_foam.gui.windows.file_stream_w.Process.start"
) as mocked_start:
# test when win._rd_cal is None
spy = QSignalSpy(win.file_server_started_sgn)
widget.serve_start_btn.clicked.emit()
self.assertEqual(0, len(spy))
mocked_start.assert_not_called()
# test when win._rd_cal is not None
win._rd_cal = MagicMock()
widget.serve_start_btn.clicked.emit()
self.assertEqual(1, len(spy))
mocked_start.assert_called_once()
# test populate sources
with patch("extra_foam.gui.windows.file_stream_w.load_runs") as lr:
with patch("extra_foam.gui.windows.file_stream_w.gather_sources"
) as gs:
with patch.object(widget, "initProgressControl") as fpc:
with patch.object(widget, "fillSourceTables") as fst:
# test load_runs return (None, None)
win._rd_cal, win._rd_raw = object(), object()
gs.return_value = (set(), set(), set())
lr.return_value = (None, None)
widget.data_folder_le.setText("abc")
lr.assert_called_with("abc")
fpc.assert_called_once_with(-1, -1)
fpc.reset_mock()
fst.assert_called_once_with(
None, None) # test _rd_cal and _rd_raw were reset
fst.reset_mock()
# test load_runs raises
lr.side_effect = ValueError
widget.data_folder_le.setText("efg")
fpc.assert_called_once_with(-1, -1)
fpc.reset_mock()
fst.assert_called_once_with(None, None)
fst.reset_mock()
with patch("extra_foam.gui.windows.file_stream_w.run_info",
return_value=(100, 1001, 1100)):
# test load_runs return
lr.side_effect = None
gs.return_value = ({
"DET1": ["data.adc"]
}, {
"output1": ["x", "y"]
}, {
"motor1": ["actualPosition"],
"motor2": ["actualCurrent"]
})
widget.data_folder_le.setText("hij")
fpc.assert_called_once_with(1001, 1100)
self.assertEqual(
"DET1",
widget._detector_src_tb.item(0, 0).text())
cell_widget = widget._detector_src_tb.cellWidget(0, 1)
self.assertEqual(1, cell_widget.count())
self.assertEqual("data.adc", cell_widget.currentText())
self.assertEqual(
"output1",
widget._instrument_src_tb.item(0, 0).text())
cell_widget = widget._instrument_src_tb.cellWidget(
0, 1)
self.assertEqual(2, cell_widget.count())
self.assertEqual("x", cell_widget.currentText())
self.assertEqual(
"motor1",
widget._control_src_tb.item(0, 0).text())
cell_widget = widget._control_src_tb.cellWidget(0, 1)
self.assertEqual(1, cell_widget.count())
self.assertEqual("actualPosition",
cell_widget.currentText())
self.assertEqual(
"motor2",
widget._control_src_tb.item(1, 0).text())
cell_widget = widget._control_src_tb.cellWidget(1, 1)
self.assertEqual(1, cell_widget.count())
self.assertEqual("actualCurrent",
cell_widget.currentText())
# None is selected.
self.assertEqual(([], [], []), widget.getSourceLists())
def setUp(self):
self.dataNavigator = XMCDDataNavigator()
self.spyDataSelectionChanged = QSignalSpy(
self.dataNavigator.dataSelectionChanged)
def testMakeCall(self):
spy = QSignalSpy(self._call_panel.callMade)
call = random.choice(CALLS)
button = self._call_panel.getButton(call)
button.clicked.emit()
self.assertEqual(bidding.asCall(spy[0][0]), call)
def testCommonStartStopReset(self):
win = self._win
com_ctrl_widget = win._com_ctrl_st
ctrl_widget = win._ctrl_widget_st
client = win._client_st
worker = win._worker_st
self.assertFalse(com_ctrl_widget.stop_btn.isEnabled())
self.assertIsNone(client._endpoint_st)
with patch.object(client, "start") as client_start:
with patch.object(win._plot_timer_st, "start") as timer_start:
spy = QSignalSpy(win.started_sgn)
QTest.mouseClick(com_ctrl_widget.start_btn, Qt.LeftButton)
self.assertEqual(
f"tcp://{com_ctrl_widget._hostname_le.text()}:"
f"{com_ctrl_widget._port_le.text()}", client._endpoint_st)
self.assertEqual(2, len(client._catalog_st))
self.assertIn("device1:output property1", client._catalog_st)
self.assertIn("device2 property2", client._catalog_st)
self.assertEqual(1, len(spy))
self.assertTrue(com_ctrl_widget.stop_btn.isEnabled())
self.assertFalse(com_ctrl_widget.start_btn.isEnabled())
self.assertFalse(com_ctrl_widget.load_dark_run_btn.isEnabled())
self.assertFalse(ctrl_widget.dummy_widget.isEnabled())
client_start.assert_called_once()
timer_start.assert_called_once()
with patch.object(client, "terminateRunST") as client_stop:
with patch.object(win._plot_timer_st, "stop") as timer_stop:
spy = QSignalSpy(win.stopped_sgn)
QTest.mouseClick(com_ctrl_widget.stop_btn, Qt.LeftButton)
self.assertEqual(1, len(spy))
self.assertFalse(com_ctrl_widget.stop_btn.isEnabled())
self.assertTrue(com_ctrl_widget.start_btn.isEnabled())
self.assertTrue(com_ctrl_widget.load_dark_run_btn.isEnabled())
self.assertTrue(ctrl_widget.dummy_widget.isEnabled())
client_stop.assert_called_once()
timer_stop.assert_called_once()
with patch.object(client, "start") as client_start:
with patch.object(win._plot_timer_st, "start") as timer_start:
with patch.object(worker, "sources") as mocked_sources:
with self.assertLogs(logger, level="ERROR") as cm:
mocked_sources.return_value = [("", "property1", 1)]
QTest.mouseClick(com_ctrl_widget.start_btn,
Qt.LeftButton)
client_start.assert_not_called()
timer_start.assert_not_called()
self.assertIn("Empty source", cm.output[0])
with self.assertLogs(logger, level="ERROR") as cm:
mocked_sources.return_value = [("device", "", 0)]
QTest.mouseClick(com_ctrl_widget.start_btn,
Qt.LeftButton)
client_start.assert_not_called()
timer_start.assert_not_called()
self.assertIn("Empty property", cm.output[0])
with self.assertLogs(logger, level="ERROR") as cm:
mocked_sources.return_value = [("device", "property",
2)]
QTest.mouseClick(com_ctrl_widget.start_btn,
Qt.LeftButton)
client_start.assert_not_called()
timer_start.assert_not_called()
self.assertIn("Not understandable data type",
cm.output[0])
with patch.object(client, "onResetST") as client_reset:
with patch.object(worker, "onResetST") as worker_reset:
with patch.object(win._line, "reset") as line_reset:
with patch.object(win._view, "reset") as view_reset:
QTest.mouseClick(com_ctrl_widget.reset_btn,
Qt.LeftButton)
client_reset.assert_called_once()
worker_reset.assert_called_once()
line_reset.assert_called_once()
view_reset.assert_called_once()
with patch.object(worker._input_st, "clear") as input_clear:
with patch.object(worker._output_st, "clear") as output_clear:
worker._reset_st = False
worker.onResetST()
input_clear.assert_called_once()
output_clear.assert_called_once()
worker._reset_st = True
with patch.object(client._transformer_st,
"reset") as transformer_reset:
with patch.object(client._output_st, "clear") as output_clear:
client.onResetST()
transformer_reset.assert_called_once()
output_clear.assert_called_once()
def testPlayNotAllowedCard(self):
spy = QSignalSpy(self._hand_panel.cardPlayed)
self._hand_panel.setCards(self._cards)
card = random.choice(self._cards)
self._click_card_helper(card)
self.assertEqual(len(spy), 0)
def testStartStop(self):
start_spy = QSignalSpy(self.gui.start_sgn)
stop_spy = QSignalSpy(self.gui.stop_sgn)
# -------------------------------------------------------------
# test when the start action button is clicked
# -------------------------------------------------------------
actions = self.gui._tool_bar.actions()
start_action = actions[0]
stop_action = actions[1]
histogram_action = actions[7]
self.assertEqual("Histogram", histogram_action.text())
histogram_action.trigger()
histogram_ctrl_widget = list(
self.gui._plot_windows.keys())[-1]._ctrl_widgets[0]
histogram_ctrl_widget.updateMetaData.reset_mock()
pump_probe_action = actions[5]
self.assertEqual("Pump-probe", pump_probe_action.text())
pump_probe_action.trigger()
pump_probe_ctrl_widget = list(
self.gui._plot_windows.keys())[-1]._ctrl_widgets[0]
pump_probe_ctrl_widget.updateMetaData.reset_mock()
start_action.trigger()
# test a ctrl widget own by the ImageToolWindow
azimuthal_integ_ctrl_widget = self.gui._image_tool._azimuthal_integ_1d_view._ctrl_widget
geometry_ctrl_widget = self.gui._image_tool._geometry_view._ctrl_widget
source_ctrl_widget = self.gui._source_cw
azimuthal_integ_ctrl_widget.updateMetaData.assert_called_once()
pump_probe_ctrl_widget.updateMetaData.assert_called_once()
histogram_ctrl_widget.updateMetaData.assert_called_once()
source_ctrl_widget.updateMetaData.assert_called_once()
self.assertEqual(1, len(start_spy))
pump_probe_ctrl_widget.onStart.assert_called_once()
histogram_ctrl_widget.onStart.assert_called_once()
azimuthal_integ_ctrl_widget.onStart.assert_called_once()
self.assertFalse(start_action.isEnabled())
self.assertTrue(stop_action.isEnabled())
self.assertFalse(source_ctrl_widget._con_view.isEnabled())
self.assertFalse(geometry_ctrl_widget.isEnabled())
self.assertTrue(self.train_worker.running)
self.assertTrue(self.pulse_worker.running)
# -------------------------------------------------------------
# test when the stop action button is clicked
# -------------------------------------------------------------
stop_action.trigger()
pump_probe_ctrl_widget.onStop.assert_called_once()
histogram_ctrl_widget.onStop.assert_called_once()
azimuthal_integ_ctrl_widget.onStop.assert_called_once()
self.assertEqual(1, len(stop_spy))
self.assertTrue(start_action.isEnabled())
self.assertFalse(stop_action.isEnabled())
self.assertTrue(source_ctrl_widget._con_view.isEnabled())
self.assertTrue(geometry_ctrl_widget.isEnabled())
self.assertFalse(self.train_worker.running)
self.assertFalse(self.pulse_worker.running)
