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()])