def test_do_action_plot_multiple_y_success(self, ws, view, twd):
col_as_x = 1
col_as_y1 = 2
col_as_y2 = 3
expected_x_data = twd.model.get_column(col_as_x)
expected_y1_data = twd.model.get_column(col_as_y1)
expected_y2_data = twd.model.get_column(col_as_y2)
view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, col_as_x)]
twd.action_set_as_x()
view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, col_as_y1),
MockQModelIndex(1, col_as_y2)]
twd.action_plot(PlotType.LINEAR)
twd.plot.subplots.assert_called_once_with()
twd.plot.mock_fig.canvas.set_window_title.assert_called_once_with(twd.model.get_name())
twd.plot.mock_ax.set_xlabel.assert_called_once_with(twd.model.get_column_header(col_as_x))
col_y1_name = twd.model.get_column_header(col_as_y1)
col_y2_name = twd.model.get_column_header(col_as_y2)
twd.plot.mock_ax.set_ylabel.assert_has_calls([call(col_y1_name), call(col_y2_name)])
twd.plot.mock_ax.plot.assert_has_calls([
call(expected_x_data, expected_y1_data,
label=TableWorkspaceDisplay.COLUMN_DISPLAY_LABEL.format(col_y1_name)),
call(expected_x_data, expected_y2_data,
label=TableWorkspaceDisplay.COLUMN_DISPLAY_LABEL.format(col_y2_name))])
twd.plot.mock_fig.show.assert_called_once_with()
twd.plot.mock_ax.legend.assert_called_once_with()
def test_that_sets_table_when_update_called(self):
# Arrange
parent_presenter = create_run_tab_presenter_mock(use_fake_state=False)
view = create_mock_masking_table()
presenter = MaskingTablePresenter(parent_presenter)
presenter._work_handler = mock.Mock()
presenter.set_view(view)
self.assertEqual(1, view.set_table.call_count)
presenter.on_display()
self.assertEqual(2, view.set_table.call_count)
first_call = mock.call([])
second_call = mock.call([
masking_information(first='Beam stop',
second='',
third='infinite-cylinder, r = 10.0'),
masking_information(first='Corners',
second='',
third='infinite-cylinder, r = 20.0'),
masking_information(first='Phi',
second='',
third='L/PHI -90.0 90.0')
]) # noqa
view.set_table.assert_has_calls([first_call, second_call])
def test_right_click_gives_context_menu_for_plot_without_fit_enabled(
self, mocked_figure_type, mocked_qmenu_cls):
fig_manager = self._create_mock_fig_manager_to_accept_right_click()
fig_manager.fit_browser.tool = None
interactor = FigureInteraction(fig_manager)
mouse_event = self._create_mock_right_click()
mocked_figure_type.return_value = FigureType.Line
# Expect a call to QMenu() for the outer menu followed by two more calls
# for the Axes and Normalization menus
qmenu_call1 = MagicMock()
qmenu_call2 = MagicMock()
qmenu_call3 = MagicMock()
mocked_qmenu_cls.side_effect = [qmenu_call1, qmenu_call2, qmenu_call3]
with patch('workbench.plotting.figureinteraction.QActionGroup',
autospec=True):
with patch.object(interactor.toolbar_manager, 'is_tool_active',
lambda: False):
with patch.object(interactor.errors_manager,
'add_error_bars_menu', MagicMock()):
interactor.on_mouse_button_press(mouse_event)
self.assertEqual(0, qmenu_call1.addSeparator.call_count)
self.assertEqual(0, qmenu_call1.addAction.call_count)
expected_qmenu_calls = [
call(),
call("Axes", qmenu_call1),
call("Normalization", qmenu_call1)
]
self.assertEqual(expected_qmenu_calls,
mocked_qmenu_cls.call_args_list)
# 4 actions in Axes submenu
self.assertEqual(4, qmenu_call2.addAction.call_count)
# 2 actions in Normalization submenu
self.assertEqual(2, qmenu_call3.addAction.call_count)
def test_set_active_font_sets_active_font_in_view(self):
self.view.active_plot_number = 1
self.presenter.set_active_font(2)
# 2 calls, one to set the plot number 1 to normal, one to
# set plot number 2 to bold
self.assertEqual(self.view.set_active_font.mock_calls[0], mock.call(1, False))
self.assertEqual(self.view.set_active_font.mock_calls[1], mock.call(2, True))
self.assertEqual(self.view.active_plot_number, 2)
def test_load_calls_loadAscii_with_correct_parameters(self, mock_mantid):
items = {'path1': 'name1', 'path2': 'name2'}
self.model._load(items)
call_list = [
mock.call('path1', OutputWorkspace='name1'),
mock.call('path2', OutputWorkspace='name2')
]
mock_mantid.LoadAscii.assert_has_calls(call_list, any_order=True)
self.assertEqual(mock_mantid.LoadAscii.call_count, 2)
def test_refit_peaks_uses_xvalue_from_input_workspace(
self, mock_get_property):
self.alg_instance.refit_peaks([])
calls = [
mock.call('InputWorkspace'),
mock.call().value.readX(0),
mock.call().value.readX().copy()
]
mock_get_property.assert_has_calls(calls, any_order=True)
def run_special_character_test(self, special_character):
self.view.get_all_selected_plot_numbers = mock.Mock(return_value=[0, 1])
self.model.get_plot_name_from_number = mock.Mock(return_value='Plot' + special_character + '1')
self.view.get_directory_name_for_saving = mock.Mock(return_value='/home/Documents')
self.presenter.export_plots_called('.xyz')
self.assertEqual(self.model.export_plot.mock_calls[0],
mock.call(0, os.path.join('/home/Documents', 'Plot-1.xyz')))
self.assertEqual(self.model.export_plot.mock_calls[1],
mock.call(1, os.path.join('/home/Documents', 'Plot-1 (1).xyz')))
def do_test_action_plot_multiple_y_error_plot(self, view, twd, plot_type, extra_errorbar_assert_kwargs=None,
append_yerr_to_selection=False):
"""
Does the test for plotting with multiple Y columns. Each of them has an associated error
:param twd: The presenter
:param view: The mock view
:param plot_type: The type of the plot
:param extra_errorbar_assert_kwargs: Extra arguments expanded in the assertion for the errorbar call
:return:
"""
if extra_errorbar_assert_kwargs is None:
extra_errorbar_assert_kwargs = dict()
col_as_x = 0
col_as_y1 = 1
col_as_y1_err = 2
col_as_y2 = 3
col_as_y2_err = 4
expected_x_data = twd.model.get_column(col_as_x)
expected_y1_data = twd.model.get_column(col_as_y1)
expected_y1_err_data = twd.model.get_column(col_as_y1_err)
expected_y2_data = twd.model.get_column(col_as_y2)
expected_y2_err_data = twd.model.get_column(col_as_y2_err)
view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, col_as_x)]
twd.action_set_as_x()
view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, col_as_y1_err)]
twd.action_set_as_y_err(col_as_y1, '0')
view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, col_as_y2_err)]
twd.action_set_as_y_err(col_as_y2, '1')
view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, col_as_y1),
MockQModelIndex(1, col_as_y2)]
if append_yerr_to_selection:
view.mock_selection_model.selectedColumns.return_value.extend(
[MockQModelIndex(1, col_as_y1_err), MockQModelIndex(1, col_as_y2_err)])
twd.action_plot(plot_type)
twd.plot.subplots.assert_called_once_with()
twd.plot.mock_fig.canvas.set_window_title.assert_called_once_with(twd.model.get_name())
twd.plot.mock_ax.set_xlabel.assert_called_once_with(twd.model.get_column_header(col_as_x))
col_y1_name = twd.model.get_column_header(col_as_y1)
col_y2_name = twd.model.get_column_header(col_as_y2)
twd.plot.mock_ax.set_ylabel.assert_has_calls([call(col_y1_name), call(col_y2_name)])
twd.plot.mock_ax.errorbar.assert_has_calls([
call(expected_x_data, expected_y1_data,
label=TableWorkspaceDisplay.COLUMN_DISPLAY_LABEL.format(col_y1_name), yerr=expected_y1_err_data,
**extra_errorbar_assert_kwargs),
call(expected_x_data, expected_y2_data,
label=TableWorkspaceDisplay.COLUMN_DISPLAY_LABEL.format(col_y2_name), yerr=expected_y2_err_data,
**extra_errorbar_assert_kwargs)])
twd.plot.mock_fig.show.assert_called_once_with()
twd.plot.mock_ax.legend.assert_called_once_with()
def test_that_add_element_lines_will_call_plot_line(self, mock_plot_line):
data = {'line1': 10.0, 'line2': 20.0, 'line3': 30.0}
self.gui._add_element_lines('Cu', data)
self.assertEqual(mock_plot_line.call_count, 3)
call_list = [
mock.call(gen_name('Cu', 'line3'), 30.0, 'C0', 'Cu'),
mock.call(gen_name('Cu', 'line2'), 20.0, 'C0', 'Cu'),
mock.call(gen_name('Cu', 'line1'), 10.0, 'C0', 'Cu')
]
mock_plot_line.assert_has_calls(call_list, any_order=True)
def test_default_view_shown(self):
mock_view = MockSettingsView()
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)
expected_calls = [call(mock_view.general_settings.view), call(mock_view.categories_settings.view)]
mock_view.container.addWidget.assert_has_calls(expected_calls)
def test_set_active_font_sets_active_font_in_view(self):
self.view.active_plot_number = 1
self.presenter.set_active_font(2)
# 2 calls, one to set the plot number 1 to normal, one to
# set plot number 2 to bold
self.assertEqual(self.view.set_active_font.mock_calls[0],
mock.call(1, False))
self.assertEqual(self.view.set_active_font.mock_calls[1],
mock.call(2, True))
self.assertEqual(self.view.active_plot_number, 2)
def test_action_plot_more_than_one_x(self, ws, view, twd):
view.mock_selection_model.selectedColumns.return_value = [
MockQModelIndex(1, 1),
MockQModelIndex(1, 2)
]
twd.action_set_as_x()
twd.action_plot(PlotType.LINEAR)
view.mock_selection_model.selectedColumns.assert_has_calls(
[call(), call()])
view.show_warning.assert_called_once_with(
TableWorkspaceDisplay.TOO_MANY_SELECTED_FOR_X)
def test_exporting_multiple_plots_with_repeated_plot_names_generates_unique_names(self):
self.view.get_all_selected_plot_numbers = mock.Mock(return_value=[0, 101, 102, 103])
self.view.get_directory_name_for_saving = mock.Mock(return_value='/home/Documents')
self.presenter.export_plots_called('.xyz')
self.assertEqual(self.model.export_plot.mock_calls[0],
mock.call(0, os.path.join('/home/Documents', 'Plot1.xyz')))
for i in range(1, len(self.model.export_plot.mock_calls)):
self.assertEqual(self.model.export_plot.mock_calls[i],
mock.call(100 + i, os.path.join('/home/Documents', 'Plot1 ({}).xyz'.format(i))))
def test_that_remove_line_calls_removeLine_the_correct_number_of_times(
self):
subplot_name = "subplot"
lines = ["one", "two", "three"]
calls = [mock.call("one"), mock.call("two"), mock.call("three")]
self.subplot._context.subplots = {subplot_name: mock.Mock()}
self.subplot.remove_lines(subplot_name, lines)
self.subplot._context.subplots[
subplot_name].removeLine.assert_has_calls(calls)
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 test_handle_plot_guess_changed_removes_all_guesses_if_workspace_is_none(
self):
self.context.fitting_context.plot_guess = True
self.context.fitting_context.guess_ws = None
self.model.plotted_fit_workspaces = [
'ws1', 'ws2_guess', 'ws3_guess', 'ws4'
]
call_list = [mock.call('ws2_guess'), mock.call('ws3_guess')]
self.presenter.handle_plot_guess_changed()
self.assertEqual(0, self.model.add_workspace_to_plot.call_count)
self.assertEqual(2, self.model.remove_workpace_from_plot.call_count)
self.model.remove_workpace_from_plot.assert_has_calls(call_list)
self.assertEqual(1, self.model.force_redraw.call_count)
def _repair_checkpoints_assertions(self, checkpoint1, checkpoint2, pid, pid2):
# None of the checkpoints should exist after the call. Thus the PID folder should be deleted and thus ignored.
directory_removal_calls = [mock.call(os.path.join(self.pr.recovery_directory_hostname, '200000')),
mock.call(os.path.join(self.pr.recovery_directory_hostname, "1000000", "check1"))]
self.pr._remove_directory_and_directory_trees.assert_has_calls(directory_removal_calls)
empty_file_calls = [mock.call(self.pr.recovery_directory_hostname)]
self.pr._remove_empty_folders_from_dir.assert_has_calls(empty_file_calls)
self.assertTrue(os.path.exists(checkpoint1))
self.assertTrue(os.path.exists(pid2))
self.assertTrue(os.path.exists(checkpoint2))
self.assertTrue(os.path.exists(pid))
def test_calculate_FFT_calls_correct_algorithm_sequence_with_imaginary(
self, field_mock, fft_mock, apodization_mock):
self.view.imaginary_data = True
name = 'MUSR22725; Group; top; Asymmetry; MA'
Im_name = 'MUSR22725; Pair Asym; test_pair; MA'
field_mock_return = mock.MagicMock()
field_mock.return_value = field_mock_return
apodization_mock_return = mock.MagicMock()
fft_mock_return = mock.MagicMock()
fft_mock.return_value = fft_mock_return
apodization_mock.return_value = apodization_mock_return
self.presenter.add_fft_workspace_to_ADS = mock.MagicMock()
self.presenter.getWorkspaceNames()
index = self.view.ws.findText(name)
self.view.ws.setCurrentIndex(index)
index = self.view.Im_ws.findText(Im_name)
self.view.Im_ws.setCurrentIndex(index)
self.presenter.calculate_FFT()
apodization_mock.has_calls(
mock.call({
'Padding': 1,
'ApodizationFunction': 'Lorentz',
'NegativePadding': True,
'InputWorkspace': Im_name,
'DecayConstant': 4.4
}),
mock.call({
'Padding': 1,
'ApodizationFunction': 'Lorentz',
'NegativePadding': True,
'InputWorkspace': name,
'DecayConstant': 4.4
}))
fft_mock.assert_called_once_with({
'Real': 0,
'InputWorkspace': apodization_mock_return,
'Transform': 'Forward',
'AcceptXRoundingErrors': True,
'AutoShift': True,
'InputImagWorkspace': apodization_mock_return,
"Imaginary": 0
})
field_mock.assert_called_once_with(fft_mock_return)
self.presenter.add_fft_workspace_to_ADS.assert_called_once_with(
name, Im_name, field_mock_return)
def run_special_character_test(self, special_character):
self.view.get_all_selected_plot_numbers = mock.Mock(
return_value=[0, 1])
self.model.get_plot_name_from_number = mock.Mock(
return_value='Plot' + special_character + '1')
self.view.get_directory_name_for_saving = mock.Mock(
return_value='/home/Documents')
self.presenter.export_plots_called('.xyz')
self.assertEqual(
self.model.export_plot.mock_calls[0],
mock.call(0, os.path.join('/home/Documents', 'Plot-1.xyz')))
self.assertEqual(
self.model.export_plot.mock_calls[1],
mock.call(1, os.path.join('/home/Documents', 'Plot-1 (1).xyz')))
def test_handle_plot_guess_changed_removes_all_guesses_if_workspace_is_none(self):
self.create_axis(len(self.tiled_group))
self.context.fitting_context.plot_guess = True
self.context.fitting_context.guess_ws = None
self.model.plotted_fit_workspaces = ['ws1', 'ws2_guess', 'ws3_guess', 'ws4']
self.model.tiled_plot_positions = self.tiled_group
self.view.get_tiled_by_type.return_value = 'group'
self.presenter.handle_plot_guess_changed()
call_list = [mock.call('ws2_guess', self.view.get_axes()), mock.call('ws3_guess', self.view.get_axes())]
self.assertEqual(0, self.model.add_workspace_to_plot.call_count)
self.assertEqual(2, self.model.remove_workspace_from_plot.call_count)
self.model.remove_workspace_from_plot.assert_has_calls(call_list)
def test_that_sets_table_when_row_changes(self):
# Arrange
parent_presenter = create_run_tab_presenter_mock(use_fake_state=False)
view = create_mock_masking_table()
presenter = MaskingTablePresenter(parent_presenter)
# Act + Assert
presenter.set_view(view)
self.assertTrue(view.set_table.call_count == 1)
presenter.on_row_changed()
self.assertTrue(view.set_table.call_count == 2)
first_call = mock.call([])
second_call = mock.call([masking_information(first='Beam stop', second='', third='infinite-cylinder, r = 10.0'),
masking_information(first='Corners', second='', third='infinite-cylinder, r = 20.0'),
masking_information(first='Phi', second='', third='L/PHI -90.0 90.0')]) # noqa
view.set_table.assert_has_calls([first_call, second_call])
def test_algorithm_state_correct_when_created(self):
mock_view = MockCategoriesView()
CategoriesSettings(None, mock_view)
for category, state in algorithm_and_states.items():
if "\\" in category:
expected_calls = [
call(mock_view.algorithm_tree_widget,
category.split("\\")[-1], state, ANY)
]
else:
expected_calls = [
call(mock_view.algorithm_tree_widget,
category.split("\\")[-1], state)
]
mock_view.add_checked_widget_item.assert_has_calls(expected_calls)
def test_load_project_interfaces_call(self, loader):
loader.return_value.load_project.return_value = True
self.pr_loader._load_project_interfaces("")
self.assertEqual(loader.return_value.load_project.call_args, mock.call(file_name=self.pr.recovery_file_ext,
load_workspaces=False))
def test_exporting_multiple_plots_generates_correct_filename(self):
self.view.get_all_selected_plot_numbers = mock.Mock(return_value=[0, 1, 2])
self.view.get_directory_name_for_saving = mock.Mock(return_value='/home/Documents')
self.presenter.export_plots_called('.xyz')
for i in range(len(self.model.export_plot.mock_calls)):
self.assertEqual(self.model.export_plot.mock_calls[i],
mock.call(i, os.path.join('/home/Documents', 'Plot{}.xyz'.format(i+1))))
def test_that_uncheck_on_removed_blocks_signals_and_calls_right_function(self):
rem_lines = ['line Total', 'line Prompt', 'line 3']
calls = [mock.call(True), mock.call(False)]
self.gui.uncheck_detectors_if_no_line_plotted = mock.Mock()
tmp_detectors = copy.deepcopy(self.gui.detectors.detectors)
for detector in self.gui.detectors.detectors:
detector.isChecked.return_value = False
self.gui.uncheck_on_removed(rem_lines)
self.gui.lines.total.blockSignals.assert_has_calls(calls)
self.gui.lines.prompt.blockSignals.assert_has_calls(calls)
self.gui.lines.delayed.blockSignals.assert_has_calls([])
self.assertEqual(1, self.gui.uncheck_detectors_if_no_line_plotted.call_count)
self.gui.detectors.detectors = tmp_detectors
def test_load_current_setting_values(self, mock_ConfigService):
# load current setting is called automatically in the constructor
PlotSettings(None)
mock_ConfigService.getString.assert_has_calls([
call(PlotSettings.NORMALIZATION),
call(PlotSettings.SHOW_TITLE),
call(PlotSettings.DEFAULT_AXIS_SCALE),
call(PlotSettings.LINE_STYLE),
call(PlotSettings.LINE_WIDTH),
call(PlotSettings.ERROR_WIDTH),
call(PlotSettings.CAPSIZE),
call(PlotSettings.CAP_THICKNESS),
call(PlotSettings.ERROR_EVERY),
call(PlotSettings.IMAGE_SCALE)
])
def test_export_button_pressed(self):
for i in range(len(EXPORT_TYPES)):
self.view.export_button.menu().actions()[i].trigger()
for i in range(len(EXPORT_TYPES)):
self.assertEqual(self.presenter.export_plots_called.mock_calls[i],
mock.call(EXPORT_TYPES[i][1]))
def test_export_button_pressed(self):
for i in range(len(EXPORT_TYPES)):
self.view.export_button.menu().actions()[i].trigger()
for i in range(len(EXPORT_TYPES)):
self.assertEqual(self.presenter.export_plots_called.mock_calls[i],
mock.call(EXPORT_TYPES[i][1]))
def test_destroy(self, mock_gc_collect):
num = 0
mock_manager = MockFigureManager(num)
GlobalFigureManager.set_active(mock_manager)
self.assertEqual(1, len(GlobalFigureManager._activeQue))
self.assertEqual(1, len(GlobalFigureManager.figs))
with patch.object(GlobalFigureManager,
'notify_observers') as mock_notify_observers:
GlobalFigureManager.destroy(num)
self.assertEqual(0, len(GlobalFigureManager._activeQue))
self.assertEqual(0, len(GlobalFigureManager.figs))
mock_gc_collect.assert_called_once_with(1)
mock_notify_observers.assert_has_calls([
call(FigureAction.Closed, num),
call(FigureAction.OrderChanged, -1)
])
def test_browser_parameters_multi_multi(self):
assert (isinstance(self, TestFunctionBrowser))
browser = self.widget
browser.setFunction('name=FlatBackground;name=LinearBackground,A0=1')
view = browser.view()
user = BrowserUser(browser)
self.assertEqual(view.getNumberOfQtProperties(), 9)
browser.setNumberOfDatasets(3)
self.assertEqual(browser.getNumberOfDatasets(), 3)
fun_str = browser.getFitFunctionString()
self.assertGreater(len(fun_str), 0)
self.assertAlmostEquals(browser.getParameter('f0.A0'), 0.0)
self.assertAlmostEquals(browser.getParameter('f1.A0'), 1.0)
browser.setParameter('f0.A0', 2.2)
browser.setParameter('f1.A0', 3.3)
self.assertAlmostEquals(browser.getParameter('f0.A0'), 2.2)
self.assertAlmostEquals(browser.getParameter('f1.A0'), 3.3)
self.assertAlmostEquals(view.getParameter('f0.A0'), 2.2)
self.assertAlmostEquals(view.getParameter('f1.A0'), 3.3)
yield self.view_set_parameter('f1.A1', 5.5)
self.assertAlmostEquals(browser.getParameter('f1.A1'), 5.5)
self.assertAlmostEquals(view.getParameter('f1.A1'), 5.5)
self.assertGreater(user.parameter_changed.call_count, 0)
self.assertEqual(user.parameter_changed.call_args_list[-1],
call('f1.', 'A1'))
yield 0.1
def test_remove_line_type_calls_remove_line(self, mock_mantid):
self.gui.plot_window = mock.Mock()
self.gui.plotting = mock.Mock()
self.gui.plotting.get_subplots.return_value = ['1', '2']
mock_mantid.mtd = {
'2695; Detector 1': mock.Mock(),
'2695; Detector 2': mock.Mock(),
'2695; Detector 3': mock.Mock()
}
mock_mantid.mtd['2695; Detector 1'].name.return_value = '2695; Detector 1'
mock_mantid.mtd['2695; Detector 2'].name.return_value = '2695; Detector 2'
expected_calls = [mock.call('1', '2695; Detector 1', spec=spectrum_index['Total']),
mock.call('2', '2695; Detector 2', spec=spectrum_index['Total'])]
self.gui.remove_line_type(2695, 'Total')
self.assertEqual(1, self.gui.plotting.get_subplots.call_count)
self.gui.plotting.remove_line.assert_has_calls(expected_calls)
def test_open_selected_in_editor(self):
checkpoint = os.listdir(self.pid)[0]
self.prm.project_recovery.open_checkpoint_in_script_editor = mock.MagicMock()
self.prm.open_selected_in_editor(checkpoint)
self.assertEqual(1, self.prm.project_recovery.open_checkpoint_in_script_editor.call_count)
self.assertEqual(self.prm.project_recovery.open_checkpoint_in_script_editor.call_args,
mock.call(os.path.join(self.pid, checkpoint)))
def test_clear_plot_model_correctly_clears_model(self, mock_remove_workspace):
workspaces = ['test1', 'test2', 'test3']
fit_workspaces = ['test4']
axes = [mock.MagicMock()]
self.model.plotted_workspaces = workspaces
self.model.plotted_fit_workspaces = fit_workspaces
self.model.clear_plot_model(axes)
self.assertEqual(mock_remove_workspace.call_count, 4)
call_list = [mock.call(workspaces[0], axes),
mock.call(workspaces[1], axes),
mock.call(workspaces[2], axes),
mock.call(fit_workspaces[0], axes)]
mock_remove_workspace.assert_has_calls(call_list)
self.assertEqual(self.model.plotted_workspaces, [])
self.assertEqual(self.model.plotted_fit_workspaces, [])
def test_remove_line_type_calls_remove_line(self, mock_mantid):
self.gui.plot_window = mock.Mock()
self.gui.plotting = mock.Mock()
self.gui.plotting.get_subplots.return_value = ['1', '2']
mock_mantid.mtd = {
'2695; Detector 1': [mock.Mock(), mock.Mock()],
'2695; Detector 2': [mock.Mock(), mock.Mock()],
'2695; Detector 3': [mock.Mock(), mock.Mock()]
}
mock_mantid.mtd['2695; Detector 1'][0].getName.return_value = 'det1, ws1 Total'
mock_mantid.mtd['2695; Detector 1'][1].getName.return_value = 'det1, ws2'
mock_mantid.mtd['2695; Detector 2'][0].getName.return_value = 'det2, ws1'
mock_mantid.mtd['2695; Detector 2'][1].getName.return_value = 'det2, ws2 Total'
expected_calls = [mock.call('1', 'det1, ws1 Total'), mock.call('2', 'det2, ws2 Total')]
self.gui.remove_line_type(2695, 'Total')
self.assertEqual(1, self.gui.plotting.get_subplots.call_count)
self.gui.plotting.remove_line.assert_has_calls(expected_calls)
def test_right_click_gives_marker_menu_when_hovering_over_one(
self, mocked_figure_type, mocked_qmenu_cls):
mouse_event = self._create_mock_right_click()
mouse_event.inaxes.get_xlim.return_value = (1, 2)
mouse_event.inaxes.get_ylim.return_value = (1, 2)
mocked_figure_type.return_value = FigureType.Line
marker1 = MagicMock()
marker2 = MagicMock()
marker3 = MagicMock()
self.interactor.markers = [marker1, marker2, marker3]
for marker in self.interactor.markers:
marker.is_above.return_value = True
# Expect a call to QMenu() for the outer menu followed by two more calls
# for the Axes and Normalization menus
qmenu_call1 = MagicMock()
qmenu_call2 = MagicMock()
qmenu_call3 = MagicMock()
qmenu_call4 = MagicMock()
mocked_qmenu_cls.side_effect = [
qmenu_call1, qmenu_call2, qmenu_call3, qmenu_call4
]
with patch('workbench.plotting.figureinteraction.QActionGroup',
autospec=True):
with patch.object(self.interactor.toolbar_manager,
'is_tool_active', lambda: False):
with patch.object(self.interactor, 'add_error_bars_menu',
MagicMock()):
self.interactor.on_mouse_button_press(mouse_event)
self.assertEqual(0, qmenu_call1.addSeparator.call_count)
self.assertEqual(0, qmenu_call1.addAction.call_count)
expected_qmenu_calls = [
call(),
call(marker1.name, qmenu_call1),
call(marker2.name, qmenu_call1),
call(marker3.name, qmenu_call1)
]
self.assertEqual(expected_qmenu_calls,
mocked_qmenu_cls.call_args_list)
# 2 Actions in marker menu
self.assertEqual(2, qmenu_call2.addAction.call_count)
self.assertEqual(2, qmenu_call3.addAction.call_count)
self.assertEqual(2, qmenu_call4.addAction.call_count)
def test_that_add_line_by_type_plots_correct_lines_with_correct_colour(self, mock_mantid):
self.gui.plotting = mock.Mock()
self.gui.plot_window = mock.Mock()
self.gui.plotting.get_subplots.return_value = ['1', '2']
mock_mantid.mtd = {
'2695; Detector 1': mock.Mock(),
'2695; Detector 2': mock.Mock(),
'2695; Detector 3': mock.Mock()
}
mock_mantid.mtd['2695; Detector 1'].name.return_value = '2695; Detector 1'
mock_mantid.mtd['2695; Detector 2'].name.return_value = '2695; Detector 2'
expected_calls = [
mock.call('1', '2695; Detector 1', color='C0', spec_num=spectrum_index['Total']),
mock.call('2', '2695; Detector 2', color='C0', spec_num=spectrum_index['Total'])
]
self.gui.add_line_by_type(2695, 'Total')
self.assertEqual(1, self.gui.plotting.get_subplots.call_count)
self.gui.plotting.plot.assert_has_calls(expected_calls)
def test_save_workspaces_path_when_false(self, pwriter):
CreateSampleWorkspace(OutputWorkspace='ws1')
file_ext = '.recfile'
saver = projectsaver.ProjectSaver(file_ext)
saver.save_project(file_name=working_project_file, project_recovery=False)
self.assertEqual(pwriter.call_args, mock.call(interfaces_to_save=[], plots_to_save=[],
project_file_ext=file_ext, save_location=working_project_file,
workspace_names=['ws1']))
def test_export_context_menu(self):
plot_numbers = [0, 1, 2]
self.view.set_plot_list(plot_numbers)
for i in range(len(EXPORT_TYPES)):
self.view.export_menu.actions()[i].trigger()
for i in range(len(EXPORT_TYPES)):
self.assertEqual(self.presenter.export_plots_called.mock_calls[i],
mock.call(EXPORT_TYPES[i][1]))
def test_export_context_menu(self):
plot_numbers = [0, 1, 2]
self.view.set_plot_list(plot_numbers)
for i in range(len(EXPORT_TYPES)):
self.view.export_menu.actions()[i].trigger()
for i in range(len(EXPORT_TYPES)):
self.assertEqual(self.presenter.export_plots_called.mock_calls[i],
mock.call(EXPORT_TYPES[i][1]))
def test_save_layout(self, mock_CONF):
presenter = GeneralSettings(None, view=Mock())
# setup parent
mock_parent = Mock()
mock_parent.saveState.return_value = "value"
presenter.parent = mock_parent
# setup CONF.get returns dictionary
test_dict = {'a': 1}
mock_CONF.get = Mock(return_value=test_dict)
# setup mock commands
presenter.view.new_layout_name.text = Mock(return_value='key')
presenter.view.new_layout_name.clear = Mock()
presenter.save_layout()
calls = [call(presenter.USER_LAYOUT), call(presenter.USER_LAYOUT)]
mock_CONF.get.assert_has_calls(calls)
mock_parent.saveState.assert_called_once_with()
mock_parent.populate_layout_menu.assert_called_once_with()
def test_delete_layout(self, mock_CONF):
presenter = GeneralSettings(None, view=Mock())
# setup parent
mock_parent = Mock()
presenter.parent = mock_parent
# setup item selection
list_item = Mock()
list_item.text.return_value = 'a'
presenter.view.layout_display.currentItem = Mock(return_value=list_item)
# setup CONF.get returns dictionary
test_dict = {'a': 1}
mock_CONF.get = Mock(return_value=test_dict)
presenter.delete_layout()
calls = [call(presenter.USER_LAYOUT), call(presenter.USER_LAYOUT)]
mock_CONF.get.assert_has_calls(calls)
mock_CONF.set.assert_called_once_with(presenter.USER_LAYOUT, {})
mock_parent.populate_layout_menu.assert_called_once_with()
def test_do_action_plot_multiple_y_success(self, ws, view, twd):
col_as_x = 1
col_as_y1 = 2
col_as_y2 = 3
expected_x_data = twd.model.get_column(col_as_x)
expected_y1_data = twd.model.get_column(col_as_y1)
expected_y2_data = twd.model.get_column(col_as_y2)
view.mock_selection_model.selectedColumns.return_value = [
MockQModelIndex(1, col_as_x)
]
twd.action_set_as_x()
view.mock_selection_model.selectedColumns.return_value = [
MockQModelIndex(1, col_as_y1),
MockQModelIndex(1, col_as_y2)
]
twd.action_plot(PlotType.LINEAR)
twd.plot.subplots.assert_called_once_with(
subplot_kw={'projection': 'mantid'})
twd.plot.mock_fig.canvas.set_window_title.assert_called_once_with(
twd.model.get_name())
twd.plot.mock_ax.set_xlabel.assert_called_once_with(
twd.model.get_column_header(col_as_x))
col_y1_name = twd.model.get_column_header(col_as_y1)
col_y2_name = twd.model.get_column_header(col_as_y2)
twd.plot.mock_ax.set_ylabel.assert_has_calls(
[call(col_y1_name), call(col_y2_name)])
twd.plot.mock_ax.plot.assert_has_calls([
call(expected_x_data,
expected_y1_data,
label=TableWorkspaceDisplay.COLUMN_DISPLAY_LABEL.format(
col_y1_name)),
call(expected_x_data,
expected_y2_data,
label=TableWorkspaceDisplay.COLUMN_DISPLAY_LABEL.format(
col_y2_name))
])
twd.plot.mock_fig.show.assert_called_once_with()
twd.plot.mock_ax.legend.assert_called_once_with()
def test_get_algorithm_data(self):
model = AlgorithmSelectorModel(None)
names, descriptors = model.get_algorithm_data()
self.assertTrue(isinstance(names, list))
self.assertTrue(isinstance(descriptors, dict))
self.assertTrue('Load' in names)
self.assertTrue('Rebin' in names)
self.assertTrue('Rebin' in descriptors['Transform'][AlgorithmSelectorModel.algorithm_key])
self.assertTrue('Rebin' in descriptors['Transform']['Rebin'][AlgorithmSelectorModel.algorithm_key])
counter = Counter(names)
self.assertEqual(counter['Rebin'], 1)
self.assertEqual(counter['DoStuff'], 1)
self.assertEqual(mock_get_algorithm_descriptors.mock_calls[-1], call(False))
def test_right_click_gives_context_menu_for_plot_without_fit_enabled(self, mocked_figure_type,
mocked_qmenu_cls):
fig_manager = self._create_mock_fig_manager_to_accept_right_click()
fig_manager.fit_browser.tool = None
interactor = FigureInteraction(fig_manager)
mouse_event = self._create_mock_right_click()
mocked_figure_type.return_value = FigureType.Line
# Expect a call to QMenu() for the outer menu followed by a call with the first
# as its parent to generate the Axes menu.
qmenu_call1 = MagicMock()
qmenu_call2 = MagicMock()
mocked_qmenu_cls.side_effect = [qmenu_call1, qmenu_call2]
with patch('workbench.plotting.figureinteraction.QActionGroup',
autospec=True):
interactor.on_mouse_button_press(mouse_event)
self.assertEqual(0, qmenu_call1.addSeparator.call_count)
self.assertEqual(0, qmenu_call1.addAction.call_count)
expected_qmenu_calls = [call(), call("Axes", qmenu_call1)]
self.assertEqual(expected_qmenu_calls, mocked_qmenu_cls.call_args_list)
self.assertEqual(4, qmenu_call2.addAction.call_count)
def test_load_current_setting_values(self, mock_ConfigService, mock_CONF):
# load current setting is called automatically in the constructor
GeneralSettings(None)
# calls().__int__() are the calls to int() on the retrieved value from ConfigService.getString
mock_CONF.get.assert_has_calls([call(GeneralSettings.PROMPT_SAVE_ON_CLOSE),
call().__int__(),
call(GeneralSettings.PROMPT_SAVE_EDITOR_MODIFIED),
call().__int__()])
mock_ConfigService.getString.assert_has_calls([call(GeneralSettings.PR_RECOVERY_ENABLED),
call(GeneralSettings.PR_TIME_BETWEEN_RECOVERY),
call(GeneralSettings.PR_NUMBER_OF_CHECKPOINTS)])
def test_update_column_headers(self, ws, view, twd):
twd.update_column_headers()
# setColumnCount is done twice - once in the TableWorkspaceDisplay initialisation, and once in the call
# to update_column_headers above
view.setColumnCount.assert_has_calls([call(ws.ROWS), call(ws.ROWS)])
def test_action_hide_selected(self, ws, view, twd):
twd.action_hide_selected()
view.hideColumn.assert_has_calls([call(1), call(2), call(3)])
def test_action_plot_more_than_one_x(self, ws, view, twd):
view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, 1), MockQModelIndex(1, 2)]
twd.action_set_as_x()
twd.action_plot(PlotType.LINEAR)
view.mock_selection_model.selectedColumns.assert_has_calls([call(), call()])
view.show_warning.assert_called_once_with(TableWorkspaceDisplay.TOO_MANY_SELECTED_FOR_X)
def convert_list_to_calls(self, list_to_convert):
call_list = []
for item in list_to_convert:
call_list.append(mock.call(item))
return call_list
def test_include_hidden_algorithms(self):
model = AlgorithmSelectorModel(None, include_hidden=True)
model.get_algorithm_data()
self.assertEqual(mock_get_algorithm_descriptors.mock_calls[-1], call(True))
def test_open_script_in_editor(self):
self.pr_loader.recovery_presenter = mock.MagicMock()
self.pr_loader._open_script_in_editor_call = mock.MagicMock()
# Ensure a script file exists
script = os.path.join(self.working_directory, "script")
open(script, 'a').close()
self.pr_loader._open_script_in_editor(script)
self.assertEqual(self.pr_loader._open_script_in_editor_call.call_count, 1)
self.assertEqual(self.pr_loader.recovery_presenter.set_up_progress_bar.call_count, 1)
self.assertEqual(self.pr_loader.recovery_presenter.set_up_progress_bar.call_args, mock.call(0))
def test_hide_multiple_plots_calls_hide_in_model(self):
self.view.get_all_selected_plot_numbers = mock.Mock(return_value=[1, 2])
self.presenter.hide_selected_plots()
self.assertEquals(self.model.hide_plot.mock_calls[0], mock.call(1))
self.assertEquals(self.model.hide_plot.mock_calls[1], mock.call(2))
def test_show_multiple_plots_shows_them(self):
self.view.get_all_selected_plot_numbers = mock.Mock(return_value=[1, 2])
self.presenter.show_multiple_selected()
self.assertEqual(self.model.show_plot.mock_calls[0], mock.call(1))
self.assertEqual(self.model.show_plot.mock_calls[1], mock.call(2))
def test_spin_of_another_thread(self, timer):
self.pr_saver._spin_off_another_time_thread()
timer.assert_has_calls([mock.call().start()])
