def setUp(self):
# Store an empty widget to parent all the views, and ensure they are deleted correctly
self.obj = QWidget()
setup_context_for_tests(self)
self.view = LoadRunWidgetView(parent=self.obj)
self.model = LoadRunWidgetModel(self.loaded_data, self.context)
self.presenter = LoadRunWidgetPresenter(self.view, self.model)
self.view.warning_popup = mock.Mock()
self.presenter.set_current_instrument("EMU")
patcher = mock.patch(
'Muon.GUI.Common.load_run_widget.load_run_model.load_utils')
self.addCleanup(patcher.stop)
self.load_utils_patcher = patcher.start()
self.load_utils_patcher.exception_message_for_failed_files.return_value = ''
file_finder_patcher = mock.patch(
'Muon.GUI.Common.load_run_widget.load_run_presenter.FileFinder')
self.addCleanup(file_finder_patcher.stop)
file_finder_patcher.start()
self.load_single_run()
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 setUp(self):
self.notify_progress = mock.MagicMock()
self.notify_done = mock.MagicMock()
self.notify_error = mock.MagicMock()
self.sans_batch_instance = mock.MagicMock()
self.sans_batch_instance.return_value = (mock.MagicMock(),
mock.MagicMock())
batch_patcher = mock.patch(
'sans.gui_logic.models.batch_process_runner.SANSBatchReduction')
self.addCleanup(batch_patcher.stop)
self.batch_mock = batch_patcher.start()
self.batch_mock.return_value = self.sans_batch_instance
load_patcher = mock.patch(
'sans.gui_logic.models.batch_process_runner.load_workspaces_from_states'
)
self.addCleanup(load_patcher.stop)
self.load_mock = load_patcher.start()
self.batch_process_runner = BatchProcessRunner(self.notify_progress,
self.notify_done,
self.notify_error)
self.states = {
0: mock.MagicMock(),
1: mock.MagicMock(),
2: mock.MagicMock()
}
def setUp(self):
self.logger_mock_instance = mock.MagicMock()
logger_patcher = mock.patch(
'ErrorReporter.error_report_presenter.Logger')
self.addCleanup(logger_patcher.stop)
self.logger_mock = logger_patcher.start()
self.logger_mock.return_value = self.logger_mock_instance
self.errorreport_mock_instance = mock.MagicMock()
errorreport_patcher = mock.patch(
'ErrorReporter.error_report_presenter.ErrorReporter')
self.addCleanup(errorreport_patcher.stop)
self.errorreport_mock = errorreport_patcher.start()
self.errorreport_mock.return_value = self.errorreport_mock_instance
zip_recovery_patcher = mock.patch(
'ErrorReporter.error_report_presenter.zip_recovery_directory')
self.addCleanup(zip_recovery_patcher.stop)
self.zip_recovery_mock = zip_recovery_patcher.start()
self.zip_recovery_mock.return_value = ('zipped_file', 'file_hash')
self.view = mock.MagicMock()
self.exit_code = 255
self.error_report_presenter = ErrorReporterPresenter(
self.view, self.exit_code)
def setUp(self):
self.model_patcher = mock.patch(RESULTS_TAB_MODEL_CLS, autospec=True)
self.view_patcher = mock.patch(RESULTS_TAB_VIEW_CLS, autospec=True)
self.mock_model = self.model_patcher.start()
self.mock_view = self.view_patcher.start()
self.mock_view.function_selection_changed.connect = mock.MagicMock()
self.mock_view.results_name_edited.connect = mock.MagicMock()
self.mock_view.output_results_requested.connect = mock.MagicMock()
def test_open_file_in_new_tab_no_import_added(self):
test_string = "Test file\n"
widget = MultiPythonFileInterpreter()
mock_open_func = mock.mock_open(read_data=test_string)
with mock.patch(widget.__module__ + '.open', mock_open_func, create=True):
with mock.patch(PERMISSION_BOX_FUNC, lambda: True):
widget.open_file_in_new_tab(test_string)
self.assertNotIn(MANTID_API_IMPORT,
widget.current_editor().editor.text())
def setUp(self):
# Store an empty widget to parent all the views, and ensure they are deleted correctly
self.obj = QWidget()
setup_context_for_tests(self)
self.context.instrument = 'EMU'
self.load_file_view = BrowseFileWidgetView(self.obj)
self.load_run_view = LoadRunWidgetView(self.obj)
self.load_file_model = BrowseFileWidgetModel(self.loaded_data,
self.context)
self.load_run_model = LoadRunWidgetModel(self.loaded_data,
self.context)
self.presenter = LoadWidgetPresenter(
LoadWidgetView(parent=self.obj,
load_file_view=self.load_file_view,
load_run_view=self.load_run_view),
LoadWidgetModel(self.loaded_data, self.context))
self.presenter.set_load_file_widget(
BrowseFileWidgetPresenter(self.load_file_view,
self.load_file_model))
self.presenter.set_load_run_widget(
LoadRunWidgetPresenter(self.load_run_view, self.load_run_model))
self.filepath = FileFinder.findRuns('MUSR00022725.nxs')[0]
self.load_patcher = mock.patch(
'Muon.GUI.Common.load_file_widget.model.load_utils.load_workspace_from_filename'
)
self.addCleanup(self.load_patcher.stop)
self.load_mock = self.load_patcher.start()
self.load_run_patcher = mock.patch(
'Muon.GUI.Common.load_run_widget.load_run_model.load_utils.load_workspace_from_filename'
)
self.addCleanup(self.load_run_patcher.stop)
self.load_run_mock = self.load_run_patcher.start()
self.mock_workspace = self.create_fake_workspace(1)
self.mock_loading_from_browse(self.mock_workspace,
"C:\dir1\dir2\dir3\EMU0001234.nxs", 1234)
file_utils.get_current_run_filename = mock.Mock(
return_value="C:\dir1\dir2\dir3\EMU0001234.nxs")
self.presenter.load_file_widget._view.warning_popup = mock.MagicMock()
self.presenter.load_run_widget._view.warning_popup = mock.MagicMock()
self.popup_patcher = mock.patch('Muon.GUI.Common.thread_model.warning')
self.addCleanup(self.popup_patcher.stop)
self.popup_mock = self.popup_patcher.start()
def setGroupAndPairsToEmptyList(grouping_context):
grouping_context._groups = []
grouping_context._pairs = []
self.group_context.reset_group_and_pairs_to_default = mock.MagicMock(
side_effect=setGroupAndPairsToEmptyList(self.group_context))
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_open_file_in_new_tab_import_added(self):
test_string = "Test file\nLoad()"
widget = MultiPythonFileInterpreter()
mock_open_func = mock.mock_open(read_data=test_string)
with mock.patch(widget.__module__ + '.open', mock_open_func, create=True):
with mock.patch(PERMISSION_BOX_FUNC, lambda: True):
widget.open_file_in_new_tab(test_string)
self.assertEqual(widget.current_editor().editor.isModified(), True,
msg="Script not marked as modified.")
self.assertIn(MANTID_API_IMPORT, widget.current_editor().editor.text(),
msg="'simpleapi' import not added to script.")
def test_open_file_in_new_tab_no_import_added(self):
test_string = "Test file\n"
widget = MultiPythonFileInterpreter()
mock_open_func = mock.mock_open(read_data=test_string)
with mock.patch(widget.__module__ + '.open',
mock_open_func,
create=True):
with mock.patch(PERMISSION_BOX_FUNC, lambda: True):
widget.open_file_in_new_tab(test_string)
self.assertNotIn(MANTID_API_IMPORT,
widget.current_editor().editor.text())
def setUp(self):
self._qapp = mock_widget.mockQapp()
# Store an empty widget to parent all the views, and ensure they are deleted correctly
self.obj = QtGui.QWidget()
self.popup_patcher = mock.patch('Muon.GUI.Common.thread_model.warning')
self.addCleanup(self.popup_patcher.stop)
self.popup_mock = self.popup_patcher.start()
self.load_patcher = mock.patch('Muon.GUI.Common.load_file_widget.model.load_utils.load_workspace_from_filename')
self.addCleanup(self.load_patcher.stop)
self.load_mock = self.load_patcher.start()
self.load_run_patcher = mock.patch(
'Muon.GUI.Common.load_run_widget.load_run_model.load_utils.load_workspace_from_filename')
self.addCleanup(self.load_run_patcher.stop)
self.load_run_mock = self.load_run_patcher.start()
setup_context_for_tests(self)
self.data_context.instrument = 'EMU'
self.load_file_view = BrowseFileWidgetView(self.obj)
self.load_run_view = LoadRunWidgetView(self.obj)
self.load_file_model = BrowseFileWidgetModel(self.loaded_data, self.context)
self.load_run_model = LoadRunWidgetModel(self.loaded_data, self.context)
self.model = LoadWidgetModel(self.loaded_data, self.context)
self.view = LoadWidgetView(parent=self.obj, load_run_view=self.load_run_view,
load_file_view=self.load_file_view)
self.presenter = LoadWidgetPresenter(view=self.view, model=self.model)
self.presenter.set_load_file_widget(BrowseFileWidgetPresenter(self.load_file_view, self.load_file_model))
self.presenter.set_load_run_widget(LoadRunWidgetPresenter(self.load_run_view, self.load_run_model))
self.presenter.load_run_widget.set_current_instrument('EMU')
self.presenter.load_file_widget._view.warning_popup = mock.MagicMock()
self.presenter.load_run_widget._view.warning_popup = mock.MagicMock()
self.load_file_view.show_file_browser_and_return_selection = mock.Mock(
return_value=["C:\\dir1\\EMU0001234.nxs"])
self.workspace_mock = self.create_fake_workspace(1)
self.load_mock.return_value = (self.workspace_mock, 1234, "C:\\dir1\\EMU0001234.nxs")
self.load_run_mock.return_value = (self.workspace_mock, 1234, "C:\\dir1\\EMU0001234.nxs")
self.presenter.load_file_widget.on_browse_button_clicked()
self.wait_for_thread(self.presenter.load_file_widget._load_thread)
self.mock_loading_to_throw()
file_utils.get_current_run_filename = mock.Mock(return_value="EMU0001234.nxs")
def test_add_line_errors(self):
ws = mock.MagicMock()
self.context.change_errors(True)
lines = line()
with mock.patch("mantid.plots.plotfunctions.plot") as plot:
plot.return_value = tuple([lines])
with mock.patch("mantid.plots.plotfunctions.errorbar") as patch:
patch.return_value = errors()
self.context.addLine(ws, 3)
self.assertEqual(plot.call_count, 1)
self.assertEqual(patch.call_count, 1)
patch.assert_called_with(self.subplot,
ws,
specNum=3,
distribution=True)
def test_open_file_in_new_tab_import_added(self):
test_string = "Test file\nLoad()"
widget = MultiPythonFileInterpreter()
mock_open_func = mock.mock_open(read_data=test_string)
with mock.patch(widget.__module__ + '.open',
mock_open_func,
create=True):
with mock.patch(PERMISSION_BOX_FUNC, lambda: True):
widget.open_file_in_new_tab(test_string)
self.assertEqual(widget.current_editor().editor.isModified(),
True,
msg="Script not marked as modified.")
self.assertIn(MANTID_API_IMPORT,
widget.current_editor().editor.text(),
msg="'simpleapi' import not added to script.")
def setUp(self):
# Store an empty widget to parent all the views, and ensure they are deleted correctly
self.obj = QWidget()
setup_context_for_tests(self)
self.data_context.instrument = 'EMU'
self.view = LoadRunWidgetView(parent=self.obj)
self.model = LoadRunWidgetModel(self.loaded_data, self.context)
self.presenter = LoadRunWidgetPresenter(self.view, self.model)
self.model.load_workspace_from_filename = mock.Mock(
return_value=([1, 2, 3], "currentRun.nxs", 1234, False))
self.view.warning_popup = mock.Mock()
self.view.disable_load_buttons = mock.Mock()
self.view.enable_load_buttons = mock.Mock()
self.presenter.set_current_instrument("EMU")
fileUtils.get_current_run_filename = mock.Mock(
return_value="EMU0001234.nxs")
patcher = mock.patch(
'Muon.GUI.Common.load_run_widget.load_run_model.load_utils')
self.addCleanup(patcher.stop)
self.load_utils_patcher = patcher.start()
self.load_utils_patcher.exception_message_for_failed_files.return_value = ''
def setUp(self):
self._qapp = mock_widget.mockQapp()
# Store an empty widget to parent all the views, and ensure they are deleted correctly
self.obj = QtGui.QWidget()
setup_context_for_tests(self)
self.data_context.instrument = 'EMU'
self.view = LoadRunWidgetView(parent=self.obj)
self.model = LoadRunWidgetModel(self.loaded_data, self.context)
self.presenter = LoadRunWidgetPresenter(self.view, self.model)
self.model.load_workspace_from_filename = mock.Mock(return_value=([1, 2, 3], "currentRun.nxs", 1234))
self.view.warning_popup = mock.Mock()
self.view.disable_load_buttons = mock.Mock()
self.view.enable_load_buttons = mock.Mock()
self.presenter.set_current_instrument("EMU")
fileUtils.get_current_run_filename = mock.Mock(return_value="EMU0001234.nxs")
patcher = mock.patch('Muon.GUI.Common.load_run_widget.load_run_model.load_utils')
self.addCleanup(patcher.stop)
self.load_utils_patcher = patcher.start()
self.load_utils_patcher.exception_message_for_failed_files.return_value = ''
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 setUp(self):
self._qapp = mock_widget.mockQapp()
self.view = BrowseFileWidgetView()
self.view.on_browse_clicked = mock.Mock()
self.view.set_file_edit = mock.Mock()
self.view.reset_edit_to_cached_value = mock.Mock()
self.view.show_file_browser_and_return_selection = mock.Mock(
return_value=["C:/dir1/file1.nxs", "C:/dir2/file2.nxs"])
setup_context_for_tests(self)
self.data_context.instrument = 'EMU'
self.model = BrowseFileWidgetModel(self.loaded_data, self.context)
self.model.exception_message_for_failed_files = mock.Mock()
self.view.disable_load_buttons = mock.Mock()
self.view.enable_load_buttons = mock.Mock()
self.view.warning_popup = mock.Mock()
self.presenter = BrowseFileWidgetPresenter(self.view, self.model)
patcher = mock.patch(
'Muon.GUI.Common.load_file_widget.model.load_utils.load_workspace_from_filename'
)
self.addCleanup(patcher.stop)
self.load_utils_patcher = patcher.start()
self.load_utils_patcher.return_value = (self.create_fake_workspace(1),
'22222', 'filename')
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_run_dialog_opens_on_execute_button_click(self):
with patch(createDialogFromName_func_name) as createDialog:
widget = AlgorithmSelectorWidget()
self._select_in_tree(widget, 'DoStuff v.2')
widget.execute_button.click()
createDialog.assert_called_once_with('DoStuff', 2, None, False, {},
'', [])
def test_run_dialog_opens_on_return_press(self):
with patch(createDialogFromName_func_name) as createDialog:
widget = AlgorithmSelectorWidget()
self._select_in_tree(widget, 'DoStuff v.2')
QTest.keyClick(widget.search_box, Qt.Key_Return)
createDialog.assert_called_once_with('DoStuff', 2, None, False, {},
'', [])
def test_process_calls_find_good_peaks(self):
with mock.patch(
'plugins.algorithms.WorkflowAlgorithms.FindPeaksAutomatic.CreateWorkspace'
) as mock_create_ws:
mock_create_ws.return_value = self.data_ws
self.alg_instance.find_good_peaks = mock.Mock()
self.alg_instance.process(self.x_values,
self.y_values,
raw_error=np.sqrt(self.y_values),
acceptance=0,
average_window=50,
bad_peak_to_consider=2,
use_poisson=False,
peak_width_estimate=5,
fit_to_baseline=False,
prog_reporter=mock.Mock())
base = self.alg_instance.average(self.y_values, 50)
base += self.alg_instance.average(self.y_values - base, 50)
flat = self.y_values - base
self.assertEqual(1, self.alg_instance.find_good_peaks.call_count)
self.alg_instance.find_good_peaks.asser_called_with(
self.x_values,
flat,
acceptance=0,
bad_peak_to_consider=2,
use_poisson=False,
fit_ws=self.data_ws,
peak_width_estimate=5)
def test_replace_incorrect_workspace(self, ws, view, presenter):
with patch(
'mantidqt.widgets.workspacedisplay.table.presenter.TableWorkspaceDisplay.load_data'
) as mock_load_data:
presenter.replace_workspace(ws.TEST_NAME + "123", ws)
self.assertNotCalled(mock_load_data)
self.assertNotCalled(view.emit_repaint)
def test_replaceWS(self):
ws = mock.Mock()
ws2 = mock.Mock()
ws.name = mock.Mock(return_value="test")
ws2.name = mock.Mock(return_value="not used")
self.context.redraw = mock.Mock()
with mock.patch("mantid.plots.plotfunctions.plot") as patch:
patch.return_value = tuple([line()])
self.context.addLine(ws, 3)
self.context.addLine(ws2, 3)
# check inital set up
keys = self.context.ws.keys()
expect = [ws, ws2]
for key in expect:
self.assertIn(key, keys)
self.assertEqual(len(keys), len(expect))
# do the method
redraw = self.context.replace_ws(ws)
self.assertEqual(redraw, True)
new_keys = self.context.ws.keys()
for key in expect:
self.assertIn(key, new_keys)
self.assertEqual(len(new_keys), len(expect))
self.assertEqual(self.context.ws[ws], ["test"])
def setUp(self):
self._qapp = QApplication.instance()
patcher = mock.patch('Muon.GUI.Common.thread_model.warning')
self.addCleanup(patcher.stop)
self.warning_box_patcher = patcher.start()
self.model = testModel()
self.thread = ThreadModel(self.model)
def test_that_preserves_empty_data(self):
scriptElement = TOFTOFScriptElement()
scriptElement.reset()
self.setupWidget.set_state(scriptElement)
with mock.patch(
'reduction_gui.reduction.toftof.toftof_reduction.TOFTOFScriptElement.reset'
):
scriptElement2 = self.setupWidget.get_state()
scriptElement.facility_name = self.settingsMock.facility_name
scriptElement.instrument_name = self.settingsMock.instrument_name
for name in dir(scriptElement):
attr1 = getattr(scriptElement, name)
try:
attr2 = getattr(scriptElement2, name)
except AttributeError:
self.fail(
"TOFTOFSetupWidget.get_state() doesn't set the attribute '{}'"
.format(name))
if not name.startswith('__') and not hasattr(attr1, '__call__'):
self.assertEqual(
attr1, attr2,
"TOFTOFSetupWidget doesn't preserve state of attribute '{}'"
.format(name))
def setUp(self):
self.logger_mock_instance = mock.MagicMock()
logger_patcher = mock.patch('ErrorReporter.error_report_presenter.Logger')
self.addCleanup(logger_patcher.stop)
self.logger_mock = logger_patcher.start()
self.logger_mock.return_value = self.logger_mock_instance
self.errorreport_mock_instance = mock.MagicMock()
errorreport_patcher = mock.patch('ErrorReporter.error_report_presenter.ErrorReporter')
self.addCleanup(errorreport_patcher.stop)
self.errorreport_mock = errorreport_patcher.start()
self.errorreport_mock.return_value = self.errorreport_mock_instance
self.view = mock.MagicMock()
self.exit_code = 255
self.error_report_presenter = ErrorReporterPresenter(self.view, self.exit_code)
def test_loading_does_not_insert_invalid_groups(self):
self.view.show_file_browser_and_return_selection = mock.Mock(
return_value="grouping.xml")
groups = [
MuonGroup(group_name="grp1", detector_ids=[1, 2, 3, 4, 5]),
MuonGroup(group_name="grp2", detector_ids=[6, 7, 8, 9, 1000])
]
pairs = [
MuonPair(pair_name="pair1",
forward_group_name="grp1",
backward_group_name="grp2")
]
with mock.patch(
"Muon.GUI.Common.grouping_tab_widget.grouping_tab_widget_presenter.xml_utils.load_grouping_from_XML"
) as mock_load:
# mock the loading to return set groups/pairs
mock_load.return_value = (groups, pairs, 'description', 'pair1')
self.view.load_grouping_button.clicked.emit(True)
self.view.display_warning_box.assert_called_once_with(
'Invalid detectors in group grp2')
six.assertCountEqual(self, self.model.group_names, ["grp1"])
six.assertCountEqual(self, self.model.pair_names, [])
self.assertEqual(self.grouping_table_view.num_rows(), 1)
self.assertEqual(self.pairing_table_view.num_rows(), 0)
def test_mantid_api_import_needed(self):
expected_results = [False, False, True, False, False, True, False,
False, False]
with mock.patch(PERMISSION_BOX_FUNC, lambda: True):
for case, expected_out in zip(self.test_cases, expected_results):
self.assertEqual(expected_out, mantid_api_import_needed(case),
msg=self.gen_fail_msg(case, expected_out))
def test_that_load_grouping_inserts_loaded_groups_and_pairs_correctly(
self):
self.view.show_file_browser_and_return_selection = mock.Mock(
return_value="grouping.xml")
groups = [
MuonGroup(group_name="grp1", detector_ids=[1, 2, 3, 4, 5]),
MuonGroup(group_name="grp2", detector_ids=[6, 7, 8, 9, 10])
]
pairs = [
MuonPair(pair_name="pair1",
forward_group_name="grp1",
backward_group_name="grp2")
]
with mock.patch(
"Muon.GUI.Common.grouping_tab_widget.grouping_tab_widget_presenter.xml_utils.load_grouping_from_XML"
) as mock_load:
# mock the loading to return set groups/pairs
mock_load.return_value = (groups, pairs, 'description', 'pair1')
self.view.load_grouping_button.clicked.emit(True)
six.assertCountEqual(self, self.model.group_names,
["grp1", "grp2"])
six.assertCountEqual(self, self.model.pair_names, ["pair1"])
self.assertEqual(self.grouping_table_view.num_rows(), 2)
self.assertEqual(self.pairing_table_view.num_rows(), 1)
self.assertEqual(
self.pairing_table_view.pairing_table.cellWidget(
0, 1).currentText(), "grp1")
self.assertEqual(
self.pairing_table_view.pairing_table.cellWidget(
0, 2).currentText(), "grp2")
def test_add_line_no_erros(self):
ws = mock.MagicMock()
with mock.patch("mantid.plots.plotfunctions.plot") as patch:
patch.return_value = tuple([line()])
self.context.addLine(ws, 3)
self.assertEqual(patch.call_count, 1)
patch.assert_called_with(self.subplot, ws, specNum=3)
def setUp(self):
self._qapp = mock_widget.mockQapp()
self.view = BrowseFileWidgetView()
self.view.on_browse_clicked = mock.Mock()
self.view.set_file_edit = mock.Mock()
self.view.reset_edit_to_cached_value = mock.Mock()
self.view.show_file_browser_and_return_selection = mock.Mock(
return_value=["C:/dir1/file1.nxs", "C:/dir2/file2.nxs"])
setup_context_for_tests(self)
self.data_context.instrument = 'EMU'
self.model = BrowseFileWidgetModel(self.loaded_data, self.context)
self.model.exception_message_for_failed_files = mock.Mock()
self.view.disable_load_buttons = mock.Mock()
self.view.enable_load_buttons = mock.Mock()
self.view.warning_popup = mock.Mock()
self.presenter = BrowseFileWidgetPresenter(self.view, self.model)
patcher = mock.patch('Muon.GUI.Common.load_file_widget.model.load_utils')
self.addCleanup(patcher.stop)
self.load_utils_patcher = patcher.start()
def test_fit_function_is_called_correctly_when_given_multiple_peaks(self):
with mock.patch(
'plugins.algorithms.WorkflowAlgorithms.FitGaussianPeaks.Fit'
) as mock_fit:
self.alg_instance.estimate_single_parameters = mock.Mock(
return_value=[1, 2, 3])
self.alg_instance.getPropertyValue = mock.Mock(return_value='ws')
ret_ws = CreateWorkspace(DataX=[1, 2, 3, 4],
DataY=[5, 6, 7, 8],
NSpec=2)
mock_fit.return_value = (None, None, None, 'parameters', ret_ws,
None, None)
yvals, params = self.alg_instance.general_fit(
self.x_values, self.y_values, [10, 20])
self.assertEqual(params, 'parameters')
np.testing.assert_equal(yvals, [7, 8])
mock_fit.assert_called_with(
Function='name=Gaussian,PeakCentre=1,Height=2,Sigma=3;'
'name=Gaussian,PeakCentre=1,Height=2,Sigma=3;',
InputWorkspace=None,
Output='fit_result',
Minimizer='Levenberg-MarquardtMD',
OutputCompositeMembers=True,
StartX=min(self.x_values),
EndX=max(self.x_values),
Constraints=
'0.900000<f0.PeakCentre<1.100000,1.768245<f0.Height<2.161188,0.000000<f0.Sigma<30,'
'1.800000<f1.PeakCentre<2.200000,2.236669<f1.Height<2.733706,0.000000<f1.Sigma<30,',
StoreInADS=False)
def test_plot(self):
with mock.patch("MultiPlotting.subplot.subplot.subplot.plot") as patch:
ws = mock.MagicMock()
subplotName = "test"
specNum = 4
self.widget.plot(subplotName, ws, specNum)
patch.assert_called_with(subplotName, ws, specNum=specNum)
self.assertEqual(patch.call_count,1)
def test_replace(self, ws, view, presenter):
# patch this out after the constructor of the presenter has finished,
# so that we reset any calls it might have made
with patch(
'mantidqt.widgets.workspacedisplay.table.presenter.TableWorkspaceDisplay.load_data') as mock_load_data:
presenter.replace_workspace(ws.TEST_NAME, ws)
mock_load_data.assert_called_once_with(view)
view.emit_repaint.assert_called_once_with()
def test_plot(self):
with mock.patch("MultiPlotting.subplot.subplot.subplot.plot") as patch:
ws = mock.MagicMock()
subplotName = "test"
specNum = 4
self.widget.plot(subplotName, ws, specNum)
patch.assert_called_with(subplotName, ws, specNum=specNum)
self.assertEquals(patch.call_count,1)
def setUp(self):
self.notify_progress = mock.MagicMock()
self.notify_done = mock.MagicMock()
self.notify_error = mock.MagicMock()
self.sans_batch_instance = mock.MagicMock()
self.sans_batch_instance.return_value = (mock.MagicMock(), mock.MagicMock())
batch_patcher = mock.patch('sans.gui_logic.models.batch_process_runner.SANSBatchReduction')
self.addCleanup(batch_patcher.stop)
self.batch_mock = batch_patcher.start()
self.batch_mock.return_value = self.sans_batch_instance
load_patcher = mock.patch('sans.gui_logic.models.batch_process_runner.load_workspaces_from_states')
self.addCleanup(load_patcher.stop)
self.load_mock = load_patcher.start()
self.batch_process_runner = BatchProcessRunner(self.notify_progress, self.notify_done, self.notify_error)
self.states = {0: mock.MagicMock(), 1: mock.MagicMock(), 2: mock.MagicMock()}
def test_replace(self, ws, view, presenter):
# patch this out after the constructor of the presenter has finished,
# so that we reset any calls it might have made
with patch(
'mantidqt.widgets.workspacedisplay.table.presenter.TableWorkspaceDisplay.load_data'
) as mock_load_data:
presenter.replace_workspace(ws.TEST_NAME, ws)
mock_load_data.assert_called_once_with(view)
view.emit_repaint.assert_called_once_with()
def test_action_sort_peaks_ws(self, ws, view, twd, mock_SortPeaksWorkspace):
view.mock_selection_model.selectedColumns = Mock(return_value=[MockQModelIndex(0, 0)])
ascending = True
with patch('mantidqt.widgets.workspacedisplay.table.model.TableWorkspaceDisplayModel.is_peaks_workspace',
return_value=True) as mock_is_peaks_workspace:
twd.action_sort(ascending)
mock_SortPeaksWorkspace.assert_called_once_with(InputWorkspace=twd.model.ws, OutputWorkspace=twd.model.ws,
ColumnNameToSortBy="col0", SortAscending=ascending)
mock_is_peaks_workspace.assert_called_once_with()
def test_exception(self):
def testing_function(widget):
raise RuntimeError('')
with patch('traceback.print_exc') as print_exc:
tester = ModalTester(QInputDialog, testing_function)
tester.start()
print_exc.assert_called_once_with()
self.assertFalse(tester.widget.isVisible())
self.assertFalse(tester.passed)
def test_run_dialog_opens_on_double_click(self):
with patch(createDialogFromName_func_name) as createDialog:
widget = AlgorithmSelectorWidget()
self._select_in_tree(widget, 'Load v.1')
selected_item = widget.tree.selectedItems()[0]
item_pos = widget.tree.visualItemRect(selected_item).center()
QTest.mouseDClick(widget.tree.viewport(), Qt.LeftButton,
Qt.NoModifier, pos=item_pos)
createDialog.assert_called_once_with('Load', 1)
def test_exception(self):
def testing_function(widget):
raise RuntimeError('')
with patch('traceback.print_exc') as print_exc:
tester = ModalTester(QInputDialog, testing_function)
tester.start()
print_exc.assert_called_once_with()
self.assertFalse(tester.widget.isVisible())
self.assertFalse(tester.passed)
def test_mask_file_for_existing_file(self):
tmp_file = tempfile.NamedTemporaryFile(mode='r')
file_name = os.path.basename(tmp_file.name)
with mock.patch(
'sans.command_interface.ISISCommandInterface.find_full_file_path'
) as mocked_finder:
mocked_finder.return_value = tmp_file.name
self.assertIsNone(MaskFile(file_name))
def test_that_save_grouping_triggers_the_correct_function(self):
# Save functionality is tested elsewhere
self.view.show_file_save_browser_and_return_selection = mock.Mock(return_value="grouping.xml")
with mock.patch(
"Muon.GUI.Common.grouping_tab_widget.grouping_tab_widget_presenter.xml_utils.save_grouping_to_XML") as mock_save:
self.view.save_grouping_button.clicked.emit(True)
self.assertEqual(mock_save.call_count, 1)
self.assertEqual(mock_save.call_args[0][-1], "grouping.xml")
def test_add_line_1(self):
specNum = 4
ws = mock.MagicMock()
# add mock subplot
subplot = mock.MagicMock()
self.subplot = mock.create_autospec(subplotContext)
with mock.patch("MultiPlotting.subplot.subplot_context.subplotContext.addLine") as patch:
self.context.addSubplot("one",subplot)
self.context.addLine("one",ws,specNum)
self.assertEquals(patch.call_count,1)
patch.assert_called_with(ws,specNum)
def test_fail_widget_open(self):
def testing_function(widget):
widget.setTextValue('Hello World!')
text = widget.textValue()
self.assertEqual(text, '')
with patch('traceback.print_exc') as print_exc:
tester = ModalTester(QInputDialog, testing_function)
tester.start()
print_exc.assert_called_once_with()
self.assertFalse(tester.widget.isVisible())
self.assertFalse(tester.passed)
def test_connected_receiver_receives_text(self):
with patch("sys.stdout") as mock_stdout:
mock_stdout.fileno.return_value = -1
recv = Receiver()
writer = WriteToSignal(mock_stdout)
writer.sig_write_received.connect(recv.capture_text)
txt = "I expect to see this"
writer.write(txt)
QCoreApplication.processEvents()
self.assertEqual(txt, recv.captured_txt)
mock_stdout.fileno.assert_called_once_with()
def test_exception_in_creator(self):
def create():
raise RuntimeError('')
def testing_function(widget):
pass
with patch('traceback.print_exc') as print_exc:
tester = ModalTester(create, testing_function)
tester.start()
print_exc.assert_called_once_with()
self.assertTrue(tester.widget is None)
self.assertFalse(tester.passed)
def setUp(self):
# patch away getting a real icon as it can hit a race condition when running tests
# in parallel
patcher = mock.patch('mantidqt.dialogs.spectraselectordialog.get_icon')
self._mock_get_icon = patcher.start()
self._mock_get_icon.return_value = QIcon()
self.addCleanup(patcher.stop)
if self._single_spec_ws is None:
self.__class__._single_spec_ws = WorkspaceFactory.Instance().create("Workspace2D", NVectors=1,
XLength=1, YLength=1)
self.__class__._multi_spec_ws = WorkspaceFactory.Instance().create("Workspace2D", NVectors=200,
XLength=1, YLength=1)
def setUp(self):
self.logger_mock_instance = mock.MagicMock()
logger_patcher = mock.patch('ErrorReporter.error_report_presenter.Logger')
self.addCleanup(logger_patcher.stop)
self.logger_mock = logger_patcher.start()
self.logger_mock.return_value = self.logger_mock_instance
self.errorreport_mock_instance = mock.MagicMock()
errorreport_patcher = mock.patch('ErrorReporter.error_report_presenter.ErrorReporter')
self.addCleanup(errorreport_patcher.stop)
self.errorreport_mock = errorreport_patcher.start()
self.errorreport_mock.return_value = self.errorreport_mock_instance
zip_recovery_patcher = mock.patch('ErrorReporter.error_report_presenter.zip_recovery_directory')
self.addCleanup(zip_recovery_patcher.stop)
self.zip_recovery_mock = zip_recovery_patcher.start()
self.zip_recovery_mock.return_value = ('zipped_file', 'file_hash')
self.view = mock.MagicMock()
self.exit_code = 255
self.error_report_presenter = ErrorReporterPresenter(self.view, self.exit_code)
def setUp(self):
self.presenter = mock.Mock(spec=PlotSelectorPresenter)
self.presenter.get_plot_name_from_number = mock.Mock(side_effect=self.se_plot_name)
self.presenter.get_initial_last_active_value = mock.Mock(side_effect=self.se_get_initial_last_active_value)
self.presenter.is_shown_by_filter = mock.Mock(side_effect=self.se_is_shown_by_filter)
patcher = mock.patch('workbench.widgets.plotselector.view.get_icon')
self.mock_get_icon = patcher.start()
self.mock_get_icon.return_value = QIcon()
self.addCleanup(patcher.stop)
self.view = PlotSelectorView(self.presenter)
self.view.table_widget.setSortingEnabled(False)
def setUp(self):
self._qapp = mock_widget.mockQapp()
# Store an empty widget to parent all the views, and ensure they are deleted correctly
self.obj = QtGui.QWidget()
setup_context_for_tests(self)
self.context.instrument = 'EMU'
self.load_file_view = BrowseFileWidgetView(self.obj)
self.load_run_view = LoadRunWidgetView(self.obj)
self.load_file_model = BrowseFileWidgetModel(self.loaded_data, self.context)
self.load_run_model = LoadRunWidgetModel(self.loaded_data, self.context)
self.presenter = LoadWidgetPresenter(
LoadWidgetView(parent=self.obj, load_file_view=self.load_file_view, load_run_view=self.load_run_view),
LoadWidgetModel(self.loaded_data, self.context))
self.presenter.set_load_file_widget(BrowseFileWidgetPresenter(self.load_file_view, self.load_file_model))
self.presenter.set_load_run_widget(LoadRunWidgetPresenter(self.load_run_view, self.load_run_model))
self.filepath = FileFinder.findRuns('MUSR00022725.nxs')[0]
self.load_patcher = mock.patch('Muon.GUI.Common.load_file_widget.model.load_utils.load_workspace_from_filename')
self.addCleanup(self.load_patcher.stop)
self.load_mock = self.load_patcher.start()
self.load_run_patcher = mock.patch(
'Muon.GUI.Common.load_run_widget.load_run_model.load_utils.load_workspace_from_filename')
self.addCleanup(self.load_run_patcher.stop)
self.load_run_mock = self.load_run_patcher.start()
self.mock_workspace = self.create_fake_workspace(1)
self.mock_loading_from_browse(self.mock_workspace, "C:\dir1\dir2\dir3\EMU0001234.nxs", 1234)
file_utils.get_current_run_filename = mock.Mock(return_value="C:\dir1\dir2\dir3\EMU0001234.nxs")
self.presenter.load_file_widget._view.warning_popup = mock.MagicMock()
self.presenter.load_run_widget._view.warning_popup = mock.MagicMock()
self.popup_patcher = mock.patch('Muon.GUI.Common.thread_model.warning')
self.addCleanup(self.popup_patcher.stop)
self.popup_mock = self.popup_patcher.start()
def test_updateLayout(self):
# add mocks
figure = mock.Mock()
self.subplot = mock.create_autospec(subplotContext)
names = ["one","two","three"]
for name in names:
self.context.addSubplot(name, mock.Mock())
gridspec = mock.Mock()
self.context._gridspec = gridspec
with mock.patch("MultiPlotting.subplot.subplot_context.subplotContext.update_gridspec") as patch:
self.context.update_layout(figure)
self.assertEquals(patch.call_count,3)
# only last iteration survives
patch.assert_called_with(gridspec,figure,2)
def setUp(self):
self._qapp = mock_widget.mockQapp()
setup_context_for_tests(self)
self.data_context.instrument = 'EMU'
self.view = BrowseFileWidgetView()
self.model = BrowseFileWidgetModel(self.loaded_data, self.context)
self.view.disable_load_buttons = mock.Mock()
self.view.enable_load_buttons = mock.Mock()
self.view.warning_popup = mock.Mock()
self.presenter = BrowseFileWidgetPresenter(self.view, self.model)
patcher = mock.patch('Muon.GUI.Common.load_file_widget.model.load_utils')
self.addCleanup(patcher.stop)
self.load_utils_patcher = patcher.start()
def test_loading_does_not_insert_invalid_groups(self):
self.view.show_file_browser_and_return_selection = mock.Mock(return_value="grouping.xml")
groups = [MuonGroup(group_name="grp1", detector_ids=[1, 2, 3, 4, 5]),
MuonGroup(group_name="grp2", detector_ids=[6, 7, 8, 9, 1000])]
pairs = [MuonPair(pair_name="pair1", forward_group_name="grp1", backward_group_name="grp2")]
with mock.patch(
"Muon.GUI.Common.grouping_tab_widget.grouping_tab_widget_presenter.xml_utils.load_grouping_from_XML") as mock_load:
# mock the loading to return set groups/pairs
mock_load.return_value = (groups, pairs, 'description')
self.view.load_grouping_button.clicked.emit(True)
self.view.display_warning_box.assert_called_once_with('Invalid detectors in group grp2')
six.assertCountEqual(self, self.model.group_names, ["grp1"])
six.assertCountEqual(self, self.model.pair_names, [])
self.assertEqual(self.grouping_table_view.num_rows(), 1)
self.assertEqual(self.pairing_table_view.num_rows(), 0)
def test_that_load_grouping_inserts_loaded_groups_and_pairs_correctly(self):
self.view.show_file_browser_and_return_selection = mock.Mock(return_value="grouping.xml")
groups = [MuonGroup(group_name="grp1", detector_ids=[1, 2, 3, 4, 5]),
MuonGroup(group_name="grp2", detector_ids=[6, 7, 8, 9, 10])]
pairs = [MuonPair(pair_name="pair1", forward_group_name="grp1", backward_group_name="grp2")]
with mock.patch(
"Muon.GUI.Common.grouping_tab_widget.grouping_tab_widget_presenter.xml_utils.load_grouping_from_XML") as mock_load:
# mock the loading to return set groups/pairs
mock_load.return_value = (groups, pairs, 'description')
self.view.load_grouping_button.clicked.emit(True)
six.assertCountEqual(self, self.model.group_names, ["grp1", "grp2"])
six.assertCountEqual(self, self.model.pair_names, ["pair1"])
self.assertEqual(self.grouping_table_view.num_rows(), 2)
self.assertEqual(self.pairing_table_view.num_rows(), 1)
self.assertEqual(self.pairing_table_view.pairing_table.cellWidget(0, 1).currentText(), "grp1")
self.assertEqual(self.pairing_table_view.pairing_table.cellWidget(0, 2).currentText(), "grp2")
def setUp(self):
self._qapp = mock_widget.mockQapp()
# Store an empty widget to parent all the views, and ensure they are deleted correctly
self.obj = QtGui.QWidget()
setup_context_for_tests(self)
self.view = LoadRunWidgetView(parent=self.obj)
self.model = LoadRunWidgetModel(self.loaded_data, self.context)
self.presenter = LoadRunWidgetPresenter(self.view, self.model)
self.view.warning_popup = mock.Mock()
self.presenter.set_current_instrument("EMU")
patcher = mock.patch('Muon.GUI.Common.load_run_widget.load_run_model.load_utils')
self.addCleanup(patcher.stop)
self.load_utils_patcher = patcher.start()
self.load_utils_patcher.exception_message_for_failed_files.return_value = ''
self.load_single_run()
def test_that_preserves_empty_data(self):
scriptElement = TOFTOFScriptElement()
scriptElement.reset()
self.setupWidget.set_state(scriptElement)
with mock.patch('reduction_gui.reduction.toftof.toftof_reduction.TOFTOFScriptElement.reset'):
scriptElement2 = self.setupWidget.get_state()
scriptElement.facility_name = self.settingsMock.facility_name
scriptElement.instrument_name = self.settingsMock.instrument_name
for name in dir(scriptElement):
attr1 = getattr(scriptElement, name)
try:
attr2 = getattr(scriptElement2, name)
except AttributeError:
self.fail("TOFTOFSetupWidget.get_state() doesn't set the attribute '{}'".format(name))
if not name.startswith('__') and not hasattr(attr1, '__call__'):
self.assertEqual(attr1, attr2, "TOFTOFSetupWidget doesn't preserve state of attribute '{}'".format(name))
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_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_that_preserves_data(self):
scriptElement = TOFTOFScriptElement()
scriptElement.reset()
scriptElement.facility_name = 'nonsense'
scriptElement.instrument_name = 'The 5th nonSense'
# prefix of (some) workspace names
scriptElement.prefix = 'ws'
# data files are here
scriptElement.dataDir = ''
# vanadium runs & comment
scriptElement.vanRuns = 'TOFTOFTestdata.nxs'
scriptElement.vanCmnt = 'vanadium comment'
scriptElement.vanTemp = OptionalFloat(None)
# empty can runs, comment, and factor
scriptElement.ecRuns = 'TOFTOFTestdata.nxs'
scriptElement.ecTemp = OptionalFloat(21.0)
scriptElement.ecFactor = 0.9
# data runs: [(runs,comment, temperature), ...]
scriptElement.dataRuns = [
[unicode('TOFTOFTestdata.nxs'), unicode('H2O 21C'), OptionalFloat(None)],
[unicode('TOFTOFTestdata.nxs'), unicode('H2O 34C'), OptionalFloat(34.0)]
]
# additional parameters
scriptElement.binEon = True
scriptElement.binEstart = -1.0
scriptElement.binEstep = 0.4
scriptElement.binEend = 1.8
scriptElement.binQon = True
scriptElement.binQstart = 0.4
scriptElement.binQstep = 0.2
scriptElement.binQend = 1.0
scriptElement.maskDetectors = '1,2'
# options
scriptElement.subtractECVan = True
scriptElement.normalise = TOFTOFScriptElement.NORM_MONITOR
scriptElement.correctTof = TOFTOFScriptElement.CORR_TOF_VAN
scriptElement.replaceNaNs = True
scriptElement.createDiff = True
scriptElement.keepSteps = True
# save data
scriptElement.saveDir = ''
scriptElement.saveSofTWNxspe = False
scriptElement.saveSofTWNexus = True
scriptElement.saveSofTWAscii = True
scriptElement.saveSofQWNexus = False
scriptElement.saveSofQWAscii = True
self.setupWidget.set_state(scriptElement)
with mock.patch('reduction_gui.reduction.toftof.toftof_reduction.TOFTOFScriptElement.reset'):
scriptElement2 = self.setupWidget.get_state()
scriptElement.facility_name = self.settingsMock.facility_name
scriptElement.instrument_name = self.settingsMock.instrument_name
for name in dir(scriptElement):
attr1 = getattr(scriptElement, name)
try:
attr2 = getattr(scriptElement2, name)
except AttributeError:
self.fail("TOFTOFSetupWidget.get_state() doesn't set the attribute '{}'".format(name))
if not name.startswith('__') and not hasattr(attr1, '__call__'):
self.assertEqual(attr1, attr2, "TOFTOFSetupWidget doesn't preserve state of attribute '{}'".format(name))
