def test_action_replace(self, view, presenter, editor):
editor.hasSelectedText = Mock(return_value=True)
editor.selectedText = Mock(return_value=self.default_search_string)
presenter.action_replace()
editor.replace.assert_called_once_with("apples")
def __init__(self, has_selection=True):
self.hasSelection = Mock(return_value=has_selection)
self.selectedRows = None
self.selectedColumns = None
self.currentIndex = None
self.mock_selection = MockQSelection()
self.selection = Mock(return_value=self.mock_selection)
def test_data_tooltip_role_monitor_row(self):
if not qtpy.PYQT5:
self.skipTest(
"QVariant cannot be instantiated in QT4, and the test fails with an error."
)
ws, model, row, index = setup_common_for_test_data()
# necessary otherwise it is returned that there is a masked bin, and we get the wrong output
ws.hasMaskedBins = Mock(return_value=False)
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=True)
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls(
[call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MONITOR_ROW_STRING,
output)
# Doing the same thing a second time should hit the cache, so no additional calls will have been made
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls(
[call.do_work(row), call.do_work(row)])
self.assertEqual(2, model.ws_spectrum_info.isMasked.call_count)
# This was called only once because the monitor was cached
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MONITOR_ROW_STRING,
output)
def test_data_tooltip_role_masked_monitor_row(self):
if not qtpy.PYQT5:
self.skipTest(
"QVariant cannot be instantiated in QT4, and the test fails with an error."
)
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=True)
model.ws_spectrum_info.isMonitor = Mock(return_value=True)
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls(
[call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(
MatrixWorkspaceTableViewModel.MASKED_MONITOR_ROW_STRING, output)
# Doing the same thing a second time should hit the cache, so no additional calls will have been made
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls(
[call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(
MatrixWorkspaceTableViewModel.MASKED_MONITOR_ROW_STRING, output)
def test_data_tooltip_role_masked_bin(self):
if not qtpy.PYQT5:
self.skipTest(
"QVariant cannot be instantiated in QT4, and the test fails with an error."
)
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=False)
ws.hasMaskedBins = Mock(return_value=True)
ws.maskedBinsIndices = Mock(return_value=[index.column()])
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls(
[call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_BIN_STRING,
output)
# Doing the same thing a second time should hit the cache, so no additional calls will have been made
output = model.data(index, Qt.ToolTipRole)
self.assertEqual(4, model.ws_spectrum_info.hasDetectors.call_count)
self.assertEqual(2, model.ws_spectrum_info.isMasked.call_count)
self.assertEqual(2, model.ws_spectrum_info.isMonitor.call_count)
# This was called only once because the monitor was cached
ws.hasMaskedBins.assert_called_once_with(row)
ws.maskedBinsIndices.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_BIN_STRING,
output)
def test_data_tooltip_role_masked_row(self):
if not qtpy.PYQT5:
self.skipTest(
"QVariant cannot be instantiated in QT4, and the test fails with an error."
)
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.hasDetectors = Mock(return_value=True)
model.ws_spectrum_info.isMasked = Mock(return_value=True)
model.ws_spectrum_info.isMonitor = Mock(return_value=False)
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls(
[call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_ROW_STRING,
output)
output = model.data(index, Qt.ToolTipRole)
# The row was masked so it should have been cached
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
# However it is checked if it is a monitor again
self.assertEqual(3, model.ws_spectrum_info.hasDetectors.call_count)
self.assertEqual(2, model.ws_spectrum_info.isMonitor.call_count)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_ROW_STRING,
output)
def setUpClass(cls):
# Mock axes tab view
mock_axes_view = Mock(
get_selected_ax_name=lambda: '(0, 0)',
get_properties=lambda: AxProperties(new_ax_view_props))
cls.ax_view_patch = patch(AX_VIEW, lambda x: mock_axes_view)
cls.ax_view_mock = cls.ax_view_patch.start()
# Mock curves tab view
cls.curve_view_mock = Mock(
get_selected_curve_name=lambda: 'old label',
get_selected_ax_name=lambda: '(0, 0)',
get_properties=lambda: CurveProperties(new_curve_view_props))
cls.curve_view_patch = patch(CURVE_VIEW, lambda x: cls.curve_view_mock)
cls.curve_view_patch.start()
cls.ax = _run_apply_properties_on_figure_with_curve()
cls.new_curve = cls.ax.containers[0]
# Mock images tab view
cls.img_view_mock = Mock(
get_selected_image_name=lambda: '(0, 0) - old label',
get_properties=lambda: ImageProperties(new_image_props))
cls.img_view_patch = patch(IMAGE_VIEW, lambda x: cls.img_view_mock)
cls.img_view_patch.start()
cls.img_ax = _run_apply_properties_on_figure_with_image()
cls.new_img = cls.img_ax.images[0]
def __init__(self):
self.addChild = StrictMock()
self.childCount = Mock(return_value=0)
self.setCheckState = Mock()
self.parent = Mock(return_value=False)
self.childCount = Mock(return_value=1)
self.child = Mock(return_value=MockQTreeWidgetChildItem(self))
def __init__(self, _):
self.close_signal = MockQtSignal()
self.rename_signal = MockQtSignal()
self.presenter = Mock()
self.presenter.clear_observer = Mock()
self.setWindowTitle = Mock()
self.deleteLater = Mock()
def wrapper(self, view, presenter, editor):
view.find.currentText = Mock(return_value=search_string)
if replace_string is not None:
view.replace = Mock()
view.replace.currentText = Mock(return_value=replace_string)
return func(self, view, presenter, editor)
def test_data_background_role_monitor_row(self):
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=True)
output = model.data(index, Qt.BackgroundRole)
model.ws_spectrum_info.hasDetectors.assert_called_with(row)
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
index.row.assert_called_once_with()
self.assertFalse(index.column.called)
self.assertEqual(model.monitor_color, output)
# Just do it a second time -> This time it's cached and should be read off the cache.
# If it is not read off the cache the assert_called_once below will fail,
# as the functions would be called a 2nd time
output = model.data(index, Qt.BackgroundRole)
model.ws_spectrum_info.hasDetectors.assert_called_with(row)
# assert that it has been called twice with the same parameters
model.ws_spectrum_info.isMasked.assert_has_calls(
[call.do_work(row), call.do_work(row)])
# only called once, as the 2nd time should have hit the cached monitor
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(model.monitor_color, output)
# assert that the row was called twice with no parameters
self.assertEqual(2, index.row.call_count)
self.assertFalse(index.column.called)
def test_do_action_plot__plot_func_throws_error(self, ws, view, twd,
mock_logger_error):
mock_plot_function = Mock()
error_message = "See bottom of keyboard for HEALTH WARNING"
mock_plot_function.side_effect = ValueError(error_message)
with patch(
'mantidqt.widgets.workspacedisplay.table.presenter.TableWorkspaceDisplay._get_plot_function_from_type') \
as mock_get_plot_function_from_type:
mock_get_plot_function_from_type.return_value = mock_plot_function
view.mock_selection_model.selectedColumns.return_value = [
MockQModelIndex(1, 1)
]
twd.action_set_as_x()
view.mock_selection_model.selectedColumns.return_value = [
MockQModelIndex(1, 2)
]
twd.action_plot(PlotType.LINEAR)
view.show_warning.assert_called_once_with(
TableWorkspaceDisplay.PLOT_FUNCTION_ERROR_MESSAGE.format(
error_message),
TableWorkspaceDisplay.INVALID_DATA_WINDOW_TITLE)
mock_logger_error.assert_called_once_with(
TableWorkspaceDisplay.PLOT_FUNCTION_ERROR_MESSAGE.format(
error_message))
self.assertNotCalled(twd.plot.mock_fig.show)
self.assertNotCalled(twd.plot.mock_ax.legend)
def test_setup_table(self):
ws = MockWorkspace()
view = MockMatrixWorkspaceDisplayView()
container = Mock(spec=StatusBarView)
container.status_bar = Mock(spec=QStatusBar)
MatrixWorkspaceDisplay(ws, view=view, container=container)
self.assertEqual(3, view.set_context_menu_actions.call_count)
self.assertEqual(1, view.set_model.call_count)
def test_setup_table(self):
ws = MockWorkspace()
view = MockMatrixWorkspaceDisplayView()
container = Mock(spec=StatusBarView)
container.status_bar = Mock(spec=QStatusBar)
MatrixWorkspaceDisplay(ws, view=view, container=container)
self.assertEqual(3, view.set_context_menu_actions.call_count)
self.assertEqual(1, view.set_model.call_count)
def wrapper(self, *args):
ws = MockWorkspace()
view = MockMatrixWorkspaceDisplayView()
mock_observer = Mock()
container = Mock(spec=StatusBarView)
container.status_bar = Mock(spec=QStatusBar)
presenter = MatrixWorkspaceDisplay(ws, view=view, ads_observer=mock_observer, container=container)
return func(self, ws, view, presenter, *args)
def test_get_plotted_workspace_names_returns_list_of_workspace_names(self):
mock_axes = [
Mock(tracked_workspaces={'test_ws': None}),
Mock(tracked_workspaces={'test_ws1': None})
]
mock_fig = Mock(get_axes=lambda: mock_axes)
plotted_workspaces = get_plotted_workspaces_names(mock_fig)
self.assertEqual(['test_ws', 'test_ws1'], sorted(plotted_workspaces))
def __init__(self):
self.clear = StrictMock()
self.setHeaderLabel = StrictMock()
self.addTopLevelItem = StrictMock()
self.topLevelItemCount = Mock(return_value=3)
self.topLevelItem = StrictMock(
return_value=MockQTreeWidgetParentItem())
self.itemClicked = Mock()
self.itemChanged = Mock()
def __init__(self):
self.set_context_menu_actions = Mock()
self.table_x = MockQTableView()
self.table_y = MockQTableView()
self.table_e = MockQTableView()
self.set_model = Mock()
self.ask_confirmation = None
self.emit_close = Mock()
self.mock_tab = MockQTab()
self.get_active_tab = Mock(return_value=self.mock_tab)
def test_monitor_5_correctly_disabled():
mock_model = Mock()
mock_model.does_instrument_support_monitor_5.return_value = False
mock_view = Mock()
settings_presenter = SettingsAdjustmentPresenter(view=mock_view,
model=mock_model)
settings_presenter.default_gui_setup()
mock_view.set_monitor_5_enabled.assert_called_with(False)
def test_instrument_update_passed_to_model(self):
mock_view = Mock()
mock_model = Mock()
presenter = SettingsAdjustmentPresenter(model=mock_model,
view=mock_view)
param = SANSInstrument.SANS2D
presenter.update_instrument(param)
self.assertEqual(param, mock_model.instrument)
def test_action_background_args_changed_with_auto_background_none(self, mock_ConfigService):
mock_view = MockSettingsView()
mock_view.auto_bkg.currentText = Mock(return_value="None")
presenter = FittingSettings(None, mock_view)
# reset any effects from the constructor
mock_ConfigService.setString.reset_mock()
mock_view.background_args.text = Mock(return_value="n=3")
presenter.action_background_args_changed()
mock_ConfigService.setString.assert_called_once_with(FittingSettings.AUTO_BACKGROUND, "")
def setUp(self):
self.axes_patch = patch(PRESENTER_REF + 'AxesTabWidgetPresenter',
new=Mock())
self.axes_mock = self.axes_patch.start()
self.curves_patch = patch(PRESENTER_REF + 'CurvesTabWidgetPresenter',
new=Mock())
self.curves_mock = self.curves_patch.start()
self.images_patch = patch(PRESENTER_REF + 'ImagesTabWidgetPresenter',
new=Mock())
self.images_mock = self.images_patch.start()
def test_drag_and_drop_adds_plot_to_correct_axes(self):
ax = self.fig.get_axes()[1]
# Find the center of the axes and simulate a drop event there
ax_x_centre = (ax.xaxis.clipbox.x1 + ax.xaxis.clipbox.x0)/2
ax_y_centre = (ax.yaxis.clipbox.y1 + ax.yaxis.clipbox.y0)/2
mock_event = Mock(pos=lambda: Mock(x=lambda: ax_x_centre, y=lambda: ax_y_centre))
mock_event.mimeData().text.return_value = "ws"
with patch('workbench.plotting.figurewindow.QMainWindow.dropEvent'):
self.fig_window.dropEvent(mock_event)
self.assertEqual(2, len(ax.lines))
def wrapper(self, *args):
ws = MockWorkspace()
view = MockMatrixWorkspaceDisplayView()
mock_observer = Mock()
container = Mock(spec=StatusBarView)
container.status_bar = Mock(spec=QStatusBar)
presenter = MatrixWorkspaceDisplay(ws,
view=view,
ads_observer=mock_observer,
container=container)
return func(self, ws, view, presenter, *args)
def test_normalise_data_set_on_fit_menu_shown(self, normaliseData_mock):
for normalised in [True, False]:
ws_artist_mock = Mock(is_normalized=normalised, workspace_index=0)
axes_mock = Mock(tracked_workspaces={'ws_name': [ws_artist_mock]})
property_browser = self._create_widget()
with patch.object(property_browser, 'get_axes', lambda: axes_mock):
with patch.object(property_browser, 'workspaceName',
lambda: 'ws_name'):
property_browser.getFitMenu().aboutToShow.emit()
property_browser.normaliseData.assert_called_once_with(normalised)
normaliseData_mock.reset_mock()
def test_fill_layout_display(self, mock_CONF):
presenter = GeneralSettings(None, view=Mock())
# setup CONF.get returns dictionary
test_dict = {'a': 1, 'b': 2, 'c': 3}
mock_CONF.get.return_value = test_dict
# setup mock commands
presenter.view.layout_display.addItem = Mock()
presenter.fill_layout_display()
calls = [call('a'), call('b'), call('c')]
presenter.view.layout_display.addItem.assert_has_calls(calls)
def _run_check_axes_distribution_consistency(self, normalization_states):
mock_tracked_workspaces = {
'ws': [
Mock(is_normalized=normalization_states[0]),
Mock(is_normalized=normalization_states[1])
],
'ws1': [Mock(is_normalized=normalization_states[2])]
}
with patch('mantid.kernel.logger.warning', Mock()) as mock_logger:
with patch.object(self.ax, 'tracked_workspaces', mock_tracked_workspaces):
self.ax.check_axes_distribution_consistency()
return mock_logger
def test_monitor_5_considered_with_update_instrument():
mock_model = Mock()
mock_model.does_instrument_support_monitor_5.return_value = True
mock_view = Mock()
settings_presenter = SettingsAdjustmentPresenter(view=mock_view,
model=mock_model)
settings_presenter.update_instrument(SANSInstrument.ZOOM)
mock_model.does_instrument_support_monitor_5.assert_called()
mock_view.set_monitor_5_enabled.assert_called_with(True)
def test_action_copy_bin_values_no_selection(self, mock_copy, mock_show_mouse_toast):
mock_table = MockQTableView()
mock_table.mock_selection_model.hasSelection = Mock(return_value=False)
mock_table.mock_selection_model.selectedColumns = Mock()
self.data_copier.copy_bin_values(mock_table, None, None)
mock_table.selectionModel.assert_called_once_with()
mock_table.mock_selection_model.hasSelection.assert_called_once_with()
# the action should never look for rows if there is no selection
self.assertNotCalled(mock_table.mock_selection_model.selectedColumns)
self.assertNotCalled(mock_copy)
mock_show_mouse_toast.assert_called_once_with(UserNotifier.NO_SELECTION_MESSAGE)
def setUp(self):
self.mock_status_bar = MockQStatusBar()
self.mock_clipboard = MockQClipboard()
self.mock_clipboard.setText = Mock()
self.data_copier = DataCopier(self.mock_status_bar)
mock_selection_model = MockQSelectionModel(has_selection=True)
mock_selection_model.selectedRows = Mock(
return_value=[MockQModelIndex(1, 1), MockQModelIndex(2, 2), MockQModelIndex(3, 3)])
mock_selection_model.selectedColumns = Mock(
return_value=[MockQModelIndex(1, 1), MockQModelIndex(2, 2), MockQModelIndex(3, 3)])
self.table = Mock(spec=TableWorkspaceDisplayView)
self.table.mock_selection_model = mock_selection_model
def test_set_hidden_interface_string(self, mock_ConfigService):
mock_view = MockCategoriesView()
mock_ConfigService.getString = Mock(return_value='')
presenter = CategoriesSettings(None, mock_view)
hidden_interface_string = 'Indirect; Muon; Reflectometry'
# reset any effects from the constructor
mock_ConfigService.setString.reset_mock()
presenter._create_hidden_categories_string = Mock(
return_value=hidden_interface_string)
presenter.set_hidden_interfaces_string(None)
mock_ConfigService.setString.assert_called_once_with(
presenter.HIDDEN_INTERFACES, ';'.join(hidden_interface_string))
def test_action_current_row_changed(self):
mock_view = MockSettingsView()
presenter = SettingsPresenter(None, view=mock_view,
general_settings=mock_view.general_settings,
categories_settings=mock_view.categories_settings,
plot_settings=mock_view.plot_settings,
fitting_settings=mock_view.fitting_settings)
mock_view.sections.item = Mock()
mock_view.sections.item().text = Mock(return_value = presenter.SETTINGS_TABS['categories_settings'])
presenter.action_section_changed(1)
self.assertEqual(1, mock_view.container.replaceWidget.call_count)
self.assertEqual(mock_view.categories_settings.view, presenter.current)
def test_handleItemChanged(self, ws, view, twd):
item = Mock(spec=WorkbenchTableWidgetItem)
item.row.return_value = 5
item.column.return_value = 5
item.data.return_value = "magic parameter"
item.is_v3d = False
twd.handleItemChanged(item)
item.row.assert_called_once_with()
item.column.assert_called_once_with()
ws.setCell.assert_called_once_with(5, 5, "magic parameter", notify_replace=False)
item.update.assert_called_once_with()
item.reset.assert_called_once_with()
def common_setup_action_plot(self, table_has_selection=True):
mock_ws = MockWorkspace()
mock_view = MockMatrixWorkspaceDisplayView()
mock_plotter = Mock()
container = Mock(spec=StatusBarView)
container.status_bar = Mock(spec=QStatusBar)
presenter = MatrixWorkspaceDisplay(mock_ws, plot=mock_plotter, view=mock_view, container=container)
# monkey-patch the spectrum plot label to count the number of calls
presenter.model.get_spectrum_plot_label = Mock()
presenter.model.get_bin_plot_label = Mock()
mock_table = MockQTableView()
# configure the mock return values
mock_table.mock_selection_model.hasSelection = Mock(return_value=table_has_selection)
return mock_plotter, mock_table, mock_view, presenter
def wrapper(self, *args):
ws = MockWorkspace()
view = Mock(spec=TableWorkspaceDisplayView)
container = Mock(spec=StatusBarView)
container.status_bar = Mock(spec=QStatusBar)
if add_selection_model:
mock_selection_model = MockQSelectionModel(has_selection=True)
mock_selection_model.selectedRows = Mock(
return_value=[MockQModelIndex(1, 1), MockQModelIndex(2, 2), MockQModelIndex(3, 3)])
mock_selection_model.selectedColumns = Mock(
return_value=[MockQModelIndex(1, 1), MockQModelIndex(2, 2), MockQModelIndex(3, 3)])
view.mock_selection_model = mock_selection_model
view.selectionModel.return_value = mock_selection_model
twd = TableWorkspaceDisplay(ws, view=view, container=container)
if add_plot:
twd.plot = MockPlotLib()
return func(self, ws, view, twd, *args)
def test_handleItemChanged_raises_ValueError(self, ws, view, twd):
item = Mock(spec=WorkbenchTableWidgetItem)
item.row.return_value = 5
item.column.return_value = 5
item.data.return_value = "magic parameter"
item.is_v3d = False
# setCell will throw an exception as a side effect
ws.setCell.side_effect = ValueError
twd.handleItemChanged(item)
item.row.assert_called_once_with()
item.column.assert_called_once_with()
ws.setCell.assert_called_once_with(5, 5, "magic parameter")
view.show_warning.assert_called_once_with(TableWorkspaceDisplay.ITEM_CHANGED_INVALID_DATA_MESSAGE)
self.assertNotCalled(item.update)
item.reset.assert_called_once_with()
def test_handleItemChanged_raises_Exception(self, ws, view, twd):
item = Mock(spec=WorkbenchTableWidgetItem)
item.row.return_value = ws.ROWS
item.column.return_value = ws.COLS
item.data.return_value = "magic parameter"
item.is_v3d = False
# setCell will throw an exception as a side effect
error_message = "TEST_EXCEPTION_MESSAGE"
ws.setCell.side_effect = Exception(error_message)
twd.handleItemChanged(item)
item.row.assert_called_once_with()
item.column.assert_called_once_with()
ws.setCell.assert_called_once_with(ws.ROWS, ws.COLS, "magic parameter")
view.show_warning.assert_called_once_with(
TableWorkspaceDisplay.ITEM_CHANGED_UNKNOWN_ERROR_MESSAGE.format(error_message))
self.assertNotCalled(item.update)
item.reset.assert_called_once_with()
def test_do_action_plot__plot_func_throws_error(self, ws, view, twd, mock_logger_error):
mock_plot_function = Mock()
error_message = "See bottom of keyboard for HEALTH WARNING"
mock_plot_function.side_effect = ValueError(error_message)
with patch(
'mantidqt.widgets.workspacedisplay.table.presenter.TableWorkspaceDisplay._get_plot_function_from_type') \
as mock_get_plot_function_from_type:
mock_get_plot_function_from_type.return_value = mock_plot_function
view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, 1)]
twd.action_set_as_x()
view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, 2)]
twd.action_plot(PlotType.LINEAR)
view.show_warning.assert_called_once_with(
TableWorkspaceDisplay.PLOT_FUNCTION_ERROR_MESSAGE.format(error_message),
TableWorkspaceDisplay.INVALID_DATA_WINDOW_TITLE)
mock_logger_error.assert_called_once_with(
TableWorkspaceDisplay.PLOT_FUNCTION_ERROR_MESSAGE.format(error_message))
self.assertNotCalled(twd.plot.mock_fig.show)
self.assertNotCalled(twd.plot.mock_ax.legend)
from collections import Counter, namedtuple
import qtpy
from mantid.py3compat.mock import Mock, patch, call
import unittest
from qtpy.QtCore import Qt
from qtpy.QtTest import QTest
from mantid.api import AlgorithmFactoryImpl
from mantidqt.utils.qt.testing import select_item_in_combo_box, select_item_in_tree, GuiTest
from mantidqt.widgets.algorithmselector.model import AlgorithmSelectorModel
from mantidqt.widgets.algorithmselector.widget import AlgorithmSelectorWidget
AlgorithmDescriptorMock = namedtuple('AlgorithmDescriptorMock', ['name', 'alias', 'category', 'version'])
mock_get_algorithm_descriptors = Mock()
mock_get_algorithm_descriptors.return_value = [
AlgorithmDescriptorMock(name='Rebin', version=1,
category='Transform', alias=''),
AlgorithmDescriptorMock(name='Rebin', version=1,
category='Transform\\Rebin', alias=''),
AlgorithmDescriptorMock(name='Load', version=1,
category='Data', alias=''),
AlgorithmDescriptorMock(name='DoStuff', version=1,
category='Stuff', alias=''),
AlgorithmDescriptorMock(name='DoStuff', version=2,
category='Stuff', alias=''),
AlgorithmDescriptorMock(name='ComesFirst', version=1,
category="Sorted", alias=''),
AlgorithmDescriptorMock(name='GoesSecond', version=1,
category="Sorted", alias='')
