def test_action_replace(self, view, presenter, editor):
        editor.hasSelectedText = Mock(return_value=True)
        editor.selectedText = Mock(return_value=self.default_search_string)

        presenter.action_replace()

        editor.replace.assert_called_once_with("apples")
Ejemplo n.º 2
0
 def __init__(self, has_selection=True):
     self.hasSelection = Mock(return_value=has_selection)
     self.selectedRows = None
     self.selectedColumns = None
     self.currentIndex = None
     self.mock_selection = MockQSelection()
     self.selection = Mock(return_value=self.mock_selection)
    def test_data_tooltip_role_monitor_row(self):
        if not qtpy.PYQT5:
            self.skipTest(
                "QVariant cannot be instantiated in QT4, and the test fails with an error."
            )
        ws, model, row, index = setup_common_for_test_data()

        # necessary otherwise it is returned that there is a masked bin, and we get the wrong output
        ws.hasMaskedBins = Mock(return_value=False)

        model.ws_spectrum_info.isMasked = Mock(return_value=False)
        model.ws_spectrum_info.isMonitor = Mock(return_value=True)

        output = model.data(index, Qt.ToolTipRole)

        model.ws_spectrum_info.hasDetectors.assert_has_calls(
            [call.do_work(row), call.do_work(row)])
        model.ws_spectrum_info.isMasked.assert_called_once_with(row)
        model.ws_spectrum_info.isMonitor.assert_called_once_with(row)

        self.assertEqual(MatrixWorkspaceTableViewModel.MONITOR_ROW_STRING,
                         output)

        # Doing the same thing a second time should hit the cache, so no additional calls will have been made
        output = model.data(index, Qt.ToolTipRole)
        model.ws_spectrum_info.hasDetectors.assert_has_calls(
            [call.do_work(row), call.do_work(row)])
        self.assertEqual(2, model.ws_spectrum_info.isMasked.call_count)
        # This was called only once because the monitor was cached
        model.ws_spectrum_info.isMonitor.assert_called_once_with(row)

        self.assertEqual(MatrixWorkspaceTableViewModel.MONITOR_ROW_STRING,
                         output)
    def test_data_tooltip_role_masked_monitor_row(self):
        if not qtpy.PYQT5:
            self.skipTest(
                "QVariant cannot be instantiated in QT4, and the test fails with an error."
            )
        ws, model, row, index = setup_common_for_test_data()

        model.ws_spectrum_info.isMasked = Mock(return_value=True)
        model.ws_spectrum_info.isMonitor = Mock(return_value=True)

        output = model.data(index, Qt.ToolTipRole)

        model.ws_spectrum_info.hasDetectors.assert_has_calls(
            [call.do_work(row), call.do_work(row)])
        model.ws_spectrum_info.isMasked.assert_called_once_with(row)
        model.ws_spectrum_info.isMonitor.assert_called_once_with(row)

        self.assertEqual(
            MatrixWorkspaceTableViewModel.MASKED_MONITOR_ROW_STRING, output)

        # Doing the same thing a second time should hit the cache, so no additional calls will have been made
        output = model.data(index, Qt.ToolTipRole)
        model.ws_spectrum_info.hasDetectors.assert_has_calls(
            [call.do_work(row), call.do_work(row)])
        model.ws_spectrum_info.isMasked.assert_called_once_with(row)
        model.ws_spectrum_info.isMonitor.assert_called_once_with(row)

        self.assertEqual(
            MatrixWorkspaceTableViewModel.MASKED_MONITOR_ROW_STRING, output)
    def test_data_tooltip_role_masked_bin(self):
        if not qtpy.PYQT5:
            self.skipTest(
                "QVariant cannot be instantiated in QT4, and the test fails with an error."
            )

        ws, model, row, index = setup_common_for_test_data()

        model.ws_spectrum_info.isMasked = Mock(return_value=False)
        model.ws_spectrum_info.isMonitor = Mock(return_value=False)
        ws.hasMaskedBins = Mock(return_value=True)
        ws.maskedBinsIndices = Mock(return_value=[index.column()])

        output = model.data(index, Qt.ToolTipRole)

        model.ws_spectrum_info.hasDetectors.assert_has_calls(
            [call.do_work(row), call.do_work(row)])
        model.ws_spectrum_info.isMasked.assert_called_once_with(row)
        model.ws_spectrum_info.isMonitor.assert_called_once_with(row)

        self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_BIN_STRING,
                         output)

        # Doing the same thing a second time should hit the cache, so no additional calls will have been made
        output = model.data(index, Qt.ToolTipRole)
        self.assertEqual(4, model.ws_spectrum_info.hasDetectors.call_count)
        self.assertEqual(2, model.ws_spectrum_info.isMasked.call_count)
        self.assertEqual(2, model.ws_spectrum_info.isMonitor.call_count)
        # This was called only once because the monitor was cached
        ws.hasMaskedBins.assert_called_once_with(row)
        ws.maskedBinsIndices.assert_called_once_with(row)

        self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_BIN_STRING,
                         output)
    def test_data_tooltip_role_masked_row(self):
        if not qtpy.PYQT5:
            self.skipTest(
                "QVariant cannot be instantiated in QT4, and the test fails with an error."
            )
        ws, model, row, index = setup_common_for_test_data()

        model.ws_spectrum_info.hasDetectors = Mock(return_value=True)
        model.ws_spectrum_info.isMasked = Mock(return_value=True)
        model.ws_spectrum_info.isMonitor = Mock(return_value=False)

        output = model.data(index, Qt.ToolTipRole)

        model.ws_spectrum_info.hasDetectors.assert_has_calls(
            [call.do_work(row), call.do_work(row)])
        model.ws_spectrum_info.isMasked.assert_called_once_with(row)
        model.ws_spectrum_info.isMonitor.assert_called_once_with(row)

        self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_ROW_STRING,
                         output)

        output = model.data(index, Qt.ToolTipRole)

        # The row was masked so it should have been cached
        model.ws_spectrum_info.isMasked.assert_called_once_with(row)

        # However it is checked if it is a monitor again
        self.assertEqual(3, model.ws_spectrum_info.hasDetectors.call_count)
        self.assertEqual(2, model.ws_spectrum_info.isMonitor.call_count)

        self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_ROW_STRING,
                         output)
Ejemplo n.º 7
0
    def setUpClass(cls):
        # Mock axes tab view
        mock_axes_view = Mock(
            get_selected_ax_name=lambda: '(0, 0)',
            get_properties=lambda: AxProperties(new_ax_view_props))
        cls.ax_view_patch = patch(AX_VIEW, lambda x: mock_axes_view)
        cls.ax_view_mock = cls.ax_view_patch.start()

        # Mock curves tab view
        cls.curve_view_mock = Mock(
            get_selected_curve_name=lambda: 'old label',
            get_selected_ax_name=lambda: '(0, 0)',
            get_properties=lambda: CurveProperties(new_curve_view_props))
        cls.curve_view_patch = patch(CURVE_VIEW, lambda x: cls.curve_view_mock)
        cls.curve_view_patch.start()

        cls.ax = _run_apply_properties_on_figure_with_curve()
        cls.new_curve = cls.ax.containers[0]

        # Mock images tab view
        cls.img_view_mock = Mock(
            get_selected_image_name=lambda: '(0, 0) - old label',
            get_properties=lambda: ImageProperties(new_image_props))
        cls.img_view_patch = patch(IMAGE_VIEW, lambda x: cls.img_view_mock)
        cls.img_view_patch.start()

        cls.img_ax = _run_apply_properties_on_figure_with_image()
        cls.new_img = cls.img_ax.images[0]
 def __init__(self):
     self.addChild = StrictMock()
     self.childCount = Mock(return_value=0)
     self.setCheckState = Mock()
     self.parent = Mock(return_value=False)
     self.childCount = Mock(return_value=1)
     self.child = Mock(return_value=MockQTreeWidgetChildItem(self))
Ejemplo n.º 9
0
 def __init__(self, _):
     self.close_signal = MockQtSignal()
     self.rename_signal = MockQtSignal()
     self.presenter = Mock()
     self.presenter.clear_observer = Mock()
     self.setWindowTitle = Mock()
     self.deleteLater = Mock()
        def wrapper(self, view, presenter, editor):
            view.find.currentText = Mock(return_value=search_string)
            if replace_string is not None:
                view.replace = Mock()
                view.replace.currentText = Mock(return_value=replace_string)

            return func(self, view, presenter, editor)
    def test_data_background_role_monitor_row(self):
        ws, model, row, index = setup_common_for_test_data()

        model.ws_spectrum_info.isMasked = Mock(return_value=False)
        model.ws_spectrum_info.isMonitor = Mock(return_value=True)

        output = model.data(index, Qt.BackgroundRole)

        model.ws_spectrum_info.hasDetectors.assert_called_with(row)
        model.ws_spectrum_info.isMasked.assert_called_once_with(row)
        model.ws_spectrum_info.isMonitor.assert_called_once_with(row)

        index.row.assert_called_once_with()
        self.assertFalse(index.column.called)

        self.assertEqual(model.monitor_color, output)

        # Just do it a second time -> This time it's cached and should be read off the cache.
        # If it is not read off the cache the assert_called_once below will fail,
        # as the functions would be called a 2nd time
        output = model.data(index, Qt.BackgroundRole)

        model.ws_spectrum_info.hasDetectors.assert_called_with(row)
        # assert that it has been called twice with the same parameters
        model.ws_spectrum_info.isMasked.assert_has_calls(
            [call.do_work(row), call.do_work(row)])
        # only called once, as the 2nd time should have hit the cached monitor
        model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
        self.assertEqual(model.monitor_color, output)

        # assert that the row was called twice with no parameters
        self.assertEqual(2, index.row.call_count)
        self.assertFalse(index.column.called)
    def test_do_action_plot__plot_func_throws_error(self, ws, view, twd,
                                                    mock_logger_error):
        mock_plot_function = Mock()
        error_message = "See bottom of keyboard for HEALTH WARNING"
        mock_plot_function.side_effect = ValueError(error_message)
        with patch(
                'mantidqt.widgets.workspacedisplay.table.presenter.TableWorkspaceDisplay._get_plot_function_from_type') \
                as mock_get_plot_function_from_type:
            mock_get_plot_function_from_type.return_value = mock_plot_function
            view.mock_selection_model.selectedColumns.return_value = [
                MockQModelIndex(1, 1)
            ]
            twd.action_set_as_x()

            view.mock_selection_model.selectedColumns.return_value = [
                MockQModelIndex(1, 2)
            ]
            twd.action_plot(PlotType.LINEAR)

            view.show_warning.assert_called_once_with(
                TableWorkspaceDisplay.PLOT_FUNCTION_ERROR_MESSAGE.format(
                    error_message),
                TableWorkspaceDisplay.INVALID_DATA_WINDOW_TITLE)
            mock_logger_error.assert_called_once_with(
                TableWorkspaceDisplay.PLOT_FUNCTION_ERROR_MESSAGE.format(
                    error_message))
        self.assertNotCalled(twd.plot.mock_fig.show)
        self.assertNotCalled(twd.plot.mock_ax.legend)
Ejemplo n.º 13
0
 def test_setup_table(self):
     ws = MockWorkspace()
     view = MockMatrixWorkspaceDisplayView()
     container = Mock(spec=StatusBarView)
     container.status_bar = Mock(spec=QStatusBar)
     MatrixWorkspaceDisplay(ws, view=view, container=container)
     self.assertEqual(3, view.set_context_menu_actions.call_count)
     self.assertEqual(1, view.set_model.call_count)
 def test_setup_table(self):
     ws = MockWorkspace()
     view = MockMatrixWorkspaceDisplayView()
     container = Mock(spec=StatusBarView)
     container.status_bar = Mock(spec=QStatusBar)
     MatrixWorkspaceDisplay(ws, view=view, container=container)
     self.assertEqual(3, view.set_context_menu_actions.call_count)
     self.assertEqual(1, view.set_model.call_count)
 def wrapper(self, *args):
     ws = MockWorkspace()
     view = MockMatrixWorkspaceDisplayView()
     mock_observer = Mock()
     container = Mock(spec=StatusBarView)
     container.status_bar = Mock(spec=QStatusBar)
     presenter = MatrixWorkspaceDisplay(ws, view=view, ads_observer=mock_observer, container=container)
     return func(self, ws, view, presenter, *args)
 def test_get_plotted_workspace_names_returns_list_of_workspace_names(self):
     mock_axes = [
         Mock(tracked_workspaces={'test_ws': None}),
         Mock(tracked_workspaces={'test_ws1': None})
     ]
     mock_fig = Mock(get_axes=lambda: mock_axes)
     plotted_workspaces = get_plotted_workspaces_names(mock_fig)
     self.assertEqual(['test_ws', 'test_ws1'], sorted(plotted_workspaces))
 def __init__(self):
     self.clear = StrictMock()
     self.setHeaderLabel = StrictMock()
     self.addTopLevelItem = StrictMock()
     self.topLevelItemCount = Mock(return_value=3)
     self.topLevelItem = StrictMock(
         return_value=MockQTreeWidgetParentItem())
     self.itemClicked = Mock()
     self.itemChanged = Mock()
Ejemplo n.º 18
0
 def __init__(self):
     self.set_context_menu_actions = Mock()
     self.table_x = MockQTableView()
     self.table_y = MockQTableView()
     self.table_e = MockQTableView()
     self.set_model = Mock()
     self.ask_confirmation = None
     self.emit_close = Mock()
     self.mock_tab = MockQTab()
     self.get_active_tab = Mock(return_value=self.mock_tab)
    def test_monitor_5_correctly_disabled():
        mock_model = Mock()
        mock_model.does_instrument_support_monitor_5.return_value = False

        mock_view = Mock()
        settings_presenter = SettingsAdjustmentPresenter(view=mock_view,
                                                         model=mock_model)
        settings_presenter.default_gui_setup()

        mock_view.set_monitor_5_enabled.assert_called_with(False)
    def test_instrument_update_passed_to_model(self):
        mock_view = Mock()
        mock_model = Mock()

        presenter = SettingsAdjustmentPresenter(model=mock_model,
                                                view=mock_view)

        param = SANSInstrument.SANS2D
        presenter.update_instrument(param)
        self.assertEqual(param, mock_model.instrument)
Ejemplo n.º 21
0
    def test_action_background_args_changed_with_auto_background_none(self, mock_ConfigService):
        mock_view = MockSettingsView()
        mock_view.auto_bkg.currentText = Mock(return_value="None")
        presenter = FittingSettings(None, mock_view)
        # reset any effects from the constructor
        mock_ConfigService.setString.reset_mock()

        mock_view.background_args.text = Mock(return_value="n=3")
        presenter.action_background_args_changed()
        mock_ConfigService.setString.assert_called_once_with(FittingSettings.AUTO_BACKGROUND, "")
Ejemplo n.º 22
0
 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()
Ejemplo n.º 23
0
    def test_drag_and_drop_adds_plot_to_correct_axes(self):
        ax = self.fig.get_axes()[1]
        # Find the center of the axes and simulate a drop event there
        ax_x_centre = (ax.xaxis.clipbox.x1 + ax.xaxis.clipbox.x0)/2
        ax_y_centre = (ax.yaxis.clipbox.y1 + ax.yaxis.clipbox.y0)/2
        mock_event = Mock(pos=lambda: Mock(x=lambda: ax_x_centre, y=lambda: ax_y_centre))
        mock_event.mimeData().text.return_value = "ws"
        with patch('workbench.plotting.figurewindow.QMainWindow.dropEvent'):
            self.fig_window.dropEvent(mock_event)

        self.assertEqual(2, len(ax.lines))
Ejemplo n.º 24
0
 def wrapper(self, *args):
     ws = MockWorkspace()
     view = MockMatrixWorkspaceDisplayView()
     mock_observer = Mock()
     container = Mock(spec=StatusBarView)
     container.status_bar = Mock(spec=QStatusBar)
     presenter = MatrixWorkspaceDisplay(ws,
                                        view=view,
                                        ads_observer=mock_observer,
                                        container=container)
     return func(self, ws, view, presenter, *args)
 def test_normalise_data_set_on_fit_menu_shown(self, normaliseData_mock):
     for normalised in [True, False]:
         ws_artist_mock = Mock(is_normalized=normalised, workspace_index=0)
         axes_mock = Mock(tracked_workspaces={'ws_name': [ws_artist_mock]})
         property_browser = self._create_widget()
         with patch.object(property_browser, 'get_axes', lambda: axes_mock):
             with patch.object(property_browser, 'workspaceName',
                               lambda: 'ws_name'):
                 property_browser.getFitMenu().aboutToShow.emit()
         property_browser.normaliseData.assert_called_once_with(normalised)
         normaliseData_mock.reset_mock()
Ejemplo n.º 26
0
    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)
Ejemplo n.º 27
0
 def _run_check_axes_distribution_consistency(self, normalization_states):
     mock_tracked_workspaces = {
         'ws': [
             Mock(is_normalized=normalization_states[0]),
             Mock(is_normalized=normalization_states[1])
         ],
         'ws1': [Mock(is_normalized=normalization_states[2])]
     }
     with patch('mantid.kernel.logger.warning', Mock()) as mock_logger:
         with patch.object(self.ax, 'tracked_workspaces', mock_tracked_workspaces):
             self.ax.check_axes_distribution_consistency()
     return mock_logger
    def test_monitor_5_considered_with_update_instrument():
        mock_model = Mock()
        mock_model.does_instrument_support_monitor_5.return_value = True

        mock_view = Mock()

        settings_presenter = SettingsAdjustmentPresenter(view=mock_view,
                                                         model=mock_model)
        settings_presenter.update_instrument(SANSInstrument.ZOOM)

        mock_model.does_instrument_support_monitor_5.assert_called()
        mock_view.set_monitor_5_enabled.assert_called_with(True)
Ejemplo n.º 29
0
    def test_action_copy_bin_values_no_selection(self, mock_copy, mock_show_mouse_toast):
        mock_table = MockQTableView()
        mock_table.mock_selection_model.hasSelection = Mock(return_value=False)
        mock_table.mock_selection_model.selectedColumns = Mock()

        self.data_copier.copy_bin_values(mock_table, None, None)

        mock_table.selectionModel.assert_called_once_with()
        mock_table.mock_selection_model.hasSelection.assert_called_once_with()
        # the action should never look for rows if there is no selection
        self.assertNotCalled(mock_table.mock_selection_model.selectedColumns)
        self.assertNotCalled(mock_copy)
        mock_show_mouse_toast.assert_called_once_with(UserNotifier.NO_SELECTION_MESSAGE)
Ejemplo n.º 30
0
    def setUp(self):
        self.mock_status_bar = MockQStatusBar()
        self.mock_clipboard = MockQClipboard()
        self.mock_clipboard.setText = Mock()
        self.data_copier = DataCopier(self.mock_status_bar)

        mock_selection_model = MockQSelectionModel(has_selection=True)
        mock_selection_model.selectedRows = Mock(
            return_value=[MockQModelIndex(1, 1), MockQModelIndex(2, 2), MockQModelIndex(3, 3)])
        mock_selection_model.selectedColumns = Mock(
            return_value=[MockQModelIndex(1, 1), MockQModelIndex(2, 2), MockQModelIndex(3, 3)])
        self.table = Mock(spec=TableWorkspaceDisplayView)
        self.table.mock_selection_model = mock_selection_model
    def test_set_hidden_interface_string(self, mock_ConfigService):
        mock_view = MockCategoriesView()
        mock_ConfigService.getString = Mock(return_value='')
        presenter = CategoriesSettings(None, mock_view)
        hidden_interface_string = 'Indirect; Muon; Reflectometry'

        # reset any effects from the constructor
        mock_ConfigService.setString.reset_mock()
        presenter._create_hidden_categories_string = Mock(
            return_value=hidden_interface_string)
        presenter.set_hidden_interfaces_string(None)
        mock_ConfigService.setString.assert_called_once_with(
            presenter.HIDDEN_INTERFACES, ';'.join(hidden_interface_string))
Ejemplo n.º 32
0
    def test_action_current_row_changed(self):
        mock_view = MockSettingsView()
        presenter = SettingsPresenter(None, view=mock_view,
                                      general_settings=mock_view.general_settings,
                                      categories_settings=mock_view.categories_settings,
                                      plot_settings=mock_view.plot_settings,
                                      fitting_settings=mock_view.fitting_settings)

        mock_view.sections.item = Mock()
        mock_view.sections.item().text = Mock(return_value = presenter.SETTINGS_TABS['categories_settings'])
        presenter.action_section_changed(1)

        self.assertEqual(1, mock_view.container.replaceWidget.call_count)
        self.assertEqual(mock_view.categories_settings.view, presenter.current)
    def test_handleItemChanged(self, ws, view, twd):
        item = Mock(spec=WorkbenchTableWidgetItem)
        item.row.return_value = 5
        item.column.return_value = 5
        item.data.return_value = "magic parameter"
        item.is_v3d = False

        twd.handleItemChanged(item)

        item.row.assert_called_once_with()
        item.column.assert_called_once_with()
        ws.setCell.assert_called_once_with(5, 5, "magic parameter", notify_replace=False)
        item.update.assert_called_once_with()
        item.reset.assert_called_once_with()
    def common_setup_action_plot(self, table_has_selection=True):
        mock_ws = MockWorkspace()
        mock_view = MockMatrixWorkspaceDisplayView()
        mock_plotter = Mock()
        container = Mock(spec=StatusBarView)
        container.status_bar = Mock(spec=QStatusBar)
        presenter = MatrixWorkspaceDisplay(mock_ws, plot=mock_plotter, view=mock_view, container=container)

        # monkey-patch the spectrum plot label to count the number of calls
        presenter.model.get_spectrum_plot_label = Mock()
        presenter.model.get_bin_plot_label = Mock()

        mock_table = MockQTableView()
        # configure the mock return values
        mock_table.mock_selection_model.hasSelection = Mock(return_value=table_has_selection)
        return mock_plotter, mock_table, mock_view, presenter
 def wrapper(self, *args):
     ws = MockWorkspace()
     view = Mock(spec=TableWorkspaceDisplayView)
     container = Mock(spec=StatusBarView)
     container.status_bar = Mock(spec=QStatusBar)
     if add_selection_model:
         mock_selection_model = MockQSelectionModel(has_selection=True)
         mock_selection_model.selectedRows = Mock(
             return_value=[MockQModelIndex(1, 1), MockQModelIndex(2, 2), MockQModelIndex(3, 3)])
         mock_selection_model.selectedColumns = Mock(
             return_value=[MockQModelIndex(1, 1), MockQModelIndex(2, 2), MockQModelIndex(3, 3)])
         view.mock_selection_model = mock_selection_model
         view.selectionModel.return_value = mock_selection_model
     twd = TableWorkspaceDisplay(ws, view=view, container=container)
     if add_plot:
         twd.plot = MockPlotLib()
     return func(self, ws, view, twd, *args)
    def test_handleItemChanged_raises_ValueError(self, ws, view, twd):
        item = Mock(spec=WorkbenchTableWidgetItem)
        item.row.return_value = 5
        item.column.return_value = 5
        item.data.return_value = "magic parameter"
        item.is_v3d = False

        # setCell will throw an exception as a side effect
        ws.setCell.side_effect = ValueError

        twd.handleItemChanged(item)

        item.row.assert_called_once_with()
        item.column.assert_called_once_with()
        ws.setCell.assert_called_once_with(5, 5, "magic parameter")
        view.show_warning.assert_called_once_with(TableWorkspaceDisplay.ITEM_CHANGED_INVALID_DATA_MESSAGE)
        self.assertNotCalled(item.update)
        item.reset.assert_called_once_with()
    def test_handleItemChanged_raises_Exception(self, ws, view, twd):
        item = Mock(spec=WorkbenchTableWidgetItem)

        item.row.return_value = ws.ROWS
        item.column.return_value = ws.COLS
        item.data.return_value = "magic parameter"
        item.is_v3d = False

        # setCell will throw an exception as a side effect
        error_message = "TEST_EXCEPTION_MESSAGE"
        ws.setCell.side_effect = Exception(error_message)

        twd.handleItemChanged(item)

        item.row.assert_called_once_with()
        item.column.assert_called_once_with()
        ws.setCell.assert_called_once_with(ws.ROWS, ws.COLS, "magic parameter")
        view.show_warning.assert_called_once_with(
            TableWorkspaceDisplay.ITEM_CHANGED_UNKNOWN_ERROR_MESSAGE.format(error_message))
        self.assertNotCalled(item.update)
        item.reset.assert_called_once_with()
    def test_do_action_plot__plot_func_throws_error(self, ws, view, twd, mock_logger_error):
        mock_plot_function = Mock()
        error_message = "See bottom of keyboard for HEALTH WARNING"
        mock_plot_function.side_effect = ValueError(error_message)
        with patch(
                'mantidqt.widgets.workspacedisplay.table.presenter.TableWorkspaceDisplay._get_plot_function_from_type') \
                as mock_get_plot_function_from_type:
            mock_get_plot_function_from_type.return_value = mock_plot_function
            view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, 1)]
            twd.action_set_as_x()

            view.mock_selection_model.selectedColumns.return_value = [MockQModelIndex(1, 2)]
            twd.action_plot(PlotType.LINEAR)

            view.show_warning.assert_called_once_with(
                TableWorkspaceDisplay.PLOT_FUNCTION_ERROR_MESSAGE.format(error_message),
                TableWorkspaceDisplay.INVALID_DATA_WINDOW_TITLE)
            mock_logger_error.assert_called_once_with(
                TableWorkspaceDisplay.PLOT_FUNCTION_ERROR_MESSAGE.format(error_message))
        self.assertNotCalled(twd.plot.mock_fig.show)
        self.assertNotCalled(twd.plot.mock_ax.legend)
Ejemplo n.º 39
0
from collections import Counter, namedtuple

import qtpy
from mantid.py3compat.mock import Mock, patch, call
import unittest

from qtpy.QtCore import Qt
from qtpy.QtTest import QTest

from mantid.api import AlgorithmFactoryImpl
from mantidqt.utils.qt.testing import select_item_in_combo_box, select_item_in_tree, GuiTest
from mantidqt.widgets.algorithmselector.model import AlgorithmSelectorModel
from mantidqt.widgets.algorithmselector.widget import AlgorithmSelectorWidget

AlgorithmDescriptorMock = namedtuple('AlgorithmDescriptorMock', ['name', 'alias', 'category', 'version'])
mock_get_algorithm_descriptors = Mock()
mock_get_algorithm_descriptors.return_value = [
    AlgorithmDescriptorMock(name='Rebin', version=1,
                            category='Transform', alias=''),
    AlgorithmDescriptorMock(name='Rebin', version=1,
                            category='Transform\\Rebin', alias=''),
    AlgorithmDescriptorMock(name='Load', version=1,
                            category='Data', alias=''),
    AlgorithmDescriptorMock(name='DoStuff', version=1,
                            category='Stuff', alias=''),
    AlgorithmDescriptorMock(name='DoStuff', version=2,
                            category='Stuff', alias=''),
    AlgorithmDescriptorMock(name='ComesFirst', version=1,
                            category="Sorted", alias=''),
    AlgorithmDescriptorMock(name='GoesSecond', version=1,
                            category="Sorted", alias='')