def setup_some_checkpoints(self):
self.pr._spin_off_another_time_thread = mock.MagicMock()
directory = self.pr.recovery_directory_hostname
# Add a numbered folder for the pid
self.pid = os.path.join(directory, "3000000")
if not os.path.exists(self.pid):
os.makedirs(self.pid)
self.pr._recovery_directory_pid = self.pid
# Add 5 workspaces
for ii in range(0, 5):
CreateSampleWorkspace(OutputWorkspace=str(ii))
self.pr.saver._spin_off_another_time_thread = mock.MagicMock()
self.pr.recovery_save()
def setUp(self):
self.context = setup_context(True)
self.context.data_context.instrument = 'MUSR'
self.context.gui_context.update({'RebinType': 'None'})
self.model = maxent_model.MaxEntModel()
self.view = maxent_view_new.MaxEntView()
self.presenter = maxent_presenter_new.MaxEntPresenter(
self.view, self.context)
file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
ws, run, filename, _ = load_utils.load_workspace_from_filename(
file_path)
self.context.data_context._loaded_data.remove_data(run=run)
self.context.data_context._loaded_data.add_data(run=[run],
workspace=ws,
filename=filename,
instrument='MUSR')
self.context.data_context.current_runs = [[22725]]
self.context.update_current_data()
test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75)
self.context.group_pair_context.add_pair(pair=test_pair)
self.view.warning_popup = mock.MagicMock()
def test_get_parameters_for_tf_single_fit_calculation(self):
self.presenter.model.create_fitted_workspace_name.return_value = (
'workspace', 'workspace directory')
self.context.group_pair_context.get_unormalisised_workspace_list = mock.MagicMock(
return_value=[
'__MUSR22725; Group; top; Asymmetry_unnorm',
'__MUSR22725; Group; bottom; Asymmetry_unnorm',
'__MUSR22725; Group; fwd; Asymmetry_unnorm'
])
result = self.presenter.get_parameters_for_tf_single_fit_calculation()
self.assertEqual(
result, {
'EndX':
15.0,
'InputFunction':
None,
'Minimizer':
'Levenberg-Marquardt',
'OutputFitWorkspace':
'workspace',
'ReNormalizedWorkspaceList':
'',
'StartX':
0.0,
'UnNormalizedWorkspaceList':
'__MUSR22725; Group; top; Asymmetry_unnorm'
})
def test_handle_tf_asymmetry_mode_succesfully_converts_back_for_single_fit(
self):
new_workspace_list = [
'MUSR22725; Group; top; Asymmetry',
'MUSR22725; Group; bottom; Asymmetry', 'MUSR22725; Group; fwd; fwd'
]
self.presenter.selected_data = new_workspace_list
self.view.function_browser.setFunction(EXAMPLE_TF_ASYMMETRY_FUNCTION)
self.view.tf_asymmetry_mode_checkbox.blockSignals(True)
self.view.tf_asymmetry_mode = True
self.presenter._tf_asymmetry_mode = True
self.view.tf_asymmetry_mode_checkbox.blockSignals(False)
self.view.is_simul_fit = mock.MagicMock(return_value=False)
fit_function = FunctionFactory.createInitialized(
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0')
self.presenter.model.convert_to_tf_function.return_value = fit_function
self.view.tf_asymmetry_mode = False
self.assertEqual(
[str(item) for item in self.presenter._fit_function], [
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0',
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0',
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0'
])
def test_that_find_beam_centre_calls_centre_finder_twice_when_COM_is_TRUE(
self):
state = mock.MagicMock()
self.beam_centre_model.COM = True
self.beam_centre_model.find_beam_centre(state)
self.assertEqual(self.SANSCentreFinder.return_value.call_count, 2)
self.SANSCentreFinder.return_value.assert_called_with(
state,
r_min=self.beam_centre_model.r_min,
r_max=self.beam_centre_model.r_max,
max_iter=self.beam_centre_model.max_iterations,
x_start=self.result['pos1'],
y_start=self.result['pos2'],
tolerance=self.beam_centre_model.tolerance,
find_direction=FindDirectionEnum.ALL,
reduction_method=True,
verbose=False,
component=DetectorType.LAB)
self.SANSCentreFinder.return_value.assert_any_call(
state,
r_min=self.beam_centre_model.r_min,
r_max=self.beam_centre_model.r_max,
max_iter=self.beam_centre_model.max_iterations,
x_start=self.beam_centre_model.lab_pos_1,
y_start=self.beam_centre_model.lab_pos_2,
tolerance=self.beam_centre_model.tolerance,
find_direction=FindDirectionEnum.ALL,
reduction_method=False,
component=DetectorType.LAB)
def test_fit_clicked_with_simultaneous_selected_with_global_parameters(
self):
self.presenter.model.get_function_name.return_value = 'GausOsc'
self.presenter.get_workspace_selected_list = mock.MagicMock(
return_value=['Input Workspace Name_1', 'Input Workspace Name 2'])
self.view.function_browser.setFunction(
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0')
self.view.simul_fit_checkbox.setChecked(True)
self.view.function_browser.setGlobalParameters(['A'])
self.presenter.model.do_simultaneous_fit.return_value = (
self.view.function_browser.getGlobalFunction(), 'Fit Suceeded',
0.5)
self.view.fit_button.clicked.emit(True)
wait_for_thread(self.presenter.calculation_thread)
simultaneous_call_args = self.presenter.model.do_simultaneous_fit.call_args
call_args_dict = simultaneous_call_args[0][0]
self.assertEqual(call_args_dict['InputWorkspace'],
['Input Workspace Name_1', 'Input Workspace Name 2'])
self.assertEqual(call_args_dict['Minimizer'], 'Levenberg-Marquardt')
self.assertEqual(call_args_dict['StartX'], [0.0, 0.0])
self.assertEqual(call_args_dict['EndX'], [15.0, 15.0])
call_args_globals = simultaneous_call_args[0][1]
self.assertEqual(call_args_globals, ['A'])
def test_switching_to_simultaneous_keeps_stored_fit_functions_same_length(
self):
self.presenter.selected_data = [
'MUSR22725; Group; top; Asymmetry',
'MUSR22725; Group; bottom; Asymmetry',
'MUSR22725; Group; fwd; Asymmetry'
]
self.view.function_browser.setFunction(
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0')
self.presenter.get_workspace_selected_list = mock.MagicMock(
return_value=[
'MUSR22725; Group; top; Asymmetry',
'MUSR22725; Group; bottom; Asymmetry',
'MUSR22725; Group; fwd; Asymmetry'
])
self.view.simul_fit_checkbox.setChecked(True)
self.assertEqual(
str(self.view.fit_object),
'composite=MultiDomainFunction,NumDeriv=true;name=GausOsc,A=0.2,Sigma=0.2,'
'Frequency=0.1,Phi=0,$domains=i'
';name=GausOsc,A=0.2,Sigma=0.2,'
'Frequency=0.1,Phi=0,$domains=i;'
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0,$domains=i')
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 setUp(self):
self.view = mock.MagicMock()
self.model = {
'property_one': [2, True, True],
'property_two': [1, False, False]
}
self.presenter = ListSelectorPresenter(self.view, self.model)
def test_that_process_all_ignores_empty_rows(self):
view = mock.MagicMock()
view.get_selected_rows = mock.MagicMock(return_value=[0, 1])
self.presenter.set_view(view)
table_model = TableModel()
populated_row = RowEntries(sample_scatter=1)
table_model.append_table_entry(populated_row)
table_model.append_table_entry(RowEntries())
self.presenter._table_model = table_model
self.presenter._process_rows = mock.MagicMock()
self.presenter.on_process_selected_clicked()
self.presenter._process_rows.assert_called_with([populated_row])
def test_that_validate_output_modes_raises_if_no_file_types_selected_for_both_mode(
self):
view = mock.MagicMock()
view.save_types = [SaveType.NO_TYPE]
view.output_mode_memory_radio_button.isChecked = mock.MagicMock(
return_value=False)
view.output_mode_file_radio_button.isChecked = mock.MagicMock(
return_value=False)
view.output_mode_both_radio_button.isChecked = mock.MagicMock(
return_value=True)
self.presenter.set_view(view)
self.assertRaises(RuntimeError, self.presenter._validate_output_modes)
def test_that_period_columns_hidden_when_multi_period_is_false(self):
self.presenter.set_view(mock.MagicMock())
self.presenter.on_multiperiod_changed(False)
self.presenter._view.hide_period_columns.assert_called_once_with()
def test_that_all_columns_shown_when_multi_period_is_true(self):
self.presenter.set_view(mock.MagicMock())
self.presenter.on_multiperiod_changed(True)
self.presenter._view.show_period_columns.assert_called_once_with()
def test_do_sequential_fit_correctly_delegates_to_do_single_fit(self):
trial_function = FunctionFactory.createInitialized(
'name = Quadratic, A0 = 0, A1 = 0, A2 = 0')
self.model.do_single_fit = mock.MagicMock(return_value=(trial_function,
'success',
0.56))
x_data = range(0, 100)
y_data = [5 + x * x for x in x_data]
workspace = CreateWorkspace(x_data, y_data)
parameter_dict = {
'Function': trial_function,
'InputWorkspace': [workspace] * 5,
'Minimizer': 'Levenberg-Marquardt',
'StartX': [0.0] * 5,
'EndX': [100.0] * 5,
'EvaluationType': 'CentrePoint'
}
self.model.do_sequential_fit(parameter_dict)
self.assertEqual(self.model.do_single_fit.call_count, 5)
self.model.do_single_fit.assert_called_with({
'Function':
mock.ANY,
'InputWorkspace':
workspace,
'Minimizer':
'Levenberg-Marquardt',
'StartX':
0.0,
'EndX':
100.0,
'EvaluationType':
'CentrePoint'
})
def test_handle_calculation_started_and_handle_calculation_ended_called_correctly(
self):
self.presenter.handle_phase_table_calculation_started = mock.MagicMock(
)
self.presenter.handle_calculation_success = mock.MagicMock()
self.presenter.handle_calculation_error = mock.MagicMock()
self.presenter.calculate_phase_table = mock.MagicMock()
self.presenter.handle_calulate_phase_table_clicked()
self.wait_for_thread(self.presenter.calculation_thread)
self.presenter.handle_phase_table_calculation_started.assert_called_once_with(
)
self.presenter.handle_calculation_success.assert_called_once_with()
self.presenter.handle_calculation_error.assert_not_called()
self.presenter.calculate_phase_table.assert_called_once_with()
def test_adding_new_fit_updates_log_values(self):
existing_selection = {
'run_number': [0, False, True],
'run_start': [1, True, True]
}
self.mock_view.log_values.return_value = existing_selection
final_selection = {
'run_number': [0, False, True],
'run_start': [1, True, True],
'magnetic_field': [2, True, True]
}
self.mock_model.log_selection.return_value = final_selection
presenter = ResultsTabPresenter(self.mock_view, self.mock_model)
presenter._get_workspace_list = mock.MagicMock(return_value=(['ws1', 'ws3'], "func1"))
# previous test verifies this is correct on construction
self.mock_view.set_output_results_button_enabled.reset_mock()
presenter.on_new_fit_performed()
self.mock_view.log_values.assert_called_once_with()
self.mock_model.log_selection.assert_called_once_with(
existing_selection=existing_selection)
final_selection = {
'run_number': [0, False, True],
'run_start': [1, True, True],
'magnetic_field': [2, True, True]
}
self.mock_view.set_log_values.assert_called_once_with(final_selection)
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 = QtWidgets.QWidget()
setup_context_for_tests(self)
self.data_context.instrument = 'MUSR'
self.gui_context.update({'RebinType': 'None'})
self.model = maxent_model.MaxEntModel()
self.view = maxent_view_new.MaxEntView(self.obj)
self.presenter = maxent_presenter_new.MaxEntPresenter(self.view, self.context)
file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
ws, run, filename = load_utils.load_workspace_from_filename(file_path)
self.data_context._loaded_data.remove_data(run=run)
self.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR')
self.data_context.current_runs = [[22725]]
self.context.update_current_data()
test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75)
self.group_context.add_pair(pair=test_pair)
self.view.warning_popup = mock.MagicMock()
def test_create_text_from_dict(self):
fig = matplotlib.figure.Figure()
ax = matplotlib.axes.Axes(fig=fig, rect=[0, 0, 0, 0])
ax.text = mock.MagicMock()
self.plots_loader.create_text_from_dict(ax=ax,
dic={
"text": "text",
"position": (1, 1),
"useTeX": 1,
"style": {
"alpha": 1,
"textSize": 1,
"color": 1,
"hAlign": 1,
"vAlign": 1,
"rotation": 1,
"zOrder": 1
}
})
self.assertEqual(ax.text.call_count, 1)
ax.text.assert_called_once_with(fontdict={
u'zorder': 1,
u'fontsize': 1,
u'color': 1,
u'alpha': 1,
u'rotation': 1,
u'verticalalignment': 1,
u'usetex': 1,
u'horizontalalignment': 1
},
s=u'text',
x=1,
y=1)
def test_updating_function_parameters_updates_relevant_stored_function_for_simul_fit(
self):
self.presenter.selected_data = [
'MUSR22725; Group; top; Asymmetry',
'MUSR22725; Group; bottom; Asymmetry',
'MUSR22725; Group; fwd; Asymmetry'
]
self.view.is_simul_fit = mock.MagicMock(return_value=True)
fit_function = FunctionFactory.createInitialized(
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0')
multi_domain_function = create_multi_domain_function([fit_function] *
3)
self.view.function_browser.setFunction(EXAMPLE_MULTI_DOMAIN_FUNCTION)
self.view.parameter_display_combo.setCurrentIndex(1)
self.view.function_browser.setParameter('A', 3)
self.presenter.handle_function_parameter_changed()
self.assertEqual(
str(self.presenter._fit_function[0]),
'composite=MultiDomainFunction,NumDeriv=true;'
'name=GausOsc,'
'A=0.2,Sigma=0.2,Frequency=0.1,Phi=0,'
'$domains=i;name=GausOsc,A=3,Sigma=0.2,Frequency=0.1,'
'Phi=0,$domains=i;name=GausOsc,A=0.2,Sigma=0.2,'
'Frequency=0.1,Phi=0,$domains=i')
def test_compile_recovery_script(self):
# make sure to clear out the script if it exists
if os.path.exists(self.pr.recovery_order_workspace_history_file):
os.remove(self.pr.recovery_order_workspace_history_file)
# Create checkpoint
CreateSampleWorkspace(OutputWorkspace="ws")
self.pr.saver._spin_off_another_time_thread = mock.MagicMock()
self.pr.recovery_save()
# Find the checkpoint
checkpoints = os.listdir(self.pr.recovery_directory_pid)
checkpoint = os.path.join(self.pr.recovery_directory_pid, checkpoints[0])
self.pr_loader._compile_recovery_script(checkpoint)
self.assertTrue(os.path.exists(self.pr.recovery_order_workspace_history_file))
# Confirm contents is correct
with open(self.pr.recovery_order_workspace_history_file, 'r') as f:
actual_file_contents = f.read()
file_contents = ""
# Strip out the time
for ii in actual_file_contents:
if ii == '#':
break
file_contents += ii
self.assertEqual(file_contents,
"from mantid.simpleapi import *\n\nCreateSampleWorkspace(OutputWorkspace='ws') ")
def test_undo_fit_resets_fit_in_view(self):
self.presenter.selected_data = [
'MUSR22725; Group; top; Asymmetry',
'MUSR22725; Group; bottom; Asymmetry',
'MUSR22725; Group; fwd; Asymmetry'
]
self.view.function_browser.setFunction(
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0')
fit_function = FunctionFactory.createInitialized(
'name=GausOsc,A=0.5,Sigma=0.5,Frequency=1,Phi=0')
self.presenter.fitting_calculation_model = mock.MagicMock()
self.presenter.model.do_single_fit.return_value = (fit_function,
'Fit Succeeded',
0.5)
self.presenter.handle_fit_clicked()
wait_for_thread(self.presenter.calculation_thread)
# test fit has updated the function
self.assertEqual(str(self.presenter._fit_function[0]),
'name=GausOsc,A=0.5,Sigma=0.5,Frequency=1,Phi=0')
self.view.undo_fit_button.clicked.emit(True)
# test undo fit has worked
self.assertEqual(str(self.presenter._fit_function[0]),
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0')
def test_workspace_loader_load_workspaces_not_called_when_load_workspaces_is_false(self):
loader = projectloader.ProjectLoader('.recfile')
loader.workspace_loader = mock.MagicMock()
loader.load_project(working_directory, load_workspaces=False)
self.assertEqual(0, loader.workspace_loader.load_workspaces.call_count)
def test_handle_table_cell_changed_other_element(self):
mocked_table_item = mock.MagicMock()
mocked_table_item.checkState.return_value = 2
self.view.get_table_item.return_value = mocked_table_item
self.presenter.row_numbers = data_presenter.TwoWayRowDict()
self.presenter.row_numbers["name1"] = 0
self.presenter.row_numbers["name2"] = 1
model_dict = {"name1": "ws1", "name2": "ws2"}
self.model.get_loaded_workspaces.return_value = model_dict
self.presenter.plot_added_notifier = mock.MagicMock()
self.presenter.plot_removed_notifier = mock.MagicMock()
self.presenter._handle_table_cell_changed(1, 1)
self.assertEqual(0, self.presenter.plot_added_notifier.notify_subscribers.call_count)
self.assertEqual(0, self.presenter.plot_removed_notifier.notify_subscribers.call_count)
def test_equality_with_globals(self):
parameter_workspace = mock.MagicMock()
fit_params1 = FitParameters(parameter_workspace, ['A'])
parameter_workspace = parameter_workspace
fit_params2 = FitParameters(parameter_workspace, ['A'])
self.assertEqual(fit_params1, fit_params2)
def test_add_maxent_workspace_to_ADS(self, workspace_wrapper_mock):
self.presenter.getWorkspaceNames()
self.context.dead_time_table = mock.MagicMock(return_value='deadtime_table_name')
self.context.first_good_data = mock.MagicMock(return_value=0.11)
self.context.last_good_data = mock.MagicMock(return_value=13.25)
self.context.phase_context.phase_tables = [create_workspace_wrapper_stub_object(x) for x in
['MUSR22222_phase_table', 'MUSR33333_phase_table',
'EMU22222_phase_table']]
self.presenter.update_phase_table_options()
maxent_workspace = mock.MagicMock(spec=Workspace)
self.presenter.add_maxent_workspace_to_ADS('MUSR22725_MaxEnt', maxent_workspace, mock.MagicMock())
workspace_wrapper_mock.assert_called_once_with(maxent_workspace,
'Muon Data/MUSR22725 MA/MUSR22725 Maxent MA/MUSR22725_MaxEnt; MaxEnt')
workspace_wrapper_mock.return_value.show.assert_called_once_with()
def setUp(self):
self.obj = QWidget()
setup_context_for_tests(self)
self.gui_variable_observer = Observer()
self.gui_context.gui_variables_notifier.add_subscriber(
self.gui_variable_observer)
self.data_context.instrument = 'MUSR'
self.view = InstrumentWidgetView(self.obj)
self.view.set_instrument('MUSR', block=True)
self.model = InstrumentWidgetModel(self.context)
self.presenter = InstrumentWidgetPresenter(self.view, self.model)
self.view.warning_popup = mock.MagicMock()
self.view.instrument_changed_warning = mock.MagicMock(return_value=1)
self.gui_variable_observer.update = mock.MagicMock()
def test_when_new_data_is_selected_clear_out_old_fits_and_information(
self):
self.presenter._fit_status = ['success', 'success', 'success']
self.presenter._fit_chi_squared = [12.3, 3.4, 0.35]
fit_function = FunctionFactory.createInitialized(
'name=GausOsc,A=0.2,Sigma=0.2,Frequency=0.1,Phi=0')
self.presenter_fit_function = [
fit_function, fit_function, fit_function
]
self.presenter.manual_selection_made = True
self.presenter._start_x = [0.15, 0.45, 0.67]
self.presenter._end_x = [0.56, 0.78, 0.34]
self.view.end_time = 0.56
self.view.start_time = 0.15
self.presenter.retrieve_first_good_data_from_run_name = mock.MagicMock(
return_value=0.15)
new_workspace_list = [
'MUSR22725; Group; top; Asymmetry',
'MUSR22725; Group; bottom; Asymmetry',
'MUSR22725; Group; fwd; Asymmetry'
]
self.presenter.selected_data = new_workspace_list
self.assertEqual(self.presenter._fit_status, [None, None, None])
self.assertEqual(self.presenter._fit_chi_squared, [0.0, 0.0, 0.0])
self.assertEqual(self.presenter._fit_function, [None, None, None])
self.assertEqual(self.presenter._selected_data, new_workspace_list)
self.assertEqual(self.presenter.manual_selection_made, True)
self.assertEqual(self.presenter.start_x, [0.15, 0.15, 0.15])
self.assertEqual(self.presenter.end_x, [0.56, 0.56, 0.56])
def test_removing_from_ads_calls_any_change_handle(self):
CreateSampleWorkspace(OutputWorkspace="ws1")
self.project.anyChangeHandle = mock.MagicMock()
ADS.remove("ws1")
self.assertEqual(1, self.project.anyChangeHandle.call_count)
def test_handle_fit_completed_adds_appropriate_fits_to_plot(self):
self.model.plotted_workspaces = self.workspace_list
self.model.plotted_workspaces_inverse_binning = {}
fit_information = FitInformation(
mock.MagicMock(), 'GaussOsc',
['MUSR62260; Group; bottom; Asymmetry; MA'],
['MUSR62260; Group; bottom; Asymmetry; MA; Fitted;'])
self.context.fitting_context.fit_list.__getitem__.return_value = fit_information
self.context.fitting_context.number_of_fits = 1
self.presenter.handle_fit_completed(fit_information)
self.assertEqual(self.model.add_workspace_to_plot.call_count, 2)
# check fit and diff workspaces plotted
self.model.add_workspace_to_plot.assert_any_call(
self.view.get_axes()[0],
'MUSR62260; Group; bottom; Asymmetry; MA; Fitted;', [1],
errors=False,
plot_kwargs=mock.ANY)
self.model.add_workspace_to_plot.assert_called_with(
self.view.get_axes()[0],
'MUSR62260; Group; bottom; Asymmetry; MA; Fitted;', [2],
errors=False,
plot_kwargs=mock.ANY)
def test_handle_sequential_fit_finished_updates_view(self):
number_of_entries = 3
fit_functions = [
FunctionFactory.createInitialized('name=GausOsc,A=0.2,'
'Sigma=0.2,Frequency=0.1,Phi=1')
] * number_of_entries
fit_status = ['Success'] * number_of_entries
fit_quality = [1.3, 2.4, 1.9]
self.presenter.fitting_calculation_model = mock.MagicMock()
self.presenter.fitting_calculation_model.result = (fit_functions,
fit_status,
fit_quality)
self.presenter.handle_seq_fit_finished()
self.assertEqual(self.view.set_fit_function_parameters.call_count,
number_of_entries)
call_list = [
mock.call(0, [0.2, 0.2, 0.1, 1]),
mock.call(1, [0.2, 0.2, 0.1, 1]),
mock.call(2, [0.2, 0.2, 0.1, 1])
]
self.view.set_fit_function_parameters.assert_has_calls(call_list)
self.assertEqual(self.view.set_fit_quality.call_count,
number_of_entries)
call_list = [
mock.call(0, 'Success', fit_quality[0]),
mock.call(1, 'Success', fit_quality[1]),
mock.call(2, 'Success', fit_quality[2])
]
self.view.set_fit_quality.assert_has_calls(call_list)
self.view.seq_fit_button.setEnabled.assert_called_once_with(True)
